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. */
922 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
926 /* Emacs doesn't actually change directory itself, it stays in the
927 same directory where it was started. */
928 strcpy (dir
, startup_dir
);
933 /* Emulate getloadavg. */
942 /* Number of processors on this machine. */
943 static unsigned num_of_processors
;
945 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
946 static struct load_sample samples
[16*60];
947 static int first_idx
= -1, last_idx
= -1;
948 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
953 int next_idx
= from
+ 1;
955 if (next_idx
>= max_idx
)
964 int prev_idx
= from
- 1;
967 prev_idx
= max_idx
- 1;
973 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
976 FILETIME ft_idle
, ft_user
, ft_kernel
;
978 /* Initialize the number of processors on this machine. */
979 if (num_of_processors
<= 0)
981 get_native_system_info (&sysinfo
);
982 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
983 if (num_of_processors
<= 0)
985 GetSystemInfo (&sysinfo
);
986 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
988 if (num_of_processors
<= 0)
989 num_of_processors
= 1;
992 /* TODO: Take into account threads that are ready to run, by
993 sampling the "\System\Processor Queue Length" performance
994 counter. The code below accounts only for threads that are
997 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
999 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1001 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1002 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1003 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1004 *idle
= uidle
.QuadPart
;
1005 *kernel
= ukernel
.QuadPart
;
1006 *user
= uuser
.QuadPart
;
1016 /* Produce the load average for a given time interval, using the
1017 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1018 1-minute, 5-minute, or 15-minute average, respectively. */
1022 double retval
= -1.0;
1025 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1026 time_t now
= samples
[last_idx
].sample_time
;
1028 if (first_idx
!= last_idx
)
1030 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1032 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1033 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1036 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1037 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1038 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1040 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1043 if (idx
== first_idx
)
1052 getloadavg (double loadavg
[], int nelem
)
1055 ULONGLONG idle
, kernel
, user
;
1056 time_t now
= time (NULL
);
1058 /* Store another sample. We ignore samples that are less than 1 sec
1060 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1062 sample_system_load (&idle
, &kernel
, &user
);
1063 last_idx
= buf_next (last_idx
);
1064 samples
[last_idx
].sample_time
= now
;
1065 samples
[last_idx
].idle
= idle
;
1066 samples
[last_idx
].kernel
= kernel
;
1067 samples
[last_idx
].user
= user
;
1068 /* If the buffer has more that 15 min worth of samples, discard
1070 if (first_idx
== -1)
1071 first_idx
= last_idx
;
1072 while (first_idx
!= last_idx
1073 && (difftime (now
, samples
[first_idx
].sample_time
)
1074 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1075 first_idx
= buf_next (first_idx
);
1078 for (elem
= 0; elem
< nelem
; elem
++)
1080 double avg
= getavg (elem
);
1084 loadavg
[elem
] = avg
;
1090 /* Emulate getpwuid, getpwnam and others. */
1092 #define PASSWD_FIELD_SIZE 256
1094 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1095 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1096 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1097 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
1098 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
1100 static struct passwd dflt_passwd
=
1112 static char dflt_group_name
[GNLEN
+1];
1114 static struct group dflt_group
=
1116 /* When group information is not available, we return this as the
1117 group for all files. */
1125 return dflt_passwd
.pw_uid
;
1131 /* I could imagine arguing for checking to see whether the user is
1132 in the Administrators group and returning a UID of 0 for that
1133 case, but I don't know how wise that would be in the long run. */
1140 return dflt_passwd
.pw_gid
;
1150 getpwuid (unsigned uid
)
1152 if (uid
== dflt_passwd
.pw_uid
)
1153 return &dflt_passwd
;
1158 getgrgid (gid_t gid
)
1164 getpwnam (char *name
)
1168 pw
= getpwuid (getuid ());
1172 if (xstrcasecmp (name
, pw
->pw_name
))
1179 init_user_info (void)
1181 /* Find the user's real name by opening the process token and
1182 looking up the name associated with the user-sid in that token.
1184 Use the relative portion of the identifier authority value from
1185 the user-sid as the user id value (same for group id using the
1186 primary group sid from the process token). */
1188 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1189 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1190 DWORD glength
= sizeof (gname
);
1191 HANDLE token
= NULL
;
1192 SID_NAME_USE user_type
;
1193 unsigned char *buf
= NULL
;
1195 TOKEN_USER user_token
;
1196 TOKEN_PRIMARY_GROUP group_token
;
1199 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1202 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1203 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1205 buf
= xmalloc (blen
);
1206 result
= get_token_information (token
, TokenUser
,
1207 (LPVOID
)buf
, blen
, &needed
);
1210 memcpy (&user_token
, buf
, sizeof (user_token
));
1211 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1213 domain
, &dlength
, &user_type
);
1221 strcpy (dflt_passwd
.pw_name
, uname
);
1222 /* Determine a reasonable uid value. */
1223 if (xstrcasecmp ("administrator", uname
) == 0)
1225 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1226 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1230 /* Use the last sub-authority value of the RID, the relative
1231 portion of the SID, as user/group ID. */
1232 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1234 /* Get group id and name. */
1235 result
= get_token_information (token
, TokenPrimaryGroup
,
1236 (LPVOID
)buf
, blen
, &needed
);
1237 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1239 buf
= xrealloc (buf
, blen
= needed
);
1240 result
= get_token_information (token
, TokenPrimaryGroup
,
1241 (LPVOID
)buf
, blen
, &needed
);
1245 memcpy (&group_token
, buf
, sizeof (group_token
));
1246 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1247 dlength
= sizeof (domain
);
1248 /* If we can get at the real Primary Group name, use that.
1249 Otherwise, the default group name was already set to
1250 "None" in globals_of_w32. */
1251 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1252 gname
, &glength
, NULL
, &dlength
,
1254 strcpy (dflt_group_name
, gname
);
1257 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1260 /* If security calls are not supported (presumably because we
1261 are running under Windows 9X), fallback to this: */
1262 else if (GetUserName (uname
, &ulength
))
1264 strcpy (dflt_passwd
.pw_name
, uname
);
1265 if (xstrcasecmp ("administrator", uname
) == 0)
1266 dflt_passwd
.pw_uid
= 0;
1268 dflt_passwd
.pw_uid
= 123;
1269 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1273 strcpy (dflt_passwd
.pw_name
, "unknown");
1274 dflt_passwd
.pw_uid
= 123;
1275 dflt_passwd
.pw_gid
= 123;
1277 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1279 /* Ensure HOME and SHELL are defined. */
1280 if (getenv ("HOME") == NULL
)
1282 if (getenv ("SHELL") == NULL
)
1285 /* Set dir and shell from environment variables. */
1286 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1287 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1291 CloseHandle (token
);
1297 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1298 return ((rand () << 15) | rand ());
1308 /* Normalize filename by converting all path separators to
1309 the specified separator. Also conditionally convert upper
1310 case path name components to lower case. */
1313 normalize_filename (register char *fp
, char path_sep
)
1318 /* Always lower-case drive letters a-z, even if the filesystem
1319 preserves case in filenames.
1320 This is so filenames can be compared by string comparison
1321 functions that are case-sensitive. Even case-preserving filesystems
1322 do not distinguish case in drive letters. */
1323 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
1329 if (NILP (Vw32_downcase_file_names
))
1333 if (*fp
== '/' || *fp
== '\\')
1340 sep
= path_sep
; /* convert to this path separator */
1341 elem
= fp
; /* start of current path element */
1344 if (*fp
>= 'a' && *fp
<= 'z')
1345 elem
= 0; /* don't convert this element */
1347 if (*fp
== 0 || *fp
== ':')
1349 sep
= *fp
; /* restore current separator (or 0) */
1350 *fp
= '/'; /* after conversion of this element */
1353 if (*fp
== '/' || *fp
== '\\')
1355 if (elem
&& elem
!= fp
)
1357 *fp
= 0; /* temporary end of string */
1358 _strlwr (elem
); /* while we convert to lower case */
1360 *fp
= sep
; /* convert (or restore) path separator */
1361 elem
= fp
+ 1; /* next element starts after separator */
1367 /* Destructively turn backslashes into slashes. */
1369 dostounix_filename (register char *p
)
1371 normalize_filename (p
, '/');
1374 /* Destructively turn slashes into backslashes. */
1376 unixtodos_filename (register char *p
)
1378 normalize_filename (p
, '\\');
1381 /* Remove all CR's that are followed by a LF.
1382 (From msdos.c...probably should figure out a way to share it,
1383 although this code isn't going to ever change.) */
1385 crlf_to_lf (register int n
, register unsigned char *buf
)
1387 unsigned char *np
= buf
;
1388 unsigned char *startp
= buf
;
1389 unsigned char *endp
= buf
+ n
;
1393 while (buf
< endp
- 1)
1397 if (*(++buf
) != 0x0a)
1408 /* Parse the root part of file name, if present. Return length and
1409 optionally store pointer to char after root. */
1411 parse_root (char * name
, char ** pPath
)
1413 char * start
= name
;
1418 /* find the root name of the volume if given */
1419 if (isalpha (name
[0]) && name
[1] == ':')
1421 /* skip past drive specifier */
1423 if (IS_DIRECTORY_SEP (name
[0]))
1426 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1432 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1437 if (IS_DIRECTORY_SEP (name
[0]))
1444 return name
- start
;
1447 /* Get long base name for name; name is assumed to be absolute. */
1449 get_long_basename (char * name
, char * buf
, int size
)
1451 WIN32_FIND_DATA find_data
;
1455 /* must be valid filename, no wild cards or other invalid characters */
1456 if (_mbspbrk (name
, "*?|<>\""))
1459 dir_handle
= FindFirstFile (name
, &find_data
);
1460 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1462 if ((len
= strlen (find_data
.cFileName
)) < size
)
1463 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1466 FindClose (dir_handle
);
1471 /* Get long name for file, if possible (assumed to be absolute). */
1473 w32_get_long_filename (char * name
, char * buf
, int size
)
1478 char full
[ MAX_PATH
];
1481 len
= strlen (name
);
1482 if (len
>= MAX_PATH
)
1485 /* Use local copy for destructive modification. */
1486 memcpy (full
, name
, len
+1);
1487 unixtodos_filename (full
);
1489 /* Copy root part verbatim. */
1490 len
= parse_root (full
, &p
);
1491 memcpy (o
, full
, len
);
1496 while (p
!= NULL
&& *p
)
1499 p
= strchr (q
, '\\');
1501 len
= get_long_basename (full
, o
, size
);
1524 is_unc_volume (const char *filename
)
1526 const char *ptr
= filename
;
1528 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1531 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1537 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1540 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1543 HKEY hrootkey
= NULL
;
1546 /* Check both the current user and the local machine to see if
1547 we have any resources. */
1549 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1553 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1554 && (lpvalue
= xmalloc (cbData
)) != NULL
1555 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1557 RegCloseKey (hrootkey
);
1563 RegCloseKey (hrootkey
);
1566 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1570 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1571 && (lpvalue
= xmalloc (cbData
)) != NULL
1572 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1574 RegCloseKey (hrootkey
);
1580 RegCloseKey (hrootkey
);
1586 char *get_emacs_configuration (void);
1589 init_environment (char ** argv
)
1591 static const char * const tempdirs
[] = {
1592 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1597 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1599 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1600 temporary files and assume "/tmp" if $TMPDIR is unset, which
1601 will break on DOS/Windows. Refuse to work if we cannot find
1602 a directory, not even "c:/", usable for that purpose. */
1603 for (i
= 0; i
< imax
; i
++)
1605 const char *tmp
= tempdirs
[i
];
1608 tmp
= getenv (tmp
+ 1);
1609 /* Note that `access' can lie to us if the directory resides on a
1610 read-only filesystem, like CD-ROM or a write-protected floppy.
1611 The only way to be really sure is to actually create a file and
1612 see if it succeeds. But I think that's too much to ask. */
1614 /* MSVCRT's _access crashes with D_OK. */
1615 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
1617 char * var
= alloca (strlen (tmp
) + 8);
1618 sprintf (var
, "TMPDIR=%s", tmp
);
1619 _putenv (strdup (var
));
1626 Fcons (build_string ("no usable temporary directories found!!"),
1628 "While setting TMPDIR: ");
1630 /* Check for environment variables and use registry settings if they
1631 don't exist. Fallback on default values where applicable. */
1636 char locale_name
[32];
1637 char default_home
[MAX_PATH
];
1640 static const struct env_entry
1646 /* If the default value is NULL, we will use the value from the
1647 outside environment or the Registry, but will not push the
1648 variable into the Emacs environment if it is defined neither
1649 in the Registry nor in the outside environment. */
1651 {"PRELOAD_WINSOCK", NULL
},
1652 {"emacs_dir", "C:/emacs"},
1653 {"EMACSLOADPATH", NULL
},
1654 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1655 {"EMACSDATA", NULL
},
1656 {"EMACSPATH", NULL
},
1663 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1665 /* We need to copy dflt_envvars[] and work on the copy because we
1666 don't want the dumped Emacs to inherit the values of
1667 environment variables we saw during dumping (which could be on
1668 a different system). The defaults above must be left intact. */
1669 struct env_entry env_vars
[N_ENV_VARS
];
1671 for (i
= 0; i
< N_ENV_VARS
; i
++)
1672 env_vars
[i
] = dflt_envvars
[i
];
1674 /* For backwards compatibility, check if a .emacs file exists in C:/
1675 If not, then we can try to default to the appdata directory under the
1676 user's profile, which is more likely to be writable. */
1677 if (!check_existing ("C:/.emacs"))
1679 HRESULT profile_result
;
1680 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1681 of Windows 95 and NT4 that have not been updated to include
1683 ShGetFolderPath_fn get_folder_path
;
1684 get_folder_path
= (ShGetFolderPath_fn
)
1685 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1687 if (get_folder_path
!= NULL
)
1689 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1692 /* If we can't get the appdata dir, revert to old behavior. */
1693 if (profile_result
== S_OK
)
1695 env_vars
[0].def_value
= default_home
;
1701 /* Get default locale info and use it for LANG. */
1702 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1703 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1704 locale_name
, sizeof (locale_name
)))
1706 for (i
= 0; i
< N_ENV_VARS
; i
++)
1708 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1710 env_vars
[i
].def_value
= locale_name
;
1716 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1718 /* Treat emacs_dir specially: set it unconditionally based on our
1722 char modname
[MAX_PATH
];
1724 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1726 if ((p
= strrchr (modname
, '\\')) == NULL
)
1730 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1732 char buf
[SET_ENV_BUF_SIZE
];
1735 for (p
= modname
; *p
; p
++)
1736 if (*p
== '\\') *p
= '/';
1738 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1739 _putenv (strdup (buf
));
1741 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1743 /* FIXME: should use substring of get_emacs_configuration ().
1744 But I don't think the Windows build supports alpha, mips etc
1745 anymore, so have taken the easy option for now. */
1746 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
1747 || xstrcasecmp (p
, "\\AMD64") == 0))
1750 p
= strrchr (modname
, '\\');
1754 p
= strrchr (modname
, '\\');
1755 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1757 char buf
[SET_ENV_BUF_SIZE
];
1760 for (p
= modname
; *p
; p
++)
1761 if (*p
== '\\') *p
= '/';
1763 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1764 _putenv (strdup (buf
));
1770 for (i
= 0; i
< N_ENV_VARS
; i
++)
1772 if (!getenv (env_vars
[i
].name
))
1776 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1777 /* Also ignore empty environment variables. */
1781 lpval
= env_vars
[i
].def_value
;
1782 dwType
= REG_EXPAND_SZ
;
1784 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
1785 Vdelayed_warnings_list
1786 = Fcons (listn (CONSTYPE_HEAP
, 2,
1787 intern ("initialization"),
1788 build_string ("Setting HOME to C:\\ by default is deprecated")),
1789 Vdelayed_warnings_list
);
1794 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1796 if (dwType
== REG_EXPAND_SZ
)
1797 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1798 else if (dwType
== REG_SZ
)
1799 strcpy (buf1
, lpval
);
1800 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1802 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1804 _putenv (strdup (buf2
));
1814 /* Rebuild system configuration to reflect invoking system. */
1815 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1817 /* Another special case: on NT, the PATH variable is actually named
1818 "Path" although cmd.exe (perhaps NT itself) arranges for
1819 environment variable lookup and setting to be case insensitive.
1820 However, Emacs assumes a fully case sensitive environment, so we
1821 need to change "Path" to "PATH" to match the expectations of
1822 various elisp packages. We do this by the sneaky method of
1823 modifying the string in the C runtime environ entry.
1825 The same applies to COMSPEC. */
1829 for (envp
= environ
; *envp
; envp
++)
1830 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1831 memcpy (*envp
, "PATH=", 5);
1832 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1833 memcpy (*envp
, "COMSPEC=", 8);
1836 /* Remember the initial working directory for getwd. */
1837 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
1838 Does it matter anywhere in Emacs? */
1839 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1843 static char modname
[MAX_PATH
];
1845 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1850 /* Determine if there is a middle mouse button, to allow parse_button
1851 to decide whether right mouse events should be mouse-2 or
1853 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1858 /* Called from expand-file-name when default-directory is not a string. */
1861 emacs_root_dir (void)
1863 static char root_dir
[FILENAME_MAX
];
1866 p
= getenv ("emacs_dir");
1869 strcpy (root_dir
, p
);
1870 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1871 dostounix_filename (root_dir
);
1875 /* We don't have scripts to automatically determine the system configuration
1876 for Emacs before it's compiled, and we don't want to have to make the
1877 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1881 get_emacs_configuration (void)
1883 char *arch
, *oem
, *os
;
1885 static char configuration_buffer
[32];
1887 /* Determine the processor type. */
1888 switch (get_processor_type ())
1891 #ifdef PROCESSOR_INTEL_386
1892 case PROCESSOR_INTEL_386
:
1893 case PROCESSOR_INTEL_486
:
1894 case PROCESSOR_INTEL_PENTIUM
:
1902 #ifdef PROCESSOR_AMD_X8664
1903 case PROCESSOR_AMD_X8664
:
1908 #ifdef PROCESSOR_MIPS_R2000
1909 case PROCESSOR_MIPS_R2000
:
1910 case PROCESSOR_MIPS_R3000
:
1911 case PROCESSOR_MIPS_R4000
:
1916 #ifdef PROCESSOR_ALPHA_21064
1917 case PROCESSOR_ALPHA_21064
:
1927 /* Use the OEM field to reflect the compiler/library combination. */
1929 #define COMPILER_NAME "msvc"
1932 #define COMPILER_NAME "mingw"
1934 #define COMPILER_NAME "unknown"
1937 oem
= COMPILER_NAME
;
1939 switch (osinfo_cache
.dwPlatformId
) {
1940 case VER_PLATFORM_WIN32_NT
:
1942 build_num
= osinfo_cache
.dwBuildNumber
;
1944 case VER_PLATFORM_WIN32_WINDOWS
:
1945 if (osinfo_cache
.dwMinorVersion
== 0) {
1950 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1952 case VER_PLATFORM_WIN32s
:
1953 /* Not supported, should not happen. */
1955 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1963 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1964 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1965 get_w32_major_version (), get_w32_minor_version (), build_num
);
1967 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1970 return configuration_buffer
;
1974 get_emacs_configuration_options (void)
1976 static char *options_buffer
;
1977 char cv
[32]; /* Enough for COMPILER_VERSION. */
1979 cv
, /* To be filled later. */
1983 #ifdef ENABLE_CHECKING
1984 " --enable-checking",
1986 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1987 with a starting space to save work here. */
1989 " --cflags", USER_CFLAGS
,
1992 " --ldflags", USER_LDFLAGS
,
1999 /* Work out the effective configure options for this build. */
2001 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2004 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2006 #define COMPILER_VERSION ""
2010 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2011 return "Error: not enough space for compiler version";
2012 cv
[sizeof (cv
) - 1] = '\0';
2014 for (i
= 0; options
[i
]; i
++)
2015 size
+= strlen (options
[i
]);
2017 options_buffer
= xmalloc (size
+ 1);
2018 options_buffer
[0] = '\0';
2020 for (i
= 0; options
[i
]; i
++)
2021 strcat (options_buffer
, options
[i
]);
2023 return options_buffer
;
2027 #include <sys/timeb.h>
2029 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2031 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2036 tv
->tv_sec
= tb
.time
;
2037 tv
->tv_usec
= tb
.millitm
* 1000L;
2038 /* Implementation note: _ftime sometimes doesn't update the dstflag
2039 according to the new timezone when the system timezone is
2040 changed. We could fix that by using GetSystemTime and
2041 GetTimeZoneInformation, but that doesn't seem necessary, since
2042 Emacs always calls gettimeofday with the 2nd argument NULL (see
2043 current_emacs_time). */
2046 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2047 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2051 /* Emulate fdutimens. */
2053 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2054 TIMESPEC[0] and TIMESPEC[1], respectively.
2055 FD must be either negative -- in which case it is ignored --
2056 or a file descriptor that is open on FILE.
2057 If FD is nonnegative, then FILE can be NULL, which means
2058 use just futimes instead of utimes.
2059 If TIMESPEC is null, FAIL.
2060 Return 0 on success, -1 (setting errno) on failure. */
2063 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2072 if (fd
< 0 && !file
)
2077 ut
.actime
= timespec
[0].tv_sec
;
2078 ut
.modtime
= timespec
[1].tv_sec
;
2080 return _futime (fd
, &ut
);
2082 return _utime (file
, &ut
);
2086 /* ------------------------------------------------------------------------- */
2087 /* IO support and wrapper functions for the Windows API. */
2088 /* ------------------------------------------------------------------------- */
2090 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2091 on network directories, so we handle that case here.
2092 (Ulrich Leodolter, 1/11/95). */
2094 sys_ctime (const time_t *t
)
2096 char *str
= (char *) ctime (t
);
2097 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2100 /* Emulate sleep...we could have done this with a define, but that
2101 would necessitate including windows.h in the files that used it.
2102 This is much easier. */
2104 sys_sleep (int seconds
)
2106 Sleep (seconds
* 1000);
2109 /* Internal MSVC functions for low-level descriptor munging */
2110 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2111 extern int __cdecl
_free_osfhnd (int fd
);
2113 /* parallel array of private info on file handles */
2114 filedesc fd_info
[ MAXDESC
];
2116 typedef struct volume_info_data
{
2117 struct volume_info_data
* next
;
2119 /* time when info was obtained */
2122 /* actual volume info */
2131 /* Global referenced by various functions. */
2132 static volume_info_data volume_info
;
2134 /* Vector to indicate which drives are local and fixed (for which cached
2135 data never expires). */
2136 static BOOL fixed_drives
[26];
2138 /* Consider cached volume information to be stale if older than 10s,
2139 at least for non-local drives. Info for fixed drives is never stale. */
2140 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2141 #define VOLINFO_STILL_VALID( root_dir, info ) \
2142 ( ( isalpha (root_dir[0]) && \
2143 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2144 || GetTickCount () - info->timestamp < 10000 )
2146 /* Cache support functions. */
2148 /* Simple linked list with linear search is sufficient. */
2149 static volume_info_data
*volume_cache
= NULL
;
2151 static volume_info_data
*
2152 lookup_volume_info (char * root_dir
)
2154 volume_info_data
* info
;
2156 for (info
= volume_cache
; info
; info
= info
->next
)
2157 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2163 add_volume_info (char * root_dir
, volume_info_data
* info
)
2165 info
->root_dir
= xstrdup (root_dir
);
2166 info
->next
= volume_cache
;
2167 volume_cache
= info
;
2171 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2172 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2173 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2174 static volume_info_data
*
2175 GetCachedVolumeInformation (char * root_dir
)
2177 volume_info_data
* info
;
2178 char default_root
[ MAX_PATH
];
2180 /* NULL for root_dir means use root from current directory. */
2181 if (root_dir
== NULL
)
2183 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2185 parse_root (default_root
, &root_dir
);
2187 root_dir
= default_root
;
2190 /* Local fixed drives can be cached permanently. Removable drives
2191 cannot be cached permanently, since the volume name and serial
2192 number (if nothing else) can change. Remote drives should be
2193 treated as if they are removable, since there is no sure way to
2194 tell whether they are or not. Also, the UNC association of drive
2195 letters mapped to remote volumes can be changed at any time (even
2196 by other processes) without notice.
2198 As a compromise, so we can benefit from caching info for remote
2199 volumes, we use a simple expiry mechanism to invalidate cache
2200 entries that are more than ten seconds old. */
2203 /* No point doing this, because WNetGetConnection is even slower than
2204 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2205 GetDriveType is about the only call of this type which does not
2206 involve network access, and so is extremely quick). */
2208 /* Map drive letter to UNC if remote. */
2209 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2211 char remote_name
[ 256 ];
2212 char drive
[3] = { root_dir
[0], ':' };
2214 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2216 /* do something */ ;
2220 info
= lookup_volume_info (root_dir
);
2222 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2230 /* Info is not cached, or is stale. */
2231 if (!GetVolumeInformation (root_dir
,
2232 name
, sizeof (name
),
2236 type
, sizeof (type
)))
2239 /* Cache the volume information for future use, overwriting existing
2240 entry if present. */
2243 info
= xmalloc (sizeof (volume_info_data
));
2244 add_volume_info (root_dir
, info
);
2252 info
->name
= xstrdup (name
);
2253 info
->serialnum
= serialnum
;
2254 info
->maxcomp
= maxcomp
;
2255 info
->flags
= flags
;
2256 info
->type
= xstrdup (type
);
2257 info
->timestamp
= GetTickCount ();
2263 /* Get information on the volume where NAME is held; set path pointer to
2264 start of pathname in NAME (past UNC header\volume header if present),
2265 if pPath is non-NULL.
2267 Note: if NAME includes symlinks, the information is for the volume
2268 of the symlink, not of its target. That's because, even though
2269 GetVolumeInformation returns information about the symlink target
2270 of its argument, we only pass the root directory to
2271 GetVolumeInformation, not the full NAME. */
2273 get_volume_info (const char * name
, const char ** pPath
)
2275 char temp
[MAX_PATH
];
2276 char *rootname
= NULL
; /* default to current volume */
2277 volume_info_data
* info
;
2282 /* Find the root name of the volume if given. */
2283 if (isalpha (name
[0]) && name
[1] == ':')
2291 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2298 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2311 info
= GetCachedVolumeInformation (rootname
);
2314 /* Set global referenced by other functions. */
2315 volume_info
= *info
;
2321 /* Determine if volume is FAT format (ie. only supports short 8.3
2322 names); also set path pointer to start of pathname in name, if
2323 pPath is non-NULL. */
2325 is_fat_volume (const char * name
, const char ** pPath
)
2327 if (get_volume_info (name
, pPath
))
2328 return (volume_info
.maxcomp
== 12);
2332 /* Map filename to a valid 8.3 name if necessary.
2333 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2335 map_w32_filename (const char * name
, const char ** pPath
)
2337 static char shortname
[MAX_PATH
];
2338 char * str
= shortname
;
2341 const char * save_name
= name
;
2343 if (strlen (name
) >= MAX_PATH
)
2345 /* Return a filename which will cause callers to fail. */
2346 strcpy (shortname
, "?");
2350 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2352 register int left
= 8; /* maximum number of chars in part */
2353 register int extn
= 0; /* extension added? */
2354 register int dots
= 2; /* maximum number of dots allowed */
2357 *str
++ = *name
++; /* skip past UNC header */
2359 while ((c
= *name
++))
2366 *str
++ = (c
== ':' ? ':' : '\\');
2367 extn
= 0; /* reset extension flags */
2368 dots
= 2; /* max 2 dots */
2369 left
= 8; /* max length 8 for main part */
2374 /* Convert path components of the form .xxx to _xxx,
2375 but leave . and .. as they are. This allows .emacs
2376 to be read as _emacs, for example. */
2380 IS_DIRECTORY_SEP (*name
))
2395 extn
= 1; /* we've got an extension */
2396 left
= 3; /* 3 chars in extension */
2400 /* any embedded dots after the first are converted to _ */
2405 case '#': /* don't lose these, they're important */
2407 str
[-1] = c
; /* replace last character of part */
2412 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2414 dots
= 0; /* started a path component */
2423 strcpy (shortname
, name
);
2424 unixtodos_filename (shortname
);
2428 *pPath
= shortname
+ (path
- save_name
);
2434 is_exec (const char * name
)
2436 char * p
= strrchr (name
, '.');
2439 && (xstrcasecmp (p
, ".exe") == 0 ||
2440 xstrcasecmp (p
, ".com") == 0 ||
2441 xstrcasecmp (p
, ".bat") == 0 ||
2442 xstrcasecmp (p
, ".cmd") == 0));
2445 /* Emulate the Unix directory procedures opendir, closedir,
2446 and readdir. We can't use the procedures supplied in sysdep.c,
2447 so we provide them here. */
2449 struct direct dir_static
; /* simulated directory contents */
2450 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2451 static int dir_is_fat
;
2452 static char dir_pathname
[MAXPATHLEN
+1];
2453 static WIN32_FIND_DATA dir_find_data
;
2455 /* Support shares on a network resource as subdirectories of a read-only
2457 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2458 static HANDLE
open_unc_volume (const char *);
2459 static char *read_unc_volume (HANDLE
, char *, int);
2460 static void close_unc_volume (HANDLE
);
2463 opendir (char *filename
)
2467 /* Opening is done by FindFirstFile. However, a read is inherent to
2468 this operation, so we defer the open until read time. */
2470 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2472 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2475 /* Note: We don't support traversal of UNC volumes via symlinks.
2476 Doing so would mean punishing 99.99% of use cases by resolving
2477 all the possible symlinks in FILENAME, recursively. */
2478 if (is_unc_volume (filename
))
2480 wnet_enum_handle
= open_unc_volume (filename
);
2481 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2485 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2492 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2493 dir_pathname
[MAXPATHLEN
] = '\0';
2494 /* Note: We don't support symlinks to file names on FAT volumes.
2495 Doing so would mean punishing 99.99% of use cases by resolving
2496 all the possible symlinks in FILENAME, recursively. */
2497 dir_is_fat
= is_fat_volume (filename
, NULL
);
2503 closedir (DIR *dirp
)
2505 /* If we have a find-handle open, close it. */
2506 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2508 FindClose (dir_find_handle
);
2509 dir_find_handle
= INVALID_HANDLE_VALUE
;
2511 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2513 close_unc_volume (wnet_enum_handle
);
2514 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2516 xfree ((char *) dirp
);
2522 int downcase
= !NILP (Vw32_downcase_file_names
);
2524 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2526 if (!read_unc_volume (wnet_enum_handle
,
2527 dir_find_data
.cFileName
,
2531 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2532 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2534 char filename
[MAXNAMLEN
+ 3];
2537 strcpy (filename
, dir_pathname
);
2538 ln
= strlen (filename
) - 1;
2539 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2540 strcat (filename
, "\\");
2541 strcat (filename
, "*");
2543 /* Note: No need to resolve symlinks in FILENAME, because
2544 FindFirst opens the directory that is the target of a
2546 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2548 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2553 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2557 /* Emacs never uses this value, so don't bother making it match
2558 value returned by stat(). */
2559 dir_static
.d_ino
= 1;
2561 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2563 /* If the file name in cFileName[] includes `?' characters, it means
2564 the original file name used characters that cannot be represented
2565 by the current ANSI codepage. To avoid total lossage, retrieve
2566 the short 8+3 alias of the long file name. */
2567 if (_mbspbrk (dir_static
.d_name
, "?"))
2569 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2570 downcase
= 1; /* 8+3 aliases are returned in all caps */
2572 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2573 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2574 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2576 /* If the file name in cFileName[] includes `?' characters, it means
2577 the original file name used characters that cannot be represented
2578 by the current ANSI codepage. To avoid total lossage, retrieve
2579 the short 8+3 alias of the long file name. */
2580 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2582 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2583 /* 8+3 aliases are returned in all caps, which could break
2584 various alists that look at filenames' extensions. */
2588 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2589 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2591 _strlwr (dir_static
.d_name
);
2595 for (p
= dir_static
.d_name
; *p
; p
++)
2596 if (*p
>= 'a' && *p
<= 'z')
2599 _strlwr (dir_static
.d_name
);
2606 open_unc_volume (const char *path
)
2612 nr
.dwScope
= RESOURCE_GLOBALNET
;
2613 nr
.dwType
= RESOURCETYPE_DISK
;
2614 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2615 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2616 nr
.lpLocalName
= NULL
;
2617 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2618 nr
.lpComment
= NULL
;
2619 nr
.lpProvider
= NULL
;
2621 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2622 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2624 if (result
== NO_ERROR
)
2627 return INVALID_HANDLE_VALUE
;
2631 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2635 DWORD bufsize
= 512;
2640 buffer
= alloca (bufsize
);
2641 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2642 if (result
!= NO_ERROR
)
2645 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2646 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2648 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2651 strncpy (readbuf
, ptr
, size
);
2656 close_unc_volume (HANDLE henum
)
2658 if (henum
!= INVALID_HANDLE_VALUE
)
2659 WNetCloseEnum (henum
);
2663 unc_volume_file_attributes (const char *path
)
2668 henum
= open_unc_volume (path
);
2669 if (henum
== INVALID_HANDLE_VALUE
)
2672 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2674 close_unc_volume (henum
);
2679 /* Ensure a network connection is authenticated. */
2681 logon_network_drive (const char *path
)
2683 NETRESOURCE resource
;
2684 char share
[MAX_PATH
];
2689 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2690 drvtype
= DRIVE_REMOTE
;
2691 else if (path
[0] == '\0' || path
[1] != ':')
2692 drvtype
= GetDriveType (NULL
);
2699 drvtype
= GetDriveType (drive
);
2702 /* Only logon to networked drives. */
2703 if (drvtype
!= DRIVE_REMOTE
)
2707 strncpy (share
, path
, MAX_PATH
);
2708 /* Truncate to just server and share name. */
2709 for (i
= 2; i
< MAX_PATH
; i
++)
2711 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2718 resource
.dwType
= RESOURCETYPE_DISK
;
2719 resource
.lpLocalName
= NULL
;
2720 resource
.lpRemoteName
= share
;
2721 resource
.lpProvider
= NULL
;
2723 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2726 /* Shadow some MSVC runtime functions to map requests for long filenames
2727 to reasonable short names if necessary. This was originally added to
2728 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2732 sys_access (const char * path
, int mode
)
2736 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
2737 newer versions blow up when passed D_OK. */
2738 path
= map_w32_filename (path
, NULL
);
2739 /* If the last element of PATH is a symlink, we need to resolve it
2740 to get the attributes of its target file. Note: any symlinks in
2741 PATH elements other than the last one are transparently resolved
2742 by GetFileAttributes below. */
2743 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
2744 path
= chase_symlinks (path
);
2746 if ((attributes
= GetFileAttributes (path
)) == -1)
2748 DWORD w32err
= GetLastError ();
2752 case ERROR_INVALID_NAME
:
2753 case ERROR_BAD_PATHNAME
:
2754 if (is_unc_volume (path
))
2756 attributes
= unc_volume_file_attributes (path
);
2757 if (attributes
== -1)
2765 case ERROR_FILE_NOT_FOUND
:
2766 case ERROR_BAD_NETPATH
:
2775 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2780 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2785 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2794 sys_chdir (const char * path
)
2796 return _chdir (map_w32_filename (path
, NULL
));
2800 sys_chmod (const char * path
, int mode
)
2802 path
= chase_symlinks (map_w32_filename (path
, NULL
));
2803 return _chmod (path
, mode
);
2807 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2809 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2815 sys_creat (const char * path
, int mode
)
2817 return _creat (map_w32_filename (path
, NULL
), mode
);
2821 sys_fopen (const char * path
, const char * mode
)
2825 const char * mode_save
= mode
;
2827 /* Force all file handles to be non-inheritable. This is necessary to
2828 ensure child processes don't unwittingly inherit handles that might
2829 prevent future file access. */
2833 else if (mode
[0] == 'w' || mode
[0] == 'a')
2834 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2838 /* Only do simplistic option parsing. */
2842 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2845 else if (mode
[0] == 'b')
2850 else if (mode
[0] == 't')
2857 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2861 return _fdopen (fd
, mode_save
);
2864 /* This only works on NTFS volumes, but is useful to have. */
2866 sys_link (const char * old
, const char * new)
2870 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2872 if (old
== NULL
|| new == NULL
)
2878 strcpy (oldname
, map_w32_filename (old
, NULL
));
2879 strcpy (newname
, map_w32_filename (new, NULL
));
2881 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2882 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2883 if (fileh
!= INVALID_HANDLE_VALUE
)
2887 /* Confusingly, the "alternate" stream name field does not apply
2888 when restoring a hard link, and instead contains the actual
2889 stream data for the link (ie. the name of the link to create).
2890 The WIN32_STREAM_ID structure before the cStreamName field is
2891 the stream header, which is then immediately followed by the
2895 WIN32_STREAM_ID wid
;
2896 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2899 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2900 data
.wid
.cStreamName
, MAX_PATH
);
2903 LPVOID context
= NULL
;
2906 data
.wid
.dwStreamId
= BACKUP_LINK
;
2907 data
.wid
.dwStreamAttributes
= 0;
2908 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2909 data
.wid
.Size
.HighPart
= 0;
2910 data
.wid
.dwStreamNameSize
= 0;
2912 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2913 offsetof (WIN32_STREAM_ID
, cStreamName
)
2914 + data
.wid
.Size
.LowPart
,
2915 &wbytes
, FALSE
, FALSE
, &context
)
2916 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2923 /* Should try mapping GetLastError to errno; for now just
2924 indicate a general error (eg. links not supported). */
2925 errno
= EINVAL
; // perhaps EMLINK?
2929 CloseHandle (fileh
);
2938 sys_mkdir (const char * path
)
2940 return _mkdir (map_w32_filename (path
, NULL
));
2943 /* Because of long name mapping issues, we need to implement this
2944 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2945 a unique name, instead of setting the input template to an empty
2948 Standard algorithm seems to be use pid or tid with a letter on the
2949 front (in place of the 6 X's) and cycle through the letters to find a
2950 unique name. We extend that to allow any reasonable character as the
2951 first of the 6 X's. */
2953 sys_mktemp (char * template)
2957 unsigned uid
= GetCurrentThreadId ();
2958 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2960 if (template == NULL
)
2962 p
= template + strlen (template);
2964 /* replace up to the last 5 X's with uid in decimal */
2965 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2967 p
[0] = '0' + uid
% 10;
2971 if (i
< 0 && p
[0] == 'X')
2976 int save_errno
= errno
;
2977 p
[0] = first_char
[i
];
2978 if (sys_access (template, 0) < 0)
2984 while (++i
< sizeof (first_char
));
2987 /* Template is badly formed or else we can't generate a unique name,
2988 so return empty string */
2994 sys_open (const char * path
, int oflag
, int mode
)
2996 const char* mpath
= map_w32_filename (path
, NULL
);
2997 /* Try to open file without _O_CREAT, to be able to write to hidden
2998 and system files. Force all file handles to be
3000 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3003 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3007 sys_rename (const char * oldname
, const char * newname
)
3010 char temp
[MAX_PATH
];
3014 /* MoveFile on Windows 95 doesn't correctly change the short file name
3015 alias in a number of circumstances (it is not easy to predict when
3016 just by looking at oldname and newname, unfortunately). In these
3017 cases, renaming through a temporary name avoids the problem.
3019 A second problem on Windows 95 is that renaming through a temp name when
3020 newname is uppercase fails (the final long name ends up in
3021 lowercase, although the short alias might be uppercase) UNLESS the
3022 long temp name is not 8.3.
3024 So, on Windows 95 we always rename through a temp name, and we make sure
3025 the temp name has a long extension to ensure correct renaming. */
3027 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3029 /* volume_info is set indirectly by map_w32_filename. */
3030 oldname_dev
= volume_info
.serialnum
;
3032 if (os_subtype
== OS_9X
)
3038 oldname
= map_w32_filename (oldname
, NULL
);
3039 if ((o
= strrchr (oldname
, '\\')))
3042 o
= (char *) oldname
;
3044 if ((p
= strrchr (temp
, '\\')))
3051 /* Force temp name to require a manufactured 8.3 alias - this
3052 seems to make the second rename work properly. */
3053 sprintf (p
, "_.%s.%u", o
, i
);
3055 result
= rename (oldname
, temp
);
3057 /* This loop must surely terminate! */
3058 while (result
< 0 && errno
== EEXIST
);
3063 /* Emulate Unix behavior - newname is deleted if it already exists
3064 (at least if it is a file; don't do this for directories).
3066 Since we mustn't do this if we are just changing the case of the
3067 file name (we would end up deleting the file we are trying to
3068 rename!), we let rename detect if the destination file already
3069 exists - that way we avoid the possible pitfalls of trying to
3070 determine ourselves whether two names really refer to the same
3071 file, which is not always possible in the general case. (Consider
3072 all the permutations of shared or subst'd drives, etc.) */
3074 newname
= map_w32_filename (newname
, NULL
);
3076 /* volume_info is set indirectly by map_w32_filename. */
3077 newname_dev
= volume_info
.serialnum
;
3079 result
= rename (temp
, newname
);
3083 DWORD w32err
= GetLastError ();
3086 && newname_dev
!= oldname_dev
)
3088 /* The implementation of `rename' on Windows does not return
3089 errno = EXDEV when you are moving a directory to a
3090 different storage device (ex. logical disk). It returns
3091 EACCES instead. So here we handle such situations and
3095 if ((attributes
= GetFileAttributes (temp
)) != -1
3096 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3099 else if (errno
== EEXIST
)
3101 if (_chmod (newname
, 0666) != 0)
3103 if (_unlink (newname
) != 0)
3105 result
= rename (temp
, newname
);
3107 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3108 && is_symlink (temp
))
3110 /* This is Windows prohibiting the user from creating a
3111 symlink in another place, since that requires
3121 sys_rmdir (const char * path
)
3123 return _rmdir (map_w32_filename (path
, NULL
));
3127 sys_unlink (const char * path
)
3129 path
= map_w32_filename (path
, NULL
);
3131 /* On Unix, unlink works without write permission. */
3132 _chmod (path
, 0666);
3133 return _unlink (path
);
3136 static FILETIME utc_base_ft
;
3137 static ULONGLONG utc_base
; /* In 100ns units */
3138 static int init
= 0;
3140 #define FILETIME_TO_U64(result, ft) \
3142 ULARGE_INTEGER uiTemp; \
3143 uiTemp.LowPart = (ft).dwLowDateTime; \
3144 uiTemp.HighPart = (ft).dwHighDateTime; \
3145 result = uiTemp.QuadPart; \
3149 initialize_utc_base (void)
3151 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3160 st
.wMilliseconds
= 0;
3162 SystemTimeToFileTime (&st
, &utc_base_ft
);
3163 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3167 convert_time (FILETIME ft
)
3173 initialize_utc_base ();
3177 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3180 FILETIME_TO_U64 (tmp
, ft
);
3181 return (time_t) ((tmp
- utc_base
) / 10000000L);
3185 convert_from_time_t (time_t time
, FILETIME
* pft
)
3191 initialize_utc_base ();
3195 /* time in 100ns units since 1-Jan-1601 */
3196 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3197 pft
->dwHighDateTime
= tmp
.HighPart
;
3198 pft
->dwLowDateTime
= tmp
.LowPart
;
3202 /* No reason to keep this; faking inode values either by hashing or even
3203 using the file index from GetInformationByHandle, is not perfect and
3204 so by default Emacs doesn't use the inode values on Windows.
3205 Instead, we now determine file-truename correctly (except for
3206 possible drive aliasing etc). */
3208 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3210 hashval (const unsigned char * str
)
3215 h
= (h
<< 4) + *str
++;
3221 /* Return the hash value of the canonical pathname, excluding the
3222 drive/UNC header, to get a hopefully unique inode number. */
3224 generate_inode_val (const char * name
)
3226 char fullname
[ MAX_PATH
];
3230 /* Get the truly canonical filename, if it exists. (Note: this
3231 doesn't resolve aliasing due to subst commands, or recognize hard
3233 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3236 parse_root (fullname
, &p
);
3237 /* Normal W32 filesystems are still case insensitive. */
3244 static PSECURITY_DESCRIPTOR
3245 get_file_security_desc_by_handle (HANDLE h
)
3247 PSECURITY_DESCRIPTOR psd
= NULL
;
3249 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3250 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3252 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3253 NULL
, NULL
, NULL
, NULL
, &psd
);
3254 if (err
!= ERROR_SUCCESS
)
3260 static PSECURITY_DESCRIPTOR
3261 get_file_security_desc_by_name (const char *fname
)
3263 PSECURITY_DESCRIPTOR psd
= NULL
;
3265 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3266 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3268 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3270 err
= GetLastError ();
3271 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3275 psd
= xmalloc (sd_len
);
3276 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3288 unsigned n_subauthorities
;
3290 /* Use the last sub-authority value of the RID, the relative
3291 portion of the SID, as user/group ID. */
3292 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3293 if (n_subauthorities
< 1)
3294 return 0; /* the "World" RID */
3295 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3298 /* Caching SID and account values for faster lokup. */
3301 # define FLEXIBLE_ARRAY_MEMBER
3303 # define FLEXIBLE_ARRAY_MEMBER 1
3308 struct w32_id
*next
;
3310 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3313 static struct w32_id
*w32_idlist
;
3316 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3318 struct w32_id
*tail
, *found
;
3320 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3322 if (equal_sid ((PSID
)tail
->sid
, sid
))
3331 strcpy (name
, found
->name
);
3339 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3342 struct w32_id
*new_entry
;
3344 /* We don't want to leave behind stale cache from when Emacs was
3348 sid_len
= get_length_sid (sid
);
3349 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3352 new_entry
->rid
= id
;
3353 strcpy (new_entry
->name
, name
);
3354 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3355 new_entry
->next
= w32_idlist
;
3356 w32_idlist
= new_entry
;
3365 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3366 unsigned *id
, char *nm
, int what
)
3369 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3371 SID_NAME_USE ignore
;
3373 DWORD name_len
= sizeof (name
);
3375 DWORD domain_len
= sizeof (domain
);
3381 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3382 else if (what
== GID
)
3383 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3387 if (!result
|| !is_valid_sid (sid
))
3389 else if (!w32_cached_id (sid
, id
, nm
))
3391 /* If FNAME is a UNC, we need to lookup account on the
3392 specified machine. */
3393 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3394 && fname
[2] != '\0')
3399 for (s
= fname
+ 2, p
= machine
;
3400 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3406 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3407 domain
, &domain_len
, &ignore
)
3408 || name_len
> UNLEN
+1)
3412 *id
= get_rid (sid
);
3414 w32_add_to_cache (sid
, *id
, name
);
3421 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3425 int dflt_usr
= 0, dflt_grp
= 0;
3434 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3436 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3439 /* Consider files to belong to current user/group, if we cannot get
3440 more accurate information. */
3443 st
->st_uid
= dflt_passwd
.pw_uid
;
3444 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3448 st
->st_gid
= dflt_passwd
.pw_gid
;
3449 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3453 /* Return non-zero if NAME is a potentially slow filesystem. */
3455 is_slow_fs (const char *name
)
3460 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3461 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3462 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3463 devtype
= GetDriveType (NULL
); /* use root of current drive */
3466 /* GetDriveType needs the root directory of the drive. */
3467 strncpy (drive_root
, name
, 2);
3468 drive_root
[2] = '\\';
3469 drive_root
[3] = '\0';
3470 devtype
= GetDriveType (drive_root
);
3472 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3475 /* MSVC stat function can't cope with UNC names and has other bugs, so
3476 replace it with our own. This also allows us to calculate consistent
3477 inode values and owner/group without hacks in the main Emacs code. */
3480 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3482 char *name
, *save_name
, *r
;
3483 WIN32_FIND_DATA wfd
;
3485 unsigned __int64 fake_inode
= 0;
3488 int rootdir
= FALSE
;
3489 PSECURITY_DESCRIPTOR psd
= NULL
;
3490 int is_a_symlink
= 0;
3491 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3492 DWORD access_rights
= 0;
3493 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3494 FILETIME ctime
, atime
, wtime
;
3496 if (path
== NULL
|| buf
== NULL
)
3502 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3503 /* Must be valid filename, no wild cards or other invalid
3504 characters. We use _mbspbrk to support multibyte strings that
3505 might look to strpbrk as if they included literal *, ?, and other
3506 characters mentioned below that are disallowed by Windows
3508 if (_mbspbrk (name
, "*?|<>\""))
3514 /* Remove trailing directory separator, unless name is the root
3515 directory of a drive or UNC volume in which case ensure there
3516 is a trailing separator. */
3517 len
= strlen (name
);
3518 name
= strcpy (alloca (len
+ 2), name
);
3520 /* Avoid a somewhat costly call to is_symlink if the filesystem
3521 doesn't support symlinks. */
3522 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3523 is_a_symlink
= is_symlink (name
);
3525 /* Plan A: Open the file and get all the necessary information via
3526 the resulting handle. This solves several issues in one blow:
3528 . retrieves attributes for the target of a symlink, if needed
3529 . gets attributes of root directories and symlinks pointing to
3530 root directories, thus avoiding the need for special-casing
3531 these and detecting them by examining the file-name format
3532 . retrieves more accurate attributes (e.g., non-zero size for
3533 some directories, esp. directories that are junction points)
3534 . correctly resolves "c:/..", "/.." and similar file names
3535 . avoids run-time penalties for 99% of use cases
3537 Plan A is always tried first, unless the user asked not to (but
3538 if the file is a symlink and we need to follow links, we try Plan
3539 A even if the user asked not to).
3541 If Plan A fails, we go to Plan B (below), where various
3542 potentially expensive techniques must be used to handle "special"
3543 files such as UNC volumes etc. */
3544 if (!(NILP (Vw32_get_true_file_attributes
)
3545 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3546 /* Following symlinks requires getting the info by handle. */
3547 || (is_a_symlink
&& follow_symlinks
))
3549 BY_HANDLE_FILE_INFORMATION info
;
3551 if (is_a_symlink
&& !follow_symlinks
)
3552 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3553 /* READ_CONTROL access rights are required to get security info
3554 by handle. But if the OS doesn't support security in the
3555 first place, we don't need to try. */
3556 if (is_windows_9x () != TRUE
)
3557 access_rights
|= READ_CONTROL
;
3559 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3561 /* If CreateFile fails with READ_CONTROL, try again with zero as
3563 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3564 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3566 if (fh
== INVALID_HANDLE_VALUE
)
3567 goto no_true_file_attributes
;
3569 /* This is more accurate in terms of getting the correct number
3570 of links, but is quite slow (it is noticeable when Emacs is
3571 making a list of file name completions). */
3572 if (GetFileInformationByHandle (fh
, &info
))
3574 nlinks
= info
.nNumberOfLinks
;
3575 /* Might as well use file index to fake inode values, but this
3576 is not guaranteed to be unique unless we keep a handle open
3577 all the time (even then there are situations where it is
3578 not unique). Reputedly, there are at most 48 bits of info
3579 (on NTFS, presumably less on FAT). */
3580 fake_inode
= info
.nFileIndexHigh
;
3582 fake_inode
+= info
.nFileIndexLow
;
3583 serialnum
= info
.dwVolumeSerialNumber
;
3584 fs_high
= info
.nFileSizeHigh
;
3585 fs_low
= info
.nFileSizeLow
;
3586 ctime
= info
.ftCreationTime
;
3587 atime
= info
.ftLastAccessTime
;
3588 wtime
= info
.ftLastWriteTime
;
3589 fattrs
= info
.dwFileAttributes
;
3593 /* We don't go to Plan B here, because it's not clear that
3594 it's a good idea. The only known use case where
3595 CreateFile succeeds, but GetFileInformationByHandle fails
3596 (with ERROR_INVALID_FUNCTION) is for character devices
3597 such as NUL, PRN, etc. For these, switching to Plan B is
3598 a net loss, because we lose the character device
3599 attribute returned by GetFileType below (FindFirstFile
3600 doesn't set that bit in the attributes), and the other
3601 fields don't make sense for character devices anyway.
3602 Emacs doesn't really care for non-file entities in the
3603 context of l?stat, so neither do we. */
3605 /* w32err is assigned so one could put a breakpoint here and
3606 examine its value, when GetFileInformationByHandle
3608 DWORD w32err
= GetLastError ();
3612 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3618 /* Test for a symlink before testing for a directory, since
3619 symlinks to directories have the directory bit set, but we
3620 don't want them to appear as directories. */
3621 if (is_a_symlink
&& !follow_symlinks
)
3622 buf
->st_mode
= S_IFLNK
;
3623 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3624 buf
->st_mode
= S_IFDIR
;
3627 DWORD ftype
= GetFileType (fh
);
3631 case FILE_TYPE_DISK
:
3632 buf
->st_mode
= S_IFREG
;
3634 case FILE_TYPE_PIPE
:
3635 buf
->st_mode
= S_IFIFO
;
3637 case FILE_TYPE_CHAR
:
3638 case FILE_TYPE_UNKNOWN
:
3640 buf
->st_mode
= S_IFCHR
;
3643 /* We produce the fallback owner and group data, based on the
3644 current user that runs Emacs, in the following cases:
3646 . this is Windows 9X
3647 . getting security by handle failed, and we need to produce
3648 information for the target of a symlink (this is better
3649 than producing a potentially misleading info about the
3652 If getting security by handle fails, and we don't need to
3653 resolve symlinks, we try getting security by name. */
3654 if (is_windows_9x () != TRUE
)
3655 psd
= get_file_security_desc_by_handle (fh
);
3658 get_file_owner_and_group (psd
, name
, buf
);
3661 else if (is_windows_9x () == TRUE
)
3662 get_file_owner_and_group (NULL
, name
, buf
);
3663 else if (!(is_a_symlink
&& follow_symlinks
))
3665 psd
= get_file_security_desc_by_name (name
);
3666 get_file_owner_and_group (psd
, name
, buf
);
3670 get_file_owner_and_group (NULL
, name
, buf
);
3675 no_true_file_attributes
:
3676 /* Plan B: Either getting a handle on the file failed, or the
3677 caller explicitly asked us to not bother making this
3678 information more accurate.
3680 Implementation note: In Plan B, we never bother to resolve
3681 symlinks, even if we got here because we tried Plan A and
3682 failed. That's because, even if the caller asked for extra
3683 precision by setting Vw32_get_true_file_attributes to t,
3684 resolving symlinks requires acquiring a file handle to the
3685 symlink, which we already know will fail. And if the user
3686 did not ask for extra precision, resolving symlinks will fly
3687 in the face of that request, since the user then wants the
3688 lightweight version of the code. */
3689 rootdir
= (path
>= save_name
+ len
- 1
3690 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3692 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3693 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3694 if (IS_DIRECTORY_SEP (r
[0])
3695 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3698 /* Note: If NAME is a symlink to the root of a UNC volume
3699 (i.e. "\\SERVER"), we will not detect that here, and we will
3700 return data about the symlink as result of FindFirst below.
3701 This is unfortunate, but that marginal use case does not
3702 justify a call to chase_symlinks which would impose a penalty
3703 on all the other use cases. (We get here for symlinks to
3704 roots of UNC volumes because CreateFile above fails for them,
3705 unlike with symlinks to root directories X:\ of drives.) */
3706 if (is_unc_volume (name
))
3708 fattrs
= unc_volume_file_attributes (name
);
3712 ctime
= atime
= wtime
= utc_base_ft
;
3716 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3717 strcat (name
, "\\");
3718 if (GetDriveType (name
) < 2)
3724 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3725 ctime
= atime
= wtime
= utc_base_ft
;
3729 if (IS_DIRECTORY_SEP (name
[len
-1]))
3732 /* (This is hacky, but helps when doing file completions on
3733 network drives.) Optimize by using information available from
3734 active readdir if possible. */
3735 len
= strlen (dir_pathname
);
3736 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3738 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3739 && !(is_a_symlink
&& follow_symlinks
)
3740 && strnicmp (save_name
, dir_pathname
, len
) == 0
3741 && IS_DIRECTORY_SEP (name
[len
])
3742 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3744 /* This was the last entry returned by readdir. */
3745 wfd
= dir_find_data
;
3749 logon_network_drive (name
);
3751 fh
= FindFirstFile (name
, &wfd
);
3752 if (fh
== INVALID_HANDLE_VALUE
)
3759 /* Note: if NAME is a symlink, the information we get from
3760 FindFirstFile is for the symlink, not its target. */
3761 fattrs
= wfd
.dwFileAttributes
;
3762 ctime
= wfd
.ftCreationTime
;
3763 atime
= wfd
.ftLastAccessTime
;
3764 wtime
= wfd
.ftLastWriteTime
;
3765 fs_high
= wfd
.nFileSizeHigh
;
3766 fs_low
= wfd
.nFileSizeLow
;
3769 serialnum
= volume_info
.serialnum
;
3771 if (is_a_symlink
&& !follow_symlinks
)
3772 buf
->st_mode
= S_IFLNK
;
3773 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3774 buf
->st_mode
= S_IFDIR
;
3776 buf
->st_mode
= S_IFREG
;
3778 get_file_owner_and_group (NULL
, name
, buf
);
3782 /* Not sure if there is any point in this. */
3783 if (!NILP (Vw32_generate_fake_inodes
))
3784 fake_inode
= generate_inode_val (name
);
3785 else if (fake_inode
== 0)
3787 /* For want of something better, try to make everything unique. */
3788 static DWORD gen_num
= 0;
3789 fake_inode
= ++gen_num
;
3793 buf
->st_ino
= fake_inode
;
3795 buf
->st_dev
= serialnum
;
3796 buf
->st_rdev
= serialnum
;
3798 buf
->st_size
= fs_high
;
3799 buf
->st_size
<<= 32;
3800 buf
->st_size
+= fs_low
;
3801 buf
->st_nlink
= nlinks
;
3803 /* Convert timestamps to Unix format. */
3804 buf
->st_mtime
= convert_time (wtime
);
3805 buf
->st_atime
= convert_time (atime
);
3806 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3807 buf
->st_ctime
= convert_time (ctime
);
3808 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3810 /* determine rwx permissions */
3811 if (is_a_symlink
&& !follow_symlinks
)
3812 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
3815 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
3816 permission
= S_IREAD
;
3818 permission
= S_IREAD
| S_IWRITE
;
3820 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3821 permission
|= S_IEXEC
;
3822 else if (is_exec (name
))
3823 permission
|= S_IEXEC
;
3826 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3832 stat (const char * path
, struct stat
* buf
)
3834 return stat_worker (path
, buf
, 1);
3838 lstat (const char * path
, struct stat
* buf
)
3840 return stat_worker (path
, buf
, 0);
3843 /* Provide fstat and utime as well as stat for consistent handling of
3846 fstat (int desc
, struct stat
* buf
)
3848 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3849 BY_HANDLE_FILE_INFORMATION info
;
3850 unsigned __int64 fake_inode
;
3853 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3855 case FILE_TYPE_DISK
:
3856 buf
->st_mode
= S_IFREG
;
3857 if (!GetFileInformationByHandle (fh
, &info
))
3863 case FILE_TYPE_PIPE
:
3864 buf
->st_mode
= S_IFIFO
;
3866 case FILE_TYPE_CHAR
:
3867 case FILE_TYPE_UNKNOWN
:
3869 buf
->st_mode
= S_IFCHR
;
3871 memset (&info
, 0, sizeof (info
));
3872 info
.dwFileAttributes
= 0;
3873 info
.ftCreationTime
= utc_base_ft
;
3874 info
.ftLastAccessTime
= utc_base_ft
;
3875 info
.ftLastWriteTime
= utc_base_ft
;
3878 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3879 buf
->st_mode
= S_IFDIR
;
3881 buf
->st_nlink
= info
.nNumberOfLinks
;
3882 /* Might as well use file index to fake inode values, but this
3883 is not guaranteed to be unique unless we keep a handle open
3884 all the time (even then there are situations where it is
3885 not unique). Reputedly, there are at most 48 bits of info
3886 (on NTFS, presumably less on FAT). */
3887 fake_inode
= info
.nFileIndexHigh
;
3889 fake_inode
+= info
.nFileIndexLow
;
3891 /* MSVC defines _ino_t to be short; other libc's might not. */
3892 if (sizeof (buf
->st_ino
) == 2)
3893 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3895 buf
->st_ino
= fake_inode
;
3897 /* Consider files to belong to current user.
3898 FIXME: this should use GetSecurityInfo API, but it is only
3899 available for _WIN32_WINNT >= 0x501. */
3900 buf
->st_uid
= dflt_passwd
.pw_uid
;
3901 buf
->st_gid
= dflt_passwd
.pw_gid
;
3902 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3903 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3905 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3906 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3908 buf
->st_size
= info
.nFileSizeHigh
;
3909 buf
->st_size
<<= 32;
3910 buf
->st_size
+= info
.nFileSizeLow
;
3912 /* Convert timestamps to Unix format. */
3913 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3914 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3915 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3916 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3917 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3919 /* determine rwx permissions */
3920 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3921 permission
= S_IREAD
;
3923 permission
= S_IREAD
| S_IWRITE
;
3925 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3926 permission
|= S_IEXEC
;
3929 #if 0 /* no way of knowing the filename */
3930 char * p
= strrchr (name
, '.');
3932 (xstrcasecmp (p
, ".exe") == 0 ||
3933 xstrcasecmp (p
, ".com") == 0 ||
3934 xstrcasecmp (p
, ".bat") == 0 ||
3935 xstrcasecmp (p
, ".cmd") == 0))
3936 permission
|= S_IEXEC
;
3940 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3946 utime (const char *name
, struct utimbuf
*times
)
3948 struct utimbuf deftime
;
3955 deftime
.modtime
= deftime
.actime
= time (NULL
);
3959 /* Need write access to set times. */
3960 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
3961 /* If NAME specifies a directory, FILE_SHARE_DELETE
3962 allows other processes to delete files inside it,
3963 while we have the directory open. */
3964 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
3965 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3966 if (fh
!= INVALID_HANDLE_VALUE
)
3968 convert_from_time_t (times
->actime
, &atime
);
3969 convert_from_time_t (times
->modtime
, &mtime
);
3970 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3987 /* Symlink-related functions. */
3988 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
3989 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
3993 symlink (char const *filename
, char const *linkname
)
3995 char linkfn
[MAX_PATH
], *tgtfn
;
3997 int dir_access
, filename_ends_in_slash
;
3999 /* Diagnostics follows Posix as much as possible. */
4000 if (filename
== NULL
|| linkname
== NULL
)
4010 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4012 errno
= ENAMETOOLONG
;
4016 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4017 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4023 /* Note: since empty FILENAME was already rejected, we can safely
4024 refer to FILENAME[1]. */
4025 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4027 /* Non-absolute FILENAME is understood as being relative to
4028 LINKNAME's directory. We need to prepend that directory to
4029 FILENAME to get correct results from sys_access below, since
4030 otherwise it will interpret FILENAME relative to the
4031 directory where the Emacs process runs. Note that
4032 make-symbolic-link always makes sure LINKNAME is a fully
4033 expanded file name. */
4035 char *p
= linkfn
+ strlen (linkfn
);
4037 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4040 strncpy (tem
, linkfn
, p
- linkfn
);
4041 tem
[p
- linkfn
] = '\0';
4042 strcat (tem
, filename
);
4043 dir_access
= sys_access (tem
, D_OK
);
4046 dir_access
= sys_access (filename
, D_OK
);
4048 /* Since Windows distinguishes between symlinks to directories and
4049 to files, we provide a kludgy feature: if FILENAME doesn't
4050 exist, but ends in a slash, we create a symlink to directory. If
4051 FILENAME exists and is a directory, we always create a symlink to
4053 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4054 if (dir_access
== 0 || filename_ends_in_slash
)
4055 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4057 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4058 if (filename_ends_in_slash
)
4059 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4062 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4064 /* ENOSYS is set by create_symbolic_link, when it detects that
4065 the OS doesn't support the CreateSymbolicLink API. */
4066 if (errno
!= ENOSYS
)
4068 DWORD w32err
= GetLastError ();
4072 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4073 TGTFN point to the same file name, go figure. */
4075 case ERROR_FILE_EXISTS
:
4078 case ERROR_ACCESS_DENIED
:
4081 case ERROR_FILE_NOT_FOUND
:
4082 case ERROR_PATH_NOT_FOUND
:
4083 case ERROR_BAD_NETPATH
:
4084 case ERROR_INVALID_REPARSE_DATA
:
4087 case ERROR_DIRECTORY
:
4090 case ERROR_PRIVILEGE_NOT_HELD
:
4091 case ERROR_NOT_ALL_ASSIGNED
:
4094 case ERROR_DISK_FULL
:
4107 /* A quick inexpensive test of whether FILENAME identifies a file that
4108 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4109 must already be in the normalized form returned by
4112 Note: for repeated operations on many files, it is best to test
4113 whether the underlying volume actually supports symlinks, by
4114 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4115 avoid the call to this function if it doesn't. That's because the
4116 call to GetFileAttributes takes a non-negligible time, especially
4117 on non-local or removable filesystems. See stat_worker for an
4118 example of how to do that. */
4120 is_symlink (const char *filename
)
4123 WIN32_FIND_DATA wfd
;
4126 attrs
= GetFileAttributes (filename
);
4129 DWORD w32err
= GetLastError ();
4133 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4135 case ERROR_ACCESS_DENIED
:
4138 case ERROR_FILE_NOT_FOUND
:
4139 case ERROR_PATH_NOT_FOUND
:
4146 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4148 logon_network_drive (filename
);
4149 fh
= FindFirstFile (filename
, &wfd
);
4150 if (fh
== INVALID_HANDLE_VALUE
)
4153 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4154 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4157 /* If NAME identifies a symbolic link, copy into BUF the file name of
4158 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4159 null-terminate the target name, even if it fits. Return the number
4160 of bytes copied, or -1 if NAME is not a symlink or any error was
4161 encountered while resolving it. The file name copied into BUF is
4162 encoded in the current ANSI codepage. */
4164 readlink (const char *name
, char *buf
, size_t buf_size
)
4167 TOKEN_PRIVILEGES privs
;
4168 int restore_privs
= 0;
4183 path
= map_w32_filename (name
, NULL
);
4185 if (strlen (path
) > MAX_PATH
)
4187 errno
= ENAMETOOLONG
;
4192 if (is_windows_9x () == TRUE
4193 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4194 || !is_symlink (path
))
4197 errno
= EINVAL
; /* not a symlink */
4201 /* Done with simple tests, now we're in for some _real_ work. */
4202 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4204 /* Implementation note: From here and onward, don't return early,
4205 since that will fail to restore the original set of privileges of
4206 the calling thread. */
4208 retval
= -1; /* not too optimistic, are we? */
4210 /* Note: In the next call to CreateFile, we use zero as the 2nd
4211 argument because, when the symlink is a hidden/system file,
4212 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4213 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4214 and directory symlinks. */
4215 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4216 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4218 if (sh
!= INVALID_HANDLE_VALUE
)
4220 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4221 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4224 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4225 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4228 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4232 /* Copy the link target name, in wide characters, fro
4233 reparse_data, then convert it to multibyte encoding in
4234 the current locale's codepage. */
4236 BYTE lname
[MAX_PATH
];
4239 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4241 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4242 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4244 /* According to MSDN, PrintNameLength does not include the
4245 terminating null character. */
4246 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4247 memcpy (lwname
, lwname_src
, lwname_len
);
4248 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4250 /* FIXME: Should we use the current file-name coding system
4251 instead of the fixed value of the ANSI codepage? */
4252 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4253 lname
, MAX_PATH
, NULL
, NULL
);
4256 /* WideCharToMultiByte failed. */
4257 DWORD w32err1
= GetLastError ();
4261 case ERROR_INSUFFICIENT_BUFFER
:
4262 errno
= ENAMETOOLONG
;
4264 case ERROR_INVALID_PARAMETER
:
4267 case ERROR_NO_UNICODE_TRANSLATION
:
4277 size_t size_to_copy
= buf_size
;
4279 BYTE
*pend
= p
+ lname_len
;
4281 /* Normalize like dostounix_filename does, but we don't
4282 want to assume that lname is null-terminated. */
4283 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4291 /* Testing for null-terminated LNAME is paranoia:
4292 WideCharToMultiByte should always return a
4293 null-terminated string when its 4th argument is -1
4294 and its 3rd argument is null-terminated (which they
4296 if (lname
[lname_len
- 1] == '\0')
4298 if (lname_len
<= buf_size
)
4299 size_to_copy
= lname_len
;
4300 strncpy (buf
, lname
, size_to_copy
);
4302 retval
= size_to_copy
;
4309 /* CreateFile failed. */
4310 DWORD w32err2
= GetLastError ();
4314 case ERROR_FILE_NOT_FOUND
:
4315 case ERROR_PATH_NOT_FOUND
:
4318 case ERROR_ACCESS_DENIED
:
4319 case ERROR_TOO_MANY_OPEN_FILES
:
4329 restore_privilege (&privs
);
4336 /* If FILE is a symlink, return its target (stored in a static
4337 buffer); otherwise return FILE.
4339 This function repeatedly resolves symlinks in the last component of
4340 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4341 until it arrives at a file whose last component is not a symlink,
4342 or some error occurs. It returns the target of the last
4343 successfully resolved symlink in the chain. If it succeeds to
4344 resolve even a single symlink, the value returned is an absolute
4345 file name with backslashes (result of GetFullPathName). By
4346 contrast, if the original FILE is returned, it is unaltered.
4348 Note: This function can set errno even if it succeeds.
4350 Implementation note: we only resolve the last portion ("basename")
4351 of the argument FILE and of each following file in the chain,
4352 disregarding any possible symlinks in its leading directories.
4353 This is because Windows system calls and library functions
4354 transparently resolve symlinks in leading directories and return
4355 correct information, as long as the basename is not a symlink. */
4357 chase_symlinks (const char *file
)
4359 static char target
[MAX_PATH
];
4360 char link
[MAX_PATH
];
4361 ssize_t res
, link_len
;
4364 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4365 return (char *)file
;
4367 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4368 return (char *)file
;
4373 /* Remove trailing slashes, as we want to resolve the last
4374 non-trivial part of the link name. */
4375 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4376 link
[link_len
--] = '\0';
4378 res
= readlink (link
, target
, MAX_PATH
);
4382 if (!(IS_DEVICE_SEP (target
[1])
4383 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4385 /* Target is relative. Append it to the directory part of
4386 the symlink, then copy the result back to target. */
4387 char *p
= link
+ link_len
;
4389 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4392 strcpy (target
, link
);
4394 /* Resolve any "." and ".." to get a fully-qualified file name
4396 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4398 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4400 if (loop_count
> 100)
4403 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4404 return (char *)file
;
4408 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4409 have a fixed max size for file names, so we don't need the kind of
4410 alloc/malloc/realloc dance the gnulib version does. We also don't
4411 support FD-relative symlinks. */
4413 careadlinkat (int fd
, char const *filename
,
4414 char *buffer
, size_t buffer_size
,
4415 struct allocator
const *alloc
,
4416 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4418 char linkname
[MAX_PATH
];
4427 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4431 char *retval
= buffer
;
4433 linkname
[link_size
++] = '\0';
4434 if (link_size
> buffer_size
)
4435 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4437 memcpy (retval
, linkname
, link_size
);
4445 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4449 return readlink (filename
, buffer
, buffer_size
);
4453 /* Support for browsing other processes and their attributes. See
4454 process.c for the Lisp bindings. */
4456 /* Helper wrapper functions. */
4458 static HANDLE WINAPI
4459 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4461 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4463 if (g_b_init_create_toolhelp32_snapshot
== 0)
4465 g_b_init_create_toolhelp32_snapshot
= 1;
4466 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4467 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4468 "CreateToolhelp32Snapshot");
4470 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4472 return INVALID_HANDLE_VALUE
;
4474 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4478 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4480 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4482 if (g_b_init_process32_first
== 0)
4484 g_b_init_process32_first
= 1;
4485 s_pfn_Process32_First
= (Process32First_Proc
)
4486 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4489 if (s_pfn_Process32_First
== NULL
)
4493 return (s_pfn_Process32_First (hSnapshot
, lppe
));
4497 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4499 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
4501 if (g_b_init_process32_next
== 0)
4503 g_b_init_process32_next
= 1;
4504 s_pfn_Process32_Next
= (Process32Next_Proc
)
4505 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4508 if (s_pfn_Process32_Next
== NULL
)
4512 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
4516 open_thread_token (HANDLE ThreadHandle
,
4517 DWORD DesiredAccess
,
4519 PHANDLE TokenHandle
)
4521 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
4522 HMODULE hm_advapi32
= NULL
;
4523 if (is_windows_9x () == TRUE
)
4525 SetLastError (ERROR_NOT_SUPPORTED
);
4528 if (g_b_init_open_thread_token
== 0)
4530 g_b_init_open_thread_token
= 1;
4531 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4532 s_pfn_Open_Thread_Token
=
4533 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
4535 if (s_pfn_Open_Thread_Token
== NULL
)
4537 SetLastError (ERROR_NOT_SUPPORTED
);
4541 s_pfn_Open_Thread_Token (
4550 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
4552 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
4553 HMODULE hm_advapi32
= NULL
;
4554 if (is_windows_9x () == TRUE
)
4558 if (g_b_init_impersonate_self
== 0)
4560 g_b_init_impersonate_self
= 1;
4561 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4562 s_pfn_Impersonate_Self
=
4563 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
4565 if (s_pfn_Impersonate_Self
== NULL
)
4569 return s_pfn_Impersonate_Self (ImpersonationLevel
);
4573 revert_to_self (void)
4575 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
4576 HMODULE hm_advapi32
= NULL
;
4577 if (is_windows_9x () == TRUE
)
4581 if (g_b_init_revert_to_self
== 0)
4583 g_b_init_revert_to_self
= 1;
4584 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4585 s_pfn_Revert_To_Self
=
4586 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
4588 if (s_pfn_Revert_To_Self
== NULL
)
4592 return s_pfn_Revert_To_Self ();
4596 get_process_memory_info (HANDLE h_proc
,
4597 PPROCESS_MEMORY_COUNTERS mem_counters
,
4600 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
4601 HMODULE hm_psapi
= NULL
;
4602 if (is_windows_9x () == TRUE
)
4606 if (g_b_init_get_process_memory_info
== 0)
4608 g_b_init_get_process_memory_info
= 1;
4609 hm_psapi
= LoadLibrary ("Psapi.dll");
4611 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
4612 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
4614 if (s_pfn_Get_Process_Memory_Info
== NULL
)
4618 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
4622 get_process_working_set_size (HANDLE h_proc
,
4626 static GetProcessWorkingSetSize_Proc
4627 s_pfn_Get_Process_Working_Set_Size
= NULL
;
4629 if (is_windows_9x () == TRUE
)
4633 if (g_b_init_get_process_working_set_size
== 0)
4635 g_b_init_get_process_working_set_size
= 1;
4636 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
4637 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4638 "GetProcessWorkingSetSize");
4640 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
4644 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
4648 global_memory_status (MEMORYSTATUS
*buf
)
4650 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
4652 if (is_windows_9x () == TRUE
)
4656 if (g_b_init_global_memory_status
== 0)
4658 g_b_init_global_memory_status
= 1;
4659 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
4660 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4661 "GlobalMemoryStatus");
4663 if (s_pfn_Global_Memory_Status
== NULL
)
4667 return s_pfn_Global_Memory_Status (buf
);
4671 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
4673 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
4675 if (is_windows_9x () == TRUE
)
4679 if (g_b_init_global_memory_status_ex
== 0)
4681 g_b_init_global_memory_status_ex
= 1;
4682 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
4683 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4684 "GlobalMemoryStatusEx");
4686 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
4690 return s_pfn_Global_Memory_Status_Ex (buf
);
4694 list_system_processes (void)
4696 struct gcpro gcpro1
;
4697 Lisp_Object proclist
= Qnil
;
4700 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4702 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4704 PROCESSENTRY32 proc_entry
;
4710 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
4711 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
4712 res
= process32_next (h_snapshot
, &proc_entry
))
4714 proc_id
= proc_entry
.th32ProcessID
;
4715 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
4718 CloseHandle (h_snapshot
);
4720 proclist
= Fnreverse (proclist
);
4727 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
4729 TOKEN_PRIVILEGES priv
;
4730 DWORD priv_size
= sizeof (priv
);
4731 DWORD opriv_size
= sizeof (*old_priv
);
4732 HANDLE h_token
= NULL
;
4733 HANDLE h_thread
= GetCurrentThread ();
4737 res
= open_thread_token (h_thread
,
4738 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4740 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
4742 if (impersonate_self (SecurityImpersonation
))
4743 res
= open_thread_token (h_thread
,
4744 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4749 priv
.PrivilegeCount
= 1;
4750 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
4751 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
4752 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
4753 old_priv
, &opriv_size
)
4754 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4758 CloseHandle (h_token
);
4764 restore_privilege (TOKEN_PRIVILEGES
*priv
)
4766 DWORD priv_size
= sizeof (*priv
);
4767 HANDLE h_token
= NULL
;
4770 if (open_thread_token (GetCurrentThread (),
4771 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4774 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
4775 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4779 CloseHandle (h_token
);
4785 ltime (ULONGLONG time_100ns
)
4787 ULONGLONG time_sec
= time_100ns
/ 10000000;
4788 int subsec
= time_100ns
% 10000000;
4789 return list4 (make_number (time_sec
>> 16),
4790 make_number (time_sec
& 0xffff),
4791 make_number (subsec
/ 10),
4792 make_number (subsec
% 10 * 100000));
4795 #define U64_TO_LISP_TIME(time) ltime (time)
4798 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
4799 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
4802 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
4803 ULONGLONG tem1
, tem2
, tem3
, tem
;
4806 || !get_process_times_fn
4807 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
4808 &ft_kernel
, &ft_user
))
4811 GetSystemTimeAsFileTime (&ft_current
);
4813 FILETIME_TO_U64 (tem1
, ft_kernel
);
4814 *stime
= U64_TO_LISP_TIME (tem1
);
4816 FILETIME_TO_U64 (tem2
, ft_user
);
4817 *utime
= U64_TO_LISP_TIME (tem2
);
4820 *ttime
= U64_TO_LISP_TIME (tem3
);
4822 FILETIME_TO_U64 (tem
, ft_creation
);
4823 /* Process no 4 (System) returns zero creation time. */
4826 *ctime
= U64_TO_LISP_TIME (tem
);
4830 FILETIME_TO_U64 (tem3
, ft_current
);
4831 tem
= (tem3
- utc_base
) - tem
;
4833 *etime
= U64_TO_LISP_TIME (tem
);
4837 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4848 system_process_attributes (Lisp_Object pid
)
4850 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4851 Lisp_Object attrs
= Qnil
;
4852 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4853 HANDLE h_snapshot
, h_proc
;
4856 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4857 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4858 DWORD glength
= sizeof (gname
);
4859 HANDLE token
= NULL
;
4860 SID_NAME_USE user_type
;
4861 unsigned char *buf
= NULL
;
4863 TOKEN_USER user_token
;
4864 TOKEN_PRIMARY_GROUP group_token
;
4867 PROCESS_MEMORY_COUNTERS mem
;
4868 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4869 DWORD minrss
, maxrss
;
4871 MEMORY_STATUS_EX memstex
;
4872 double totphys
= 0.0;
4873 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4875 BOOL result
= FALSE
;
4877 CHECK_NUMBER_OR_FLOAT (pid
);
4878 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4880 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4882 GCPRO3 (attrs
, decoded_cmd
, tem
);
4884 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4889 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4890 for (res
= process32_first (h_snapshot
, &pe
); res
;
4891 res
= process32_next (h_snapshot
, &pe
))
4893 if (proc_id
== pe
.th32ProcessID
)
4896 decoded_cmd
= build_string ("Idle");
4899 /* Decode the command name from locale-specific
4901 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4902 strlen (pe
.szExeFile
));
4904 code_convert_string_norecord (cmd_str
,
4905 Vlocale_coding_system
, 0);
4907 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4908 attrs
= Fcons (Fcons (Qppid
,
4909 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4911 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4913 attrs
= Fcons (Fcons (Qthcount
,
4914 make_fixnum_or_float (pe
.cntThreads
)),
4921 CloseHandle (h_snapshot
);
4930 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4932 /* If we were denied a handle to the process, try again after
4933 enabling the SeDebugPrivilege in our process. */
4936 TOKEN_PRIVILEGES priv_current
;
4938 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4940 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4942 restore_privilege (&priv_current
);
4948 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4951 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4952 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4954 buf
= xmalloc (blen
);
4955 result
= get_token_information (token
, TokenUser
,
4956 (LPVOID
)buf
, blen
, &needed
);
4959 memcpy (&user_token
, buf
, sizeof (user_token
));
4960 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4962 euid
= get_rid (user_token
.User
.Sid
);
4963 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4968 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4971 strcpy (uname
, "unknown");
4975 ulength
= strlen (uname
);
4981 /* Determine a reasonable euid and gid values. */
4982 if (xstrcasecmp ("administrator", uname
) == 0)
4984 euid
= 500; /* well-known Administrator uid */
4985 egid
= 513; /* well-known None gid */
4989 /* Get group id and name. */
4990 result
= get_token_information (token
, TokenPrimaryGroup
,
4991 (LPVOID
)buf
, blen
, &needed
);
4992 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4994 buf
= xrealloc (buf
, blen
= needed
);
4995 result
= get_token_information (token
, TokenPrimaryGroup
,
4996 (LPVOID
)buf
, blen
, &needed
);
5000 memcpy (&group_token
, buf
, sizeof (group_token
));
5001 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5003 egid
= get_rid (group_token
.PrimaryGroup
);
5004 dlength
= sizeof (domain
);
5006 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5007 gname
, &glength
, NULL
, &dlength
,
5010 w32_add_to_cache (group_token
.PrimaryGroup
,
5014 strcpy (gname
, "None");
5018 glength
= strlen (gname
);
5026 if (!is_windows_9x ())
5028 /* We couldn't open the process token, presumably because of
5029 insufficient access rights. Assume this process is run
5031 strcpy (uname
, "SYSTEM");
5032 strcpy (gname
, "None");
5033 euid
= 18; /* SYSTEM */
5034 egid
= 513; /* None */
5035 glength
= strlen (gname
);
5036 ulength
= strlen (uname
);
5038 /* If we are running under Windows 9X, where security calls are
5039 not supported, we assume all processes are run by the current
5041 else if (GetUserName (uname
, &ulength
))
5043 if (xstrcasecmp ("administrator", uname
) == 0)
5048 strcpy (gname
, "None");
5049 glength
= strlen (gname
);
5050 ulength
= strlen (uname
);
5056 strcpy (uname
, "administrator");
5057 ulength
= strlen (uname
);
5058 strcpy (gname
, "None");
5059 glength
= strlen (gname
);
5062 CloseHandle (token
);
5065 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5066 tem
= make_unibyte_string (uname
, ulength
);
5067 attrs
= Fcons (Fcons (Quser
,
5068 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5070 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5071 tem
= make_unibyte_string (gname
, glength
);
5072 attrs
= Fcons (Fcons (Qgroup
,
5073 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5076 if (global_memory_status_ex (&memstex
))
5077 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5078 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5080 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5081 double, so we need to do this for it... */
5083 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5084 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5085 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5087 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5089 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5090 else if (global_memory_status (&memst
))
5091 totphys
= memst
.dwTotalPhys
/ 1024.0;
5094 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5097 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5099 attrs
= Fcons (Fcons (Qmajflt
,
5100 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5102 attrs
= Fcons (Fcons (Qvsize
,
5103 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5105 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5107 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5110 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5112 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5114 attrs
= Fcons (Fcons (Qmajflt
,
5115 make_fixnum_or_float (mem
.PageFaultCount
)),
5117 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5119 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5122 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5124 DWORD rss
= maxrss
/ 1024;
5126 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5128 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5131 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5133 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5134 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5135 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5136 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5137 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5138 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5141 /* FIXME: Retrieve command line by walking the PEB of the process. */
5144 CloseHandle (h_proc
);
5150 /* Wrappers for winsock functions to map between our file descriptors
5151 and winsock's handles; also set h_errno for convenience.
5153 To allow Emacs to run on systems which don't have winsock support
5154 installed, we dynamically link to winsock on startup if present, and
5155 otherwise provide the minimum necessary functionality
5156 (eg. gethostname). */
5158 /* function pointers for relevant socket functions */
5159 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5160 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5161 int (PASCAL
*pfn_WSAGetLastError
) (void);
5162 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5163 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5164 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5165 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5166 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5167 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5168 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5169 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5170 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5171 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5172 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5173 int (PASCAL
*pfn_WSACleanup
) (void);
5175 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5176 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5177 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5178 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5179 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5180 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5181 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5182 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5183 const char * optval
, int optlen
);
5184 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5185 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5187 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5188 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5189 struct sockaddr
* from
, int * fromlen
);
5190 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5191 const struct sockaddr
* to
, int tolen
);
5193 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5194 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5195 #ifndef HANDLE_FLAG_INHERIT
5196 #define HANDLE_FLAG_INHERIT 1
5200 static int winsock_inuse
;
5205 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5207 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5208 after WSAStartup returns successfully, but it seems reasonable
5209 to allow unloading winsock anyway in that case. */
5210 if (pfn_WSACleanup () == 0 ||
5211 pfn_WSAGetLastError () == WSAENETDOWN
)
5213 if (FreeLibrary (winsock_lib
))
5222 init_winsock (int load_now
)
5224 WSADATA winsockData
;
5226 if (winsock_lib
!= NULL
)
5229 pfn_SetHandleInformation
5230 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5231 "SetHandleInformation");
5233 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5235 if (winsock_lib
!= NULL
)
5237 /* dynamically link to socket functions */
5239 #define LOAD_PROC(fn) \
5240 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5243 LOAD_PROC (WSAStartup
);
5244 LOAD_PROC (WSASetLastError
);
5245 LOAD_PROC (WSAGetLastError
);
5246 LOAD_PROC (WSAEventSelect
);
5247 LOAD_PROC (WSACreateEvent
);
5248 LOAD_PROC (WSACloseEvent
);
5251 LOAD_PROC (connect
);
5252 LOAD_PROC (ioctlsocket
);
5255 LOAD_PROC (closesocket
);
5256 LOAD_PROC (shutdown
);
5259 LOAD_PROC (inet_addr
);
5260 LOAD_PROC (gethostname
);
5261 LOAD_PROC (gethostbyname
);
5262 LOAD_PROC (getservbyname
);
5263 LOAD_PROC (getpeername
);
5264 LOAD_PROC (WSACleanup
);
5265 LOAD_PROC (setsockopt
);
5267 LOAD_PROC (getsockname
);
5269 LOAD_PROC (recvfrom
);
5273 /* specify version 1.1 of winsock */
5274 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5276 if (winsockData
.wVersion
!= 0x101)
5281 /* Report that winsock exists and is usable, but leave
5282 socket functions disabled. I am assuming that calling
5283 WSAStartup does not require any network interaction,
5284 and in particular does not cause or require a dial-up
5285 connection to be established. */
5288 FreeLibrary (winsock_lib
);
5296 FreeLibrary (winsock_lib
);
5306 /* function to set h_errno for compatibility; map winsock error codes to
5307 normal system codes where they overlap (non-overlapping definitions
5308 are already in <sys/socket.h> */
5312 if (winsock_lib
== NULL
)
5315 h_errno
= pfn_WSAGetLastError ();
5319 case WSAEACCES
: h_errno
= EACCES
; break;
5320 case WSAEBADF
: h_errno
= EBADF
; break;
5321 case WSAEFAULT
: h_errno
= EFAULT
; break;
5322 case WSAEINTR
: h_errno
= EINTR
; break;
5323 case WSAEINVAL
: h_errno
= EINVAL
; break;
5324 case WSAEMFILE
: h_errno
= EMFILE
; break;
5325 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5326 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5334 if (h_errno
== 0 && winsock_lib
!= NULL
)
5335 pfn_WSASetLastError (0);
5338 /* Extend strerror to handle the winsock-specific error codes. */
5342 } _wsa_errlist
[] = {
5343 {WSAEINTR
, "Interrupted function call"},
5344 {WSAEBADF
, "Bad file descriptor"},
5345 {WSAEACCES
, "Permission denied"},
5346 {WSAEFAULT
, "Bad address"},
5347 {WSAEINVAL
, "Invalid argument"},
5348 {WSAEMFILE
, "Too many open files"},
5350 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5351 {WSAEINPROGRESS
, "Operation now in progress"},
5352 {WSAEALREADY
, "Operation already in progress"},
5353 {WSAENOTSOCK
, "Socket operation on non-socket"},
5354 {WSAEDESTADDRREQ
, "Destination address required"},
5355 {WSAEMSGSIZE
, "Message too long"},
5356 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5357 {WSAENOPROTOOPT
, "Bad protocol option"},
5358 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5359 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5360 {WSAEOPNOTSUPP
, "Operation not supported"},
5361 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5362 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5363 {WSAEADDRINUSE
, "Address already in use"},
5364 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5365 {WSAENETDOWN
, "Network is down"},
5366 {WSAENETUNREACH
, "Network is unreachable"},
5367 {WSAENETRESET
, "Network dropped connection on reset"},
5368 {WSAECONNABORTED
, "Software caused connection abort"},
5369 {WSAECONNRESET
, "Connection reset by peer"},
5370 {WSAENOBUFS
, "No buffer space available"},
5371 {WSAEISCONN
, "Socket is already connected"},
5372 {WSAENOTCONN
, "Socket is not connected"},
5373 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5374 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5375 {WSAETIMEDOUT
, "Connection timed out"},
5376 {WSAECONNREFUSED
, "Connection refused"},
5377 {WSAELOOP
, "Network loop"}, /* not sure */
5378 {WSAENAMETOOLONG
, "Name is too long"},
5379 {WSAEHOSTDOWN
, "Host is down"},
5380 {WSAEHOSTUNREACH
, "No route to host"},
5381 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5382 {WSAEPROCLIM
, "Too many processes"},
5383 {WSAEUSERS
, "Too many users"}, /* not sure */
5384 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5385 {WSAESTALE
, "Data is stale"}, /* not sure */
5386 {WSAEREMOTE
, "Remote error"}, /* not sure */
5388 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5389 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5390 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5391 {WSAEDISCON
, "Graceful shutdown in progress"},
5393 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5394 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5395 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5396 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5397 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5398 {WSASYSCALLFAILURE
, "System call failure"},
5399 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5400 {WSATYPE_NOT_FOUND
, "Class type not found"},
5401 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5402 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5403 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5406 {WSAHOST_NOT_FOUND
, "Host not found"},
5407 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5408 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5409 {WSANO_DATA
, "Valid name, no data record of requested type"},
5415 sys_strerror (int error_no
)
5418 static char unknown_msg
[40];
5420 if (error_no
>= 0 && error_no
< sys_nerr
)
5421 return sys_errlist
[error_no
];
5423 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5424 if (_wsa_errlist
[i
].errnum
== error_no
)
5425 return _wsa_errlist
[i
].msg
;
5427 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5431 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5432 but I believe the method of keeping the socket handle separate (and
5433 insuring it is not inheritable) is the correct one. */
5435 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5437 static int socket_to_fd (SOCKET s
);
5440 sys_socket (int af
, int type
, int protocol
)
5444 if (winsock_lib
== NULL
)
5447 return INVALID_SOCKET
;
5452 /* call the real socket function */
5453 s
= pfn_socket (af
, type
, protocol
);
5455 if (s
!= INVALID_SOCKET
)
5456 return socket_to_fd (s
);
5462 /* Convert a SOCKET to a file descriptor. */
5464 socket_to_fd (SOCKET s
)
5469 /* Although under NT 3.5 _open_osfhandle will accept a socket
5470 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5471 that does not work under NT 3.1. However, we can get the same
5472 effect by using a backdoor function to replace an existing
5473 descriptor handle with the one we want. */
5475 /* allocate a file descriptor (with appropriate flags) */
5476 fd
= _open ("NUL:", _O_RDWR
);
5479 /* Make a non-inheritable copy of the socket handle. Note
5480 that it is possible that sockets aren't actually kernel
5481 handles, which appears to be the case on Windows 9x when
5482 the MS Proxy winsock client is installed. */
5484 /* Apparently there is a bug in NT 3.51 with some service
5485 packs, which prevents using DuplicateHandle to make a
5486 socket handle non-inheritable (causes WSACleanup to
5487 hang). The work-around is to use SetHandleInformation
5488 instead if it is available and implemented. */
5489 if (pfn_SetHandleInformation
)
5491 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5495 HANDLE parent
= GetCurrentProcess ();
5496 HANDLE new_s
= INVALID_HANDLE_VALUE
;
5498 if (DuplicateHandle (parent
,
5504 DUPLICATE_SAME_ACCESS
))
5506 /* It is possible that DuplicateHandle succeeds even
5507 though the socket wasn't really a kernel handle,
5508 because a real handle has the same value. So
5509 test whether the new handle really is a socket. */
5510 long nonblocking
= 0;
5511 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
5513 pfn_closesocket (s
);
5518 CloseHandle (new_s
);
5523 fd_info
[fd
].hnd
= (HANDLE
) s
;
5525 /* set our own internal flags */
5526 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
5532 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5534 /* attach child_process to fd_info */
5535 if (fd_info
[ fd
].cp
!= NULL
)
5537 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
5541 fd_info
[ fd
].cp
= cp
;
5544 winsock_inuse
++; /* count open sockets */
5551 pfn_closesocket (s
);
5557 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
5559 if (winsock_lib
== NULL
)
5562 return SOCKET_ERROR
;
5566 if (fd_info
[s
].flags
& FILE_SOCKET
)
5568 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
5569 if (rc
== SOCKET_ERROR
)
5574 return SOCKET_ERROR
;
5578 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
5580 if (winsock_lib
== NULL
)
5583 return SOCKET_ERROR
;
5587 if (fd_info
[s
].flags
& FILE_SOCKET
)
5589 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
5590 if (rc
== SOCKET_ERROR
)
5595 return SOCKET_ERROR
;
5599 sys_htons (u_short hostshort
)
5601 return (winsock_lib
!= NULL
) ?
5602 pfn_htons (hostshort
) : hostshort
;
5606 sys_ntohs (u_short netshort
)
5608 return (winsock_lib
!= NULL
) ?
5609 pfn_ntohs (netshort
) : netshort
;
5613 sys_inet_addr (const char * cp
)
5615 return (winsock_lib
!= NULL
) ?
5616 pfn_inet_addr (cp
) : INADDR_NONE
;
5620 sys_gethostname (char * name
, int namelen
)
5622 if (winsock_lib
!= NULL
)
5623 return pfn_gethostname (name
, namelen
);
5625 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
5626 return !GetComputerName (name
, (DWORD
*)&namelen
);
5629 return SOCKET_ERROR
;
5633 sys_gethostbyname (const char * name
)
5635 struct hostent
* host
;
5637 if (winsock_lib
== NULL
)
5644 host
= pfn_gethostbyname (name
);
5651 sys_getservbyname (const char * name
, const char * proto
)
5653 struct servent
* serv
;
5655 if (winsock_lib
== NULL
)
5662 serv
= pfn_getservbyname (name
, proto
);
5669 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
5671 if (winsock_lib
== NULL
)
5674 return SOCKET_ERROR
;
5678 if (fd_info
[s
].flags
& FILE_SOCKET
)
5680 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
5681 if (rc
== SOCKET_ERROR
)
5686 return SOCKET_ERROR
;
5690 sys_shutdown (int s
, int how
)
5692 if (winsock_lib
== NULL
)
5695 return SOCKET_ERROR
;
5699 if (fd_info
[s
].flags
& FILE_SOCKET
)
5701 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
5702 if (rc
== SOCKET_ERROR
)
5707 return SOCKET_ERROR
;
5711 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
5713 if (winsock_lib
== NULL
)
5716 return SOCKET_ERROR
;
5720 if (fd_info
[s
].flags
& FILE_SOCKET
)
5722 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
5723 (const char *)optval
, optlen
);
5724 if (rc
== SOCKET_ERROR
)
5729 return SOCKET_ERROR
;
5733 sys_listen (int s
, int backlog
)
5735 if (winsock_lib
== NULL
)
5738 return SOCKET_ERROR
;
5742 if (fd_info
[s
].flags
& FILE_SOCKET
)
5744 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
5745 if (rc
== SOCKET_ERROR
)
5748 fd_info
[s
].flags
|= FILE_LISTEN
;
5752 return SOCKET_ERROR
;
5756 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
5758 if (winsock_lib
== NULL
)
5761 return SOCKET_ERROR
;
5765 if (fd_info
[s
].flags
& FILE_SOCKET
)
5767 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
5768 if (rc
== SOCKET_ERROR
)
5773 return SOCKET_ERROR
;
5777 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
5779 if (winsock_lib
== NULL
)
5786 if (fd_info
[s
].flags
& FILE_LISTEN
)
5788 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
5790 if (t
== INVALID_SOCKET
)
5793 fd
= socket_to_fd (t
);
5795 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5796 ResetEvent (fd_info
[s
].cp
->char_avail
);
5804 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
5805 struct sockaddr
* from
, int * fromlen
)
5807 if (winsock_lib
== NULL
)
5810 return SOCKET_ERROR
;
5814 if (fd_info
[s
].flags
& FILE_SOCKET
)
5816 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
5817 if (rc
== SOCKET_ERROR
)
5822 return SOCKET_ERROR
;
5826 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5827 const struct sockaddr
* to
, int tolen
)
5829 if (winsock_lib
== NULL
)
5832 return SOCKET_ERROR
;
5836 if (fd_info
[s
].flags
& FILE_SOCKET
)
5838 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5839 if (rc
== SOCKET_ERROR
)
5844 return SOCKET_ERROR
;
5847 /* Windows does not have an fcntl function. Provide an implementation
5848 solely for making sockets non-blocking. */
5850 fcntl (int s
, int cmd
, int options
)
5852 if (winsock_lib
== NULL
)
5859 if (fd_info
[s
].flags
& FILE_SOCKET
)
5861 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
5863 unsigned long nblock
= 1;
5864 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5865 if (rc
== SOCKET_ERROR
)
5867 /* Keep track of the fact that we set this to non-blocking. */
5868 fd_info
[s
].flags
|= FILE_NDELAY
;
5874 return SOCKET_ERROR
;
5878 return SOCKET_ERROR
;
5882 /* Shadow main io functions: we need to handle pipes and sockets more
5883 intelligently, and implement non-blocking mode as well. */
5896 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5898 child_process
* cp
= fd_info
[fd
].cp
;
5900 fd_info
[fd
].cp
= NULL
;
5902 if (CHILD_ACTIVE (cp
))
5904 /* if last descriptor to active child_process then cleanup */
5906 for (i
= 0; i
< MAXDESC
; i
++)
5910 if (fd_info
[i
].cp
== cp
)
5915 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5917 if (winsock_lib
== NULL
) emacs_abort ();
5919 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5920 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5922 winsock_inuse
--; /* count open sockets */
5929 /* Note that sockets do not need special treatment here (at least on
5930 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5931 closesocket is equivalent to CloseHandle, which is to be expected
5932 because socket handles are fully fledged kernel handles. */
5935 if (rc
== 0 && fd
< MAXDESC
)
5936 fd_info
[fd
].flags
= 0;
5947 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5949 /* duplicate our internal info as well */
5950 fd_info
[new_fd
] = fd_info
[fd
];
5956 sys_dup2 (int src
, int dst
)
5960 if (dst
< 0 || dst
>= MAXDESC
)
5966 /* make sure we close the destination first if it's a pipe or socket */
5967 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5970 rc
= _dup2 (src
, dst
);
5973 /* duplicate our internal info as well */
5974 fd_info
[dst
] = fd_info
[src
];
5979 /* Unix pipe() has only one arg */
5981 sys_pipe (int * phandles
)
5986 /* make pipe handles non-inheritable; when we spawn a child, we
5987 replace the relevant handle with an inheritable one. Also put
5988 pipes into binary mode; we will do text mode translation ourselves
5990 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5994 /* Protect against overflow, since Windows can open more handles than
5995 our fd_info array has room for. */
5996 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5998 _close (phandles
[0]);
5999 _close (phandles
[1]);
6004 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6005 fd_info
[phandles
[0]].flags
= flags
;
6007 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6008 fd_info
[phandles
[1]].flags
= flags
;
6015 /* Function to do blocking read of one byte, needed to implement
6016 select. It is only allowed on sockets and pipes. */
6018 _sys_read_ahead (int fd
)
6023 if (fd
< 0 || fd
>= MAXDESC
)
6024 return STATUS_READ_ERROR
;
6026 cp
= fd_info
[fd
].cp
;
6028 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6029 return STATUS_READ_ERROR
;
6031 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6032 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6034 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6038 cp
->status
= STATUS_READ_IN_PROGRESS
;
6040 if (fd_info
[fd
].flags
& FILE_PIPE
)
6042 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6044 /* Give subprocess time to buffer some more output for us before
6045 reporting that input is available; we need this because Windows 95
6046 connects DOS programs to pipes by making the pipe appear to be
6047 the normal console stdout - as a result most DOS programs will
6048 write to stdout without buffering, ie. one character at a
6049 time. Even some W32 programs do this - "dir" in a command
6050 shell on NT is very slow if we don't do this. */
6053 int wait
= w32_pipe_read_delay
;
6059 /* Yield remainder of our time slice, effectively giving a
6060 temporary priority boost to the child process. */
6064 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6066 HANDLE hnd
= fd_info
[fd
].hnd
;
6067 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6070 /* Configure timeouts for blocking read. */
6071 if (!GetCommTimeouts (hnd
, &ct
))
6072 return STATUS_READ_ERROR
;
6073 ct
.ReadIntervalTimeout
= 0;
6074 ct
.ReadTotalTimeoutMultiplier
= 0;
6075 ct
.ReadTotalTimeoutConstant
= 0;
6076 if (!SetCommTimeouts (hnd
, &ct
))
6077 return STATUS_READ_ERROR
;
6079 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6081 if (GetLastError () != ERROR_IO_PENDING
)
6082 return STATUS_READ_ERROR
;
6083 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6084 return STATUS_READ_ERROR
;
6087 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6089 unsigned long nblock
= 0;
6090 /* We always want this to block, so temporarily disable NDELAY. */
6091 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6092 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6094 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6096 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6099 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6103 if (rc
== sizeof (char))
6104 cp
->status
= STATUS_READ_SUCCEEDED
;
6106 cp
->status
= STATUS_READ_FAILED
;
6112 _sys_wait_accept (int fd
)
6118 if (fd
< 0 || fd
>= MAXDESC
)
6119 return STATUS_READ_ERROR
;
6121 cp
= fd_info
[fd
].cp
;
6123 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6124 return STATUS_READ_ERROR
;
6126 cp
->status
= STATUS_READ_FAILED
;
6128 hEv
= pfn_WSACreateEvent ();
6129 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6130 if (rc
!= SOCKET_ERROR
)
6132 rc
= WaitForSingleObject (hEv
, INFINITE
);
6133 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6134 if (rc
== WAIT_OBJECT_0
)
6135 cp
->status
= STATUS_READ_SUCCEEDED
;
6137 pfn_WSACloseEvent (hEv
);
6143 sys_read (int fd
, char * buffer
, unsigned int count
)
6148 char * orig_buffer
= buffer
;
6156 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6158 child_process
*cp
= fd_info
[fd
].cp
;
6160 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6168 /* re-read CR carried over from last read */
6169 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6171 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6175 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6178 /* presence of a child_process structure means we are operating in
6179 non-blocking mode - otherwise we just call _read directly.
6180 Note that the child_process structure might be missing because
6181 reap_subprocess has been called; in this case the pipe is
6182 already broken, so calling _read on it is okay. */
6185 int current_status
= cp
->status
;
6187 switch (current_status
)
6189 case STATUS_READ_FAILED
:
6190 case STATUS_READ_ERROR
:
6191 /* report normal EOF if nothing in buffer */
6193 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6196 case STATUS_READ_READY
:
6197 case STATUS_READ_IN_PROGRESS
:
6198 DebPrint (("sys_read called when read is in progress\n"));
6199 errno
= EWOULDBLOCK
;
6202 case STATUS_READ_SUCCEEDED
:
6203 /* consume read-ahead char */
6204 *buffer
++ = cp
->chr
;
6207 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6208 ResetEvent (cp
->char_avail
);
6210 case STATUS_READ_ACKNOWLEDGED
:
6214 DebPrint (("sys_read: bad status %d\n", current_status
));
6219 if (fd_info
[fd
].flags
& FILE_PIPE
)
6221 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6222 to_read
= min (waiting
, (DWORD
) count
);
6225 nchars
+= _read (fd
, buffer
, to_read
);
6227 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6229 HANDLE hnd
= fd_info
[fd
].hnd
;
6230 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6236 /* Configure timeouts for non-blocking read. */
6237 if (!GetCommTimeouts (hnd
, &ct
))
6242 ct
.ReadIntervalTimeout
= MAXDWORD
;
6243 ct
.ReadTotalTimeoutMultiplier
= 0;
6244 ct
.ReadTotalTimeoutConstant
= 0;
6245 if (!SetCommTimeouts (hnd
, &ct
))
6251 if (!ResetEvent (ovl
->hEvent
))
6256 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6258 if (GetLastError () != ERROR_IO_PENDING
)
6263 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6272 else /* FILE_SOCKET */
6274 if (winsock_lib
== NULL
) emacs_abort ();
6276 /* do the equivalent of a non-blocking read */
6277 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6278 if (waiting
== 0 && nchars
== 0)
6280 h_errno
= errno
= EWOULDBLOCK
;
6286 /* always use binary mode for sockets */
6287 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6288 if (res
== SOCKET_ERROR
)
6290 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6291 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6301 int nread
= _read (fd
, buffer
, count
);
6304 else if (nchars
== 0)
6309 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6310 /* Perform text mode translation if required. */
6311 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6313 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6314 /* If buffer contains only CR, return that. To be absolutely
6315 sure we should attempt to read the next char, but in
6316 practice a CR to be followed by LF would not appear by
6317 itself in the buffer. */
6318 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6320 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6326 nchars
= _read (fd
, buffer
, count
);
6331 /* From w32xfns.c */
6332 extern HANDLE interrupt_handle
;
6334 /* For now, don't bother with a non-blocking mode */
6336 sys_write (int fd
, const void * buffer
, unsigned int count
)
6346 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6348 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6354 /* Perform text mode translation if required. */
6355 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6357 char * tmpbuf
= alloca (count
* 2);
6358 unsigned char * src
= (void *)buffer
;
6359 unsigned char * dst
= tmpbuf
;
6364 unsigned char *next
;
6365 /* copy next line or remaining bytes */
6366 next
= _memccpy (dst
, src
, '\n', nbytes
);
6369 /* copied one line ending with '\n' */
6370 int copied
= next
- dst
;
6373 /* insert '\r' before '\n' */
6380 /* copied remaining partial line -> now finished */
6387 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6389 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6390 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6391 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6394 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6396 if (GetLastError () != ERROR_IO_PENDING
)
6401 if (detect_input_pending ())
6402 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6405 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6406 if (active
== WAIT_OBJECT_0
)
6407 { /* User pressed C-g, cancel write, then leave. Don't bother
6408 cleaning up as we may only get stuck in buggy drivers. */
6409 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6414 if (active
== WAIT_OBJECT_0
+ 1
6415 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6422 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6424 unsigned long nblock
= 0;
6425 if (winsock_lib
== NULL
) emacs_abort ();
6427 /* TODO: implement select() properly so non-blocking I/O works. */
6428 /* For now, make sure the write blocks. */
6429 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6430 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6432 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6434 /* Set the socket back to non-blocking if it was before,
6435 for other operations that support it. */
6436 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6439 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6442 if (nchars
== SOCKET_ERROR
)
6444 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6445 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6451 /* Some networked filesystems don't like too large writes, so
6452 break them into smaller chunks. See the Comments section of
6453 the MSDN documentation of WriteFile for details behind the
6454 choice of the value of CHUNK below. See also the thread
6455 http://thread.gmane.org/gmane.comp.version-control.git/145294
6456 in the git mailing list. */
6457 const unsigned char *p
= buffer
;
6458 const unsigned chunk
= 30 * 1024 * 1024;
6463 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6464 int n
= _write (fd
, p
, this_chunk
);
6472 else if (n
< this_chunk
)
6482 /* The Windows CRT functions are "optimized for speed", so they don't
6483 check for timezone and DST changes if they were last called less
6484 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
6485 all Emacs features that repeatedly call time functions (e.g.,
6486 display-time) are in real danger of missing timezone and DST
6487 changes. Calling tzset before each localtime call fixes that. */
6489 sys_localtime (const time_t *t
)
6492 return localtime (t
);
6497 /* Try loading LIBRARY_ID from the file(s) specified in
6498 Vdynamic_library_alist. If the library is loaded successfully,
6499 return the handle of the DLL, and record the filename in the
6500 property :loaded-from of LIBRARY_ID. If the library could not be
6501 found, or when it was already loaded (because the handle is not
6502 recorded anywhere, and so is lost after use), return NULL.
6504 We could also save the handle in :loaded-from, but currently
6505 there's no use case for it. */
6507 w32_delayed_load (Lisp_Object library_id
)
6509 HMODULE library_dll
= NULL
;
6511 CHECK_SYMBOL (library_id
);
6513 if (CONSP (Vdynamic_library_alist
)
6514 && NILP (Fassq (library_id
, Vlibrary_cache
)))
6516 Lisp_Object found
= Qnil
;
6517 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
6520 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
6522 CHECK_STRING_CAR (dlls
);
6523 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
6525 char name
[MAX_PATH
];
6528 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
6529 found
= Fcons (XCAR (dlls
),
6531 /* Possibly truncated */
6532 ? make_specified_string (name
, -1, len
, 1)
6538 Fput (library_id
, QCloaded_from
, found
);
6546 check_windows_init_file (void)
6548 /* A common indication that Emacs is not installed properly is when
6549 it cannot find the Windows installation file. If this file does
6550 not exist in the expected place, tell the user. */
6552 if (!noninteractive
&& !inhibit_window_system
6553 /* Vload_path is not yet initialized when we are loading
6555 && NILP (Vpurify_flag
))
6557 Lisp_Object init_file
;
6560 init_file
= build_string ("term/w32-win");
6561 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
6564 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
6565 char *init_file_name
= SDATA (init_file
);
6566 char *load_path
= SDATA (load_path_print
);
6567 char *buffer
= alloca (1024
6568 + strlen (init_file_name
)
6569 + strlen (load_path
));
6572 "The Emacs Windows initialization file \"%s.el\" "
6573 "could not be found in your Emacs installation. "
6574 "Emacs checked the following directories for this file:\n"
6576 "When Emacs cannot find this file, it usually means that it "
6577 "was not installed properly, or its distribution file was "
6578 "not unpacked properly.\nSee the README.W32 file in the "
6579 "top-level Emacs directory for more information.",
6580 init_file_name
, load_path
);
6583 "Emacs Abort Dialog",
6584 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
6585 /* Use the low-level system abort. */
6596 term_ntproc (int ignored
)
6602 /* shutdown the socket interface if necessary */
6609 init_ntproc (int dumping
)
6611 sigset_t initial_mask
= 0;
6613 /* Initialize the socket interface now if available and requested by
6614 the user by defining PRELOAD_WINSOCK; otherwise loading will be
6615 delayed until open-network-stream is called (w32-has-winsock can
6616 also be used to dynamically load or reload winsock).
6618 Conveniently, init_environment is called before us, so
6619 PRELOAD_WINSOCK can be set in the registry. */
6621 /* Always initialize this correctly. */
6624 if (getenv ("PRELOAD_WINSOCK") != NULL
)
6625 init_winsock (TRUE
);
6627 /* Initial preparation for subprocess support: replace our standard
6628 handles with non-inheritable versions. */
6631 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
6632 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
6633 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
6635 parent
= GetCurrentProcess ();
6637 /* ignore errors when duplicating and closing; typically the
6638 handles will be invalid when running as a gui program. */
6639 DuplicateHandle (parent
,
6640 GetStdHandle (STD_INPUT_HANDLE
),
6645 DUPLICATE_SAME_ACCESS
);
6647 DuplicateHandle (parent
,
6648 GetStdHandle (STD_OUTPUT_HANDLE
),
6653 DUPLICATE_SAME_ACCESS
);
6655 DuplicateHandle (parent
,
6656 GetStdHandle (STD_ERROR_HANDLE
),
6661 DUPLICATE_SAME_ACCESS
);
6667 if (stdin_save
!= INVALID_HANDLE_VALUE
)
6668 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
6670 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
6673 if (stdout_save
!= INVALID_HANDLE_VALUE
)
6674 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
6676 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6679 if (stderr_save
!= INVALID_HANDLE_VALUE
)
6680 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
6682 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6686 /* unfortunately, atexit depends on implementation of malloc */
6687 /* atexit (term_ntproc); */
6690 /* Make sure we start with all signals unblocked. */
6691 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
6692 signal (SIGABRT
, term_ntproc
);
6696 /* determine which drives are fixed, for GetCachedVolumeInformation */
6698 /* GetDriveType must have trailing backslash. */
6699 char drive
[] = "A:\\";
6701 /* Loop over all possible drive letters */
6702 while (*drive
<= 'Z')
6704 /* Record if this drive letter refers to a fixed drive. */
6705 fixed_drives
[DRIVE_INDEX (*drive
)] =
6706 (GetDriveType (drive
) == DRIVE_FIXED
);
6711 /* Reset the volume info cache. */
6712 volume_cache
= NULL
;
6717 shutdown_handler ensures that buffers' autosave files are
6718 up to date when the user logs off, or the system shuts down.
6721 shutdown_handler (DWORD type
)
6723 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
6724 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
6725 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
6726 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
6728 /* Shut down cleanly, making sure autosave files are up to date. */
6729 shut_down_emacs (0, Qnil
);
6732 /* Allow other handlers to handle this signal. */
6737 globals_of_w32 is used to initialize those global variables that
6738 must always be initialized on startup even when the global variable
6739 initialized is non zero (see the function main in emacs.c).
6742 globals_of_w32 (void)
6744 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
6746 get_process_times_fn
= (GetProcessTimes_Proc
)
6747 GetProcAddress (kernel32
, "GetProcessTimes");
6749 DEFSYM (QCloaded_from
, ":loaded-from");
6751 g_b_init_is_windows_9x
= 0;
6752 g_b_init_open_process_token
= 0;
6753 g_b_init_get_token_information
= 0;
6754 g_b_init_lookup_account_sid
= 0;
6755 g_b_init_get_sid_sub_authority
= 0;
6756 g_b_init_get_sid_sub_authority_count
= 0;
6757 g_b_init_get_security_info
= 0;
6758 g_b_init_get_file_security
= 0;
6759 g_b_init_get_security_descriptor_owner
= 0;
6760 g_b_init_get_security_descriptor_group
= 0;
6761 g_b_init_is_valid_sid
= 0;
6762 g_b_init_create_toolhelp32_snapshot
= 0;
6763 g_b_init_process32_first
= 0;
6764 g_b_init_process32_next
= 0;
6765 g_b_init_open_thread_token
= 0;
6766 g_b_init_impersonate_self
= 0;
6767 g_b_init_revert_to_self
= 0;
6768 g_b_init_get_process_memory_info
= 0;
6769 g_b_init_get_process_working_set_size
= 0;
6770 g_b_init_global_memory_status
= 0;
6771 g_b_init_global_memory_status_ex
= 0;
6772 g_b_init_equal_sid
= 0;
6773 g_b_init_copy_sid
= 0;
6774 g_b_init_get_length_sid
= 0;
6775 g_b_init_get_native_system_info
= 0;
6776 g_b_init_get_system_times
= 0;
6777 g_b_init_create_symbolic_link
= 0;
6778 num_of_processors
= 0;
6779 /* The following sets a handler for shutdown notifications for
6780 console apps. This actually applies to Emacs in both console and
6781 GUI modes, since we had to fool windows into thinking emacs is a
6782 console application to get console mode to work. */
6783 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
6785 /* "None" is the default group name on standalone workstations. */
6786 strcpy (dflt_group_name
, "None");
6789 /* For make-serial-process */
6791 serial_open (char *port
)
6797 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
6798 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
6799 if (hnd
== INVALID_HANDLE_VALUE
)
6800 error ("Could not open %s", port
);
6801 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
6803 error ("Could not open %s", port
);
6807 error ("Could not create child process");
6809 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6810 fd_info
[ fd
].hnd
= hnd
;
6811 fd_info
[ fd
].flags
|=
6812 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
6813 if (fd_info
[ fd
].cp
!= NULL
)
6815 error ("fd_info[fd = %d] is already in use", fd
);
6817 fd_info
[ fd
].cp
= cp
;
6818 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6819 if (cp
->ovl_read
.hEvent
== NULL
)
6820 error ("Could not create read event");
6821 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6822 if (cp
->ovl_write
.hEvent
== NULL
)
6823 error ("Could not create write event");
6828 /* For serial-process-configure */
6830 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
6832 Lisp_Object childp2
= Qnil
;
6833 Lisp_Object tem
= Qnil
;
6837 char summary
[4] = "???"; /* This usually becomes "8N1". */
6839 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
6840 error ("Not a serial process");
6841 hnd
= fd_info
[ p
->outfd
].hnd
;
6843 childp2
= Fcopy_sequence (p
->childp
);
6845 /* Initialize timeouts for blocking read and blocking write. */
6846 if (!GetCommTimeouts (hnd
, &ct
))
6847 error ("GetCommTimeouts() failed");
6848 ct
.ReadIntervalTimeout
= 0;
6849 ct
.ReadTotalTimeoutMultiplier
= 0;
6850 ct
.ReadTotalTimeoutConstant
= 0;
6851 ct
.WriteTotalTimeoutMultiplier
= 0;
6852 ct
.WriteTotalTimeoutConstant
= 0;
6853 if (!SetCommTimeouts (hnd
, &ct
))
6854 error ("SetCommTimeouts() failed");
6855 /* Read port attributes and prepare default configuration. */
6856 memset (&dcb
, 0, sizeof (dcb
));
6857 dcb
.DCBlength
= sizeof (DCB
);
6858 if (!GetCommState (hnd
, &dcb
))
6859 error ("GetCommState() failed");
6862 dcb
.fAbortOnError
= FALSE
;
6863 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
6868 /* Configure speed. */
6869 if (!NILP (Fplist_member (contact
, QCspeed
)))
6870 tem
= Fplist_get (contact
, QCspeed
);
6872 tem
= Fplist_get (p
->childp
, QCspeed
);
6874 dcb
.BaudRate
= XINT (tem
);
6875 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
6877 /* Configure bytesize. */
6878 if (!NILP (Fplist_member (contact
, QCbytesize
)))
6879 tem
= Fplist_get (contact
, QCbytesize
);
6881 tem
= Fplist_get (p
->childp
, QCbytesize
);
6883 tem
= make_number (8);
6885 if (XINT (tem
) != 7 && XINT (tem
) != 8)
6886 error (":bytesize must be nil (8), 7, or 8");
6887 dcb
.ByteSize
= XINT (tem
);
6888 summary
[0] = XINT (tem
) + '0';
6889 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
6891 /* Configure parity. */
6892 if (!NILP (Fplist_member (contact
, QCparity
)))
6893 tem
= Fplist_get (contact
, QCparity
);
6895 tem
= Fplist_get (p
->childp
, QCparity
);
6896 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6897 error (":parity must be nil (no parity), `even', or `odd'");
6898 dcb
.fParity
= FALSE
;
6899 dcb
.Parity
= NOPARITY
;
6900 dcb
.fErrorChar
= FALSE
;
6905 else if (EQ (tem
, Qeven
))
6909 dcb
.Parity
= EVENPARITY
;
6910 dcb
.fErrorChar
= TRUE
;
6912 else if (EQ (tem
, Qodd
))
6916 dcb
.Parity
= ODDPARITY
;
6917 dcb
.fErrorChar
= TRUE
;
6919 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6921 /* Configure stopbits. */
6922 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6923 tem
= Fplist_get (contact
, QCstopbits
);
6925 tem
= Fplist_get (p
->childp
, QCstopbits
);
6927 tem
= make_number (1);
6929 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6930 error (":stopbits must be nil (1 stopbit), 1, or 2");
6931 summary
[2] = XINT (tem
) + '0';
6932 if (XINT (tem
) == 1)
6933 dcb
.StopBits
= ONESTOPBIT
;
6934 else if (XINT (tem
) == 2)
6935 dcb
.StopBits
= TWOSTOPBITS
;
6936 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6938 /* Configure flowcontrol. */
6939 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6940 tem
= Fplist_get (contact
, QCflowcontrol
);
6942 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6943 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6944 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6945 dcb
.fOutxCtsFlow
= FALSE
;
6946 dcb
.fOutxDsrFlow
= FALSE
;
6947 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6948 dcb
.fDsrSensitivity
= FALSE
;
6949 dcb
.fTXContinueOnXoff
= FALSE
;
6952 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6953 dcb
.XonChar
= 17; /* Control-Q */
6954 dcb
.XoffChar
= 19; /* Control-S */
6957 /* Already configured. */
6959 else if (EQ (tem
, Qhw
))
6961 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6962 dcb
.fOutxCtsFlow
= TRUE
;
6964 else if (EQ (tem
, Qsw
))
6969 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6971 /* Activate configuration. */
6972 if (!SetCommState (hnd
, &dcb
))
6973 error ("SetCommState() failed");
6975 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6976 pset_childp (p
, childp2
);
6982 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
6987 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
6988 int fd
= process
->infd
;
6992 n
= sys_read (fd
, (char*)buf
, sz
);
6999 if (err
== EWOULDBLOCK
)
7001 /* Set a small timeout. */
7002 timeout
= make_emacs_time (1, 0);
7004 FD_SET ((int)fd
, &fdset
);
7006 /* Use select with the timeout to poll the selector. */
7007 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7011 continue; /* Try again. */
7013 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7014 Also accept select return 0 as an indicator to EAGAIN. */
7015 if (sc
== 0 || errno
== EWOULDBLOCK
)
7018 err
= errno
; /* Other errors are just passed on. */
7021 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7028 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7030 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7031 int fd
= process
->outfd
;
7032 ssize_t n
= sys_write (fd
, buf
, sz
);
7034 /* 0 or more bytes written means everything went fine. */
7038 /* Negative bytes written means we got an error in errno.
7039 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7040 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7041 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7045 #endif /* HAVE_GNUTLS */