1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2013 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, _mbslwr, _mbsrchr, ... */
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 SIZE_T PeakWorkingSetSize
;
107 SIZE_T WorkingSetSize
;
108 SIZE_T QuotaPeakPagedPoolUsage
;
109 SIZE_T QuotaPagedPoolUsage
;
110 SIZE_T QuotaPeakNonPagedPoolUsage
;
111 SIZE_T QuotaNonPagedPoolUsage
;
112 SIZE_T PagefileUsage
;
113 SIZE_T 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 PSIZE_T lpMinimumWorkingSetSize
,
355 PSIZE_T 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 ());
1307 /* Current codepage for encoding file names. */
1308 static int file_name_codepage
;
1310 /* Return the maximum length in bytes of a multibyte character
1311 sequence encoded in the current ANSI codepage. This is required to
1312 correctly walk the encoded file names one character at a time. */
1314 max_filename_mbslen (void)
1316 /* A simple cache to avoid calling GetCPInfo every time we need to
1317 normalize a file name. The file-name encoding is not supposed to
1318 be changed too frequently, if ever. */
1319 static Lisp_Object last_file_name_encoding
;
1320 static int last_max_mbslen
;
1321 Lisp_Object current_encoding
;
1323 current_encoding
= Vfile_name_coding_system
;
1324 if (NILP (current_encoding
))
1325 current_encoding
= Vdefault_file_name_coding_system
;
1327 if (!EQ (last_file_name_encoding
, current_encoding
))
1331 last_file_name_encoding
= current_encoding
;
1332 /* Default to the current ANSI codepage. */
1333 file_name_codepage
= w32_ansi_code_page
;
1334 if (!NILP (current_encoding
))
1336 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1337 char *cp
= NULL
, *end
;
1340 if (strncmp (cpname
, "cp", 2) == 0)
1342 else if (strncmp (cpname
, "windows-", 8) == 0)
1348 cpnum
= strtol (cp
, &end
, 10);
1349 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1350 file_name_codepage
= cpnum
;
1354 if (!file_name_codepage
)
1355 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1357 if (!GetCPInfo (file_name_codepage
, &cp_info
))
1359 file_name_codepage
= CP_ACP
;
1360 if (!GetCPInfo (file_name_codepage
, &cp_info
))
1363 last_max_mbslen
= cp_info
.MaxCharSize
;
1366 return last_max_mbslen
;
1369 /* Normalize filename by converting all path separators to
1370 the specified separator. Also conditionally convert upper
1371 case path name components to lower case. */
1374 normalize_filename (register char *fp
, char path_sep
)
1378 int dbcs_p
= max_filename_mbslen () > 1;
1380 /* Always lower-case drive letters a-z, even if the filesystem
1381 preserves case in filenames.
1382 This is so filenames can be compared by string comparison
1383 functions that are case-sensitive. Even case-preserving filesystems
1384 do not distinguish case in drive letters. */
1386 p2
= CharNextExA (file_name_codepage
, fp
, 0);
1390 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
1396 if (NILP (Vw32_downcase_file_names
))
1400 if (*fp
== '/' || *fp
== '\\')
1405 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1410 sep
= path_sep
; /* convert to this path separator */
1411 elem
= fp
; /* start of current path element */
1414 if (*fp
>= 'a' && *fp
<= 'z')
1415 elem
= 0; /* don't convert this element */
1417 if (*fp
== 0 || *fp
== ':')
1419 sep
= *fp
; /* restore current separator (or 0) */
1420 *fp
= '/'; /* after conversion of this element */
1423 if (*fp
== '/' || *fp
== '\\')
1425 if (elem
&& elem
!= fp
)
1427 *fp
= 0; /* temporary end of string */
1428 _mbslwr (elem
); /* while we convert to lower case */
1430 *fp
= sep
; /* convert (or restore) path separator */
1431 elem
= fp
+ 1; /* next element starts after separator */
1439 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1444 /* Destructively turn backslashes into slashes. */
1446 dostounix_filename (register char *p
)
1448 normalize_filename (p
, '/');
1451 /* Destructively turn slashes into backslashes. */
1453 unixtodos_filename (register char *p
)
1455 normalize_filename (p
, '\\');
1458 /* Remove all CR's that are followed by a LF.
1459 (From msdos.c...probably should figure out a way to share it,
1460 although this code isn't going to ever change.) */
1462 crlf_to_lf (register int n
, register unsigned char *buf
)
1464 unsigned char *np
= buf
;
1465 unsigned char *startp
= buf
;
1466 unsigned char *endp
= buf
+ n
;
1470 while (buf
< endp
- 1)
1474 if (*(++buf
) != 0x0a)
1485 /* Parse the root part of file name, if present. Return length and
1486 optionally store pointer to char after root. */
1488 parse_root (char * name
, char ** pPath
)
1490 char * start
= name
;
1495 /* find the root name of the volume if given */
1496 if (isalpha (name
[0]) && name
[1] == ':')
1498 /* skip past drive specifier */
1500 if (IS_DIRECTORY_SEP (name
[0]))
1503 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1506 int dbcs_p
= max_filename_mbslen () > 1;
1511 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1514 name
= CharNextExA (file_name_codepage
, name
, 0);
1519 if (IS_DIRECTORY_SEP (name
[0]))
1526 return name
- start
;
1529 /* Get long base name for name; name is assumed to be absolute. */
1531 get_long_basename (char * name
, char * buf
, int size
)
1533 WIN32_FIND_DATA find_data
;
1537 /* must be valid filename, no wild cards or other invalid characters */
1538 if (_mbspbrk (name
, "*?|<>\""))
1541 dir_handle
= FindFirstFile (name
, &find_data
);
1542 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1544 if ((len
= strlen (find_data
.cFileName
)) < size
)
1545 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1548 FindClose (dir_handle
);
1553 /* Get long name for file, if possible (assumed to be absolute). */
1555 w32_get_long_filename (char * name
, char * buf
, int size
)
1560 char full
[ MAX_PATH
];
1563 len
= strlen (name
);
1564 if (len
>= MAX_PATH
)
1567 /* Use local copy for destructive modification. */
1568 memcpy (full
, name
, len
+1);
1569 unixtodos_filename (full
);
1571 /* Copy root part verbatim. */
1572 len
= parse_root (full
, &p
);
1573 memcpy (o
, full
, len
);
1578 while (p
!= NULL
&& *p
)
1581 p
= _mbschr (q
, '\\');
1583 len
= get_long_basename (full
, o
, size
);
1606 is_unc_volume (const char *filename
)
1608 const char *ptr
= filename
;
1610 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1613 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1619 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1622 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1625 HKEY hrootkey
= NULL
;
1628 /* Check both the current user and the local machine to see if
1629 we have any resources. */
1631 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1635 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1636 && (lpvalue
= xmalloc (cbData
)) != NULL
1637 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1639 RegCloseKey (hrootkey
);
1645 RegCloseKey (hrootkey
);
1648 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1652 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1653 && (lpvalue
= xmalloc (cbData
)) != NULL
1654 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1656 RegCloseKey (hrootkey
);
1662 RegCloseKey (hrootkey
);
1668 char *get_emacs_configuration (void);
1671 init_environment (char ** argv
)
1673 static const char * const tempdirs
[] = {
1674 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1679 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1681 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1682 temporary files and assume "/tmp" if $TMPDIR is unset, which
1683 will break on DOS/Windows. Refuse to work if we cannot find
1684 a directory, not even "c:/", usable for that purpose. */
1685 for (i
= 0; i
< imax
; i
++)
1687 const char *tmp
= tempdirs
[i
];
1690 tmp
= getenv (tmp
+ 1);
1691 /* Note that `access' can lie to us if the directory resides on a
1692 read-only filesystem, like CD-ROM or a write-protected floppy.
1693 The only way to be really sure is to actually create a file and
1694 see if it succeeds. But I think that's too much to ask. */
1696 /* MSVCRT's _access crashes with D_OK. */
1697 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
1699 char * var
= alloca (strlen (tmp
) + 8);
1700 sprintf (var
, "TMPDIR=%s", tmp
);
1701 _putenv (strdup (var
));
1708 Fcons (build_string ("no usable temporary directories found!!"),
1710 "While setting TMPDIR: ");
1712 /* Check for environment variables and use registry settings if they
1713 don't exist. Fallback on default values where applicable. */
1718 char locale_name
[32];
1719 char default_home
[MAX_PATH
];
1722 static const struct env_entry
1728 /* If the default value is NULL, we will use the value from the
1729 outside environment or the Registry, but will not push the
1730 variable into the Emacs environment if it is defined neither
1731 in the Registry nor in the outside environment. */
1733 {"PRELOAD_WINSOCK", NULL
},
1734 {"emacs_dir", "C:/emacs"},
1735 {"EMACSLOADPATH", NULL
},
1736 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1737 {"EMACSDATA", NULL
},
1738 {"EMACSPATH", NULL
},
1745 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1747 /* We need to copy dflt_envvars[] and work on the copy because we
1748 don't want the dumped Emacs to inherit the values of
1749 environment variables we saw during dumping (which could be on
1750 a different system). The defaults above must be left intact. */
1751 struct env_entry env_vars
[N_ENV_VARS
];
1753 for (i
= 0; i
< N_ENV_VARS
; i
++)
1754 env_vars
[i
] = dflt_envvars
[i
];
1756 /* For backwards compatibility, check if a .emacs file exists in C:/
1757 If not, then we can try to default to the appdata directory under the
1758 user's profile, which is more likely to be writable. */
1759 if (!check_existing ("C:/.emacs"))
1761 HRESULT profile_result
;
1762 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1763 of Windows 95 and NT4 that have not been updated to include
1765 ShGetFolderPath_fn get_folder_path
;
1766 get_folder_path
= (ShGetFolderPath_fn
)
1767 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1769 if (get_folder_path
!= NULL
)
1771 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1774 /* If we can't get the appdata dir, revert to old behavior. */
1775 if (profile_result
== S_OK
)
1777 env_vars
[0].def_value
= default_home
;
1783 /* Get default locale info and use it for LANG. */
1784 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1785 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1786 locale_name
, sizeof (locale_name
)))
1788 for (i
= 0; i
< N_ENV_VARS
; i
++)
1790 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1792 env_vars
[i
].def_value
= locale_name
;
1798 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1800 /* Treat emacs_dir specially: set it unconditionally based on our
1804 char modname
[MAX_PATH
];
1806 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1808 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
1812 if ((p
= _mbsrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1814 char buf
[SET_ENV_BUF_SIZE
];
1817 for (p
= modname
; *p
; p
= CharNext (p
))
1818 if (*p
== '\\') *p
= '/';
1820 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1821 _putenv (strdup (buf
));
1823 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1825 /* FIXME: should use substring of get_emacs_configuration ().
1826 But I don't think the Windows build supports alpha, mips etc
1827 anymore, so have taken the easy option for now. */
1828 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
1829 || xstrcasecmp (p
, "\\AMD64") == 0))
1832 p
= _mbsrchr (modname
, '\\');
1836 p
= _mbsrchr (modname
, '\\');
1837 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1839 char buf
[SET_ENV_BUF_SIZE
];
1842 for (p
= modname
; *p
; p
= CharNext (p
))
1843 if (*p
== '\\') *p
= '/';
1845 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1846 _putenv (strdup (buf
));
1852 for (i
= 0; i
< N_ENV_VARS
; i
++)
1854 if (!getenv (env_vars
[i
].name
))
1858 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1859 /* Also ignore empty environment variables. */
1863 lpval
= env_vars
[i
].def_value
;
1864 dwType
= REG_EXPAND_SZ
;
1866 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
1867 Vdelayed_warnings_list
1868 = Fcons (listn (CONSTYPE_HEAP
, 2,
1869 intern ("initialization"),
1870 build_string ("Setting HOME to C:\\ by default is deprecated")),
1871 Vdelayed_warnings_list
);
1876 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1878 if (dwType
== REG_EXPAND_SZ
)
1879 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1880 else if (dwType
== REG_SZ
)
1881 strcpy (buf1
, lpval
);
1882 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1884 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1886 _putenv (strdup (buf2
));
1896 /* Rebuild system configuration to reflect invoking system. */
1897 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1899 /* Another special case: on NT, the PATH variable is actually named
1900 "Path" although cmd.exe (perhaps NT itself) arranges for
1901 environment variable lookup and setting to be case insensitive.
1902 However, Emacs assumes a fully case sensitive environment, so we
1903 need to change "Path" to "PATH" to match the expectations of
1904 various elisp packages. We do this by the sneaky method of
1905 modifying the string in the C runtime environ entry.
1907 The same applies to COMSPEC. */
1911 for (envp
= environ
; *envp
; envp
++)
1912 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1913 memcpy (*envp
, "PATH=", 5);
1914 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1915 memcpy (*envp
, "COMSPEC=", 8);
1918 /* Remember the initial working directory for getwd. */
1919 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
1920 Does it matter anywhere in Emacs? */
1921 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1925 static char modname
[MAX_PATH
];
1927 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1932 /* Determine if there is a middle mouse button, to allow parse_button
1933 to decide whether right mouse events should be mouse-2 or
1935 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1940 /* Called from expand-file-name when default-directory is not a string. */
1943 emacs_root_dir (void)
1945 static char root_dir
[FILENAME_MAX
];
1948 p
= getenv ("emacs_dir");
1951 strcpy (root_dir
, p
);
1952 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1953 dostounix_filename (root_dir
);
1957 /* We don't have scripts to automatically determine the system configuration
1958 for Emacs before it's compiled, and we don't want to have to make the
1959 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1963 get_emacs_configuration (void)
1965 char *arch
, *oem
, *os
;
1967 static char configuration_buffer
[32];
1969 /* Determine the processor type. */
1970 switch (get_processor_type ())
1973 #ifdef PROCESSOR_INTEL_386
1974 case PROCESSOR_INTEL_386
:
1975 case PROCESSOR_INTEL_486
:
1976 case PROCESSOR_INTEL_PENTIUM
:
1984 #ifdef PROCESSOR_AMD_X8664
1985 case PROCESSOR_AMD_X8664
:
1990 #ifdef PROCESSOR_MIPS_R2000
1991 case PROCESSOR_MIPS_R2000
:
1992 case PROCESSOR_MIPS_R3000
:
1993 case PROCESSOR_MIPS_R4000
:
1998 #ifdef PROCESSOR_ALPHA_21064
1999 case PROCESSOR_ALPHA_21064
:
2009 /* Use the OEM field to reflect the compiler/library combination. */
2011 #define COMPILER_NAME "msvc"
2014 #define COMPILER_NAME "mingw"
2016 #define COMPILER_NAME "unknown"
2019 oem
= COMPILER_NAME
;
2021 switch (osinfo_cache
.dwPlatformId
) {
2022 case VER_PLATFORM_WIN32_NT
:
2024 build_num
= osinfo_cache
.dwBuildNumber
;
2026 case VER_PLATFORM_WIN32_WINDOWS
:
2027 if (osinfo_cache
.dwMinorVersion
== 0) {
2032 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2034 case VER_PLATFORM_WIN32s
:
2035 /* Not supported, should not happen. */
2037 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2045 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
2046 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
2047 get_w32_major_version (), get_w32_minor_version (), build_num
);
2049 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
2052 return configuration_buffer
;
2056 get_emacs_configuration_options (void)
2058 static char *options_buffer
;
2059 char cv
[32]; /* Enough for COMPILER_VERSION. */
2061 cv
, /* To be filled later. */
2065 #ifdef ENABLE_CHECKING
2066 " --enable-checking",
2068 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2069 with a starting space to save work here. */
2071 " --cflags", USER_CFLAGS
,
2074 " --ldflags", USER_LDFLAGS
,
2081 /* Work out the effective configure options for this build. */
2083 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2086 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2088 #define COMPILER_VERSION ""
2092 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2093 return "Error: not enough space for compiler version";
2094 cv
[sizeof (cv
) - 1] = '\0';
2096 for (i
= 0; options
[i
]; i
++)
2097 size
+= strlen (options
[i
]);
2099 options_buffer
= xmalloc (size
+ 1);
2100 options_buffer
[0] = '\0';
2102 for (i
= 0; options
[i
]; i
++)
2103 strcat (options_buffer
, options
[i
]);
2105 return options_buffer
;
2109 #include <sys/timeb.h>
2111 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2113 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2118 tv
->tv_sec
= tb
.time
;
2119 tv
->tv_usec
= tb
.millitm
* 1000L;
2120 /* Implementation note: _ftime sometimes doesn't update the dstflag
2121 according to the new timezone when the system timezone is
2122 changed. We could fix that by using GetSystemTime and
2123 GetTimeZoneInformation, but that doesn't seem necessary, since
2124 Emacs always calls gettimeofday with the 2nd argument NULL (see
2125 current_emacs_time). */
2128 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2129 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2133 /* Emulate fdutimens. */
2135 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2136 TIMESPEC[0] and TIMESPEC[1], respectively.
2137 FD must be either negative -- in which case it is ignored --
2138 or a file descriptor that is open on FILE.
2139 If FD is nonnegative, then FILE can be NULL, which means
2140 use just futimes instead of utimes.
2141 If TIMESPEC is null, FAIL.
2142 Return 0 on success, -1 (setting errno) on failure. */
2145 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2154 if (fd
< 0 && !file
)
2159 ut
.actime
= timespec
[0].tv_sec
;
2160 ut
.modtime
= timespec
[1].tv_sec
;
2162 return _futime (fd
, &ut
);
2164 return _utime (file
, &ut
);
2168 /* ------------------------------------------------------------------------- */
2169 /* IO support and wrapper functions for the Windows API. */
2170 /* ------------------------------------------------------------------------- */
2172 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2173 on network directories, so we handle that case here.
2174 (Ulrich Leodolter, 1/11/95). */
2176 sys_ctime (const time_t *t
)
2178 char *str
= (char *) ctime (t
);
2179 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2182 /* Emulate sleep...we could have done this with a define, but that
2183 would necessitate including windows.h in the files that used it.
2184 This is much easier. */
2186 sys_sleep (int seconds
)
2188 Sleep (seconds
* 1000);
2191 /* Internal MSVC functions for low-level descriptor munging */
2192 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2193 extern int __cdecl
_free_osfhnd (int fd
);
2195 /* parallel array of private info on file handles */
2196 filedesc fd_info
[ MAXDESC
];
2198 typedef struct volume_info_data
{
2199 struct volume_info_data
* next
;
2201 /* time when info was obtained */
2204 /* actual volume info */
2213 /* Global referenced by various functions. */
2214 static volume_info_data volume_info
;
2216 /* Vector to indicate which drives are local and fixed (for which cached
2217 data never expires). */
2218 static BOOL fixed_drives
[26];
2220 /* Consider cached volume information to be stale if older than 10s,
2221 at least for non-local drives. Info for fixed drives is never stale. */
2222 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2223 #define VOLINFO_STILL_VALID( root_dir, info ) \
2224 ( ( isalpha (root_dir[0]) && \
2225 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2226 || GetTickCount () - info->timestamp < 10000 )
2228 /* Cache support functions. */
2230 /* Simple linked list with linear search is sufficient. */
2231 static volume_info_data
*volume_cache
= NULL
;
2233 static volume_info_data
*
2234 lookup_volume_info (char * root_dir
)
2236 volume_info_data
* info
;
2238 for (info
= volume_cache
; info
; info
= info
->next
)
2239 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2245 add_volume_info (char * root_dir
, volume_info_data
* info
)
2247 info
->root_dir
= xstrdup (root_dir
);
2248 info
->next
= volume_cache
;
2249 volume_cache
= info
;
2253 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2254 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2255 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2256 static volume_info_data
*
2257 GetCachedVolumeInformation (char * root_dir
)
2259 volume_info_data
* info
;
2260 char default_root
[ MAX_PATH
];
2262 /* NULL for root_dir means use root from current directory. */
2263 if (root_dir
== NULL
)
2265 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2267 parse_root (default_root
, &root_dir
);
2269 root_dir
= default_root
;
2272 /* Local fixed drives can be cached permanently. Removable drives
2273 cannot be cached permanently, since the volume name and serial
2274 number (if nothing else) can change. Remote drives should be
2275 treated as if they are removable, since there is no sure way to
2276 tell whether they are or not. Also, the UNC association of drive
2277 letters mapped to remote volumes can be changed at any time (even
2278 by other processes) without notice.
2280 As a compromise, so we can benefit from caching info for remote
2281 volumes, we use a simple expiry mechanism to invalidate cache
2282 entries that are more than ten seconds old. */
2285 /* No point doing this, because WNetGetConnection is even slower than
2286 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2287 GetDriveType is about the only call of this type which does not
2288 involve network access, and so is extremely quick). */
2290 /* Map drive letter to UNC if remote. */
2291 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2293 char remote_name
[ 256 ];
2294 char drive
[3] = { root_dir
[0], ':' };
2296 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2298 /* do something */ ;
2302 info
= lookup_volume_info (root_dir
);
2304 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2312 /* Info is not cached, or is stale. */
2313 if (!GetVolumeInformation (root_dir
,
2314 name
, sizeof (name
),
2318 type
, sizeof (type
)))
2321 /* Cache the volume information for future use, overwriting existing
2322 entry if present. */
2325 info
= xmalloc (sizeof (volume_info_data
));
2326 add_volume_info (root_dir
, info
);
2334 info
->name
= xstrdup (name
);
2335 info
->serialnum
= serialnum
;
2336 info
->maxcomp
= maxcomp
;
2337 info
->flags
= flags
;
2338 info
->type
= xstrdup (type
);
2339 info
->timestamp
= GetTickCount ();
2345 /* Get information on the volume where NAME is held; set path pointer to
2346 start of pathname in NAME (past UNC header\volume header if present),
2347 if pPath is non-NULL.
2349 Note: if NAME includes symlinks, the information is for the volume
2350 of the symlink, not of its target. That's because, even though
2351 GetVolumeInformation returns information about the symlink target
2352 of its argument, we only pass the root directory to
2353 GetVolumeInformation, not the full NAME. */
2355 get_volume_info (const char * name
, const char ** pPath
)
2357 char temp
[MAX_PATH
];
2358 char *rootname
= NULL
; /* default to current volume */
2359 volume_info_data
* info
;
2364 /* Find the root name of the volume if given. */
2365 if (isalpha (name
[0]) && name
[1] == ':')
2373 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2377 int dbcs_p
= max_filename_mbslen () > 1;
2382 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2388 const char *p
= name
;
2390 name
= CharNextExA (file_name_codepage
, name
, 0);
2391 memcpy (str
, p
, name
- p
);
2404 info
= GetCachedVolumeInformation (rootname
);
2407 /* Set global referenced by other functions. */
2408 volume_info
= *info
;
2414 /* Determine if volume is FAT format (ie. only supports short 8.3
2415 names); also set path pointer to start of pathname in name, if
2416 pPath is non-NULL. */
2418 is_fat_volume (const char * name
, const char ** pPath
)
2420 if (get_volume_info (name
, pPath
))
2421 return (volume_info
.maxcomp
== 12);
2425 /* Map filename to a valid 8.3 name if necessary.
2426 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2428 map_w32_filename (const char * name
, const char ** pPath
)
2430 static char shortname
[MAX_PATH
];
2431 char * str
= shortname
;
2434 const char * save_name
= name
;
2436 if (strlen (name
) >= MAX_PATH
)
2438 /* Return a filename which will cause callers to fail. */
2439 strcpy (shortname
, "?");
2443 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2445 register int left
= 8; /* maximum number of chars in part */
2446 register int extn
= 0; /* extension added? */
2447 register int dots
= 2; /* maximum number of dots allowed */
2450 *str
++ = *name
++; /* skip past UNC header */
2452 while ((c
= *name
++))
2459 *str
++ = (c
== ':' ? ':' : '\\');
2460 extn
= 0; /* reset extension flags */
2461 dots
= 2; /* max 2 dots */
2462 left
= 8; /* max length 8 for main part */
2467 /* Convert path components of the form .xxx to _xxx,
2468 but leave . and .. as they are. This allows .emacs
2469 to be read as _emacs, for example. */
2473 IS_DIRECTORY_SEP (*name
))
2488 extn
= 1; /* we've got an extension */
2489 left
= 3; /* 3 chars in extension */
2493 /* any embedded dots after the first are converted to _ */
2498 case '#': /* don't lose these, they're important */
2500 str
[-1] = c
; /* replace last character of part */
2505 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2507 dots
= 0; /* started a path component */
2516 strcpy (shortname
, name
);
2517 unixtodos_filename (shortname
);
2521 *pPath
= shortname
+ (path
- save_name
);
2527 is_exec (const char * name
)
2529 char * p
= strrchr (name
, '.');
2532 && (xstrcasecmp (p
, ".exe") == 0 ||
2533 xstrcasecmp (p
, ".com") == 0 ||
2534 xstrcasecmp (p
, ".bat") == 0 ||
2535 xstrcasecmp (p
, ".cmd") == 0));
2538 /* Emulate the Unix directory procedures opendir, closedir,
2539 and readdir. We can't use the procedures supplied in sysdep.c,
2540 so we provide them here. */
2542 struct direct dir_static
; /* simulated directory contents */
2543 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2544 static int dir_is_fat
;
2545 static char dir_pathname
[MAXPATHLEN
+1];
2546 static WIN32_FIND_DATA dir_find_data
;
2548 /* Support shares on a network resource as subdirectories of a read-only
2550 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2551 static HANDLE
open_unc_volume (const char *);
2552 static char *read_unc_volume (HANDLE
, char *, int);
2553 static void close_unc_volume (HANDLE
);
2556 opendir (char *filename
)
2560 /* Opening is done by FindFirstFile. However, a read is inherent to
2561 this operation, so we defer the open until read time. */
2563 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2565 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2568 /* Note: We don't support traversal of UNC volumes via symlinks.
2569 Doing so would mean punishing 99.99% of use cases by resolving
2570 all the possible symlinks in FILENAME, recursively. */
2571 if (is_unc_volume (filename
))
2573 wnet_enum_handle
= open_unc_volume (filename
);
2574 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2578 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2585 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2586 dir_pathname
[MAXPATHLEN
] = '\0';
2587 /* Note: We don't support symlinks to file names on FAT volumes.
2588 Doing so would mean punishing 99.99% of use cases by resolving
2589 all the possible symlinks in FILENAME, recursively. */
2590 dir_is_fat
= is_fat_volume (filename
, NULL
);
2596 closedir (DIR *dirp
)
2598 /* If we have a find-handle open, close it. */
2599 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2601 FindClose (dir_find_handle
);
2602 dir_find_handle
= INVALID_HANDLE_VALUE
;
2604 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2606 close_unc_volume (wnet_enum_handle
);
2607 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2609 xfree ((char *) dirp
);
2615 int downcase
= !NILP (Vw32_downcase_file_names
);
2617 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2619 if (!read_unc_volume (wnet_enum_handle
,
2620 dir_find_data
.cFileName
,
2624 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2625 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2627 char filename
[MAXNAMLEN
+ 3];
2629 int dbcs_p
= max_filename_mbslen () > 1;
2631 strcpy (filename
, dir_pathname
);
2632 ln
= strlen (filename
) - 1;
2635 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2636 strcat (filename
, "\\");
2640 char *end
= filename
+ ln
+ 1;
2641 char *last_char
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
2643 if (!IS_DIRECTORY_SEP (*last_char
))
2644 strcat (filename
, "\\");
2646 strcat (filename
, "*");
2648 /* Note: No need to resolve symlinks in FILENAME, because
2649 FindFirst opens the directory that is the target of a
2651 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2653 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2658 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2662 /* Emacs never uses this value, so don't bother making it match
2663 value returned by stat(). */
2664 dir_static
.d_ino
= 1;
2666 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2668 /* If the file name in cFileName[] includes `?' characters, it means
2669 the original file name used characters that cannot be represented
2670 by the current ANSI codepage. To avoid total lossage, retrieve
2671 the short 8+3 alias of the long file name. */
2672 if (_mbspbrk (dir_static
.d_name
, "?"))
2674 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2675 downcase
= 1; /* 8+3 aliases are returned in all caps */
2677 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2678 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2679 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2681 /* If the file name in cFileName[] includes `?' characters, it means
2682 the original file name used characters that cannot be represented
2683 by the current ANSI codepage. To avoid total lossage, retrieve
2684 the short 8+3 alias of the long file name. */
2685 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2687 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2688 /* 8+3 aliases are returned in all caps, which could break
2689 various alists that look at filenames' extensions. */
2693 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2694 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2696 _mbslwr (dir_static
.d_name
);
2700 int dbcs_p
= max_filename_mbslen () > 1;
2701 for (p
= dir_static
.d_name
; *p
; )
2703 if (*p
>= 'a' && *p
<= 'z')
2706 p
= CharNextExA (file_name_codepage
, p
, 0);
2711 _mbslwr (dir_static
.d_name
);
2718 open_unc_volume (const char *path
)
2724 nr
.dwScope
= RESOURCE_GLOBALNET
;
2725 nr
.dwType
= RESOURCETYPE_DISK
;
2726 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2727 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2728 nr
.lpLocalName
= NULL
;
2729 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2730 nr
.lpComment
= NULL
;
2731 nr
.lpProvider
= NULL
;
2733 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2734 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2736 if (result
== NO_ERROR
)
2739 return INVALID_HANDLE_VALUE
;
2743 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2747 DWORD bufsize
= 512;
2750 int dbcs_p
= max_filename_mbslen () > 1;
2753 buffer
= alloca (bufsize
);
2754 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2755 if (result
!= NO_ERROR
)
2758 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2759 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2762 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2765 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
))
2766 ptr
= CharNextExA (file_name_codepage
, ptr
, 0);
2770 strncpy (readbuf
, ptr
, size
);
2775 close_unc_volume (HANDLE henum
)
2777 if (henum
!= INVALID_HANDLE_VALUE
)
2778 WNetCloseEnum (henum
);
2782 unc_volume_file_attributes (const char *path
)
2787 henum
= open_unc_volume (path
);
2788 if (henum
== INVALID_HANDLE_VALUE
)
2791 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2793 close_unc_volume (henum
);
2798 /* Ensure a network connection is authenticated. */
2800 logon_network_drive (const char *path
)
2802 NETRESOURCE resource
;
2803 char share
[MAX_PATH
];
2810 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2811 drvtype
= DRIVE_REMOTE
;
2812 else if (path
[0] == '\0' || path
[1] != ':')
2813 drvtype
= GetDriveType (NULL
);
2820 drvtype
= GetDriveType (drive
);
2823 /* Only logon to networked drives. */
2824 if (drvtype
!= DRIVE_REMOTE
)
2828 strncpy (share
, path
, MAX_PATH
);
2829 /* Truncate to just server and share name. */
2830 dbcs_p
= max_filename_mbslen () > 1;
2831 for (p
= share
+ 2; *p
&& p
< share
+ MAX_PATH
; )
2833 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
2839 p
= CharNextExA (file_name_codepage
, p
, 0);
2844 resource
.dwType
= RESOURCETYPE_DISK
;
2845 resource
.lpLocalName
= NULL
;
2846 resource
.lpRemoteName
= share
;
2847 resource
.lpProvider
= NULL
;
2849 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2852 /* Shadow some MSVC runtime functions to map requests for long filenames
2853 to reasonable short names if necessary. This was originally added to
2854 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2858 sys_access (const char * path
, int mode
)
2862 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
2863 newer versions blow up when passed D_OK. */
2864 path
= map_w32_filename (path
, NULL
);
2865 /* If the last element of PATH is a symlink, we need to resolve it
2866 to get the attributes of its target file. Note: any symlinks in
2867 PATH elements other than the last one are transparently resolved
2868 by GetFileAttributes below. */
2869 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
2870 path
= chase_symlinks (path
);
2872 if ((attributes
= GetFileAttributes (path
)) == -1)
2874 DWORD w32err
= GetLastError ();
2878 case ERROR_INVALID_NAME
:
2879 case ERROR_BAD_PATHNAME
:
2880 if (is_unc_volume (path
))
2882 attributes
= unc_volume_file_attributes (path
);
2883 if (attributes
== -1)
2891 case ERROR_FILE_NOT_FOUND
:
2892 case ERROR_BAD_NETPATH
:
2901 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2906 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2911 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2920 sys_chdir (const char * path
)
2922 return _chdir (map_w32_filename (path
, NULL
));
2926 sys_chmod (const char * path
, int mode
)
2928 path
= chase_symlinks (map_w32_filename (path
, NULL
));
2929 return _chmod (path
, mode
);
2933 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2935 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2941 sys_creat (const char * path
, int mode
)
2943 return _creat (map_w32_filename (path
, NULL
), mode
);
2947 sys_fopen (const char * path
, const char * mode
)
2951 const char * mode_save
= mode
;
2953 /* Force all file handles to be non-inheritable. This is necessary to
2954 ensure child processes don't unwittingly inherit handles that might
2955 prevent future file access. */
2959 else if (mode
[0] == 'w' || mode
[0] == 'a')
2960 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2964 /* Only do simplistic option parsing. */
2968 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2971 else if (mode
[0] == 'b')
2976 else if (mode
[0] == 't')
2983 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2987 return _fdopen (fd
, mode_save
);
2990 /* This only works on NTFS volumes, but is useful to have. */
2992 sys_link (const char * old
, const char * new)
2996 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2998 if (old
== NULL
|| new == NULL
)
3004 strcpy (oldname
, map_w32_filename (old
, NULL
));
3005 strcpy (newname
, map_w32_filename (new, NULL
));
3007 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3008 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3009 if (fileh
!= INVALID_HANDLE_VALUE
)
3013 /* Confusingly, the "alternate" stream name field does not apply
3014 when restoring a hard link, and instead contains the actual
3015 stream data for the link (ie. the name of the link to create).
3016 The WIN32_STREAM_ID structure before the cStreamName field is
3017 the stream header, which is then immediately followed by the
3021 WIN32_STREAM_ID wid
;
3022 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3025 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3026 data
.wid
.cStreamName
, MAX_PATH
);
3029 LPVOID context
= NULL
;
3032 data
.wid
.dwStreamId
= BACKUP_LINK
;
3033 data
.wid
.dwStreamAttributes
= 0;
3034 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3035 data
.wid
.Size
.HighPart
= 0;
3036 data
.wid
.dwStreamNameSize
= 0;
3038 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3039 offsetof (WIN32_STREAM_ID
, cStreamName
)
3040 + data
.wid
.Size
.LowPart
,
3041 &wbytes
, FALSE
, FALSE
, &context
)
3042 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3049 /* Should try mapping GetLastError to errno; for now just
3050 indicate a general error (eg. links not supported). */
3051 errno
= EINVAL
; // perhaps EMLINK?
3055 CloseHandle (fileh
);
3064 sys_mkdir (const char * path
)
3066 return _mkdir (map_w32_filename (path
, NULL
));
3069 /* Because of long name mapping issues, we need to implement this
3070 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
3071 a unique name, instead of setting the input template to an empty
3074 Standard algorithm seems to be use pid or tid with a letter on the
3075 front (in place of the 6 X's) and cycle through the letters to find a
3076 unique name. We extend that to allow any reasonable character as the
3077 first of the 6 X's. */
3079 sys_mktemp (char * template)
3083 unsigned uid
= GetCurrentThreadId ();
3084 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3086 if (template == NULL
)
3088 p
= template + strlen (template);
3090 /* replace up to the last 5 X's with uid in decimal */
3091 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3093 p
[0] = '0' + uid
% 10;
3097 if (i
< 0 && p
[0] == 'X')
3102 int save_errno
= errno
;
3103 p
[0] = first_char
[i
];
3104 if (sys_access (template, 0) < 0)
3110 while (++i
< sizeof (first_char
));
3113 /* Template is badly formed or else we can't generate a unique name,
3114 so return empty string */
3120 sys_open (const char * path
, int oflag
, int mode
)
3122 const char* mpath
= map_w32_filename (path
, NULL
);
3123 /* Try to open file without _O_CREAT, to be able to write to hidden
3124 and system files. Force all file handles to be
3126 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3128 res
= _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3129 if (res
>= 0 && res
< MAXDESC
)
3130 fd_info
[res
].flags
= 0;
3136 sys_rename (const char * oldname
, const char * newname
)
3139 char temp
[MAX_PATH
];
3143 /* MoveFile on Windows 95 doesn't correctly change the short file name
3144 alias in a number of circumstances (it is not easy to predict when
3145 just by looking at oldname and newname, unfortunately). In these
3146 cases, renaming through a temporary name avoids the problem.
3148 A second problem on Windows 95 is that renaming through a temp name when
3149 newname is uppercase fails (the final long name ends up in
3150 lowercase, although the short alias might be uppercase) UNLESS the
3151 long temp name is not 8.3.
3153 So, on Windows 95 we always rename through a temp name, and we make sure
3154 the temp name has a long extension to ensure correct renaming. */
3156 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3158 /* volume_info is set indirectly by map_w32_filename. */
3159 oldname_dev
= volume_info
.serialnum
;
3161 if (os_subtype
== OS_9X
)
3167 oldname
= map_w32_filename (oldname
, NULL
);
3168 if ((o
= strrchr (oldname
, '\\')))
3171 o
= (char *) oldname
;
3173 if ((p
= strrchr (temp
, '\\')))
3180 /* Force temp name to require a manufactured 8.3 alias - this
3181 seems to make the second rename work properly. */
3182 sprintf (p
, "_.%s.%u", o
, i
);
3184 result
= rename (oldname
, temp
);
3186 /* This loop must surely terminate! */
3187 while (result
< 0 && errno
== EEXIST
);
3192 /* Emulate Unix behavior - newname is deleted if it already exists
3193 (at least if it is a file; don't do this for directories).
3195 Since we mustn't do this if we are just changing the case of the
3196 file name (we would end up deleting the file we are trying to
3197 rename!), we let rename detect if the destination file already
3198 exists - that way we avoid the possible pitfalls of trying to
3199 determine ourselves whether two names really refer to the same
3200 file, which is not always possible in the general case. (Consider
3201 all the permutations of shared or subst'd drives, etc.) */
3203 newname
= map_w32_filename (newname
, NULL
);
3205 /* volume_info is set indirectly by map_w32_filename. */
3206 newname_dev
= volume_info
.serialnum
;
3208 result
= rename (temp
, newname
);
3212 DWORD w32err
= GetLastError ();
3215 && newname_dev
!= oldname_dev
)
3217 /* The implementation of `rename' on Windows does not return
3218 errno = EXDEV when you are moving a directory to a
3219 different storage device (ex. logical disk). It returns
3220 EACCES instead. So here we handle such situations and
3224 if ((attributes
= GetFileAttributes (temp
)) != -1
3225 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3228 else if (errno
== EEXIST
)
3230 if (_chmod (newname
, 0666) != 0)
3232 if (_unlink (newname
) != 0)
3234 result
= rename (temp
, newname
);
3236 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3237 && is_symlink (temp
))
3239 /* This is Windows prohibiting the user from creating a
3240 symlink in another place, since that requires
3250 sys_rmdir (const char * path
)
3252 return _rmdir (map_w32_filename (path
, NULL
));
3256 sys_unlink (const char * path
)
3258 path
= map_w32_filename (path
, NULL
);
3260 /* On Unix, unlink works without write permission. */
3261 _chmod (path
, 0666);
3262 return _unlink (path
);
3265 static FILETIME utc_base_ft
;
3266 static ULONGLONG utc_base
; /* In 100ns units */
3267 static int init
= 0;
3269 #define FILETIME_TO_U64(result, ft) \
3271 ULARGE_INTEGER uiTemp; \
3272 uiTemp.LowPart = (ft).dwLowDateTime; \
3273 uiTemp.HighPart = (ft).dwHighDateTime; \
3274 result = uiTemp.QuadPart; \
3278 initialize_utc_base (void)
3280 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3289 st
.wMilliseconds
= 0;
3291 SystemTimeToFileTime (&st
, &utc_base_ft
);
3292 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3296 convert_time (FILETIME ft
)
3302 initialize_utc_base ();
3306 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3309 FILETIME_TO_U64 (tmp
, ft
);
3310 return (time_t) ((tmp
- utc_base
) / 10000000L);
3314 convert_from_time_t (time_t time
, FILETIME
* pft
)
3320 initialize_utc_base ();
3324 /* time in 100ns units since 1-Jan-1601 */
3325 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3326 pft
->dwHighDateTime
= tmp
.HighPart
;
3327 pft
->dwLowDateTime
= tmp
.LowPart
;
3331 /* No reason to keep this; faking inode values either by hashing or even
3332 using the file index from GetInformationByHandle, is not perfect and
3333 so by default Emacs doesn't use the inode values on Windows.
3334 Instead, we now determine file-truename correctly (except for
3335 possible drive aliasing etc). */
3337 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3339 hashval (const unsigned char * str
)
3344 h
= (h
<< 4) + *str
++;
3350 /* Return the hash value of the canonical pathname, excluding the
3351 drive/UNC header, to get a hopefully unique inode number. */
3353 generate_inode_val (const char * name
)
3355 char fullname
[ MAX_PATH
];
3359 /* Get the truly canonical filename, if it exists. (Note: this
3360 doesn't resolve aliasing due to subst commands, or recognize hard
3362 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3365 parse_root (fullname
, &p
);
3366 /* Normal W32 filesystems are still case insensitive. */
3373 static PSECURITY_DESCRIPTOR
3374 get_file_security_desc_by_handle (HANDLE h
)
3376 PSECURITY_DESCRIPTOR psd
= NULL
;
3378 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3379 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3381 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3382 NULL
, NULL
, NULL
, NULL
, &psd
);
3383 if (err
!= ERROR_SUCCESS
)
3389 static PSECURITY_DESCRIPTOR
3390 get_file_security_desc_by_name (const char *fname
)
3392 PSECURITY_DESCRIPTOR psd
= NULL
;
3394 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3395 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3397 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3399 err
= GetLastError ();
3400 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3404 psd
= xmalloc (sd_len
);
3405 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3417 unsigned n_subauthorities
;
3419 /* Use the last sub-authority value of the RID, the relative
3420 portion of the SID, as user/group ID. */
3421 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3422 if (n_subauthorities
< 1)
3423 return 0; /* the "World" RID */
3424 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3427 /* Caching SID and account values for faster lokup. */
3430 # define FLEXIBLE_ARRAY_MEMBER
3432 # define FLEXIBLE_ARRAY_MEMBER 1
3437 struct w32_id
*next
;
3439 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3442 static struct w32_id
*w32_idlist
;
3445 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3447 struct w32_id
*tail
, *found
;
3449 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3451 if (equal_sid ((PSID
)tail
->sid
, sid
))
3460 strcpy (name
, found
->name
);
3468 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3471 struct w32_id
*new_entry
;
3473 /* We don't want to leave behind stale cache from when Emacs was
3477 sid_len
= get_length_sid (sid
);
3478 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3481 new_entry
->rid
= id
;
3482 strcpy (new_entry
->name
, name
);
3483 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3484 new_entry
->next
= w32_idlist
;
3485 w32_idlist
= new_entry
;
3494 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3497 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3499 SID_NAME_USE ignore
;
3501 DWORD name_len
= sizeof (name
);
3503 DWORD domain_len
= sizeof (domain
);
3508 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3509 else if (what
== GID
)
3510 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3514 if (!result
|| !is_valid_sid (sid
))
3516 else if (!w32_cached_id (sid
, id
, nm
))
3518 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3519 domain
, &domain_len
, &ignore
)
3520 || name_len
> UNLEN
+1)
3524 *id
= get_rid (sid
);
3526 w32_add_to_cache (sid
, *id
, name
);
3533 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3535 int dflt_usr
= 0, dflt_grp
= 0;
3544 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3546 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3549 /* Consider files to belong to current user/group, if we cannot get
3550 more accurate information. */
3553 st
->st_uid
= dflt_passwd
.pw_uid
;
3554 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3558 st
->st_gid
= dflt_passwd
.pw_gid
;
3559 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3563 /* Return non-zero if NAME is a potentially slow filesystem. */
3565 is_slow_fs (const char *name
)
3570 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3571 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3572 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3573 devtype
= GetDriveType (NULL
); /* use root of current drive */
3576 /* GetDriveType needs the root directory of the drive. */
3577 strncpy (drive_root
, name
, 2);
3578 drive_root
[2] = '\\';
3579 drive_root
[3] = '\0';
3580 devtype
= GetDriveType (drive_root
);
3582 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3585 /* MSVC stat function can't cope with UNC names and has other bugs, so
3586 replace it with our own. This also allows us to calculate consistent
3587 inode values and owner/group without hacks in the main Emacs code. */
3590 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3592 char *name
, *save_name
, *r
;
3593 WIN32_FIND_DATA wfd
;
3595 unsigned __int64 fake_inode
= 0;
3598 int rootdir
= FALSE
;
3599 PSECURITY_DESCRIPTOR psd
= NULL
;
3600 int is_a_symlink
= 0;
3601 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3602 DWORD access_rights
= 0;
3603 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3604 FILETIME ctime
, atime
, wtime
;
3607 if (path
== NULL
|| buf
== NULL
)
3613 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3614 /* Must be valid filename, no wild cards or other invalid
3615 characters. We use _mbspbrk to support multibyte strings that
3616 might look to strpbrk as if they included literal *, ?, and other
3617 characters mentioned below that are disallowed by Windows
3619 if (_mbspbrk (name
, "*?|<>\""))
3625 /* Remove trailing directory separator, unless name is the root
3626 directory of a drive or UNC volume in which case ensure there
3627 is a trailing separator. */
3628 len
= strlen (name
);
3629 name
= strcpy (alloca (len
+ 2), name
);
3631 /* Avoid a somewhat costly call to is_symlink if the filesystem
3632 doesn't support symlinks. */
3633 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3634 is_a_symlink
= is_symlink (name
);
3636 /* Plan A: Open the file and get all the necessary information via
3637 the resulting handle. This solves several issues in one blow:
3639 . retrieves attributes for the target of a symlink, if needed
3640 . gets attributes of root directories and symlinks pointing to
3641 root directories, thus avoiding the need for special-casing
3642 these and detecting them by examining the file-name format
3643 . retrieves more accurate attributes (e.g., non-zero size for
3644 some directories, esp. directories that are junction points)
3645 . correctly resolves "c:/..", "/.." and similar file names
3646 . avoids run-time penalties for 99% of use cases
3648 Plan A is always tried first, unless the user asked not to (but
3649 if the file is a symlink and we need to follow links, we try Plan
3650 A even if the user asked not to).
3652 If Plan A fails, we go to Plan B (below), where various
3653 potentially expensive techniques must be used to handle "special"
3654 files such as UNC volumes etc. */
3655 if (!(NILP (Vw32_get_true_file_attributes
)
3656 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3657 /* Following symlinks requires getting the info by handle. */
3658 || (is_a_symlink
&& follow_symlinks
))
3660 BY_HANDLE_FILE_INFORMATION info
;
3662 if (is_a_symlink
&& !follow_symlinks
)
3663 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3664 /* READ_CONTROL access rights are required to get security info
3665 by handle. But if the OS doesn't support security in the
3666 first place, we don't need to try. */
3667 if (is_windows_9x () != TRUE
)
3668 access_rights
|= READ_CONTROL
;
3670 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3672 /* If CreateFile fails with READ_CONTROL, try again with zero as
3674 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3675 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3677 if (fh
== INVALID_HANDLE_VALUE
)
3678 goto no_true_file_attributes
;
3680 /* This is more accurate in terms of getting the correct number
3681 of links, but is quite slow (it is noticeable when Emacs is
3682 making a list of file name completions). */
3683 if (GetFileInformationByHandle (fh
, &info
))
3685 nlinks
= info
.nNumberOfLinks
;
3686 /* Might as well use file index to fake inode values, but this
3687 is not guaranteed to be unique unless we keep a handle open
3688 all the time (even then there are situations where it is
3689 not unique). Reputedly, there are at most 48 bits of info
3690 (on NTFS, presumably less on FAT). */
3691 fake_inode
= info
.nFileIndexHigh
;
3693 fake_inode
+= info
.nFileIndexLow
;
3694 serialnum
= info
.dwVolumeSerialNumber
;
3695 fs_high
= info
.nFileSizeHigh
;
3696 fs_low
= info
.nFileSizeLow
;
3697 ctime
= info
.ftCreationTime
;
3698 atime
= info
.ftLastAccessTime
;
3699 wtime
= info
.ftLastWriteTime
;
3700 fattrs
= info
.dwFileAttributes
;
3704 /* We don't go to Plan B here, because it's not clear that
3705 it's a good idea. The only known use case where
3706 CreateFile succeeds, but GetFileInformationByHandle fails
3707 (with ERROR_INVALID_FUNCTION) is for character devices
3708 such as NUL, PRN, etc. For these, switching to Plan B is
3709 a net loss, because we lose the character device
3710 attribute returned by GetFileType below (FindFirstFile
3711 doesn't set that bit in the attributes), and the other
3712 fields don't make sense for character devices anyway.
3713 Emacs doesn't really care for non-file entities in the
3714 context of l?stat, so neither do we. */
3716 /* w32err is assigned so one could put a breakpoint here and
3717 examine its value, when GetFileInformationByHandle
3719 DWORD w32err
= GetLastError ();
3723 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3729 /* Test for a symlink before testing for a directory, since
3730 symlinks to directories have the directory bit set, but we
3731 don't want them to appear as directories. */
3732 if (is_a_symlink
&& !follow_symlinks
)
3733 buf
->st_mode
= S_IFLNK
;
3734 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3735 buf
->st_mode
= S_IFDIR
;
3738 DWORD ftype
= GetFileType (fh
);
3742 case FILE_TYPE_DISK
:
3743 buf
->st_mode
= S_IFREG
;
3745 case FILE_TYPE_PIPE
:
3746 buf
->st_mode
= S_IFIFO
;
3748 case FILE_TYPE_CHAR
:
3749 case FILE_TYPE_UNKNOWN
:
3751 buf
->st_mode
= S_IFCHR
;
3754 /* We produce the fallback owner and group data, based on the
3755 current user that runs Emacs, in the following cases:
3757 . this is Windows 9X
3758 . getting security by handle failed, and we need to produce
3759 information for the target of a symlink (this is better
3760 than producing a potentially misleading info about the
3763 If getting security by handle fails, and we don't need to
3764 resolve symlinks, we try getting security by name. */
3765 if (is_windows_9x () != TRUE
)
3766 psd
= get_file_security_desc_by_handle (fh
);
3769 get_file_owner_and_group (psd
, buf
);
3772 else if (is_windows_9x () == TRUE
)
3773 get_file_owner_and_group (NULL
, buf
);
3774 else if (!(is_a_symlink
&& follow_symlinks
))
3776 psd
= get_file_security_desc_by_name (name
);
3777 get_file_owner_and_group (psd
, buf
);
3781 get_file_owner_and_group (NULL
, buf
);
3786 no_true_file_attributes
:
3787 /* Plan B: Either getting a handle on the file failed, or the
3788 caller explicitly asked us to not bother making this
3789 information more accurate.
3791 Implementation note: In Plan B, we never bother to resolve
3792 symlinks, even if we got here because we tried Plan A and
3793 failed. That's because, even if the caller asked for extra
3794 precision by setting Vw32_get_true_file_attributes to t,
3795 resolving symlinks requires acquiring a file handle to the
3796 symlink, which we already know will fail. And if the user
3797 did not ask for extra precision, resolving symlinks will fly
3798 in the face of that request, since the user then wants the
3799 lightweight version of the code. */
3800 dbcs_p
= max_filename_mbslen () > 1;
3801 rootdir
= (path
>= save_name
+ len
- 1
3802 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3804 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3805 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3806 if (IS_DIRECTORY_SEP (r
[0])
3807 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3810 /* Note: If NAME is a symlink to the root of a UNC volume
3811 (i.e. "\\SERVER"), we will not detect that here, and we will
3812 return data about the symlink as result of FindFirst below.
3813 This is unfortunate, but that marginal use case does not
3814 justify a call to chase_symlinks which would impose a penalty
3815 on all the other use cases. (We get here for symlinks to
3816 roots of UNC volumes because CreateFile above fails for them,
3817 unlike with symlinks to root directories X:\ of drives.) */
3818 if (is_unc_volume (name
))
3820 fattrs
= unc_volume_file_attributes (name
);
3824 ctime
= atime
= wtime
= utc_base_ft
;
3830 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3831 strcat (name
, "\\");
3835 char *end
= name
+ len
;
3836 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
3838 if (!IS_DIRECTORY_SEP (*n
))
3839 strcat (name
, "\\");
3841 if (GetDriveType (name
) < 2)
3847 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3848 ctime
= atime
= wtime
= utc_base_ft
;
3854 if (IS_DIRECTORY_SEP (name
[len
-1]))
3859 char *end
= name
+ len
;
3860 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
3862 if (IS_DIRECTORY_SEP (*n
))
3866 /* (This is hacky, but helps when doing file completions on
3867 network drives.) Optimize by using information available from
3868 active readdir if possible. */
3869 len
= strlen (dir_pathname
);
3872 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3877 char *end
= dir_pathname
+ len
;
3878 char *n
= CharPrevExA (file_name_codepage
, dir_pathname
, end
, 0);
3880 if (IS_DIRECTORY_SEP (*n
))
3883 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3884 && !(is_a_symlink
&& follow_symlinks
)
3885 && strnicmp (save_name
, dir_pathname
, len
) == 0
3886 && IS_DIRECTORY_SEP (name
[len
])
3887 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3889 /* This was the last entry returned by readdir. */
3890 wfd
= dir_find_data
;
3894 logon_network_drive (name
);
3896 fh
= FindFirstFile (name
, &wfd
);
3897 if (fh
== INVALID_HANDLE_VALUE
)
3904 /* Note: if NAME is a symlink, the information we get from
3905 FindFirstFile is for the symlink, not its target. */
3906 fattrs
= wfd
.dwFileAttributes
;
3907 ctime
= wfd
.ftCreationTime
;
3908 atime
= wfd
.ftLastAccessTime
;
3909 wtime
= wfd
.ftLastWriteTime
;
3910 fs_high
= wfd
.nFileSizeHigh
;
3911 fs_low
= wfd
.nFileSizeLow
;
3914 serialnum
= volume_info
.serialnum
;
3916 if (is_a_symlink
&& !follow_symlinks
)
3917 buf
->st_mode
= S_IFLNK
;
3918 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3919 buf
->st_mode
= S_IFDIR
;
3921 buf
->st_mode
= S_IFREG
;
3923 get_file_owner_and_group (NULL
, buf
);
3927 /* Not sure if there is any point in this. */
3928 if (!NILP (Vw32_generate_fake_inodes
))
3929 fake_inode
= generate_inode_val (name
);
3930 else if (fake_inode
== 0)
3932 /* For want of something better, try to make everything unique. */
3933 static DWORD gen_num
= 0;
3934 fake_inode
= ++gen_num
;
3938 buf
->st_ino
= fake_inode
;
3940 buf
->st_dev
= serialnum
;
3941 buf
->st_rdev
= serialnum
;
3943 buf
->st_size
= fs_high
;
3944 buf
->st_size
<<= 32;
3945 buf
->st_size
+= fs_low
;
3946 buf
->st_nlink
= nlinks
;
3948 /* Convert timestamps to Unix format. */
3949 buf
->st_mtime
= convert_time (wtime
);
3950 buf
->st_atime
= convert_time (atime
);
3951 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3952 buf
->st_ctime
= convert_time (ctime
);
3953 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3955 /* determine rwx permissions */
3956 if (is_a_symlink
&& !follow_symlinks
)
3957 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
3960 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
3961 permission
= S_IREAD
;
3963 permission
= S_IREAD
| S_IWRITE
;
3965 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3966 permission
|= S_IEXEC
;
3967 else if (is_exec (name
))
3968 permission
|= S_IEXEC
;
3971 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3977 stat (const char * path
, struct stat
* buf
)
3979 return stat_worker (path
, buf
, 1);
3983 lstat (const char * path
, struct stat
* buf
)
3985 return stat_worker (path
, buf
, 0);
3988 /* Provide fstat and utime as well as stat for consistent handling of
3991 fstat (int desc
, struct stat
* buf
)
3993 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3994 BY_HANDLE_FILE_INFORMATION info
;
3995 unsigned __int64 fake_inode
;
3998 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4000 case FILE_TYPE_DISK
:
4001 buf
->st_mode
= S_IFREG
;
4002 if (!GetFileInformationByHandle (fh
, &info
))
4008 case FILE_TYPE_PIPE
:
4009 buf
->st_mode
= S_IFIFO
;
4011 case FILE_TYPE_CHAR
:
4012 case FILE_TYPE_UNKNOWN
:
4014 buf
->st_mode
= S_IFCHR
;
4016 memset (&info
, 0, sizeof (info
));
4017 info
.dwFileAttributes
= 0;
4018 info
.ftCreationTime
= utc_base_ft
;
4019 info
.ftLastAccessTime
= utc_base_ft
;
4020 info
.ftLastWriteTime
= utc_base_ft
;
4023 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4024 buf
->st_mode
= S_IFDIR
;
4026 buf
->st_nlink
= info
.nNumberOfLinks
;
4027 /* Might as well use file index to fake inode values, but this
4028 is not guaranteed to be unique unless we keep a handle open
4029 all the time (even then there are situations where it is
4030 not unique). Reputedly, there are at most 48 bits of info
4031 (on NTFS, presumably less on FAT). */
4032 fake_inode
= info
.nFileIndexHigh
;
4034 fake_inode
+= info
.nFileIndexLow
;
4036 /* MSVC defines _ino_t to be short; other libc's might not. */
4037 if (sizeof (buf
->st_ino
) == 2)
4038 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4040 buf
->st_ino
= fake_inode
;
4042 /* Consider files to belong to current user.
4043 FIXME: this should use GetSecurityInfo API, but it is only
4044 available for _WIN32_WINNT >= 0x501. */
4045 buf
->st_uid
= dflt_passwd
.pw_uid
;
4046 buf
->st_gid
= dflt_passwd
.pw_gid
;
4047 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
4048 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
4050 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4051 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4053 buf
->st_size
= info
.nFileSizeHigh
;
4054 buf
->st_size
<<= 32;
4055 buf
->st_size
+= info
.nFileSizeLow
;
4057 /* Convert timestamps to Unix format. */
4058 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4059 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4060 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4061 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4062 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4064 /* determine rwx permissions */
4065 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4066 permission
= S_IREAD
;
4068 permission
= S_IREAD
| S_IWRITE
;
4070 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4071 permission
|= S_IEXEC
;
4074 #if 0 /* no way of knowing the filename */
4075 char * p
= strrchr (name
, '.');
4077 (xstrcasecmp (p
, ".exe") == 0 ||
4078 xstrcasecmp (p
, ".com") == 0 ||
4079 xstrcasecmp (p
, ".bat") == 0 ||
4080 xstrcasecmp (p
, ".cmd") == 0))
4081 permission
|= S_IEXEC
;
4085 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4091 utime (const char *name
, struct utimbuf
*times
)
4093 struct utimbuf deftime
;
4100 deftime
.modtime
= deftime
.actime
= time (NULL
);
4104 /* Need write access to set times. */
4105 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
4106 /* If NAME specifies a directory, FILE_SHARE_DELETE
4107 allows other processes to delete files inside it,
4108 while we have the directory open. */
4109 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4110 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4111 if (fh
!= INVALID_HANDLE_VALUE
)
4113 convert_from_time_t (times
->actime
, &atime
);
4114 convert_from_time_t (times
->modtime
, &mtime
);
4115 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4132 /* Symlink-related functions. */
4133 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4134 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4138 symlink (char const *filename
, char const *linkname
)
4140 char linkfn
[MAX_PATH
], *tgtfn
;
4142 int dir_access
, filename_ends_in_slash
;
4145 /* Diagnostics follows Posix as much as possible. */
4146 if (filename
== NULL
|| linkname
== NULL
)
4156 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4158 errno
= ENAMETOOLONG
;
4162 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4163 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4169 dbcs_p
= max_filename_mbslen () > 1;
4171 /* Note: since empty FILENAME was already rejected, we can safely
4172 refer to FILENAME[1]. */
4173 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4175 /* Non-absolute FILENAME is understood as being relative to
4176 LINKNAME's directory. We need to prepend that directory to
4177 FILENAME to get correct results from sys_access below, since
4178 otherwise it will interpret FILENAME relative to the
4179 directory where the Emacs process runs. Note that
4180 make-symbolic-link always makes sure LINKNAME is a fully
4181 expanded file name. */
4183 char *p
= linkfn
+ strlen (linkfn
);
4187 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4192 char *p1
= CharPrevExA (file_name_codepage
, linkfn
, p
, 0);
4194 while (p
> linkfn
&& !IS_ANY_SEP (*p1
))
4197 p1
= CharPrevExA (file_name_codepage
, linkfn
, p1
, 0);
4201 strncpy (tem
, linkfn
, p
- linkfn
);
4202 tem
[p
- linkfn
] = '\0';
4203 strcat (tem
, filename
);
4204 dir_access
= sys_access (tem
, D_OK
);
4207 dir_access
= sys_access (filename
, D_OK
);
4209 /* Since Windows distinguishes between symlinks to directories and
4210 to files, we provide a kludgy feature: if FILENAME doesn't
4211 exist, but ends in a slash, we create a symlink to directory. If
4212 FILENAME exists and is a directory, we always create a symlink to
4215 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4218 const char *end
= filename
+ strlen (filename
);
4219 const char *n
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
4221 filename_ends_in_slash
= IS_DIRECTORY_SEP (*n
);
4223 if (dir_access
== 0 || filename_ends_in_slash
)
4224 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4226 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4227 if (filename_ends_in_slash
)
4228 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4231 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4233 /* ENOSYS is set by create_symbolic_link, when it detects that
4234 the OS doesn't support the CreateSymbolicLink API. */
4235 if (errno
!= ENOSYS
)
4237 DWORD w32err
= GetLastError ();
4241 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4242 TGTFN point to the same file name, go figure. */
4244 case ERROR_FILE_EXISTS
:
4247 case ERROR_ACCESS_DENIED
:
4250 case ERROR_FILE_NOT_FOUND
:
4251 case ERROR_PATH_NOT_FOUND
:
4252 case ERROR_BAD_NETPATH
:
4253 case ERROR_INVALID_REPARSE_DATA
:
4256 case ERROR_DIRECTORY
:
4259 case ERROR_PRIVILEGE_NOT_HELD
:
4260 case ERROR_NOT_ALL_ASSIGNED
:
4263 case ERROR_DISK_FULL
:
4276 /* A quick inexpensive test of whether FILENAME identifies a file that
4277 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4278 must already be in the normalized form returned by
4281 Note: for repeated operations on many files, it is best to test
4282 whether the underlying volume actually supports symlinks, by
4283 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4284 avoid the call to this function if it doesn't. That's because the
4285 call to GetFileAttributes takes a non-negligible time, especially
4286 on non-local or removable filesystems. See stat_worker for an
4287 example of how to do that. */
4289 is_symlink (const char *filename
)
4292 WIN32_FIND_DATA wfd
;
4295 attrs
= GetFileAttributes (filename
);
4298 DWORD w32err
= GetLastError ();
4302 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4304 case ERROR_ACCESS_DENIED
:
4307 case ERROR_FILE_NOT_FOUND
:
4308 case ERROR_PATH_NOT_FOUND
:
4315 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4317 logon_network_drive (filename
);
4318 fh
= FindFirstFile (filename
, &wfd
);
4319 if (fh
== INVALID_HANDLE_VALUE
)
4322 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4323 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4326 /* If NAME identifies a symbolic link, copy into BUF the file name of
4327 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4328 null-terminate the target name, even if it fits. Return the number
4329 of bytes copied, or -1 if NAME is not a symlink or any error was
4330 encountered while resolving it. The file name copied into BUF is
4331 encoded in the current ANSI codepage. */
4333 readlink (const char *name
, char *buf
, size_t buf_size
)
4336 TOKEN_PRIVILEGES privs
;
4337 int restore_privs
= 0;
4352 path
= map_w32_filename (name
, NULL
);
4354 if (strlen (path
) > MAX_PATH
)
4356 errno
= ENAMETOOLONG
;
4361 if (is_windows_9x () == TRUE
4362 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4363 || !is_symlink (path
))
4366 errno
= EINVAL
; /* not a symlink */
4370 /* Done with simple tests, now we're in for some _real_ work. */
4371 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4373 /* Implementation note: From here and onward, don't return early,
4374 since that will fail to restore the original set of privileges of
4375 the calling thread. */
4377 retval
= -1; /* not too optimistic, are we? */
4379 /* Note: In the next call to CreateFile, we use zero as the 2nd
4380 argument because, when the symlink is a hidden/system file,
4381 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4382 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4383 and directory symlinks. */
4384 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4385 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4387 if (sh
!= INVALID_HANDLE_VALUE
)
4389 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4390 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4393 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4394 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4397 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4401 /* Copy the link target name, in wide characters, fro
4402 reparse_data, then convert it to multibyte encoding in
4403 the current locale's codepage. */
4405 BYTE lname
[MAX_PATH
];
4408 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4410 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4411 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4412 /* This updates file_name_codepage which we need below. */
4413 int dbcs_p
= max_filename_mbslen () > 1;
4415 /* According to MSDN, PrintNameLength does not include the
4416 terminating null character. */
4417 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4418 memcpy (lwname
, lwname_src
, lwname_len
);
4419 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4421 lname_len
= WideCharToMultiByte (file_name_codepage
, 0, lwname
, -1,
4422 lname
, MAX_PATH
, NULL
, NULL
);
4425 /* WideCharToMultiByte failed. */
4426 DWORD w32err1
= GetLastError ();
4430 case ERROR_INSUFFICIENT_BUFFER
:
4431 errno
= ENAMETOOLONG
;
4433 case ERROR_INVALID_PARAMETER
:
4436 case ERROR_NO_UNICODE_TRANSLATION
:
4446 size_t size_to_copy
= buf_size
;
4447 BYTE
*p
= lname
, *p2
;
4448 BYTE
*pend
= p
+ lname_len
;
4450 /* Normalize like dostounix_filename does, but we don't
4451 want to assume that lname is null-terminated. */
4453 p2
= CharNextExA (file_name_codepage
, p
, 0);
4456 if (*p
&& *p2
== ':' && *p
>= 'A' && *p
<= 'Z')
4467 p
= CharNextExA (file_name_codepage
, p
, 0);
4468 /* CharNextExA doesn't advance at null character. */
4475 /* Testing for null-terminated LNAME is paranoia:
4476 WideCharToMultiByte should always return a
4477 null-terminated string when its 4th argument is -1
4478 and its 3rd argument is null-terminated (which they
4480 if (lname
[lname_len
- 1] == '\0')
4482 if (lname_len
<= buf_size
)
4483 size_to_copy
= lname_len
;
4484 strncpy (buf
, lname
, size_to_copy
);
4486 retval
= size_to_copy
;
4493 /* CreateFile failed. */
4494 DWORD w32err2
= GetLastError ();
4498 case ERROR_FILE_NOT_FOUND
:
4499 case ERROR_PATH_NOT_FOUND
:
4502 case ERROR_ACCESS_DENIED
:
4503 case ERROR_TOO_MANY_OPEN_FILES
:
4513 restore_privilege (&privs
);
4520 /* If FILE is a symlink, return its target (stored in a static
4521 buffer); otherwise return FILE.
4523 This function repeatedly resolves symlinks in the last component of
4524 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4525 until it arrives at a file whose last component is not a symlink,
4526 or some error occurs. It returns the target of the last
4527 successfully resolved symlink in the chain. If it succeeds to
4528 resolve even a single symlink, the value returned is an absolute
4529 file name with backslashes (result of GetFullPathName). By
4530 contrast, if the original FILE is returned, it is unaltered.
4532 Note: This function can set errno even if it succeeds.
4534 Implementation note: we only resolve the last portion ("basename")
4535 of the argument FILE and of each following file in the chain,
4536 disregarding any possible symlinks in its leading directories.
4537 This is because Windows system calls and library functions
4538 transparently resolve symlinks in leading directories and return
4539 correct information, as long as the basename is not a symlink. */
4541 chase_symlinks (const char *file
)
4543 static char target
[MAX_PATH
];
4544 char link
[MAX_PATH
];
4545 ssize_t res
, link_len
;
4549 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4550 return (char *)file
;
4552 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4553 return (char *)file
;
4555 dbcs_p
= max_filename_mbslen () > 1;
4559 /* Remove trailing slashes, as we want to resolve the last
4560 non-trivial part of the link name. */
4563 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4564 link
[link_len
--] = '\0';
4566 else if (link_len
> 3)
4568 char *n
= CharPrevExA (file_name_codepage
, link
, link
+ link_len
, 0);
4570 while (n
>= link
+ 2 && IS_DIRECTORY_SEP (*n
))
4573 n
= CharPrevExA (file_name_codepage
, link
, n
, 0);
4577 res
= readlink (link
, target
, MAX_PATH
);
4581 if (!(IS_DEVICE_SEP (target
[1])
4582 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4584 /* Target is relative. Append it to the directory part of
4585 the symlink, then copy the result back to target. */
4586 char *p
= link
+ link_len
;
4590 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4595 char *p1
= CharPrevExA (file_name_codepage
, link
, p
, 0);
4597 while (p
> link
&& !IS_ANY_SEP (*p1
))
4600 p1
= CharPrevExA (file_name_codepage
, link
, p1
, 0);
4604 strcpy (target
, link
);
4606 /* Resolve any "." and ".." to get a fully-qualified file name
4608 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4610 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4612 if (loop_count
> 100)
4615 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4616 return (char *)file
;
4620 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4621 have a fixed max size for file names, so we don't need the kind of
4622 alloc/malloc/realloc dance the gnulib version does. We also don't
4623 support FD-relative symlinks. */
4625 careadlinkat (int fd
, char const *filename
,
4626 char *buffer
, size_t buffer_size
,
4627 struct allocator
const *alloc
,
4628 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4630 char linkname
[MAX_PATH
];
4639 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4643 char *retval
= buffer
;
4645 linkname
[link_size
++] = '\0';
4646 if (link_size
> buffer_size
)
4647 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4649 memcpy (retval
, linkname
, link_size
);
4657 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4661 return readlink (filename
, buffer
, buffer_size
);
4665 /* Support for browsing other processes and their attributes. See
4666 process.c for the Lisp bindings. */
4668 /* Helper wrapper functions. */
4670 static HANDLE WINAPI
4671 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4673 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4675 if (g_b_init_create_toolhelp32_snapshot
== 0)
4677 g_b_init_create_toolhelp32_snapshot
= 1;
4678 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4679 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4680 "CreateToolhelp32Snapshot");
4682 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4684 return INVALID_HANDLE_VALUE
;
4686 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4690 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4692 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4694 if (g_b_init_process32_first
== 0)
4696 g_b_init_process32_first
= 1;
4697 s_pfn_Process32_First
= (Process32First_Proc
)
4698 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4701 if (s_pfn_Process32_First
== NULL
)
4705 return (s_pfn_Process32_First (hSnapshot
, lppe
));
4709 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4711 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
4713 if (g_b_init_process32_next
== 0)
4715 g_b_init_process32_next
= 1;
4716 s_pfn_Process32_Next
= (Process32Next_Proc
)
4717 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4720 if (s_pfn_Process32_Next
== NULL
)
4724 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
4728 open_thread_token (HANDLE ThreadHandle
,
4729 DWORD DesiredAccess
,
4731 PHANDLE TokenHandle
)
4733 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
4734 HMODULE hm_advapi32
= NULL
;
4735 if (is_windows_9x () == TRUE
)
4737 SetLastError (ERROR_NOT_SUPPORTED
);
4740 if (g_b_init_open_thread_token
== 0)
4742 g_b_init_open_thread_token
= 1;
4743 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4744 s_pfn_Open_Thread_Token
=
4745 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
4747 if (s_pfn_Open_Thread_Token
== NULL
)
4749 SetLastError (ERROR_NOT_SUPPORTED
);
4753 s_pfn_Open_Thread_Token (
4762 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
4764 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
4765 HMODULE hm_advapi32
= NULL
;
4766 if (is_windows_9x () == TRUE
)
4770 if (g_b_init_impersonate_self
== 0)
4772 g_b_init_impersonate_self
= 1;
4773 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4774 s_pfn_Impersonate_Self
=
4775 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
4777 if (s_pfn_Impersonate_Self
== NULL
)
4781 return s_pfn_Impersonate_Self (ImpersonationLevel
);
4785 revert_to_self (void)
4787 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
4788 HMODULE hm_advapi32
= NULL
;
4789 if (is_windows_9x () == TRUE
)
4793 if (g_b_init_revert_to_self
== 0)
4795 g_b_init_revert_to_self
= 1;
4796 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4797 s_pfn_Revert_To_Self
=
4798 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
4800 if (s_pfn_Revert_To_Self
== NULL
)
4804 return s_pfn_Revert_To_Self ();
4808 get_process_memory_info (HANDLE h_proc
,
4809 PPROCESS_MEMORY_COUNTERS mem_counters
,
4812 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
4813 HMODULE hm_psapi
= NULL
;
4814 if (is_windows_9x () == TRUE
)
4818 if (g_b_init_get_process_memory_info
== 0)
4820 g_b_init_get_process_memory_info
= 1;
4821 hm_psapi
= LoadLibrary ("Psapi.dll");
4823 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
4824 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
4826 if (s_pfn_Get_Process_Memory_Info
== NULL
)
4830 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
4834 get_process_working_set_size (HANDLE h_proc
,
4838 static GetProcessWorkingSetSize_Proc
4839 s_pfn_Get_Process_Working_Set_Size
= NULL
;
4841 if (is_windows_9x () == TRUE
)
4845 if (g_b_init_get_process_working_set_size
== 0)
4847 g_b_init_get_process_working_set_size
= 1;
4848 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
4849 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4850 "GetProcessWorkingSetSize");
4852 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
4856 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
4860 global_memory_status (MEMORYSTATUS
*buf
)
4862 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
4864 if (is_windows_9x () == TRUE
)
4868 if (g_b_init_global_memory_status
== 0)
4870 g_b_init_global_memory_status
= 1;
4871 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
4872 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4873 "GlobalMemoryStatus");
4875 if (s_pfn_Global_Memory_Status
== NULL
)
4879 return s_pfn_Global_Memory_Status (buf
);
4883 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
4885 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
4887 if (is_windows_9x () == TRUE
)
4891 if (g_b_init_global_memory_status_ex
== 0)
4893 g_b_init_global_memory_status_ex
= 1;
4894 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
4895 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4896 "GlobalMemoryStatusEx");
4898 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
4902 return s_pfn_Global_Memory_Status_Ex (buf
);
4906 list_system_processes (void)
4908 struct gcpro gcpro1
;
4909 Lisp_Object proclist
= Qnil
;
4912 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4914 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4916 PROCESSENTRY32 proc_entry
;
4922 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
4923 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
4924 res
= process32_next (h_snapshot
, &proc_entry
))
4926 proc_id
= proc_entry
.th32ProcessID
;
4927 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
4930 CloseHandle (h_snapshot
);
4932 proclist
= Fnreverse (proclist
);
4939 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
4941 TOKEN_PRIVILEGES priv
;
4942 DWORD priv_size
= sizeof (priv
);
4943 DWORD opriv_size
= sizeof (*old_priv
);
4944 HANDLE h_token
= NULL
;
4945 HANDLE h_thread
= GetCurrentThread ();
4949 res
= open_thread_token (h_thread
,
4950 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4952 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
4954 if (impersonate_self (SecurityImpersonation
))
4955 res
= open_thread_token (h_thread
,
4956 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4961 priv
.PrivilegeCount
= 1;
4962 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
4963 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
4964 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
4965 old_priv
, &opriv_size
)
4966 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4970 CloseHandle (h_token
);
4976 restore_privilege (TOKEN_PRIVILEGES
*priv
)
4978 DWORD priv_size
= sizeof (*priv
);
4979 HANDLE h_token
= NULL
;
4982 if (open_thread_token (GetCurrentThread (),
4983 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4986 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
4987 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4991 CloseHandle (h_token
);
4997 ltime (ULONGLONG time_100ns
)
4999 ULONGLONG time_sec
= time_100ns
/ 10000000;
5000 int subsec
= time_100ns
% 10000000;
5001 return list4 (make_number (time_sec
>> 16),
5002 make_number (time_sec
& 0xffff),
5003 make_number (subsec
/ 10),
5004 make_number (subsec
% 10 * 100000));
5007 #define U64_TO_LISP_TIME(time) ltime (time)
5010 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5011 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5014 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5015 ULONGLONG tem1
, tem2
, tem3
, tem
;
5018 || !get_process_times_fn
5019 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5020 &ft_kernel
, &ft_user
))
5023 GetSystemTimeAsFileTime (&ft_current
);
5025 FILETIME_TO_U64 (tem1
, ft_kernel
);
5026 *stime
= U64_TO_LISP_TIME (tem1
);
5028 FILETIME_TO_U64 (tem2
, ft_user
);
5029 *utime
= U64_TO_LISP_TIME (tem2
);
5032 *ttime
= U64_TO_LISP_TIME (tem3
);
5034 FILETIME_TO_U64 (tem
, ft_creation
);
5035 /* Process no 4 (System) returns zero creation time. */
5038 *ctime
= U64_TO_LISP_TIME (tem
);
5042 FILETIME_TO_U64 (tem3
, ft_current
);
5043 tem
= (tem3
- utc_base
) - tem
;
5045 *etime
= U64_TO_LISP_TIME (tem
);
5049 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5060 system_process_attributes (Lisp_Object pid
)
5062 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5063 Lisp_Object attrs
= Qnil
;
5064 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5065 HANDLE h_snapshot
, h_proc
;
5068 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5069 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5070 DWORD glength
= sizeof (gname
);
5071 HANDLE token
= NULL
;
5072 SID_NAME_USE user_type
;
5073 unsigned char *buf
= NULL
;
5075 TOKEN_USER user_token
;
5076 TOKEN_PRIMARY_GROUP group_token
;
5079 PROCESS_MEMORY_COUNTERS mem
;
5080 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5081 SIZE_T minrss
, maxrss
;
5083 MEMORY_STATUS_EX memstex
;
5084 double totphys
= 0.0;
5085 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5087 BOOL result
= FALSE
;
5089 CHECK_NUMBER_OR_FLOAT (pid
);
5090 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5092 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5094 GCPRO3 (attrs
, decoded_cmd
, tem
);
5096 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5101 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5102 for (res
= process32_first (h_snapshot
, &pe
); res
;
5103 res
= process32_next (h_snapshot
, &pe
))
5105 if (proc_id
== pe
.th32ProcessID
)
5108 decoded_cmd
= build_string ("Idle");
5111 /* Decode the command name from locale-specific
5113 cmd_str
= make_unibyte_string (pe
.szExeFile
,
5114 strlen (pe
.szExeFile
));
5116 code_convert_string_norecord (cmd_str
,
5117 Vlocale_coding_system
, 0);
5119 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5120 attrs
= Fcons (Fcons (Qppid
,
5121 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5123 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5125 attrs
= Fcons (Fcons (Qthcount
,
5126 make_fixnum_or_float (pe
.cntThreads
)),
5133 CloseHandle (h_snapshot
);
5142 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5144 /* If we were denied a handle to the process, try again after
5145 enabling the SeDebugPrivilege in our process. */
5148 TOKEN_PRIVILEGES priv_current
;
5150 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5152 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5154 restore_privilege (&priv_current
);
5160 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5163 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5164 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5166 buf
= xmalloc (blen
);
5167 result
= get_token_information (token
, TokenUser
,
5168 (LPVOID
)buf
, blen
, &needed
);
5171 memcpy (&user_token
, buf
, sizeof (user_token
));
5172 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5174 euid
= get_rid (user_token
.User
.Sid
);
5175 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5180 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5183 strcpy (uname
, "unknown");
5187 ulength
= strlen (uname
);
5193 /* Determine a reasonable euid and gid values. */
5194 if (xstrcasecmp ("administrator", uname
) == 0)
5196 euid
= 500; /* well-known Administrator uid */
5197 egid
= 513; /* well-known None gid */
5201 /* Get group id and name. */
5202 result
= get_token_information (token
, TokenPrimaryGroup
,
5203 (LPVOID
)buf
, blen
, &needed
);
5204 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5206 buf
= xrealloc (buf
, blen
= needed
);
5207 result
= get_token_information (token
, TokenPrimaryGroup
,
5208 (LPVOID
)buf
, blen
, &needed
);
5212 memcpy (&group_token
, buf
, sizeof (group_token
));
5213 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5215 egid
= get_rid (group_token
.PrimaryGroup
);
5216 dlength
= sizeof (domain
);
5218 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5219 gname
, &glength
, NULL
, &dlength
,
5222 w32_add_to_cache (group_token
.PrimaryGroup
,
5226 strcpy (gname
, "None");
5230 glength
= strlen (gname
);
5238 if (!is_windows_9x ())
5240 /* We couldn't open the process token, presumably because of
5241 insufficient access rights. Assume this process is run
5243 strcpy (uname
, "SYSTEM");
5244 strcpy (gname
, "None");
5245 euid
= 18; /* SYSTEM */
5246 egid
= 513; /* None */
5247 glength
= strlen (gname
);
5248 ulength
= strlen (uname
);
5250 /* If we are running under Windows 9X, where security calls are
5251 not supported, we assume all processes are run by the current
5253 else if (GetUserName (uname
, &ulength
))
5255 if (xstrcasecmp ("administrator", uname
) == 0)
5260 strcpy (gname
, "None");
5261 glength
= strlen (gname
);
5262 ulength
= strlen (uname
);
5268 strcpy (uname
, "administrator");
5269 ulength
= strlen (uname
);
5270 strcpy (gname
, "None");
5271 glength
= strlen (gname
);
5274 CloseHandle (token
);
5277 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5278 tem
= make_unibyte_string (uname
, ulength
);
5279 attrs
= Fcons (Fcons (Quser
,
5280 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5282 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5283 tem
= make_unibyte_string (gname
, glength
);
5284 attrs
= Fcons (Fcons (Qgroup
,
5285 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5288 if (global_memory_status_ex (&memstex
))
5289 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5290 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5292 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5293 double, so we need to do this for it... */
5295 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5296 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5297 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5299 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5301 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5302 else if (global_memory_status (&memst
))
5303 totphys
= memst
.dwTotalPhys
/ 1024.0;
5306 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5309 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5311 attrs
= Fcons (Fcons (Qmajflt
,
5312 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5314 attrs
= Fcons (Fcons (Qvsize
,
5315 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5317 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5319 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5322 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5324 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5326 attrs
= Fcons (Fcons (Qmajflt
,
5327 make_fixnum_or_float (mem
.PageFaultCount
)),
5329 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5331 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5334 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5336 DWORD rss
= maxrss
/ 1024;
5338 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5340 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5343 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5345 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5346 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5347 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5348 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5349 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5350 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5353 /* FIXME: Retrieve command line by walking the PEB of the process. */
5356 CloseHandle (h_proc
);
5362 /* Wrappers for winsock functions to map between our file descriptors
5363 and winsock's handles; also set h_errno for convenience.
5365 To allow Emacs to run on systems which don't have winsock support
5366 installed, we dynamically link to winsock on startup if present, and
5367 otherwise provide the minimum necessary functionality
5368 (eg. gethostname). */
5370 /* function pointers for relevant socket functions */
5371 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5372 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5373 int (PASCAL
*pfn_WSAGetLastError
) (void);
5374 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5375 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5376 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5377 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5378 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5379 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5380 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5381 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5382 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5383 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5384 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5385 int (PASCAL
*pfn_WSACleanup
) (void);
5387 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5388 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5389 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5390 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5391 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5392 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5393 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5394 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5395 const char * optval
, int optlen
);
5396 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5397 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5399 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5400 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5401 struct sockaddr
* from
, int * fromlen
);
5402 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5403 const struct sockaddr
* to
, int tolen
);
5405 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5406 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5407 #ifndef HANDLE_FLAG_INHERIT
5408 #define HANDLE_FLAG_INHERIT 1
5412 static int winsock_inuse
;
5417 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5419 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5420 after WSAStartup returns successfully, but it seems reasonable
5421 to allow unloading winsock anyway in that case. */
5422 if (pfn_WSACleanup () == 0 ||
5423 pfn_WSAGetLastError () == WSAENETDOWN
)
5425 if (FreeLibrary (winsock_lib
))
5434 init_winsock (int load_now
)
5436 WSADATA winsockData
;
5438 if (winsock_lib
!= NULL
)
5441 pfn_SetHandleInformation
5442 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5443 "SetHandleInformation");
5445 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5447 if (winsock_lib
!= NULL
)
5449 /* dynamically link to socket functions */
5451 #define LOAD_PROC(fn) \
5452 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5455 LOAD_PROC (WSAStartup
);
5456 LOAD_PROC (WSASetLastError
);
5457 LOAD_PROC (WSAGetLastError
);
5458 LOAD_PROC (WSAEventSelect
);
5459 LOAD_PROC (WSACreateEvent
);
5460 LOAD_PROC (WSACloseEvent
);
5463 LOAD_PROC (connect
);
5464 LOAD_PROC (ioctlsocket
);
5467 LOAD_PROC (closesocket
);
5468 LOAD_PROC (shutdown
);
5471 LOAD_PROC (inet_addr
);
5472 LOAD_PROC (gethostname
);
5473 LOAD_PROC (gethostbyname
);
5474 LOAD_PROC (getservbyname
);
5475 LOAD_PROC (getpeername
);
5476 LOAD_PROC (WSACleanup
);
5477 LOAD_PROC (setsockopt
);
5479 LOAD_PROC (getsockname
);
5481 LOAD_PROC (recvfrom
);
5485 /* specify version 1.1 of winsock */
5486 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5488 if (winsockData
.wVersion
!= 0x101)
5493 /* Report that winsock exists and is usable, but leave
5494 socket functions disabled. I am assuming that calling
5495 WSAStartup does not require any network interaction,
5496 and in particular does not cause or require a dial-up
5497 connection to be established. */
5500 FreeLibrary (winsock_lib
);
5508 FreeLibrary (winsock_lib
);
5518 /* function to set h_errno for compatibility; map winsock error codes to
5519 normal system codes where they overlap (non-overlapping definitions
5520 are already in <sys/socket.h> */
5524 if (winsock_lib
== NULL
)
5527 h_errno
= pfn_WSAGetLastError ();
5531 case WSAEACCES
: h_errno
= EACCES
; break;
5532 case WSAEBADF
: h_errno
= EBADF
; break;
5533 case WSAEFAULT
: h_errno
= EFAULT
; break;
5534 case WSAEINTR
: h_errno
= EINTR
; break;
5535 case WSAEINVAL
: h_errno
= EINVAL
; break;
5536 case WSAEMFILE
: h_errno
= EMFILE
; break;
5537 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5538 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5546 if (h_errno
== 0 && winsock_lib
!= NULL
)
5547 pfn_WSASetLastError (0);
5550 /* Extend strerror to handle the winsock-specific error codes. */
5554 } _wsa_errlist
[] = {
5555 {WSAEINTR
, "Interrupted function call"},
5556 {WSAEBADF
, "Bad file descriptor"},
5557 {WSAEACCES
, "Permission denied"},
5558 {WSAEFAULT
, "Bad address"},
5559 {WSAEINVAL
, "Invalid argument"},
5560 {WSAEMFILE
, "Too many open files"},
5562 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5563 {WSAEINPROGRESS
, "Operation now in progress"},
5564 {WSAEALREADY
, "Operation already in progress"},
5565 {WSAENOTSOCK
, "Socket operation on non-socket"},
5566 {WSAEDESTADDRREQ
, "Destination address required"},
5567 {WSAEMSGSIZE
, "Message too long"},
5568 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5569 {WSAENOPROTOOPT
, "Bad protocol option"},
5570 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5571 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5572 {WSAEOPNOTSUPP
, "Operation not supported"},
5573 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5574 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5575 {WSAEADDRINUSE
, "Address already in use"},
5576 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5577 {WSAENETDOWN
, "Network is down"},
5578 {WSAENETUNREACH
, "Network is unreachable"},
5579 {WSAENETRESET
, "Network dropped connection on reset"},
5580 {WSAECONNABORTED
, "Software caused connection abort"},
5581 {WSAECONNRESET
, "Connection reset by peer"},
5582 {WSAENOBUFS
, "No buffer space available"},
5583 {WSAEISCONN
, "Socket is already connected"},
5584 {WSAENOTCONN
, "Socket is not connected"},
5585 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5586 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5587 {WSAETIMEDOUT
, "Connection timed out"},
5588 {WSAECONNREFUSED
, "Connection refused"},
5589 {WSAELOOP
, "Network loop"}, /* not sure */
5590 {WSAENAMETOOLONG
, "Name is too long"},
5591 {WSAEHOSTDOWN
, "Host is down"},
5592 {WSAEHOSTUNREACH
, "No route to host"},
5593 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5594 {WSAEPROCLIM
, "Too many processes"},
5595 {WSAEUSERS
, "Too many users"}, /* not sure */
5596 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5597 {WSAESTALE
, "Data is stale"}, /* not sure */
5598 {WSAEREMOTE
, "Remote error"}, /* not sure */
5600 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5601 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5602 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5603 {WSAEDISCON
, "Graceful shutdown in progress"},
5605 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5606 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5607 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5608 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5609 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5610 {WSASYSCALLFAILURE
, "System call failure"},
5611 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5612 {WSATYPE_NOT_FOUND
, "Class type not found"},
5613 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5614 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5615 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5618 {WSAHOST_NOT_FOUND
, "Host not found"},
5619 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5620 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5621 {WSANO_DATA
, "Valid name, no data record of requested type"},
5627 sys_strerror (int error_no
)
5630 static char unknown_msg
[40];
5632 if (error_no
>= 0 && error_no
< sys_nerr
)
5633 return sys_errlist
[error_no
];
5635 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5636 if (_wsa_errlist
[i
].errnum
== error_no
)
5637 return _wsa_errlist
[i
].msg
;
5639 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5643 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5644 but I believe the method of keeping the socket handle separate (and
5645 insuring it is not inheritable) is the correct one. */
5647 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5649 static int socket_to_fd (SOCKET s
);
5652 sys_socket (int af
, int type
, int protocol
)
5656 if (winsock_lib
== NULL
)
5658 errno
= h_errno
= ENETDOWN
;
5659 return INVALID_SOCKET
;
5664 /* call the real socket function */
5665 s
= pfn_socket (af
, type
, protocol
);
5667 if (s
!= INVALID_SOCKET
)
5669 int retval
= socket_to_fd (s
);
5680 /* Convert a SOCKET to a file descriptor. */
5682 socket_to_fd (SOCKET s
)
5687 /* Although under NT 3.5 _open_osfhandle will accept a socket
5688 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5689 that does not work under NT 3.1. However, we can get the same
5690 effect by using a backdoor function to replace an existing
5691 descriptor handle with the one we want. */
5693 /* allocate a file descriptor (with appropriate flags) */
5694 fd
= _open ("NUL:", _O_RDWR
);
5697 /* Make a non-inheritable copy of the socket handle. Note
5698 that it is possible that sockets aren't actually kernel
5699 handles, which appears to be the case on Windows 9x when
5700 the MS Proxy winsock client is installed. */
5702 /* Apparently there is a bug in NT 3.51 with some service
5703 packs, which prevents using DuplicateHandle to make a
5704 socket handle non-inheritable (causes WSACleanup to
5705 hang). The work-around is to use SetHandleInformation
5706 instead if it is available and implemented. */
5707 if (pfn_SetHandleInformation
)
5709 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5713 HANDLE parent
= GetCurrentProcess ();
5714 HANDLE new_s
= INVALID_HANDLE_VALUE
;
5716 if (DuplicateHandle (parent
,
5722 DUPLICATE_SAME_ACCESS
))
5724 /* It is possible that DuplicateHandle succeeds even
5725 though the socket wasn't really a kernel handle,
5726 because a real handle has the same value. So
5727 test whether the new handle really is a socket. */
5728 long nonblocking
= 0;
5729 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
5731 pfn_closesocket (s
);
5736 CloseHandle (new_s
);
5741 eassert (fd
< MAXDESC
);
5742 fd_info
[fd
].hnd
= (HANDLE
) s
;
5744 /* set our own internal flags */
5745 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
5751 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5753 /* attach child_process to fd_info */
5754 if (fd_info
[ fd
].cp
!= NULL
)
5756 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
5760 fd_info
[ fd
].cp
= cp
;
5763 winsock_inuse
++; /* count open sockets */
5770 pfn_closesocket (s
);
5776 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
5778 if (winsock_lib
== NULL
)
5780 errno
= h_errno
= ENOTSOCK
;
5781 return SOCKET_ERROR
;
5785 if (fd_info
[s
].flags
& FILE_SOCKET
)
5787 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
5788 if (rc
== SOCKET_ERROR
)
5792 errno
= h_errno
= ENOTSOCK
;
5793 return SOCKET_ERROR
;
5797 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
5799 if (winsock_lib
== NULL
)
5801 errno
= h_errno
= ENOTSOCK
;
5802 return SOCKET_ERROR
;
5806 if (fd_info
[s
].flags
& FILE_SOCKET
)
5808 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
5809 if (rc
== SOCKET_ERROR
)
5813 errno
= h_errno
= ENOTSOCK
;
5814 return SOCKET_ERROR
;
5818 sys_htons (u_short hostshort
)
5820 return (winsock_lib
!= NULL
) ?
5821 pfn_htons (hostshort
) : hostshort
;
5825 sys_ntohs (u_short netshort
)
5827 return (winsock_lib
!= NULL
) ?
5828 pfn_ntohs (netshort
) : netshort
;
5832 sys_inet_addr (const char * cp
)
5834 return (winsock_lib
!= NULL
) ?
5835 pfn_inet_addr (cp
) : INADDR_NONE
;
5839 sys_gethostname (char * name
, int namelen
)
5841 if (winsock_lib
!= NULL
)
5842 return pfn_gethostname (name
, namelen
);
5844 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
5845 return !GetComputerName (name
, (DWORD
*)&namelen
);
5847 errno
= h_errno
= EFAULT
;
5848 return SOCKET_ERROR
;
5852 sys_gethostbyname (const char * name
)
5854 struct hostent
* host
;
5856 if (winsock_lib
== NULL
)
5858 errno
= h_errno
= ENETDOWN
;
5863 host
= pfn_gethostbyname (name
);
5870 sys_getservbyname (const char * name
, const char * proto
)
5872 struct servent
* serv
;
5874 if (winsock_lib
== NULL
)
5876 errno
= h_errno
= ENETDOWN
;
5881 serv
= pfn_getservbyname (name
, proto
);
5888 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
5890 if (winsock_lib
== NULL
)
5892 errno
= h_errno
= ENETDOWN
;
5893 return SOCKET_ERROR
;
5897 if (fd_info
[s
].flags
& FILE_SOCKET
)
5899 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
5900 if (rc
== SOCKET_ERROR
)
5904 errno
= h_errno
= ENOTSOCK
;
5905 return SOCKET_ERROR
;
5909 sys_shutdown (int s
, int how
)
5911 if (winsock_lib
== NULL
)
5913 errno
= h_errno
= ENETDOWN
;
5914 return SOCKET_ERROR
;
5918 if (fd_info
[s
].flags
& FILE_SOCKET
)
5920 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
5921 if (rc
== SOCKET_ERROR
)
5925 errno
= h_errno
= ENOTSOCK
;
5926 return SOCKET_ERROR
;
5930 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
5932 if (winsock_lib
== NULL
)
5934 errno
= h_errno
= ENETDOWN
;
5935 return SOCKET_ERROR
;
5939 if (fd_info
[s
].flags
& FILE_SOCKET
)
5941 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
5942 (const char *)optval
, optlen
);
5943 if (rc
== SOCKET_ERROR
)
5947 errno
= h_errno
= ENOTSOCK
;
5948 return SOCKET_ERROR
;
5952 sys_listen (int s
, int backlog
)
5954 if (winsock_lib
== NULL
)
5956 errno
= h_errno
= ENETDOWN
;
5957 return SOCKET_ERROR
;
5961 if (fd_info
[s
].flags
& FILE_SOCKET
)
5963 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
5964 if (rc
== SOCKET_ERROR
)
5967 fd_info
[s
].flags
|= FILE_LISTEN
;
5970 errno
= h_errno
= ENOTSOCK
;
5971 return SOCKET_ERROR
;
5975 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
5977 if (winsock_lib
== NULL
)
5979 errno
= h_errno
= ENETDOWN
;
5980 return SOCKET_ERROR
;
5984 if (fd_info
[s
].flags
& FILE_SOCKET
)
5986 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
5987 if (rc
== SOCKET_ERROR
)
5991 errno
= h_errno
= ENOTSOCK
;
5992 return SOCKET_ERROR
;
5996 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
5998 if (winsock_lib
== NULL
)
6000 errno
= h_errno
= ENETDOWN
;
6005 if (fd_info
[s
].flags
& FILE_LISTEN
)
6007 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6009 if (t
== INVALID_SOCKET
)
6013 fd
= socket_to_fd (t
);
6015 errno
= h_errno
; /* socket_to_fd sets h_errno */
6020 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6021 ResetEvent (fd_info
[s
].cp
->char_avail
);
6025 errno
= h_errno
= ENOTSOCK
;
6030 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6031 struct sockaddr
* from
, int * fromlen
)
6033 if (winsock_lib
== NULL
)
6035 errno
= h_errno
= ENETDOWN
;
6036 return SOCKET_ERROR
;
6040 if (fd_info
[s
].flags
& FILE_SOCKET
)
6042 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6043 if (rc
== SOCKET_ERROR
)
6047 errno
= h_errno
= ENOTSOCK
;
6048 return SOCKET_ERROR
;
6052 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6053 const struct sockaddr
* to
, int tolen
)
6055 if (winsock_lib
== NULL
)
6057 errno
= h_errno
= ENETDOWN
;
6058 return SOCKET_ERROR
;
6062 if (fd_info
[s
].flags
& FILE_SOCKET
)
6064 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6065 if (rc
== SOCKET_ERROR
)
6069 errno
= h_errno
= ENOTSOCK
;
6070 return SOCKET_ERROR
;
6073 /* Windows does not have an fcntl function. Provide an implementation
6074 solely for making sockets non-blocking. */
6076 fcntl (int s
, int cmd
, int options
)
6078 if (winsock_lib
== NULL
)
6080 errno
= h_errno
= ENETDOWN
;
6085 if (fd_info
[s
].flags
& FILE_SOCKET
)
6087 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
6089 unsigned long nblock
= 1;
6090 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6091 if (rc
== SOCKET_ERROR
)
6093 /* Keep track of the fact that we set this to non-blocking. */
6094 fd_info
[s
].flags
|= FILE_NDELAY
;
6100 return SOCKET_ERROR
;
6103 errno
= h_errno
= ENOTSOCK
;
6104 return SOCKET_ERROR
;
6108 /* Shadow main io functions: we need to handle pipes and sockets more
6109 intelligently, and implement non-blocking mode as well. */
6122 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6124 child_process
* cp
= fd_info
[fd
].cp
;
6126 fd_info
[fd
].cp
= NULL
;
6128 if (CHILD_ACTIVE (cp
))
6130 /* if last descriptor to active child_process then cleanup */
6132 for (i
= 0; i
< MAXDESC
; i
++)
6136 if (fd_info
[i
].cp
== cp
)
6141 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6143 if (winsock_lib
== NULL
) emacs_abort ();
6145 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6146 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6148 winsock_inuse
--; /* count open sockets */
6155 if (fd
>= 0 && fd
< MAXDESC
)
6156 fd_info
[fd
].flags
= 0;
6158 /* Note that sockets do not need special treatment here (at least on
6159 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6160 closesocket is equivalent to CloseHandle, which is to be expected
6161 because socket handles are fully fledged kernel handles. */
6173 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6175 /* duplicate our internal info as well */
6176 fd_info
[new_fd
] = fd_info
[fd
];
6182 sys_dup2 (int src
, int dst
)
6186 if (dst
< 0 || dst
>= MAXDESC
)
6192 /* make sure we close the destination first if it's a pipe or socket */
6193 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6196 rc
= _dup2 (src
, dst
);
6199 /* duplicate our internal info as well */
6200 fd_info
[dst
] = fd_info
[src
];
6205 /* Unix pipe() has only one arg */
6207 sys_pipe (int * phandles
)
6212 /* make pipe handles non-inheritable; when we spawn a child, we
6213 replace the relevant handle with an inheritable one. Also put
6214 pipes into binary mode; we will do text mode translation ourselves
6216 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6220 /* Protect against overflow, since Windows can open more handles than
6221 our fd_info array has room for. */
6222 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6224 _close (phandles
[0]);
6225 _close (phandles
[1]);
6231 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6232 fd_info
[phandles
[0]].flags
= flags
;
6234 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6235 fd_info
[phandles
[1]].flags
= flags
;
6242 /* Function to do blocking read of one byte, needed to implement
6243 select. It is only allowed on sockets and pipes. */
6245 _sys_read_ahead (int fd
)
6250 if (fd
< 0 || fd
>= MAXDESC
)
6251 return STATUS_READ_ERROR
;
6253 cp
= fd_info
[fd
].cp
;
6255 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6256 return STATUS_READ_ERROR
;
6258 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6259 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6261 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6265 cp
->status
= STATUS_READ_IN_PROGRESS
;
6267 if (fd_info
[fd
].flags
& FILE_PIPE
)
6269 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6271 /* Give subprocess time to buffer some more output for us before
6272 reporting that input is available; we need this because Windows 95
6273 connects DOS programs to pipes by making the pipe appear to be
6274 the normal console stdout - as a result most DOS programs will
6275 write to stdout without buffering, ie. one character at a
6276 time. Even some W32 programs do this - "dir" in a command
6277 shell on NT is very slow if we don't do this. */
6280 int wait
= w32_pipe_read_delay
;
6286 /* Yield remainder of our time slice, effectively giving a
6287 temporary priority boost to the child process. */
6291 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6293 HANDLE hnd
= fd_info
[fd
].hnd
;
6294 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6297 /* Configure timeouts for blocking read. */
6298 if (!GetCommTimeouts (hnd
, &ct
))
6300 cp
->status
= STATUS_READ_ERROR
;
6301 return STATUS_READ_ERROR
;
6303 ct
.ReadIntervalTimeout
= 0;
6304 ct
.ReadTotalTimeoutMultiplier
= 0;
6305 ct
.ReadTotalTimeoutConstant
= 0;
6306 if (!SetCommTimeouts (hnd
, &ct
))
6308 cp
->status
= STATUS_READ_ERROR
;
6309 return STATUS_READ_ERROR
;
6312 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6314 if (GetLastError () != ERROR_IO_PENDING
)
6316 cp
->status
= STATUS_READ_ERROR
;
6317 return STATUS_READ_ERROR
;
6319 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6321 cp
->status
= STATUS_READ_ERROR
;
6322 return STATUS_READ_ERROR
;
6326 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6328 unsigned long nblock
= 0;
6329 /* We always want this to block, so temporarily disable NDELAY. */
6330 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6331 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6333 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6335 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6338 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6342 if (rc
== sizeof (char))
6343 cp
->status
= STATUS_READ_SUCCEEDED
;
6345 cp
->status
= STATUS_READ_FAILED
;
6351 _sys_wait_accept (int fd
)
6357 if (fd
< 0 || fd
>= MAXDESC
)
6358 return STATUS_READ_ERROR
;
6360 cp
= fd_info
[fd
].cp
;
6362 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6363 return STATUS_READ_ERROR
;
6365 cp
->status
= STATUS_READ_FAILED
;
6367 hEv
= pfn_WSACreateEvent ();
6368 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6369 if (rc
!= SOCKET_ERROR
)
6371 rc
= WaitForSingleObject (hEv
, INFINITE
);
6372 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6373 if (rc
== WAIT_OBJECT_0
)
6374 cp
->status
= STATUS_READ_SUCCEEDED
;
6376 pfn_WSACloseEvent (hEv
);
6382 sys_read (int fd
, char * buffer
, unsigned int count
)
6387 char * orig_buffer
= buffer
;
6395 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6397 child_process
*cp
= fd_info
[fd
].cp
;
6399 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6407 /* re-read CR carried over from last read */
6408 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6410 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6414 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6417 /* presence of a child_process structure means we are operating in
6418 non-blocking mode - otherwise we just call _read directly.
6419 Note that the child_process structure might be missing because
6420 reap_subprocess has been called; in this case the pipe is
6421 already broken, so calling _read on it is okay. */
6424 int current_status
= cp
->status
;
6426 switch (current_status
)
6428 case STATUS_READ_FAILED
:
6429 case STATUS_READ_ERROR
:
6430 /* report normal EOF if nothing in buffer */
6432 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6435 case STATUS_READ_READY
:
6436 case STATUS_READ_IN_PROGRESS
:
6437 DebPrint (("sys_read called when read is in progress\n"));
6438 errno
= EWOULDBLOCK
;
6441 case STATUS_READ_SUCCEEDED
:
6442 /* consume read-ahead char */
6443 *buffer
++ = cp
->chr
;
6446 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6447 ResetEvent (cp
->char_avail
);
6449 case STATUS_READ_ACKNOWLEDGED
:
6453 DebPrint (("sys_read: bad status %d\n", current_status
));
6458 if (fd_info
[fd
].flags
& FILE_PIPE
)
6460 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6461 to_read
= min (waiting
, (DWORD
) count
);
6464 nchars
+= _read (fd
, buffer
, to_read
);
6466 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6468 HANDLE hnd
= fd_info
[fd
].hnd
;
6469 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6475 /* Configure timeouts for non-blocking read. */
6476 if (!GetCommTimeouts (hnd
, &ct
))
6481 ct
.ReadIntervalTimeout
= MAXDWORD
;
6482 ct
.ReadTotalTimeoutMultiplier
= 0;
6483 ct
.ReadTotalTimeoutConstant
= 0;
6484 if (!SetCommTimeouts (hnd
, &ct
))
6490 if (!ResetEvent (ovl
->hEvent
))
6495 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6497 if (GetLastError () != ERROR_IO_PENDING
)
6502 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6511 else /* FILE_SOCKET */
6513 if (winsock_lib
== NULL
) emacs_abort ();
6515 /* do the equivalent of a non-blocking read */
6516 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6517 if (waiting
== 0 && nchars
== 0)
6519 h_errno
= errno
= EWOULDBLOCK
;
6525 /* always use binary mode for sockets */
6526 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6527 if (res
== SOCKET_ERROR
)
6529 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6530 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6540 int nread
= _read (fd
, buffer
, count
);
6543 else if (nchars
== 0)
6548 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6549 /* Perform text mode translation if required. */
6550 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6552 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6553 /* If buffer contains only CR, return that. To be absolutely
6554 sure we should attempt to read the next char, but in
6555 practice a CR to be followed by LF would not appear by
6556 itself in the buffer. */
6557 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6559 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6565 nchars
= _read (fd
, buffer
, count
);
6570 /* From w32xfns.c */
6571 extern HANDLE interrupt_handle
;
6573 /* For now, don't bother with a non-blocking mode */
6575 sys_write (int fd
, const void * buffer
, unsigned int count
)
6585 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6587 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6593 /* Perform text mode translation if required. */
6594 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6596 char * tmpbuf
= alloca (count
* 2);
6597 unsigned char * src
= (void *)buffer
;
6598 unsigned char * dst
= tmpbuf
;
6603 unsigned char *next
;
6604 /* copy next line or remaining bytes */
6605 next
= _memccpy (dst
, src
, '\n', nbytes
);
6608 /* copied one line ending with '\n' */
6609 int copied
= next
- dst
;
6612 /* insert '\r' before '\n' */
6619 /* copied remaining partial line -> now finished */
6626 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6628 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6629 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6630 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6633 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6635 if (GetLastError () != ERROR_IO_PENDING
)
6640 if (detect_input_pending ())
6641 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6644 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6645 if (active
== WAIT_OBJECT_0
)
6646 { /* User pressed C-g, cancel write, then leave. Don't bother
6647 cleaning up as we may only get stuck in buggy drivers. */
6648 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6653 if (active
== WAIT_OBJECT_0
+ 1
6654 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6661 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6663 unsigned long nblock
= 0;
6664 if (winsock_lib
== NULL
) emacs_abort ();
6666 /* TODO: implement select() properly so non-blocking I/O works. */
6667 /* For now, make sure the write blocks. */
6668 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6669 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6671 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6673 /* Set the socket back to non-blocking if it was before,
6674 for other operations that support it. */
6675 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6678 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6681 if (nchars
== SOCKET_ERROR
)
6683 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6684 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6690 /* Some networked filesystems don't like too large writes, so
6691 break them into smaller chunks. See the Comments section of
6692 the MSDN documentation of WriteFile for details behind the
6693 choice of the value of CHUNK below. See also the thread
6694 http://thread.gmane.org/gmane.comp.version-control.git/145294
6695 in the git mailing list. */
6696 const unsigned char *p
= buffer
;
6697 const unsigned chunk
= 30 * 1024 * 1024;
6702 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6703 int n
= _write (fd
, p
, this_chunk
);
6711 else if (n
< this_chunk
)
6721 /* The Windows CRT functions are "optimized for speed", so they don't
6722 check for timezone and DST changes if they were last called less
6723 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
6724 all Emacs features that repeatedly call time functions (e.g.,
6725 display-time) are in real danger of missing timezone and DST
6726 changes. Calling tzset before each localtime call fixes that. */
6728 sys_localtime (const time_t *t
)
6731 return localtime (t
);
6736 /* Try loading LIBRARY_ID from the file(s) specified in
6737 Vdynamic_library_alist. If the library is loaded successfully,
6738 return the handle of the DLL, and record the filename in the
6739 property :loaded-from of LIBRARY_ID. If the library could not be
6740 found, or when it was already loaded (because the handle is not
6741 recorded anywhere, and so is lost after use), return NULL.
6743 We could also save the handle in :loaded-from, but currently
6744 there's no use case for it. */
6746 w32_delayed_load (Lisp_Object library_id
)
6748 HMODULE library_dll
= NULL
;
6750 CHECK_SYMBOL (library_id
);
6752 if (CONSP (Vdynamic_library_alist
)
6753 && NILP (Fassq (library_id
, Vlibrary_cache
)))
6755 Lisp_Object found
= Qnil
;
6756 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
6759 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
6761 CHECK_STRING_CAR (dlls
);
6762 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
6764 char name
[MAX_PATH
];
6767 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
6768 found
= Fcons (XCAR (dlls
),
6770 /* Possibly truncated */
6771 ? make_specified_string (name
, -1, len
, 1)
6777 Fput (library_id
, QCloaded_from
, found
);
6785 check_windows_init_file (void)
6787 /* A common indication that Emacs is not installed properly is when
6788 it cannot find the Windows installation file. If this file does
6789 not exist in the expected place, tell the user. */
6791 if (!noninteractive
&& !inhibit_window_system
6792 /* Vload_path is not yet initialized when we are loading
6794 && NILP (Vpurify_flag
))
6796 Lisp_Object init_file
;
6799 init_file
= build_string ("term/w32-win");
6800 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
6803 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
6804 char *init_file_name
= SDATA (init_file
);
6805 char *load_path
= SDATA (load_path_print
);
6806 char *buffer
= alloca (1024
6807 + strlen (init_file_name
)
6808 + strlen (load_path
));
6811 "The Emacs Windows initialization file \"%s.el\" "
6812 "could not be found in your Emacs installation. "
6813 "Emacs checked the following directories for this file:\n"
6815 "When Emacs cannot find this file, it usually means that it "
6816 "was not installed properly, or its distribution file was "
6817 "not unpacked properly.\nSee the README.W32 file in the "
6818 "top-level Emacs directory for more information.",
6819 init_file_name
, load_path
);
6822 "Emacs Abort Dialog",
6823 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
6824 /* Use the low-level system abort. */
6835 term_ntproc (int ignored
)
6841 /* shutdown the socket interface if necessary */
6848 init_ntproc (int dumping
)
6850 sigset_t initial_mask
= 0;
6852 /* Initialize the socket interface now if available and requested by
6853 the user by defining PRELOAD_WINSOCK; otherwise loading will be
6854 delayed until open-network-stream is called (w32-has-winsock can
6855 also be used to dynamically load or reload winsock).
6857 Conveniently, init_environment is called before us, so
6858 PRELOAD_WINSOCK can be set in the registry. */
6860 /* Always initialize this correctly. */
6863 if (getenv ("PRELOAD_WINSOCK") != NULL
)
6864 init_winsock (TRUE
);
6866 /* Initial preparation for subprocess support: replace our standard
6867 handles with non-inheritable versions. */
6870 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
6871 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
6872 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
6874 parent
= GetCurrentProcess ();
6876 /* ignore errors when duplicating and closing; typically the
6877 handles will be invalid when running as a gui program. */
6878 DuplicateHandle (parent
,
6879 GetStdHandle (STD_INPUT_HANDLE
),
6884 DUPLICATE_SAME_ACCESS
);
6886 DuplicateHandle (parent
,
6887 GetStdHandle (STD_OUTPUT_HANDLE
),
6892 DUPLICATE_SAME_ACCESS
);
6894 DuplicateHandle (parent
,
6895 GetStdHandle (STD_ERROR_HANDLE
),
6900 DUPLICATE_SAME_ACCESS
);
6906 if (stdin_save
!= INVALID_HANDLE_VALUE
)
6907 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
6909 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
6912 if (stdout_save
!= INVALID_HANDLE_VALUE
)
6913 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
6915 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6918 if (stderr_save
!= INVALID_HANDLE_VALUE
)
6919 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
6921 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6925 /* unfortunately, atexit depends on implementation of malloc */
6926 /* atexit (term_ntproc); */
6929 /* Make sure we start with all signals unblocked. */
6930 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
6931 signal (SIGABRT
, term_ntproc
);
6935 /* determine which drives are fixed, for GetCachedVolumeInformation */
6937 /* GetDriveType must have trailing backslash. */
6938 char drive
[] = "A:\\";
6940 /* Loop over all possible drive letters */
6941 while (*drive
<= 'Z')
6943 /* Record if this drive letter refers to a fixed drive. */
6944 fixed_drives
[DRIVE_INDEX (*drive
)] =
6945 (GetDriveType (drive
) == DRIVE_FIXED
);
6950 /* Reset the volume info cache. */
6951 volume_cache
= NULL
;
6956 shutdown_handler ensures that buffers' autosave files are
6957 up to date when the user logs off, or the system shuts down.
6960 shutdown_handler (DWORD type
)
6962 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
6963 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
6964 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
6965 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
6967 /* Shut down cleanly, making sure autosave files are up to date. */
6968 shut_down_emacs (0, Qnil
);
6971 /* Allow other handlers to handle this signal. */
6976 globals_of_w32 is used to initialize those global variables that
6977 must always be initialized on startup even when the global variable
6978 initialized is non zero (see the function main in emacs.c).
6981 globals_of_w32 (void)
6983 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
6985 get_process_times_fn
= (GetProcessTimes_Proc
)
6986 GetProcAddress (kernel32
, "GetProcessTimes");
6988 DEFSYM (QCloaded_from
, ":loaded-from");
6990 g_b_init_is_windows_9x
= 0;
6991 g_b_init_open_process_token
= 0;
6992 g_b_init_get_token_information
= 0;
6993 g_b_init_lookup_account_sid
= 0;
6994 g_b_init_get_sid_sub_authority
= 0;
6995 g_b_init_get_sid_sub_authority_count
= 0;
6996 g_b_init_get_security_info
= 0;
6997 g_b_init_get_file_security
= 0;
6998 g_b_init_get_security_descriptor_owner
= 0;
6999 g_b_init_get_security_descriptor_group
= 0;
7000 g_b_init_is_valid_sid
= 0;
7001 g_b_init_create_toolhelp32_snapshot
= 0;
7002 g_b_init_process32_first
= 0;
7003 g_b_init_process32_next
= 0;
7004 g_b_init_open_thread_token
= 0;
7005 g_b_init_impersonate_self
= 0;
7006 g_b_init_revert_to_self
= 0;
7007 g_b_init_get_process_memory_info
= 0;
7008 g_b_init_get_process_working_set_size
= 0;
7009 g_b_init_global_memory_status
= 0;
7010 g_b_init_global_memory_status_ex
= 0;
7011 g_b_init_equal_sid
= 0;
7012 g_b_init_copy_sid
= 0;
7013 g_b_init_get_length_sid
= 0;
7014 g_b_init_get_native_system_info
= 0;
7015 g_b_init_get_system_times
= 0;
7016 g_b_init_create_symbolic_link
= 0;
7017 num_of_processors
= 0;
7018 /* The following sets a handler for shutdown notifications for
7019 console apps. This actually applies to Emacs in both console and
7020 GUI modes, since we had to fool windows into thinking emacs is a
7021 console application to get console mode to work. */
7022 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
7024 /* "None" is the default group name on standalone workstations. */
7025 strcpy (dflt_group_name
, "None");
7028 /* For make-serial-process */
7030 serial_open (char *port
)
7036 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
7037 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
7038 if (hnd
== INVALID_HANDLE_VALUE
)
7039 error ("Could not open %s", port
);
7040 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
7042 error ("Could not open %s", port
);
7046 error ("Could not create child process");
7048 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7049 fd_info
[ fd
].hnd
= hnd
;
7050 fd_info
[ fd
].flags
|=
7051 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
7052 if (fd_info
[ fd
].cp
!= NULL
)
7054 error ("fd_info[fd = %d] is already in use", fd
);
7056 fd_info
[ fd
].cp
= cp
;
7057 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7058 if (cp
->ovl_read
.hEvent
== NULL
)
7059 error ("Could not create read event");
7060 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7061 if (cp
->ovl_write
.hEvent
== NULL
)
7062 error ("Could not create write event");
7067 /* For serial-process-configure */
7069 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
7071 Lisp_Object childp2
= Qnil
;
7072 Lisp_Object tem
= Qnil
;
7076 char summary
[4] = "???"; /* This usually becomes "8N1". */
7078 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
7079 error ("Not a serial process");
7080 hnd
= fd_info
[ p
->outfd
].hnd
;
7082 childp2
= Fcopy_sequence (p
->childp
);
7084 /* Initialize timeouts for blocking read and blocking write. */
7085 if (!GetCommTimeouts (hnd
, &ct
))
7086 error ("GetCommTimeouts() failed");
7087 ct
.ReadIntervalTimeout
= 0;
7088 ct
.ReadTotalTimeoutMultiplier
= 0;
7089 ct
.ReadTotalTimeoutConstant
= 0;
7090 ct
.WriteTotalTimeoutMultiplier
= 0;
7091 ct
.WriteTotalTimeoutConstant
= 0;
7092 if (!SetCommTimeouts (hnd
, &ct
))
7093 error ("SetCommTimeouts() failed");
7094 /* Read port attributes and prepare default configuration. */
7095 memset (&dcb
, 0, sizeof (dcb
));
7096 dcb
.DCBlength
= sizeof (DCB
);
7097 if (!GetCommState (hnd
, &dcb
))
7098 error ("GetCommState() failed");
7101 dcb
.fAbortOnError
= FALSE
;
7102 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7107 /* Configure speed. */
7108 if (!NILP (Fplist_member (contact
, QCspeed
)))
7109 tem
= Fplist_get (contact
, QCspeed
);
7111 tem
= Fplist_get (p
->childp
, QCspeed
);
7113 dcb
.BaudRate
= XINT (tem
);
7114 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
7116 /* Configure bytesize. */
7117 if (!NILP (Fplist_member (contact
, QCbytesize
)))
7118 tem
= Fplist_get (contact
, QCbytesize
);
7120 tem
= Fplist_get (p
->childp
, QCbytesize
);
7122 tem
= make_number (8);
7124 if (XINT (tem
) != 7 && XINT (tem
) != 8)
7125 error (":bytesize must be nil (8), 7, or 8");
7126 dcb
.ByteSize
= XINT (tem
);
7127 summary
[0] = XINT (tem
) + '0';
7128 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
7130 /* Configure parity. */
7131 if (!NILP (Fplist_member (contact
, QCparity
)))
7132 tem
= Fplist_get (contact
, QCparity
);
7134 tem
= Fplist_get (p
->childp
, QCparity
);
7135 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
7136 error (":parity must be nil (no parity), `even', or `odd'");
7137 dcb
.fParity
= FALSE
;
7138 dcb
.Parity
= NOPARITY
;
7139 dcb
.fErrorChar
= FALSE
;
7144 else if (EQ (tem
, Qeven
))
7148 dcb
.Parity
= EVENPARITY
;
7149 dcb
.fErrorChar
= TRUE
;
7151 else if (EQ (tem
, Qodd
))
7155 dcb
.Parity
= ODDPARITY
;
7156 dcb
.fErrorChar
= TRUE
;
7158 childp2
= Fplist_put (childp2
, QCparity
, tem
);
7160 /* Configure stopbits. */
7161 if (!NILP (Fplist_member (contact
, QCstopbits
)))
7162 tem
= Fplist_get (contact
, QCstopbits
);
7164 tem
= Fplist_get (p
->childp
, QCstopbits
);
7166 tem
= make_number (1);
7168 if (XINT (tem
) != 1 && XINT (tem
) != 2)
7169 error (":stopbits must be nil (1 stopbit), 1, or 2");
7170 summary
[2] = XINT (tem
) + '0';
7171 if (XINT (tem
) == 1)
7172 dcb
.StopBits
= ONESTOPBIT
;
7173 else if (XINT (tem
) == 2)
7174 dcb
.StopBits
= TWOSTOPBITS
;
7175 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
7177 /* Configure flowcontrol. */
7178 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
7179 tem
= Fplist_get (contact
, QCflowcontrol
);
7181 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
7182 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
7183 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7184 dcb
.fOutxCtsFlow
= FALSE
;
7185 dcb
.fOutxDsrFlow
= FALSE
;
7186 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
7187 dcb
.fDsrSensitivity
= FALSE
;
7188 dcb
.fTXContinueOnXoff
= FALSE
;
7191 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
7192 dcb
.XonChar
= 17; /* Control-Q */
7193 dcb
.XoffChar
= 19; /* Control-S */
7196 /* Already configured. */
7198 else if (EQ (tem
, Qhw
))
7200 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
7201 dcb
.fOutxCtsFlow
= TRUE
;
7203 else if (EQ (tem
, Qsw
))
7208 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
7210 /* Activate configuration. */
7211 if (!SetCommState (hnd
, &dcb
))
7212 error ("SetCommState() failed");
7214 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
7215 pset_childp (p
, childp2
);
7221 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7226 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7227 int fd
= process
->infd
;
7231 n
= sys_read (fd
, (char*)buf
, sz
);
7238 if (err
== EWOULDBLOCK
)
7240 /* Set a small timeout. */
7241 timeout
= make_emacs_time (1, 0);
7243 FD_SET ((int)fd
, &fdset
);
7245 /* Use select with the timeout to poll the selector. */
7246 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7250 continue; /* Try again. */
7252 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7253 Also accept select return 0 as an indicator to EAGAIN. */
7254 if (sc
== 0 || errno
== EWOULDBLOCK
)
7257 err
= errno
; /* Other errors are just passed on. */
7260 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7267 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7269 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7270 int fd
= process
->outfd
;
7271 ssize_t n
= sys_write (fd
, buf
, sz
);
7273 /* 0 or more bytes written means everything went fine. */
7277 /* Negative bytes written means we got an error in errno.
7278 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7279 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7280 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7284 #endif /* HAVE_GNUTLS */