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
23 #include <mingw_time.h>
24 #include <stddef.h> /* for offsetof */
27 #include <float.h> /* for DBL_EPSILON */
34 #include <time.h> /* must be before nt/inc/sys/time.h, for MinGW64 */
36 #include <sys/utime.h>
39 /* must include CRT headers *before* config.h */
42 #include <mbstring.h> /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
69 #include "epaths.h" /* for SHELL */
74 /* MinGW64 (_W64) defines these in its _mingw.h. */
75 #if defined(__GNUC__) && !defined(_W64)
76 #define _ANONYMOUS_UNION
77 #define _ANONYMOUS_STRUCT
80 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
81 use a different name to avoid compilation problems. */
82 typedef struct _MEMORY_STATUS_EX
{
85 DWORDLONG ullTotalPhys
;
86 DWORDLONG ullAvailPhys
;
87 DWORDLONG ullTotalPageFile
;
88 DWORDLONG ullAvailPageFile
;
89 DWORDLONG ullTotalVirtual
;
90 DWORDLONG ullAvailVirtual
;
91 DWORDLONG ullAvailExtendedVirtual
;
92 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
94 /* These are here so that GDB would know about these data types. This
95 allows to attach GDB to Emacs when a fatal exception is triggered
96 and Windows pops up the "application needs to be closed" dialog.
97 At that point, _gnu_exception_handler, the top-level exception
98 handler installed by the MinGW startup code, is somewhere on the
99 call-stack of the main thread, so going to that call frame and
100 looking at the argument to _gnu_exception_handler, which is a
101 PEXCEPTION_POINTERS pointer, can reveal the exception code
102 (excptr->ExceptionRecord->ExceptionCode) and the address where the
103 exception happened (excptr->ExceptionRecord->ExceptionAddress), as
104 well as some additional information specific to the exception. */
105 PEXCEPTION_POINTERS excptr
;
106 PEXCEPTION_RECORD excprec
;
112 #include <tlhelp32.h>
117 #if _WIN32_WINNT < 0x0500
118 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
119 /* This either is not in psapi.h or guarded by higher value of
120 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
121 defines it in psapi.h */
122 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
124 DWORD PageFaultCount
;
125 SIZE_T PeakWorkingSetSize
;
126 SIZE_T WorkingSetSize
;
127 SIZE_T QuotaPeakPagedPoolUsage
;
128 SIZE_T QuotaPagedPoolUsage
;
129 SIZE_T QuotaPeakNonPagedPoolUsage
;
130 SIZE_T QuotaNonPagedPoolUsage
;
131 SIZE_T PagefileUsage
;
132 SIZE_T PeakPagefileUsage
;
134 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
138 #include <winioctl.h>
144 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
145 define them by hand if not already defined. */
146 #ifndef SDDL_REVISION_1
147 #define SDDL_REVISION_1 1
148 #endif /* SDDL_REVISION_1 */
150 #if defined(_MSC_VER) || defined(_W64)
151 /* MSVC and MinGW64 don't provide the definition of
152 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
153 which cannot be included because it triggers conflicts with other
154 Windows API headers. So we define it here by hand. */
156 typedef struct _REPARSE_DATA_BUFFER
{
158 USHORT ReparseDataLength
;
162 USHORT SubstituteNameOffset
;
163 USHORT SubstituteNameLength
;
164 USHORT PrintNameOffset
;
165 USHORT PrintNameLength
;
168 } SymbolicLinkReparseBuffer
;
170 USHORT SubstituteNameOffset
;
171 USHORT SubstituteNameLength
;
172 USHORT PrintNameOffset
;
173 USHORT PrintNameLength
;
175 } MountPointReparseBuffer
;
178 } GenericReparseBuffer
;
180 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
182 #ifndef FILE_DEVICE_FILE_SYSTEM
183 #define FILE_DEVICE_FILE_SYSTEM 9
185 #ifndef METHOD_BUFFERED
186 #define METHOD_BUFFERED 0
188 #ifndef FILE_ANY_ACCESS
189 #define FILE_ANY_ACCESS 0x00000000
192 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
194 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
195 #ifndef FSCTL_GET_REPARSE_POINT
196 #define FSCTL_GET_REPARSE_POINT \
197 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
201 /* TCP connection support. */
202 #include <sys/socket.h>
221 #include <iphlpapi.h> /* should be after winsock2.h */
225 #include "w32common.h"
227 #include "w32select.h"
229 #include "dispextern.h" /* for xstrcasecmp */
230 #include "coding.h" /* for Vlocale_coding_system */
232 #include "careadlinkat.h"
233 #include "allocator.h"
235 /* For serial_configure and serial_open. */
238 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
239 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
241 Lisp_Object QCloaded_from
;
243 void globals_of_w32 (void);
244 static DWORD
get_rid (PSID
);
245 static int is_symlink (const char *);
246 static char * chase_symlinks (const char *);
247 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
248 static int restore_privilege (TOKEN_PRIVILEGES
*);
249 static BOOL WINAPI
revert_to_self (void);
251 static int sys_access (const char *, int);
252 extern void *e_malloc (size_t);
253 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
254 struct timespec
*, void *);
255 extern int sys_dup (int);
260 /* Initialization states.
262 WARNING: If you add any more such variables for additional APIs,
263 you MUST add initialization for them to globals_of_w32
264 below. This is because these variables might get set
265 to non-NULL values during dumping, but the dumped Emacs
266 cannot reuse those values, because it could be run on a
267 different version of the OS, where API addresses are
269 static BOOL g_b_init_is_windows_9x
;
270 static BOOL g_b_init_open_process_token
;
271 static BOOL g_b_init_get_token_information
;
272 static BOOL g_b_init_lookup_account_sid
;
273 static BOOL g_b_init_get_sid_sub_authority
;
274 static BOOL g_b_init_get_sid_sub_authority_count
;
275 static BOOL g_b_init_get_security_info
;
276 static BOOL g_b_init_get_file_security
;
277 static BOOL g_b_init_get_security_descriptor_owner
;
278 static BOOL g_b_init_get_security_descriptor_group
;
279 static BOOL g_b_init_is_valid_sid
;
280 static BOOL g_b_init_create_toolhelp32_snapshot
;
281 static BOOL g_b_init_process32_first
;
282 static BOOL g_b_init_process32_next
;
283 static BOOL g_b_init_open_thread_token
;
284 static BOOL g_b_init_impersonate_self
;
285 static BOOL g_b_init_revert_to_self
;
286 static BOOL g_b_init_get_process_memory_info
;
287 static BOOL g_b_init_get_process_working_set_size
;
288 static BOOL g_b_init_global_memory_status
;
289 static BOOL g_b_init_global_memory_status_ex
;
290 static BOOL g_b_init_get_length_sid
;
291 static BOOL g_b_init_equal_sid
;
292 static BOOL g_b_init_copy_sid
;
293 static BOOL g_b_init_get_native_system_info
;
294 static BOOL g_b_init_get_system_times
;
295 static BOOL g_b_init_create_symbolic_link
;
296 static BOOL g_b_init_get_security_descriptor_dacl
;
297 static BOOL g_b_init_convert_sd_to_sddl
;
298 static BOOL g_b_init_convert_sddl_to_sd
;
299 static BOOL g_b_init_is_valid_security_descriptor
;
300 static BOOL g_b_init_set_file_security
;
301 static BOOL g_b_init_get_adapters_info
;
304 BEGIN: Wrapper functions around OpenProcessToken
305 and other functions in advapi32.dll that are only
306 supported in Windows NT / 2k / XP
308 /* ** Function pointer typedefs ** */
309 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
310 HANDLE ProcessHandle
,
312 PHANDLE TokenHandle
);
313 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
315 TOKEN_INFORMATION_CLASS TokenInformationClass
,
316 LPVOID TokenInformation
,
317 DWORD TokenInformationLength
,
318 PDWORD ReturnLength
);
319 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
320 HANDLE process_handle
,
321 LPFILETIME creation_time
,
322 LPFILETIME exit_time
,
323 LPFILETIME kernel_time
,
324 LPFILETIME user_time
);
326 GetProcessTimes_Proc get_process_times_fn
= NULL
;
329 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
330 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
331 const char * const SetFileSecurity_Name
= "SetFileSecurityW";
333 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
334 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
335 const char * const SetFileSecurity_Name
= "SetFileSecurityA";
337 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
338 LPCTSTR lpSystemName
,
343 LPDWORD cbDomainName
,
344 PSID_NAME_USE peUse
);
345 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
348 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
350 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
352 SE_OBJECT_TYPE ObjectType
,
353 SECURITY_INFORMATION SecurityInfo
,
358 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
359 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
361 SECURITY_INFORMATION RequestedInformation
,
362 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
364 LPDWORD lpnLengthNeeded
);
365 typedef BOOL (WINAPI
*SetFileSecurity_Proc
) (
367 SECURITY_INFORMATION SecurityInformation
,
368 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
369 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
370 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
372 LPBOOL lpbOwnerDefaulted
);
373 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
374 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
376 LPBOOL lpbGroupDefaulted
);
377 typedef BOOL (WINAPI
*GetSecurityDescriptorDacl_Proc
) (
378 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
379 LPBOOL lpbDaclPresent
,
381 LPBOOL lpbDaclDefaulted
);
382 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
384 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
386 DWORD th32ProcessID
);
387 typedef BOOL (WINAPI
* Process32First_Proc
) (
389 LPPROCESSENTRY32 lppe
);
390 typedef BOOL (WINAPI
* Process32Next_Proc
) (
392 LPPROCESSENTRY32 lppe
);
393 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
397 PHANDLE TokenHandle
);
398 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
399 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
400 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
401 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
403 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
405 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
407 PSIZE_T lpMinimumWorkingSetSize
,
408 PSIZE_T lpMaximumWorkingSetSize
);
409 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
410 LPMEMORYSTATUS lpBuffer
);
411 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
412 LPMEMORY_STATUS_EX lpBuffer
);
413 typedef BOOL (WINAPI
* CopySid_Proc
) (
414 DWORD nDestinationSidLength
,
415 PSID pDestinationSid
,
417 typedef BOOL (WINAPI
* EqualSid_Proc
) (
420 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
422 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
423 LPSYSTEM_INFO lpSystemInfo
);
424 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
425 LPFILETIME lpIdleTime
,
426 LPFILETIME lpKernelTime
,
427 LPFILETIME lpUserTime
);
428 typedef BOOLEAN (WINAPI
*CreateSymbolicLink_Proc
) (
429 LPTSTR lpSymlinkFileName
,
430 LPTSTR lpTargetFileName
,
432 typedef BOOL (WINAPI
*ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
) (
433 LPCTSTR StringSecurityDescriptor
,
434 DWORD StringSDRevision
,
435 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
436 PULONG SecurityDescriptorSize
);
437 typedef BOOL (WINAPI
*ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
) (
438 PSECURITY_DESCRIPTOR SecurityDescriptor
,
439 DWORD RequestedStringSDRevision
,
440 SECURITY_INFORMATION SecurityInformation
,
441 LPTSTR
*StringSecurityDescriptor
,
442 PULONG StringSecurityDescriptorLen
);
443 typedef BOOL (WINAPI
*IsValidSecurityDescriptor_Proc
) (PSECURITY_DESCRIPTOR
);
444 typedef DWORD (WINAPI
*GetAdaptersInfo_Proc
) (
445 PIP_ADAPTER_INFO pAdapterInfo
,
448 /* ** A utility function ** */
452 static BOOL s_b_ret
= 0;
453 OSVERSIONINFO os_ver
;
454 if (g_b_init_is_windows_9x
== 0)
456 g_b_init_is_windows_9x
= 1;
457 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
458 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
459 if (GetVersionEx (&os_ver
))
461 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
467 static Lisp_Object
ltime (ULONGLONG
);
469 /* Get total user and system times for get-internal-run-time.
470 Returns a list of integers if the times are provided by the OS
471 (NT derivatives), otherwise it returns the result of current-time. */
473 w32_get_internal_run_time (void)
475 if (get_process_times_fn
)
477 FILETIME create
, exit
, kernel
, user
;
478 HANDLE proc
= GetCurrentProcess ();
479 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
481 LARGE_INTEGER user_int
, kernel_int
, total
;
482 user_int
.LowPart
= user
.dwLowDateTime
;
483 user_int
.HighPart
= user
.dwHighDateTime
;
484 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
485 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
486 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
487 return ltime (total
.QuadPart
);
491 return Fcurrent_time ();
494 /* ** The wrapper functions ** */
497 open_process_token (HANDLE ProcessHandle
,
501 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
502 HMODULE hm_advapi32
= NULL
;
503 if (is_windows_9x () == TRUE
)
507 if (g_b_init_open_process_token
== 0)
509 g_b_init_open_process_token
= 1;
510 hm_advapi32
= LoadLibrary ("Advapi32.dll");
511 s_pfn_Open_Process_Token
=
512 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
514 if (s_pfn_Open_Process_Token
== NULL
)
519 s_pfn_Open_Process_Token (
527 get_token_information (HANDLE TokenHandle
,
528 TOKEN_INFORMATION_CLASS TokenInformationClass
,
529 LPVOID TokenInformation
,
530 DWORD TokenInformationLength
,
533 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
534 HMODULE hm_advapi32
= NULL
;
535 if (is_windows_9x () == TRUE
)
539 if (g_b_init_get_token_information
== 0)
541 g_b_init_get_token_information
= 1;
542 hm_advapi32
= LoadLibrary ("Advapi32.dll");
543 s_pfn_Get_Token_Information
=
544 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
546 if (s_pfn_Get_Token_Information
== NULL
)
551 s_pfn_Get_Token_Information (
553 TokenInformationClass
,
555 TokenInformationLength
,
561 lookup_account_sid (LPCTSTR lpSystemName
,
566 LPDWORD cbDomainName
,
569 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
570 HMODULE hm_advapi32
= NULL
;
571 if (is_windows_9x () == TRUE
)
575 if (g_b_init_lookup_account_sid
== 0)
577 g_b_init_lookup_account_sid
= 1;
578 hm_advapi32
= LoadLibrary ("Advapi32.dll");
579 s_pfn_Lookup_Account_Sid
=
580 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
582 if (s_pfn_Lookup_Account_Sid
== NULL
)
587 s_pfn_Lookup_Account_Sid (
599 get_sid_sub_authority (PSID pSid
, DWORD n
)
601 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
602 static DWORD zero
= 0U;
603 HMODULE hm_advapi32
= NULL
;
604 if (is_windows_9x () == TRUE
)
608 if (g_b_init_get_sid_sub_authority
== 0)
610 g_b_init_get_sid_sub_authority
= 1;
611 hm_advapi32
= LoadLibrary ("Advapi32.dll");
612 s_pfn_Get_Sid_Sub_Authority
=
613 (GetSidSubAuthority_Proc
) GetProcAddress (
614 hm_advapi32
, "GetSidSubAuthority");
616 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
620 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
624 get_sid_sub_authority_count (PSID pSid
)
626 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
627 static UCHAR zero
= 0U;
628 HMODULE hm_advapi32
= NULL
;
629 if (is_windows_9x () == TRUE
)
633 if (g_b_init_get_sid_sub_authority_count
== 0)
635 g_b_init_get_sid_sub_authority_count
= 1;
636 hm_advapi32
= LoadLibrary ("Advapi32.dll");
637 s_pfn_Get_Sid_Sub_Authority_Count
=
638 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
639 hm_advapi32
, "GetSidSubAuthorityCount");
641 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
645 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
649 get_security_info (HANDLE handle
,
650 SE_OBJECT_TYPE ObjectType
,
651 SECURITY_INFORMATION SecurityInfo
,
656 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
658 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
659 HMODULE hm_advapi32
= NULL
;
660 if (is_windows_9x () == TRUE
)
664 if (g_b_init_get_security_info
== 0)
666 g_b_init_get_security_info
= 1;
667 hm_advapi32
= LoadLibrary ("Advapi32.dll");
668 s_pfn_Get_Security_Info
=
669 (GetSecurityInfo_Proc
) GetProcAddress (
670 hm_advapi32
, "GetSecurityInfo");
672 if (s_pfn_Get_Security_Info
== NULL
)
676 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
677 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
678 ppSecurityDescriptor
));
682 get_file_security (LPCTSTR lpFileName
,
683 SECURITY_INFORMATION RequestedInformation
,
684 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
686 LPDWORD lpnLengthNeeded
)
688 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
689 HMODULE hm_advapi32
= NULL
;
690 if (is_windows_9x () == TRUE
)
695 if (g_b_init_get_file_security
== 0)
697 g_b_init_get_file_security
= 1;
698 hm_advapi32
= LoadLibrary ("Advapi32.dll");
699 s_pfn_Get_File_Security
=
700 (GetFileSecurity_Proc
) GetProcAddress (
701 hm_advapi32
, GetFileSecurity_Name
);
703 if (s_pfn_Get_File_Security
== NULL
)
708 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
709 pSecurityDescriptor
, nLength
,
714 set_file_security (LPCTSTR lpFileName
,
715 SECURITY_INFORMATION SecurityInformation
,
716 PSECURITY_DESCRIPTOR pSecurityDescriptor
)
718 static SetFileSecurity_Proc s_pfn_Set_File_Security
= NULL
;
719 HMODULE hm_advapi32
= NULL
;
720 if (is_windows_9x () == TRUE
)
725 if (g_b_init_set_file_security
== 0)
727 g_b_init_set_file_security
= 1;
728 hm_advapi32
= LoadLibrary ("Advapi32.dll");
729 s_pfn_Set_File_Security
=
730 (SetFileSecurity_Proc
) GetProcAddress (
731 hm_advapi32
, SetFileSecurity_Name
);
733 if (s_pfn_Set_File_Security
== NULL
)
738 return (s_pfn_Set_File_Security (lpFileName
, SecurityInformation
,
739 pSecurityDescriptor
));
743 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
745 LPBOOL lpbOwnerDefaulted
)
747 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
748 HMODULE hm_advapi32
= NULL
;
749 if (is_windows_9x () == TRUE
)
754 if (g_b_init_get_security_descriptor_owner
== 0)
756 g_b_init_get_security_descriptor_owner
= 1;
757 hm_advapi32
= LoadLibrary ("Advapi32.dll");
758 s_pfn_Get_Security_Descriptor_Owner
=
759 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
760 hm_advapi32
, "GetSecurityDescriptorOwner");
762 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
767 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
772 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
774 LPBOOL lpbGroupDefaulted
)
776 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
777 HMODULE hm_advapi32
= NULL
;
778 if (is_windows_9x () == TRUE
)
783 if (g_b_init_get_security_descriptor_group
== 0)
785 g_b_init_get_security_descriptor_group
= 1;
786 hm_advapi32
= LoadLibrary ("Advapi32.dll");
787 s_pfn_Get_Security_Descriptor_Group
=
788 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
789 hm_advapi32
, "GetSecurityDescriptorGroup");
791 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
796 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
801 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
802 LPBOOL lpbDaclPresent
,
804 LPBOOL lpbDaclDefaulted
)
806 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl
= NULL
;
807 HMODULE hm_advapi32
= NULL
;
808 if (is_windows_9x () == TRUE
)
813 if (g_b_init_get_security_descriptor_dacl
== 0)
815 g_b_init_get_security_descriptor_dacl
= 1;
816 hm_advapi32
= LoadLibrary ("Advapi32.dll");
817 s_pfn_Get_Security_Descriptor_Dacl
=
818 (GetSecurityDescriptorDacl_Proc
) GetProcAddress (
819 hm_advapi32
, "GetSecurityDescriptorDacl");
821 if (s_pfn_Get_Security_Descriptor_Dacl
== NULL
)
826 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor
,
827 lpbDaclPresent
, pDacl
,
832 is_valid_sid (PSID sid
)
834 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
835 HMODULE hm_advapi32
= NULL
;
836 if (is_windows_9x () == TRUE
)
840 if (g_b_init_is_valid_sid
== 0)
842 g_b_init_is_valid_sid
= 1;
843 hm_advapi32
= LoadLibrary ("Advapi32.dll");
845 (IsValidSid_Proc
) GetProcAddress (
846 hm_advapi32
, "IsValidSid");
848 if (s_pfn_Is_Valid_Sid
== NULL
)
852 return (s_pfn_Is_Valid_Sid (sid
));
856 equal_sid (PSID sid1
, PSID sid2
)
858 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
859 HMODULE hm_advapi32
= NULL
;
860 if (is_windows_9x () == TRUE
)
864 if (g_b_init_equal_sid
== 0)
866 g_b_init_equal_sid
= 1;
867 hm_advapi32
= LoadLibrary ("Advapi32.dll");
869 (EqualSid_Proc
) GetProcAddress (
870 hm_advapi32
, "EqualSid");
872 if (s_pfn_Equal_Sid
== NULL
)
876 return (s_pfn_Equal_Sid (sid1
, sid2
));
880 get_length_sid (PSID sid
)
882 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
883 HMODULE hm_advapi32
= NULL
;
884 if (is_windows_9x () == TRUE
)
888 if (g_b_init_get_length_sid
== 0)
890 g_b_init_get_length_sid
= 1;
891 hm_advapi32
= LoadLibrary ("Advapi32.dll");
892 s_pfn_Get_Length_Sid
=
893 (GetLengthSid_Proc
) GetProcAddress (
894 hm_advapi32
, "GetLengthSid");
896 if (s_pfn_Get_Length_Sid
== NULL
)
900 return (s_pfn_Get_Length_Sid (sid
));
904 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
906 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
907 HMODULE hm_advapi32
= NULL
;
908 if (is_windows_9x () == TRUE
)
912 if (g_b_init_copy_sid
== 0)
914 g_b_init_copy_sid
= 1;
915 hm_advapi32
= LoadLibrary ("Advapi32.dll");
917 (CopySid_Proc
) GetProcAddress (
918 hm_advapi32
, "CopySid");
920 if (s_pfn_Copy_Sid
== NULL
)
924 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
928 END: Wrapper functions around OpenProcessToken
929 and other functions in advapi32.dll that are only
930 supported in Windows NT / 2k / XP
934 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
936 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
937 if (is_windows_9x () != TRUE
)
939 if (g_b_init_get_native_system_info
== 0)
941 g_b_init_get_native_system_info
= 1;
942 s_pfn_Get_Native_System_Info
=
943 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
944 "GetNativeSystemInfo");
946 if (s_pfn_Get_Native_System_Info
!= NULL
)
947 s_pfn_Get_Native_System_Info (lpSystemInfo
);
950 lpSystemInfo
->dwNumberOfProcessors
= -1;
954 get_system_times (LPFILETIME lpIdleTime
,
955 LPFILETIME lpKernelTime
,
956 LPFILETIME lpUserTime
)
958 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
959 if (is_windows_9x () == TRUE
)
963 if (g_b_init_get_system_times
== 0)
965 g_b_init_get_system_times
= 1;
966 s_pfn_Get_System_times
=
967 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
970 if (s_pfn_Get_System_times
== NULL
)
972 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
975 static BOOLEAN WINAPI
976 create_symbolic_link (LPTSTR lpSymlinkFilename
,
977 LPTSTR lpTargetFileName
,
980 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link
= NULL
;
983 if (is_windows_9x () == TRUE
)
988 if (g_b_init_create_symbolic_link
== 0)
990 g_b_init_create_symbolic_link
= 1;
992 s_pfn_Create_Symbolic_Link
=
993 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
994 "CreateSymbolicLinkW");
996 s_pfn_Create_Symbolic_Link
=
997 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
998 "CreateSymbolicLinkA");
1001 if (s_pfn_Create_Symbolic_Link
== NULL
)
1007 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
1009 /* If we were denied creation of the symlink, try again after
1010 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1013 TOKEN_PRIVILEGES priv_current
;
1015 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
, &priv_current
))
1017 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
1019 restore_privilege (&priv_current
);
1027 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor
)
1029 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc
= NULL
;
1031 if (is_windows_9x () == TRUE
)
1037 if (g_b_init_is_valid_security_descriptor
== 0)
1039 g_b_init_is_valid_security_descriptor
= 1;
1040 s_pfn_Is_Valid_Security_Descriptor_Proc
=
1041 (IsValidSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1042 "IsValidSecurityDescriptor");
1044 if (s_pfn_Is_Valid_Security_Descriptor_Proc
== NULL
)
1050 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor
);
1054 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor
,
1055 DWORD RequestedStringSDRevision
,
1056 SECURITY_INFORMATION SecurityInformation
,
1057 LPTSTR
*StringSecurityDescriptor
,
1058 PULONG StringSecurityDescriptorLen
)
1060 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL
= NULL
;
1063 if (is_windows_9x () == TRUE
)
1069 if (g_b_init_convert_sd_to_sddl
== 0)
1071 g_b_init_convert_sd_to_sddl
= 1;
1073 s_pfn_Convert_SD_To_SDDL
=
1074 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1075 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1077 s_pfn_Convert_SD_To_SDDL
=
1078 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1079 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1082 if (s_pfn_Convert_SD_To_SDDL
== NULL
)
1088 retval
= s_pfn_Convert_SD_To_SDDL (SecurityDescriptor
,
1089 RequestedStringSDRevision
,
1090 SecurityInformation
,
1091 StringSecurityDescriptor
,
1092 StringSecurityDescriptorLen
);
1098 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor
,
1099 DWORD StringSDRevision
,
1100 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
1101 PULONG SecurityDescriptorSize
)
1103 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD
= NULL
;
1106 if (is_windows_9x () == TRUE
)
1112 if (g_b_init_convert_sddl_to_sd
== 0)
1114 g_b_init_convert_sddl_to_sd
= 1;
1116 s_pfn_Convert_SDDL_To_SD
=
1117 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1118 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1120 s_pfn_Convert_SDDL_To_SD
=
1121 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1122 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1125 if (s_pfn_Convert_SDDL_To_SD
== NULL
)
1131 retval
= s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor
,
1134 SecurityDescriptorSize
);
1140 get_adapters_info (PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
1142 static GetAdaptersInfo_Proc s_pfn_Get_Adapters_Info
= NULL
;
1143 HMODULE hm_iphlpapi
= NULL
;
1145 if (is_windows_9x () == TRUE
)
1146 return ERROR_NOT_SUPPORTED
;
1148 if (g_b_init_get_adapters_info
== 0)
1150 g_b_init_get_adapters_info
= 1;
1151 hm_iphlpapi
= LoadLibrary ("Iphlpapi.dll");
1153 s_pfn_Get_Adapters_Info
= (GetAdaptersInfo_Proc
)
1154 GetProcAddress (hm_iphlpapi
, "GetAdaptersInfo");
1156 if (s_pfn_Get_Adapters_Info
== NULL
)
1157 return ERROR_NOT_SUPPORTED
;
1158 return s_pfn_Get_Adapters_Info (pAdapterInfo
, pOutBufLen
);
1163 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1164 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1166 This is called from alloc.c:valid_pointer_p. */
1168 w32_valid_pointer_p (void *p
, int size
)
1171 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
1175 unsigned char *buf
= alloca (size
);
1176 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
1187 /* Converting file names from UTF-8 to either UTF-16 or the ANSI
1188 codepage defined by file-name-coding-system. */
1190 /* Current codepage for encoding file names. */
1191 static int file_name_codepage
;
1193 /* Produce a Windows ANSI codepage suitable for encoding file names.
1194 Return the information about that codepage in CP_INFO. */
1196 codepage_for_filenames (CPINFO
*cp_info
)
1198 /* A simple cache to avoid calling GetCPInfo every time we need to
1199 encode/decode a file name. The file-name encoding is not
1200 supposed to be changed too frequently, if ever. */
1201 static Lisp_Object last_file_name_encoding
;
1203 Lisp_Object current_encoding
;
1205 current_encoding
= Vfile_name_coding_system
;
1206 if (NILP (current_encoding
))
1207 current_encoding
= Vdefault_file_name_coding_system
;
1209 if (!EQ (last_file_name_encoding
, current_encoding
))
1211 /* Default to the current ANSI codepage. */
1212 file_name_codepage
= w32_ansi_code_page
;
1214 if (NILP (current_encoding
))
1216 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1217 char *cp
= NULL
, *end
;
1220 if (strncmp (cpname
, "cp", 2) == 0)
1222 else if (strncmp (cpname
, "windows-", 8) == 0)
1228 cpnum
= strtol (cp
, &end
, 10);
1229 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1230 file_name_codepage
= cpnum
;
1234 if (!file_name_codepage
)
1235 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1237 if (!GetCPInfo (file_name_codepage
, &cp
))
1239 file_name_codepage
= CP_ACP
;
1240 if (!GetCPInfo (file_name_codepage
, &cp
))
1247 return file_name_codepage
;
1251 filename_to_utf16 (const char *fn_in
, wchar_t *fn_out
)
1253 int result
= MultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1258 DWORD err
= GetLastError ();
1262 case ERROR_INVALID_FLAGS
:
1263 case ERROR_INVALID_PARAMETER
:
1266 case ERROR_INSUFFICIENT_BUFFER
:
1267 case ERROR_NO_UNICODE_TRANSLATION
:
1278 filename_from_utf16 (const wchar_t *fn_in
, char *fn_out
)
1280 int result
= WideCharToMultiByte (CP_UTF8
, 0, fn_in
, -1,
1281 fn_out
, MAX_UTF8_PATH
, NULL
, NULL
);
1285 DWORD err
= GetLastError ();
1289 case ERROR_INVALID_FLAGS
:
1290 case ERROR_INVALID_PARAMETER
:
1293 case ERROR_INSUFFICIENT_BUFFER
:
1294 case ERROR_NO_UNICODE_TRANSLATION
:
1305 filename_to_ansi (const char *fn_in
, char *fn_out
)
1307 wchar_t fn_utf16
[MAX_PATH
];
1309 if (filename_to_utf16 (fn_in
, fn_utf16
) == 0)
1312 int codepage
= codepage_for_filenames (NULL
);
1314 result
= WideCharToMultiByte (codepage
, 0, fn_utf16
, -1,
1315 fn_out
, MAX_PATH
, NULL
, NULL
);
1318 DWORD err
= GetLastError ();
1322 case ERROR_INVALID_FLAGS
:
1323 case ERROR_INVALID_PARAMETER
:
1326 case ERROR_INSUFFICIENT_BUFFER
:
1327 case ERROR_NO_UNICODE_TRANSLATION
:
1340 filename_from_ansi (const char *fn_in
, char *fn_out
)
1342 wchar_t fn_utf16
[MAX_PATH
];
1343 int codepage
= codepage_for_filenames (NULL
);
1344 int result
= MultiByteToWideChar (codepage
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1345 fn_utf16
, MAX_PATH
);
1349 DWORD err
= GetLastError ();
1353 case ERROR_INVALID_FLAGS
:
1354 case ERROR_INVALID_PARAMETER
:
1357 case ERROR_INSUFFICIENT_BUFFER
:
1358 case ERROR_NO_UNICODE_TRANSLATION
:
1365 return filename_from_utf16 (fn_utf16
, fn_out
);
1370 /* The directory where we started, in UTF-8. */
1371 static char startup_dir
[MAX_UTF8_PATH
];
1373 /* Get the current working directory. */
1375 getcwd (char *dir
, int dirsize
)
1382 if (dirsize
<= strlen (startup_dir
))
1388 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
1392 /* Emacs doesn't actually change directory itself, it stays in the
1393 same directory where it was started. */
1394 strcpy (dir
, startup_dir
);
1399 /* Emulate getloadavg. */
1401 struct load_sample
{
1408 /* Number of processors on this machine. */
1409 static unsigned num_of_processors
;
1411 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1412 static struct load_sample samples
[16*60];
1413 static int first_idx
= -1, last_idx
= -1;
1414 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
1419 int next_idx
= from
+ 1;
1421 if (next_idx
>= max_idx
)
1430 int prev_idx
= from
- 1;
1433 prev_idx
= max_idx
- 1;
1439 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
1441 SYSTEM_INFO sysinfo
;
1442 FILETIME ft_idle
, ft_user
, ft_kernel
;
1444 /* Initialize the number of processors on this machine. */
1445 if (num_of_processors
<= 0)
1447 get_native_system_info (&sysinfo
);
1448 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1449 if (num_of_processors
<= 0)
1451 GetSystemInfo (&sysinfo
);
1452 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1454 if (num_of_processors
<= 0)
1455 num_of_processors
= 1;
1458 /* TODO: Take into account threads that are ready to run, by
1459 sampling the "\System\Processor Queue Length" performance
1460 counter. The code below accounts only for threads that are
1461 actually running. */
1463 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1465 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1467 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1468 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1469 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1470 *idle
= uidle
.QuadPart
;
1471 *kernel
= ukernel
.QuadPart
;
1472 *user
= uuser
.QuadPart
;
1482 /* Produce the load average for a given time interval, using the
1483 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1484 1-minute, 5-minute, or 15-minute average, respectively. */
1488 double retval
= -1.0;
1491 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1492 time_t now
= samples
[last_idx
].sample_time
;
1494 if (first_idx
!= last_idx
)
1496 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1498 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1499 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1502 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1503 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1504 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1506 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1509 if (idx
== first_idx
)
1518 getloadavg (double loadavg
[], int nelem
)
1521 ULONGLONG idle
, kernel
, user
;
1522 time_t now
= time (NULL
);
1524 /* Store another sample. We ignore samples that are less than 1 sec
1526 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1528 sample_system_load (&idle
, &kernel
, &user
);
1529 last_idx
= buf_next (last_idx
);
1530 samples
[last_idx
].sample_time
= now
;
1531 samples
[last_idx
].idle
= idle
;
1532 samples
[last_idx
].kernel
= kernel
;
1533 samples
[last_idx
].user
= user
;
1534 /* If the buffer has more that 15 min worth of samples, discard
1536 if (first_idx
== -1)
1537 first_idx
= last_idx
;
1538 while (first_idx
!= last_idx
1539 && (difftime (now
, samples
[first_idx
].sample_time
)
1540 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1541 first_idx
= buf_next (first_idx
);
1544 for (elem
= 0; elem
< nelem
; elem
++)
1546 double avg
= getavg (elem
);
1550 loadavg
[elem
] = avg
;
1556 /* Emulate getpwuid, getpwnam and others. */
1558 #define PASSWD_FIELD_SIZE 256
1560 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1561 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1562 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1563 static char dflt_passwd_dir
[MAX_UTF8_PATH
];
1564 static char dflt_passwd_shell
[MAX_UTF8_PATH
];
1566 static struct passwd dflt_passwd
=
1578 static char dflt_group_name
[GNLEN
+1];
1580 static struct group dflt_group
=
1582 /* When group information is not available, we return this as the
1583 group for all files. */
1591 return dflt_passwd
.pw_uid
;
1597 /* I could imagine arguing for checking to see whether the user is
1598 in the Administrators group and returning a UID of 0 for that
1599 case, but I don't know how wise that would be in the long run. */
1606 return dflt_passwd
.pw_gid
;
1616 getpwuid (unsigned uid
)
1618 if (uid
== dflt_passwd
.pw_uid
)
1619 return &dflt_passwd
;
1624 getgrgid (gid_t gid
)
1630 getpwnam (char *name
)
1634 pw
= getpwuid (getuid ());
1638 if (xstrcasecmp (name
, pw
->pw_name
))
1645 init_user_info (void)
1647 /* Find the user's real name by opening the process token and
1648 looking up the name associated with the user-sid in that token.
1650 Use the relative portion of the identifier authority value from
1651 the user-sid as the user id value (same for group id using the
1652 primary group sid from the process token). */
1654 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1655 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1656 DWORD glength
= sizeof (gname
);
1657 HANDLE token
= NULL
;
1658 SID_NAME_USE user_type
;
1659 unsigned char *buf
= NULL
;
1661 TOKEN_USER user_token
;
1662 TOKEN_PRIMARY_GROUP group_token
;
1665 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1668 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1669 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1671 buf
= xmalloc (blen
);
1672 result
= get_token_information (token
, TokenUser
,
1673 (LPVOID
)buf
, blen
, &needed
);
1676 memcpy (&user_token
, buf
, sizeof (user_token
));
1677 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1679 domain
, &dlength
, &user_type
);
1687 strcpy (dflt_passwd
.pw_name
, uname
);
1688 /* Determine a reasonable uid value. */
1689 if (xstrcasecmp ("administrator", uname
) == 0)
1691 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1692 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1696 /* Use the last sub-authority value of the RID, the relative
1697 portion of the SID, as user/group ID. */
1698 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1700 /* Get group id and name. */
1701 result
= get_token_information (token
, TokenPrimaryGroup
,
1702 (LPVOID
)buf
, blen
, &needed
);
1703 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1705 buf
= xrealloc (buf
, blen
= needed
);
1706 result
= get_token_information (token
, TokenPrimaryGroup
,
1707 (LPVOID
)buf
, blen
, &needed
);
1711 memcpy (&group_token
, buf
, sizeof (group_token
));
1712 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1713 dlength
= sizeof (domain
);
1714 /* If we can get at the real Primary Group name, use that.
1715 Otherwise, the default group name was already set to
1716 "None" in globals_of_w32. */
1717 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1718 gname
, &glength
, NULL
, &dlength
,
1720 strcpy (dflt_group_name
, gname
);
1723 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1726 /* If security calls are not supported (presumably because we
1727 are running under Windows 9X), fallback to this: */
1728 else if (GetUserName (uname
, &ulength
))
1730 strcpy (dflt_passwd
.pw_name
, uname
);
1731 if (xstrcasecmp ("administrator", uname
) == 0)
1732 dflt_passwd
.pw_uid
= 0;
1734 dflt_passwd
.pw_uid
= 123;
1735 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1739 strcpy (dflt_passwd
.pw_name
, "unknown");
1740 dflt_passwd
.pw_uid
= 123;
1741 dflt_passwd
.pw_gid
= 123;
1743 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1745 /* Set dir and shell from environment variables. */
1746 if (w32_unicode_filenames
)
1748 wchar_t *home
= _wgetenv (L
"HOME");
1749 wchar_t *shell
= _wgetenv (L
"SHELL");
1751 /* Ensure HOME and SHELL are defined. */
1756 filename_from_utf16 (home
, dflt_passwd
.pw_dir
);
1757 filename_from_utf16 (shell
, dflt_passwd
.pw_shell
);
1761 char *home
= getenv ("HOME");
1762 char *shell
= getenv ("SHELL");
1768 filename_from_ansi (home
, dflt_passwd
.pw_dir
);
1769 filename_from_ansi (shell
, dflt_passwd
.pw_shell
);
1774 CloseHandle (token
);
1780 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1781 return ((rand () << 15) | rand ());
1790 /* Return the maximum length in bytes of a multibyte character
1791 sequence encoded in the current ANSI codepage. This is required to
1792 correctly walk the encoded file names one character at a time. */
1794 max_filename_mbslen (void)
1798 codepage_for_filenames (&cp_info
);
1799 return cp_info
.MaxCharSize
;
1802 /* Normalize filename by converting in-place all of its path
1803 separators to the separator specified by PATH_SEP. */
1806 normalize_filename (register char *fp
, char path_sep
)
1810 /* Always lower-case drive letters a-z, even if the filesystem
1811 preserves case in filenames.
1812 This is so filenames can be compared by string comparison
1813 functions that are case-sensitive. Even case-preserving filesystems
1814 do not distinguish case in drive letters. */
1817 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
1825 if (*fp
== '/' || *fp
== '\\')
1831 /* Destructively turn backslashes into slashes. */
1833 dostounix_filename (register char *p
)
1835 normalize_filename (p
, '/');
1838 /* Destructively turn slashes into backslashes. */
1840 unixtodos_filename (register char *p
)
1842 normalize_filename (p
, '\\');
1845 /* Remove all CR's that are followed by a LF.
1846 (From msdos.c...probably should figure out a way to share it,
1847 although this code isn't going to ever change.) */
1849 crlf_to_lf (register int n
, register unsigned char *buf
)
1851 unsigned char *np
= buf
;
1852 unsigned char *startp
= buf
;
1853 unsigned char *endp
= buf
+ n
;
1857 while (buf
< endp
- 1)
1861 if (*(++buf
) != 0x0a)
1872 /* Parse the root part of file name, if present. Return length and
1873 optionally store pointer to char after root. */
1875 parse_root (char * name
, char ** pPath
)
1877 char * start
= name
;
1882 /* find the root name of the volume if given */
1883 if (isalpha (name
[0]) && name
[1] == ':')
1885 /* skip past drive specifier */
1887 if (IS_DIRECTORY_SEP (name
[0]))
1890 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1897 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1902 if (IS_DIRECTORY_SEP (name
[0]))
1909 return name
- start
;
1912 /* Get long base name for name; name is assumed to be absolute. */
1914 get_long_basename (char * name
, char * buf
, int size
)
1917 char fname_utf8
[MAX_UTF8_PATH
];
1921 /* Must be valid filename, no wild cards or other invalid characters. */
1922 if (strpbrk (name
, "*?|<>\""))
1925 if (w32_unicode_filenames
)
1927 wchar_t fname_utf16
[MAX_PATH
];
1928 WIN32_FIND_DATAW find_data_wide
;
1930 filename_to_utf16 (name
, fname_utf16
);
1931 dir_handle
= FindFirstFileW (fname_utf16
, &find_data_wide
);
1932 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1933 cstatus
= filename_from_utf16 (find_data_wide
.cFileName
, fname_utf8
);
1937 char fname_ansi
[MAX_PATH
];
1938 WIN32_FIND_DATAA find_data_ansi
;
1940 filename_to_ansi (name
, fname_ansi
);
1941 dir_handle
= FindFirstFileA (fname_ansi
, &find_data_ansi
);
1942 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1943 cstatus
= filename_from_ansi (find_data_ansi
.cFileName
, fname_utf8
);
1946 if (cstatus
== 0 && (len
= strlen (fname_utf8
)) < size
)
1947 memcpy (buf
, fname_utf8
, len
+ 1);
1951 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1952 FindClose (dir_handle
);
1957 /* Get long name for file, if possible (assumed to be absolute). */
1959 w32_get_long_filename (char * name
, char * buf
, int size
)
1964 char full
[ MAX_UTF8_PATH
];
1967 len
= strlen (name
);
1968 if (len
>= MAX_UTF8_PATH
)
1971 /* Use local copy for destructive modification. */
1972 memcpy (full
, name
, len
+1);
1973 unixtodos_filename (full
);
1975 /* Copy root part verbatim. */
1976 len
= parse_root (full
, &p
);
1977 memcpy (o
, full
, len
);
1982 while (p
!= NULL
&& *p
)
1985 p
= strchr (q
, '\\');
1987 len
= get_long_basename (full
, o
, size
);
2010 w32_get_short_filename (char * name
, char * buf
, int size
)
2012 if (w32_unicode_filenames
)
2014 wchar_t name_utf16
[MAX_PATH
], short_name
[MAX_PATH
];
2015 unsigned int retval
;
2017 filename_to_utf16 (name
, name_utf16
);
2018 retval
= GetShortPathNameW (name_utf16
, short_name
, size
);
2019 if (retval
&& retval
< size
)
2020 filename_from_utf16 (short_name
, buf
);
2025 char name_ansi
[MAX_PATH
];
2027 filename_to_ansi (name
, name_ansi
);
2028 return GetShortPathNameA (name_ansi
, buf
, size
);
2033 is_unc_volume (const char *filename
)
2035 const char *ptr
= filename
;
2037 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
2040 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
2046 /* Emulate the Posix unsetenv. */
2048 unsetenv (const char *name
)
2054 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
2059 name_len
= strlen (name
);
2060 /* MS docs says an environment variable cannot be longer than 32K. */
2061 if (name_len
> 32767)
2066 /* It is safe to use 'alloca' with 32K size, since the stack is at
2067 least 2MB, and we set it to 8MB in the link command line. */
2068 var
= alloca (name_len
+ 2);
2069 strncpy (var
, name
, name_len
);
2070 var
[name_len
++] = '=';
2071 var
[name_len
] = '\0';
2072 return _putenv (var
);
2075 /* MS _putenv doesn't support removing a variable when the argument
2076 does not include the '=' character, so we fix that here. */
2078 sys_putenv (char *str
)
2080 const char *const name_end
= strchr (str
, '=');
2082 if (name_end
== NULL
)
2084 /* Remove the variable from the environment. */
2085 return unsetenv (str
);
2088 return _putenv (str
);
2091 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
2094 w32_get_resource (char *key
, LPDWORD lpdwtype
)
2097 HKEY hrootkey
= NULL
;
2100 /* Check both the current user and the local machine to see if
2101 we have any resources. */
2103 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2107 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2108 && (lpvalue
= xmalloc (cbData
)) != NULL
2109 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2111 RegCloseKey (hrootkey
);
2117 RegCloseKey (hrootkey
);
2120 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2124 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2125 && (lpvalue
= xmalloc (cbData
)) != NULL
2126 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2128 RegCloseKey (hrootkey
);
2134 RegCloseKey (hrootkey
);
2141 init_environment (char ** argv
)
2143 static const char * const tempdirs
[] = {
2144 "$TMPDIR", "$TEMP", "$TMP", "c:/"
2149 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
2151 /* Implementation note: This function explicitly works with ANSI
2152 file names, not with UTF-8 encoded file names. This is because
2153 this function pushes variables into the Emacs's environment, and
2154 the environment variables are always assumed to be in the
2155 locale-specific encoding. Do NOT call any functions that accept
2156 UTF-8 file names from this function! */
2158 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
2159 temporary files and assume "/tmp" if $TMPDIR is unset, which
2160 will break on DOS/Windows. Refuse to work if we cannot find
2161 a directory, not even "c:/", usable for that purpose. */
2162 for (i
= 0; i
< imax
; i
++)
2164 const char *tmp
= tempdirs
[i
];
2167 tmp
= getenv (tmp
+ 1);
2168 /* Note that `access' can lie to us if the directory resides on a
2169 read-only filesystem, like CD-ROM or a write-protected floppy.
2170 The only way to be really sure is to actually create a file and
2171 see if it succeeds. But I think that's too much to ask. */
2173 /* MSVCRT's _access crashes with D_OK, so we use our replacement. */
2174 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
2176 char * var
= alloca (strlen (tmp
) + 8);
2177 sprintf (var
, "TMPDIR=%s", tmp
);
2178 _putenv (strdup (var
));
2185 Fcons (build_string ("no usable temporary directories found!!"),
2187 "While setting TMPDIR: ");
2189 /* Check for environment variables and use registry settings if they
2190 don't exist. Fallback on default values where applicable. */
2195 char locale_name
[32];
2196 char default_home
[MAX_PATH
];
2199 static const struct env_entry
2205 /* If the default value is NULL, we will use the value from the
2206 outside environment or the Registry, but will not push the
2207 variable into the Emacs environment if it is defined neither
2208 in the Registry nor in the outside environment. */
2210 {"PRELOAD_WINSOCK", NULL
},
2211 {"emacs_dir", "C:/emacs"},
2212 {"EMACSLOADPATH", NULL
},
2213 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2214 {"EMACSDATA", NULL
},
2215 {"EMACSPATH", NULL
},
2222 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2224 /* We need to copy dflt_envvars[] and work on the copy because we
2225 don't want the dumped Emacs to inherit the values of
2226 environment variables we saw during dumping (which could be on
2227 a different system). The defaults above must be left intact. */
2228 struct env_entry env_vars
[N_ENV_VARS
];
2230 for (i
= 0; i
< N_ENV_VARS
; i
++)
2231 env_vars
[i
] = dflt_envvars
[i
];
2233 /* For backwards compatibility, check if a .emacs file exists in C:/
2234 If not, then we can try to default to the appdata directory under the
2235 user's profile, which is more likely to be writable. */
2236 if (sys_access ("C:/.emacs", F_OK
) != 0)
2238 HRESULT profile_result
;
2239 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2240 of Windows 95 and NT4 that have not been updated to include
2242 ShGetFolderPath_fn get_folder_path
;
2243 get_folder_path
= (ShGetFolderPath_fn
)
2244 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2246 if (get_folder_path
!= NULL
)
2248 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2251 /* If we can't get the appdata dir, revert to old behavior. */
2252 if (profile_result
== S_OK
)
2254 env_vars
[0].def_value
= default_home
;
2260 /* Get default locale info and use it for LANG. */
2261 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2262 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2263 locale_name
, sizeof (locale_name
)))
2265 for (i
= 0; i
< N_ENV_VARS
; i
++)
2267 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2269 env_vars
[i
].def_value
= locale_name
;
2275 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2277 /* Treat emacs_dir specially: set it unconditionally based on our
2281 char modname
[MAX_PATH
];
2283 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2285 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2289 if ((p
= _mbsrchr (modname
, '\\'))
2290 /* From bin means installed Emacs, from src means uninstalled. */
2291 && (xstrcasecmp (p
, "\\bin") == 0 || xstrcasecmp (p
, "\\src") == 0))
2293 char buf
[SET_ENV_BUF_SIZE
];
2294 int within_build_tree
= xstrcasecmp (p
, "\\src") == 0;
2297 for (p
= modname
; *p
; p
= CharNext (p
))
2298 if (*p
== '\\') *p
= '/';
2300 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2301 _putenv (strdup (buf
));
2302 /* If we are running from the Posix-like build tree, define
2303 SHELL to point to our own cmdproxy. The loop below will
2304 then disregard PATH_EXEC and the default value. */
2305 if (within_build_tree
)
2307 _snprintf (buf
, sizeof (buf
) - 1,
2308 "SHELL=%s/nt/cmdproxy.exe", modname
);
2309 _putenv (strdup (buf
));
2314 for (i
= 0; i
< N_ENV_VARS
; i
++)
2316 if (!getenv (env_vars
[i
].name
))
2319 char bufc
[SET_ENV_BUF_SIZE
];
2321 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2322 /* Also ignore empty environment variables. */
2327 if (strcmp (env_vars
[i
].name
, "SHELL") == 0)
2329 /* Look for cmdproxy.exe in every directory in
2330 PATH_EXEC. FIXME: This does not find cmdproxy
2331 in nt/ when we run uninstalled. */
2332 char fname
[MAX_PATH
];
2333 const char *pstart
= PATH_EXEC
, *pend
;
2336 pend
= _mbschr (pstart
, ';');
2338 pend
= pstart
+ strlen (pstart
);
2339 /* Be defensive against series of ;;; characters. */
2342 strncpy (fname
, pstart
, pend
- pstart
);
2343 fname
[pend
- pstart
] = '/';
2344 strcpy (&fname
[pend
- pstart
+ 1], "cmdproxy.exe");
2345 ExpandEnvironmentStrings ((LPSTR
) fname
, bufc
,
2347 if (sys_access (bufc
, F_OK
) == 0)
2360 /* If not found in any directory, use the
2361 default as the last resort. */
2362 lpval
= env_vars
[i
].def_value
;
2363 dwType
= REG_EXPAND_SZ
;
2369 lpval
= env_vars
[i
].def_value
;
2370 dwType
= REG_EXPAND_SZ
;
2372 if (strcmp (env_vars
[i
].name
, "HOME") == 0 && !appdata
)
2373 Vdelayed_warnings_list
2374 = Fcons (listn (CONSTYPE_HEAP
, 2,
2375 intern ("initialization"),
2376 build_string ("Setting HOME to C:\\ by default is deprecated")),
2377 Vdelayed_warnings_list
);
2382 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2384 if (dwType
== REG_EXPAND_SZ
)
2385 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2386 else if (dwType
== REG_SZ
)
2387 strcpy (buf1
, lpval
);
2388 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2390 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2392 _putenv (strdup (buf2
));
2402 /* Rebuild system configuration to reflect invoking system. */
2403 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2405 /* Another special case: on NT, the PATH variable is actually named
2406 "Path" although cmd.exe (perhaps NT itself) arranges for
2407 environment variable lookup and setting to be case insensitive.
2408 However, Emacs assumes a fully case sensitive environment, so we
2409 need to change "Path" to "PATH" to match the expectations of
2410 various elisp packages. We do this by the sneaky method of
2411 modifying the string in the C runtime environ entry.
2413 The same applies to COMSPEC. */
2417 for (envp
= environ
; *envp
; envp
++)
2418 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2419 memcpy (*envp
, "PATH=", 5);
2420 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2421 memcpy (*envp
, "COMSPEC=", 8);
2424 /* Remember the initial working directory for getcwd. */
2425 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2426 Does it matter anywhere in Emacs? */
2427 if (w32_unicode_filenames
)
2429 wchar_t wstartup_dir
[MAX_PATH
];
2431 if (!GetCurrentDirectoryW (MAX_PATH
, wstartup_dir
))
2433 filename_from_utf16 (wstartup_dir
, startup_dir
);
2437 char astartup_dir
[MAX_PATH
];
2439 if (!GetCurrentDirectoryA (MAX_PATH
, astartup_dir
))
2441 filename_from_ansi (astartup_dir
, startup_dir
);
2445 static char modname
[MAX_PATH
];
2447 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2452 /* Determine if there is a middle mouse button, to allow parse_button
2453 to decide whether right mouse events should be mouse-2 or
2455 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2460 /* Called from expand-file-name when default-directory is not a string. */
2463 emacs_root_dir (void)
2465 static char root_dir
[MAX_UTF8_PATH
];
2468 p
= getenv ("emacs_dir");
2471 filename_from_ansi (p
, root_dir
);
2472 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2473 dostounix_filename (root_dir
);
2477 #include <sys/timeb.h>
2479 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2481 gettimeofday (struct timeval
*__restrict tv
, struct timezone
*__restrict tz
)
2486 tv
->tv_sec
= tb
.time
;
2487 tv
->tv_usec
= tb
.millitm
* 1000L;
2488 /* Implementation note: _ftime sometimes doesn't update the dstflag
2489 according to the new timezone when the system timezone is
2490 changed. We could fix that by using GetSystemTime and
2491 GetTimeZoneInformation, but that doesn't seem necessary, since
2492 Emacs always calls gettimeofday with the 2nd argument NULL (see
2493 current_emacs_time). */
2496 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2497 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2502 /* Emulate fdutimens. */
2504 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2505 TIMESPEC[0] and TIMESPEC[1], respectively.
2506 FD must be either negative -- in which case it is ignored --
2507 or a file descriptor that is open on FILE.
2508 If FD is nonnegative, then FILE can be NULL, which means
2509 use just futimes instead of utimes.
2510 If TIMESPEC is null, FAIL.
2511 Return 0 on success, -1 (setting errno) on failure. */
2514 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2521 if (fd
< 0 && !file
)
2526 /* _futime's prototype defines 2nd arg as having the type 'struct
2527 _utimbuf', while utime needs to accept 'struct utimbuf' for
2528 compatibility with Posix. So we need to use 2 different (but
2529 equivalent) types to avoid compiler warnings, sigh. */
2532 struct _utimbuf _ut
;
2534 _ut
.actime
= timespec
[0].tv_sec
;
2535 _ut
.modtime
= timespec
[1].tv_sec
;
2536 return _futime (fd
, &_ut
);
2542 ut
.actime
= timespec
[0].tv_sec
;
2543 ut
.modtime
= timespec
[1].tv_sec
;
2544 /* Call 'utime', which is implemented below, not the MS library
2545 function, which fails on directories. */
2546 return utime (file
, &ut
);
2551 /* ------------------------------------------------------------------------- */
2552 /* IO support and wrapper functions for the Windows API. */
2553 /* ------------------------------------------------------------------------- */
2555 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2556 on network directories, so we handle that case here.
2557 (Ulrich Leodolter, 1/11/95). */
2559 sys_ctime (const time_t *t
)
2561 char *str
= (char *) ctime (t
);
2562 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2565 /* Emulate sleep...we could have done this with a define, but that
2566 would necessitate including windows.h in the files that used it.
2567 This is much easier. */
2569 sys_sleep (int seconds
)
2571 Sleep (seconds
* 1000);
2574 /* Internal MSVC functions for low-level descriptor munging */
2575 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2576 extern int __cdecl
_free_osfhnd (int fd
);
2578 /* parallel array of private info on file handles */
2579 filedesc fd_info
[ MAXDESC
];
2581 typedef struct volume_info_data
{
2582 struct volume_info_data
* next
;
2584 /* time when info was obtained */
2587 /* actual volume info */
2596 /* Global referenced by various functions. */
2597 static volume_info_data volume_info
;
2599 /* Vector to indicate which drives are local and fixed (for which cached
2600 data never expires). */
2601 static BOOL fixed_drives
[26];
2603 /* Consider cached volume information to be stale if older than 10s,
2604 at least for non-local drives. Info for fixed drives is never stale. */
2605 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2606 #define VOLINFO_STILL_VALID( root_dir, info ) \
2607 ( ( isalpha (root_dir[0]) && \
2608 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2609 || GetTickCount () - info->timestamp < 10000 )
2611 /* Cache support functions. */
2613 /* Simple linked list with linear search is sufficient. */
2614 static volume_info_data
*volume_cache
= NULL
;
2616 static volume_info_data
*
2617 lookup_volume_info (char * root_dir
)
2619 volume_info_data
* info
;
2621 for (info
= volume_cache
; info
; info
= info
->next
)
2622 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2628 add_volume_info (char * root_dir
, volume_info_data
* info
)
2630 info
->root_dir
= xstrdup (root_dir
);
2631 info
->next
= volume_cache
;
2632 volume_cache
= info
;
2636 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2637 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2638 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2639 static volume_info_data
*
2640 GetCachedVolumeInformation (char * root_dir
)
2642 volume_info_data
* info
;
2643 char default_root
[ MAX_PATH
];
2645 /* NULL for root_dir means use root from current directory. */
2646 if (root_dir
== NULL
)
2648 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2650 parse_root (default_root
, &root_dir
);
2652 root_dir
= default_root
;
2655 /* Local fixed drives can be cached permanently. Removable drives
2656 cannot be cached permanently, since the volume name and serial
2657 number (if nothing else) can change. Remote drives should be
2658 treated as if they are removable, since there is no sure way to
2659 tell whether they are or not. Also, the UNC association of drive
2660 letters mapped to remote volumes can be changed at any time (even
2661 by other processes) without notice.
2663 As a compromise, so we can benefit from caching info for remote
2664 volumes, we use a simple expiry mechanism to invalidate cache
2665 entries that are more than ten seconds old. */
2668 /* No point doing this, because WNetGetConnection is even slower than
2669 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2670 GetDriveType is about the only call of this type which does not
2671 involve network access, and so is extremely quick). */
2673 /* Map drive letter to UNC if remote. */
2674 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2676 char remote_name
[ 256 ];
2677 char drive
[3] = { root_dir
[0], ':' };
2679 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2681 /* do something */ ;
2685 info
= lookup_volume_info (root_dir
);
2687 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2695 /* Info is not cached, or is stale. */
2696 if (!GetVolumeInformation (root_dir
,
2697 name
, sizeof (name
),
2701 type
, sizeof (type
)))
2704 /* Cache the volume information for future use, overwriting existing
2705 entry if present. */
2708 info
= xmalloc (sizeof (volume_info_data
));
2709 add_volume_info (root_dir
, info
);
2717 info
->name
= xstrdup (name
);
2718 info
->serialnum
= serialnum
;
2719 info
->maxcomp
= maxcomp
;
2720 info
->flags
= flags
;
2721 info
->type
= xstrdup (type
);
2722 info
->timestamp
= GetTickCount ();
2728 /* Get information on the volume where NAME is held; set path pointer to
2729 start of pathname in NAME (past UNC header\volume header if present),
2730 if pPath is non-NULL.
2732 Note: if NAME includes symlinks, the information is for the volume
2733 of the symlink, not of its target. That's because, even though
2734 GetVolumeInformation returns information about the symlink target
2735 of its argument, we only pass the root directory to
2736 GetVolumeInformation, not the full NAME. */
2738 get_volume_info (const char * name
, const char ** pPath
)
2740 char temp
[MAX_PATH
];
2741 char *rootname
= NULL
; /* default to current volume */
2742 volume_info_data
* info
;
2747 /* Find the root name of the volume if given. */
2748 if (isalpha (name
[0]) && name
[1] == ':')
2756 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2760 int dbcs_p
= max_filename_mbslen () > 1;
2765 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2771 const char *p
= name
;
2773 name
= CharNextExA (file_name_codepage
, name
, 0);
2774 memcpy (str
, p
, name
- p
);
2787 info
= GetCachedVolumeInformation (rootname
);
2790 /* Set global referenced by other functions. */
2791 volume_info
= *info
;
2797 /* Determine if volume is FAT format (ie. only supports short 8.3
2798 names); also set path pointer to start of pathname in name, if
2799 pPath is non-NULL. */
2801 is_fat_volume (const char * name
, const char ** pPath
)
2803 if (get_volume_info (name
, pPath
))
2804 return (volume_info
.maxcomp
== 12);
2808 /* Map filename to a valid 8.3 name if necessary.
2809 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2811 map_w32_filename (const char * name
, const char ** pPath
)
2813 static char shortname
[MAX_PATH
];
2814 char * str
= shortname
;
2817 const char * save_name
= name
;
2819 if (strlen (name
) >= MAX_PATH
)
2821 /* Return a filename which will cause callers to fail. */
2822 strcpy (shortname
, "?");
2826 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2828 register int left
= 8; /* maximum number of chars in part */
2829 register int extn
= 0; /* extension added? */
2830 register int dots
= 2; /* maximum number of dots allowed */
2833 *str
++ = *name
++; /* skip past UNC header */
2835 while ((c
= *name
++))
2842 *str
++ = (c
== ':' ? ':' : '\\');
2843 extn
= 0; /* reset extension flags */
2844 dots
= 2; /* max 2 dots */
2845 left
= 8; /* max length 8 for main part */
2850 /* Convert path components of the form .xxx to _xxx,
2851 but leave . and .. as they are. This allows .emacs
2852 to be read as _emacs, for example. */
2856 IS_DIRECTORY_SEP (*name
))
2871 extn
= 1; /* we've got an extension */
2872 left
= 3; /* 3 chars in extension */
2876 /* any embedded dots after the first are converted to _ */
2881 case '#': /* don't lose these, they're important */
2883 str
[-1] = c
; /* replace last character of part */
2888 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2890 dots
= 0; /* started a path component */
2899 strcpy (shortname
, name
);
2900 unixtodos_filename (shortname
);
2904 *pPath
= shortname
+ (path
- save_name
);
2910 is_exec (const char * name
)
2912 char * p
= strrchr (name
, '.');
2915 && (xstrcasecmp (p
, ".exe") == 0 ||
2916 xstrcasecmp (p
, ".com") == 0 ||
2917 xstrcasecmp (p
, ".bat") == 0 ||
2918 xstrcasecmp (p
, ".cmd") == 0));
2921 /* Emulate the Unix directory procedures opendir, closedir,
2922 and readdir. We can't use the procedures supplied in sysdep.c,
2923 so we provide them here. */
2925 struct dirent dir_static
; /* simulated directory contents */
2926 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2927 static int dir_is_fat
;
2928 static char dir_pathname
[MAXPATHLEN
+1];
2929 static WIN32_FIND_DATA dir_find_data
;
2931 /* Support shares on a network resource as subdirectories of a read-only
2933 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2934 static HANDLE
open_unc_volume (const char *);
2935 static char *read_unc_volume (HANDLE
, char *, int);
2936 static void close_unc_volume (HANDLE
);
2939 opendir (const char *filename
)
2943 /* Opening is done by FindFirstFile. However, a read is inherent to
2944 this operation, so we defer the open until read time. */
2946 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2948 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2951 /* Note: We don't support traversal of UNC volumes via symlinks.
2952 Doing so would mean punishing 99.99% of use cases by resolving
2953 all the possible symlinks in FILENAME, recursively. */
2954 if (is_unc_volume (filename
))
2956 wnet_enum_handle
= open_unc_volume (filename
);
2957 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2961 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2968 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2969 dir_pathname
[MAXPATHLEN
] = '\0';
2970 /* Note: We don't support symlinks to file names on FAT volumes.
2971 Doing so would mean punishing 99.99% of use cases by resolving
2972 all the possible symlinks in FILENAME, recursively. */
2973 dir_is_fat
= is_fat_volume (filename
, NULL
);
2979 closedir (DIR *dirp
)
2981 /* If we have a find-handle open, close it. */
2982 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2984 FindClose (dir_find_handle
);
2985 dir_find_handle
= INVALID_HANDLE_VALUE
;
2987 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2989 close_unc_volume (wnet_enum_handle
);
2990 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2992 xfree ((char *) dirp
);
2998 int downcase
= !NILP (Vw32_downcase_file_names
);
3000 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3002 if (!read_unc_volume (wnet_enum_handle
,
3003 dir_find_data
.cFileName
,
3007 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3008 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3010 char filename
[MAXNAMLEN
+ 3];
3012 int dbcs_p
= max_filename_mbslen () > 1;
3014 strcpy (filename
, dir_pathname
);
3015 ln
= strlen (filename
) - 1;
3018 if (!IS_DIRECTORY_SEP (filename
[ln
]))
3019 strcat (filename
, "\\");
3023 char *end
= filename
+ ln
+ 1;
3024 char *last_char
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
3026 if (!IS_DIRECTORY_SEP (*last_char
))
3027 strcat (filename
, "\\");
3029 strcat (filename
, "*");
3031 /* Note: No need to resolve symlinks in FILENAME, because
3032 FindFirst opens the directory that is the target of a
3034 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
3036 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3041 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
3045 /* Emacs never uses this value, so don't bother making it match
3046 value returned by stat(). */
3047 dir_static
.d_ino
= 1;
3049 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
3051 /* If the file name in cFileName[] includes `?' characters, it means
3052 the original file name used characters that cannot be represented
3053 by the current ANSI codepage. To avoid total lossage, retrieve
3054 the short 8+3 alias of the long file name. */
3055 if (_mbspbrk (dir_static
.d_name
, "?"))
3057 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
3058 downcase
= 1; /* 8+3 aliases are returned in all caps */
3060 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3061 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
3062 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3064 /* If the file name in cFileName[] includes `?' characters, it means
3065 the original file name used characters that cannot be represented
3066 by the current ANSI codepage. To avoid total lossage, retrieve
3067 the short 8+3 alias of the long file name. */
3068 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
3070 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
3071 /* 8+3 aliases are returned in all caps, which could break
3072 various alists that look at filenames' extensions. */
3076 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
3077 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3079 _mbslwr (dir_static
.d_name
);
3083 int dbcs_p
= max_filename_mbslen () > 1;
3084 for (p
= dir_static
.d_name
; *p
; )
3086 if (*p
>= 'a' && *p
<= 'z')
3089 p
= CharNextExA (file_name_codepage
, p
, 0);
3094 _mbslwr (dir_static
.d_name
);
3101 open_unc_volume (const char *path
)
3107 nr
.dwScope
= RESOURCE_GLOBALNET
;
3108 nr
.dwType
= RESOURCETYPE_DISK
;
3109 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3110 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3111 nr
.lpLocalName
= NULL
;
3112 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
3113 nr
.lpComment
= NULL
;
3114 nr
.lpProvider
= NULL
;
3116 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3117 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
3119 if (result
== NO_ERROR
)
3122 return INVALID_HANDLE_VALUE
;
3126 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
3130 DWORD bufsize
= 512;
3133 int dbcs_p
= max_filename_mbslen () > 1;
3136 buffer
= alloca (bufsize
);
3137 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
3138 if (result
!= NO_ERROR
)
3141 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3142 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
3145 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
3148 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
))
3149 ptr
= CharNextExA (file_name_codepage
, ptr
, 0);
3153 strncpy (readbuf
, ptr
, size
);
3158 close_unc_volume (HANDLE henum
)
3160 if (henum
!= INVALID_HANDLE_VALUE
)
3161 WNetCloseEnum (henum
);
3165 unc_volume_file_attributes (const char *path
)
3170 henum
= open_unc_volume (path
);
3171 if (henum
== INVALID_HANDLE_VALUE
)
3174 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3176 close_unc_volume (henum
);
3181 /* Ensure a network connection is authenticated. */
3183 logon_network_drive (const char *path
)
3185 NETRESOURCE resource
;
3186 char share
[MAX_PATH
];
3193 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3194 drvtype
= DRIVE_REMOTE
;
3195 else if (path
[0] == '\0' || path
[1] != ':')
3196 drvtype
= GetDriveType (NULL
);
3203 drvtype
= GetDriveType (drive
);
3206 /* Only logon to networked drives. */
3207 if (drvtype
!= DRIVE_REMOTE
)
3211 strncpy (share
, path
, MAX_PATH
);
3212 /* Truncate to just server and share name. */
3213 dbcs_p
= max_filename_mbslen () > 1;
3214 for (p
= share
+ 2; *p
&& p
< share
+ MAX_PATH
; )
3216 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3222 p
= CharNextExA (file_name_codepage
, p
, 0);
3227 resource
.dwType
= RESOURCETYPE_DISK
;
3228 resource
.lpLocalName
= NULL
;
3229 resource
.lpRemoteName
= share
;
3230 resource
.lpProvider
= NULL
;
3232 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3235 /* Emulate faccessat(2). */
3237 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3241 if (dirfd
!= AT_FDCWD
3242 && !(IS_DIRECTORY_SEP (path
[0])
3243 || IS_DEVICE_SEP (path
[1])))
3249 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3250 newer versions blow up when passed D_OK. */
3251 path
= map_w32_filename (path
, NULL
);
3252 /* If the last element of PATH is a symlink, we need to resolve it
3253 to get the attributes of its target file. Note: any symlinks in
3254 PATH elements other than the last one are transparently resolved
3255 by GetFileAttributes below. */
3256 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3257 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3258 path
= chase_symlinks (path
);
3260 if ((attributes
= GetFileAttributes (path
)) == -1)
3262 DWORD w32err
= GetLastError ();
3266 case ERROR_INVALID_NAME
:
3267 case ERROR_BAD_PATHNAME
:
3268 if (is_unc_volume (path
))
3270 attributes
= unc_volume_file_attributes (path
);
3271 if (attributes
== -1)
3279 case ERROR_FILE_NOT_FOUND
:
3280 case ERROR_BAD_NETPATH
:
3289 if ((mode
& X_OK
) != 0
3290 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3295 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3300 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3308 /* A version of 'access' to be used locally with file names in
3309 locale-specific encoding. Does not resolve symlinks and does not
3310 support file names on FAT12 and FAT16 volumes, but that's OK, since
3311 we only invoke this function for files inside the Emacs source or
3312 installation tree, on directories (so any symlinks should have the
3313 directory bit set), and on short file names such as "C:/.emacs". */
3315 sys_access (const char *fname
, int mode
)
3317 char fname_copy
[MAX_PATH
], *p
;
3320 strcpy (fname_copy
, fname
);
3321 /* Do the equivalent of unixtodos_filename. */
3322 for (p
= fname_copy
; *p
; p
= CharNext (p
))
3326 if ((attributes
= GetFileAttributesA (fname_copy
)) == -1)
3328 DWORD w32err
= GetLastError ();
3332 case ERROR_INVALID_NAME
:
3333 case ERROR_BAD_PATHNAME
:
3334 case ERROR_FILE_NOT_FOUND
:
3335 case ERROR_BAD_NETPATH
:
3344 if ((mode
& X_OK
) != 0
3345 && !(is_exec (fname_copy
)
3346 || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3351 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3356 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3364 /* Shadow some MSVC runtime functions to map requests for long filenames
3365 to reasonable short names if necessary. This was originally added to
3366 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3370 sys_chdir (const char * path
)
3372 /* FIXME: Temporary. Also, figure out what to do with
3373 map_w32_filename, as the original code did this:
3374 _chdir(map_w32_filename (path, NULL)). */
3375 if (w32_unicode_filenames
)
3377 wchar_t newdir
[MAXPATHLEN
];
3379 if (filename_to_utf16 (path
, newdir
) == 0)
3380 return _wchdir (newdir
);
3385 char newdir
[MAXPATHLEN
];
3387 if (filename_to_ansi (path
, newdir
) == 0)
3388 return _chdir (path
);
3394 sys_chmod (const char * path
, int mode
)
3396 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3397 return _chmod (path
, mode
);
3401 sys_creat (const char * path
, int mode
)
3403 return _creat (map_w32_filename (path
, NULL
), mode
);
3407 sys_fopen (const char * path
, const char * mode
)
3411 const char * mode_save
= mode
;
3413 /* Force all file handles to be non-inheritable. This is necessary to
3414 ensure child processes don't unwittingly inherit handles that might
3415 prevent future file access. */
3419 else if (mode
[0] == 'w' || mode
[0] == 'a')
3420 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3424 /* Only do simplistic option parsing. */
3428 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3431 else if (mode
[0] == 'b')
3436 else if (mode
[0] == 't')
3443 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
3447 return _fdopen (fd
, mode_save
);
3450 /* This only works on NTFS volumes, but is useful to have. */
3452 sys_link (const char * old
, const char * new)
3456 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
3458 if (old
== NULL
|| new == NULL
)
3464 strcpy (oldname
, map_w32_filename (old
, NULL
));
3465 strcpy (newname
, map_w32_filename (new, NULL
));
3467 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3468 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3469 if (fileh
!= INVALID_HANDLE_VALUE
)
3473 /* Confusingly, the "alternate" stream name field does not apply
3474 when restoring a hard link, and instead contains the actual
3475 stream data for the link (ie. the name of the link to create).
3476 The WIN32_STREAM_ID structure before the cStreamName field is
3477 the stream header, which is then immediately followed by the
3481 WIN32_STREAM_ID wid
;
3482 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3485 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3486 data
.wid
.cStreamName
, MAX_PATH
);
3489 LPVOID context
= NULL
;
3492 data
.wid
.dwStreamId
= BACKUP_LINK
;
3493 data
.wid
.dwStreamAttributes
= 0;
3494 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3495 data
.wid
.Size
.HighPart
= 0;
3496 data
.wid
.dwStreamNameSize
= 0;
3498 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3499 offsetof (WIN32_STREAM_ID
, cStreamName
)
3500 + data
.wid
.Size
.LowPart
,
3501 &wbytes
, FALSE
, FALSE
, &context
)
3502 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3509 /* Should try mapping GetLastError to errno; for now just
3510 indicate a general error (eg. links not supported). */
3511 errno
= EINVAL
; // perhaps EMLINK?
3515 CloseHandle (fileh
);
3524 sys_mkdir (const char * path
)
3526 return _mkdir (map_w32_filename (path
, NULL
));
3530 sys_open (const char * path
, int oflag
, int mode
)
3532 const char* mpath
= map_w32_filename (path
, NULL
);
3535 /* If possible, try to open file without _O_CREAT, to be able to
3536 write to existing hidden and system files. Force all file
3537 handles to be non-inheritable. */
3538 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
3539 res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3541 res
= _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3546 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
3549 Standard algorithm for generating a temporary file name seems to be
3550 use pid or tid with a letter on the front (in place of the 6 X's)
3551 and cycle through the letters to find a unique name. We extend
3552 that to allow any reasonable character as the first of the 6 X's,
3553 so that the number of simultaneously used temporary files will be
3557 mkostemp (char * template, int flags
)
3561 unsigned uid
= GetCurrentThreadId ();
3562 int save_errno
= errno
;
3563 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3566 if (template == NULL
)
3569 p
= template + strlen (template);
3571 /* replace up to the last 5 X's with uid in decimal */
3572 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3574 p
[0] = '0' + uid
% 10;
3578 if (i
< 0 && p
[0] == 'X')
3583 p
[0] = first_char
[i
];
3584 if ((fd
= sys_open (template,
3585 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
3586 S_IRUSR
| S_IWUSR
)) >= 0
3594 while (++i
< sizeof (first_char
));
3597 /* Template is badly formed or else we can't generate a unique name. */
3602 fchmod (int fd
, mode_t mode
)
3608 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
3611 char temp
[MAX_PATH
];
3615 /* MoveFile on Windows 95 doesn't correctly change the short file name
3616 alias in a number of circumstances (it is not easy to predict when
3617 just by looking at oldname and newname, unfortunately). In these
3618 cases, renaming through a temporary name avoids the problem.
3620 A second problem on Windows 95 is that renaming through a temp name when
3621 newname is uppercase fails (the final long name ends up in
3622 lowercase, although the short alias might be uppercase) UNLESS the
3623 long temp name is not 8.3.
3625 So, on Windows 95 we always rename through a temp name, and we make sure
3626 the temp name has a long extension to ensure correct renaming. */
3628 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3630 /* volume_info is set indirectly by map_w32_filename. */
3631 oldname_dev
= volume_info
.serialnum
;
3633 if (os_subtype
== OS_9X
)
3639 oldname
= map_w32_filename (oldname
, NULL
);
3640 if ((o
= strrchr (oldname
, '\\')))
3643 o
= (char *) oldname
;
3645 if ((p
= strrchr (temp
, '\\')))
3652 /* Force temp name to require a manufactured 8.3 alias - this
3653 seems to make the second rename work properly. */
3654 sprintf (p
, "_.%s.%u", o
, i
);
3656 result
= rename (oldname
, temp
);
3658 /* This loop must surely terminate! */
3659 while (result
< 0 && errno
== EEXIST
);
3664 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
3665 (at least if it is a file; don't do this for directories).
3667 Since we mustn't do this if we are just changing the case of the
3668 file name (we would end up deleting the file we are trying to
3669 rename!), we let rename detect if the destination file already
3670 exists - that way we avoid the possible pitfalls of trying to
3671 determine ourselves whether two names really refer to the same
3672 file, which is not always possible in the general case. (Consider
3673 all the permutations of shared or subst'd drives, etc.) */
3675 newname
= map_w32_filename (newname
, NULL
);
3677 /* volume_info is set indirectly by map_w32_filename. */
3678 newname_dev
= volume_info
.serialnum
;
3680 result
= rename (temp
, newname
);
3682 if (result
< 0 && force
)
3684 DWORD w32err
= GetLastError ();
3687 && newname_dev
!= oldname_dev
)
3689 /* The implementation of `rename' on Windows does not return
3690 errno = EXDEV when you are moving a directory to a
3691 different storage device (ex. logical disk). It returns
3692 EACCES instead. So here we handle such situations and
3696 if ((attributes
= GetFileAttributes (temp
)) != -1
3697 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3700 else if (errno
== EEXIST
)
3702 if (_chmod (newname
, 0666) != 0)
3704 if (_unlink (newname
) != 0)
3706 result
= rename (temp
, newname
);
3708 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3709 && is_symlink (temp
))
3711 /* This is Windows prohibiting the user from creating a
3712 symlink in another place, since that requires
3722 sys_rename (char const *old
, char const *new)
3724 return sys_rename_replace (old
, new, TRUE
);
3728 sys_rmdir (const char * path
)
3730 return _rmdir (map_w32_filename (path
, NULL
));
3734 sys_unlink (const char * path
)
3736 path
= map_w32_filename (path
, NULL
);
3738 /* On Unix, unlink works without write permission. */
3739 _chmod (path
, 0666);
3740 return _unlink (path
);
3743 static FILETIME utc_base_ft
;
3744 static ULONGLONG utc_base
; /* In 100ns units */
3745 static int init
= 0;
3747 #define FILETIME_TO_U64(result, ft) \
3749 ULARGE_INTEGER uiTemp; \
3750 uiTemp.LowPart = (ft).dwLowDateTime; \
3751 uiTemp.HighPart = (ft).dwHighDateTime; \
3752 result = uiTemp.QuadPart; \
3756 initialize_utc_base (void)
3758 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3767 st
.wMilliseconds
= 0;
3769 SystemTimeToFileTime (&st
, &utc_base_ft
);
3770 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3774 convert_time (FILETIME ft
)
3780 initialize_utc_base ();
3784 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3787 FILETIME_TO_U64 (tmp
, ft
);
3788 return (time_t) ((tmp
- utc_base
) / 10000000L);
3792 convert_from_time_t (time_t time
, FILETIME
* pft
)
3798 initialize_utc_base ();
3802 /* time in 100ns units since 1-Jan-1601 */
3803 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3804 pft
->dwHighDateTime
= tmp
.HighPart
;
3805 pft
->dwLowDateTime
= tmp
.LowPart
;
3808 static PSECURITY_DESCRIPTOR
3809 get_file_security_desc_by_handle (HANDLE h
)
3811 PSECURITY_DESCRIPTOR psd
= NULL
;
3813 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3814 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3816 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3817 NULL
, NULL
, NULL
, NULL
, &psd
);
3818 if (err
!= ERROR_SUCCESS
)
3824 static PSECURITY_DESCRIPTOR
3825 get_file_security_desc_by_name (const char *fname
)
3827 PSECURITY_DESCRIPTOR psd
= NULL
;
3829 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3830 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3832 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3834 err
= GetLastError ();
3835 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3839 psd
= xmalloc (sd_len
);
3840 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3852 unsigned n_subauthorities
;
3854 /* Use the last sub-authority value of the RID, the relative
3855 portion of the SID, as user/group ID. */
3856 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3857 if (n_subauthorities
< 1)
3858 return 0; /* the "World" RID */
3859 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3862 /* Caching SID and account values for faster lokup. */
3866 struct w32_id
*next
;
3868 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3871 static struct w32_id
*w32_idlist
;
3874 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3876 struct w32_id
*tail
, *found
;
3878 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3880 if (equal_sid ((PSID
)tail
->sid
, sid
))
3889 strcpy (name
, found
->name
);
3897 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3900 struct w32_id
*new_entry
;
3902 /* We don't want to leave behind stale cache from when Emacs was
3906 sid_len
= get_length_sid (sid
);
3907 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3910 new_entry
->rid
= id
;
3911 strcpy (new_entry
->name
, name
);
3912 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3913 new_entry
->next
= w32_idlist
;
3914 w32_idlist
= new_entry
;
3923 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3927 SID_NAME_USE ignore
;
3929 DWORD name_len
= sizeof (name
);
3931 DWORD domain_len
= sizeof (domain
);
3936 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3937 else if (what
== GID
)
3938 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3942 if (!result
|| !is_valid_sid (sid
))
3944 else if (!w32_cached_id (sid
, id
, nm
))
3946 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3947 domain
, &domain_len
, &ignore
)
3948 || name_len
> UNLEN
+1)
3952 *id
= get_rid (sid
);
3954 w32_add_to_cache (sid
, *id
, name
);
3961 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3963 int dflt_usr
= 0, dflt_grp
= 0;
3972 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3974 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3977 /* Consider files to belong to current user/group, if we cannot get
3978 more accurate information. */
3981 st
->st_uid
= dflt_passwd
.pw_uid
;
3982 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3986 st
->st_gid
= dflt_passwd
.pw_gid
;
3987 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3991 /* Return non-zero if NAME is a potentially slow filesystem. */
3993 is_slow_fs (const char *name
)
3998 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3999 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
4000 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
4001 devtype
= GetDriveType (NULL
); /* use root of current drive */
4004 /* GetDriveType needs the root directory of the drive. */
4005 strncpy (drive_root
, name
, 2);
4006 drive_root
[2] = '\\';
4007 drive_root
[3] = '\0';
4008 devtype
= GetDriveType (drive_root
);
4010 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
4013 /* If this is non-zero, the caller wants accurate information about
4014 file's owner and group, which could be expensive to get. */
4015 int w32_stat_get_owner_group
;
4017 /* MSVC stat function can't cope with UNC names and has other bugs, so
4018 replace it with our own. This also allows us to calculate consistent
4019 inode values and owner/group without hacks in the main Emacs code. */
4022 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
4024 char *name
, *save_name
, *r
;
4025 WIN32_FIND_DATA wfd
;
4027 unsigned __int64 fake_inode
= 0;
4030 int rootdir
= FALSE
;
4031 PSECURITY_DESCRIPTOR psd
= NULL
;
4032 int is_a_symlink
= 0;
4033 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
4034 DWORD access_rights
= 0;
4035 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
4036 FILETIME ctime
, atime
, wtime
;
4039 if (path
== NULL
|| buf
== NULL
)
4045 save_name
= name
= (char *) map_w32_filename (path
, &path
);
4046 /* Must be valid filename, no wild cards or other invalid
4047 characters. We use _mbspbrk to support multibyte strings that
4048 might look to strpbrk as if they included literal *, ?, and other
4049 characters mentioned below that are disallowed by Windows
4051 if (_mbspbrk (name
, "*?|<>\""))
4057 /* Remove trailing directory separator, unless name is the root
4058 directory of a drive or UNC volume in which case ensure there
4059 is a trailing separator. */
4060 len
= strlen (name
);
4061 name
= strcpy (alloca (len
+ 2), name
);
4063 /* Avoid a somewhat costly call to is_symlink if the filesystem
4064 doesn't support symlinks. */
4065 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4066 is_a_symlink
= is_symlink (name
);
4068 /* Plan A: Open the file and get all the necessary information via
4069 the resulting handle. This solves several issues in one blow:
4071 . retrieves attributes for the target of a symlink, if needed
4072 . gets attributes of root directories and symlinks pointing to
4073 root directories, thus avoiding the need for special-casing
4074 these and detecting them by examining the file-name format
4075 . retrieves more accurate attributes (e.g., non-zero size for
4076 some directories, esp. directories that are junction points)
4077 . correctly resolves "c:/..", "/.." and similar file names
4078 . avoids run-time penalties for 99% of use cases
4080 Plan A is always tried first, unless the user asked not to (but
4081 if the file is a symlink and we need to follow links, we try Plan
4082 A even if the user asked not to).
4084 If Plan A fails, we go to Plan B (below), where various
4085 potentially expensive techniques must be used to handle "special"
4086 files such as UNC volumes etc. */
4087 if (!(NILP (Vw32_get_true_file_attributes
)
4088 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4089 /* Following symlinks requires getting the info by handle. */
4090 || (is_a_symlink
&& follow_symlinks
))
4092 BY_HANDLE_FILE_INFORMATION info
;
4094 if (is_a_symlink
&& !follow_symlinks
)
4095 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4096 /* READ_CONTROL access rights are required to get security info
4097 by handle. But if the OS doesn't support security in the
4098 first place, we don't need to try. */
4099 if (is_windows_9x () != TRUE
)
4100 access_rights
|= READ_CONTROL
;
4102 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4104 /* If CreateFile fails with READ_CONTROL, try again with zero as
4106 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4107 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
4109 if (fh
== INVALID_HANDLE_VALUE
)
4110 goto no_true_file_attributes
;
4112 /* This is more accurate in terms of getting the correct number
4113 of links, but is quite slow (it is noticeable when Emacs is
4114 making a list of file name completions). */
4115 if (GetFileInformationByHandle (fh
, &info
))
4117 nlinks
= info
.nNumberOfLinks
;
4118 /* Might as well use file index to fake inode values, but this
4119 is not guaranteed to be unique unless we keep a handle open
4120 all the time (even then there are situations where it is
4121 not unique). Reputedly, there are at most 48 bits of info
4122 (on NTFS, presumably less on FAT). */
4123 fake_inode
= info
.nFileIndexHigh
;
4125 fake_inode
+= info
.nFileIndexLow
;
4126 serialnum
= info
.dwVolumeSerialNumber
;
4127 fs_high
= info
.nFileSizeHigh
;
4128 fs_low
= info
.nFileSizeLow
;
4129 ctime
= info
.ftCreationTime
;
4130 atime
= info
.ftLastAccessTime
;
4131 wtime
= info
.ftLastWriteTime
;
4132 fattrs
= info
.dwFileAttributes
;
4136 /* We don't go to Plan B here, because it's not clear that
4137 it's a good idea. The only known use case where
4138 CreateFile succeeds, but GetFileInformationByHandle fails
4139 (with ERROR_INVALID_FUNCTION) is for character devices
4140 such as NUL, PRN, etc. For these, switching to Plan B is
4141 a net loss, because we lose the character device
4142 attribute returned by GetFileType below (FindFirstFile
4143 doesn't set that bit in the attributes), and the other
4144 fields don't make sense for character devices anyway.
4145 Emacs doesn't really care for non-file entities in the
4146 context of l?stat, so neither do we. */
4148 /* w32err is assigned so one could put a breakpoint here and
4149 examine its value, when GetFileInformationByHandle
4151 DWORD w32err
= GetLastError ();
4155 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4161 /* Test for a symlink before testing for a directory, since
4162 symlinks to directories have the directory bit set, but we
4163 don't want them to appear as directories. */
4164 if (is_a_symlink
&& !follow_symlinks
)
4165 buf
->st_mode
= S_IFLNK
;
4166 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4167 buf
->st_mode
= S_IFDIR
;
4170 DWORD ftype
= GetFileType (fh
);
4174 case FILE_TYPE_DISK
:
4175 buf
->st_mode
= S_IFREG
;
4177 case FILE_TYPE_PIPE
:
4178 buf
->st_mode
= S_IFIFO
;
4180 case FILE_TYPE_CHAR
:
4181 case FILE_TYPE_UNKNOWN
:
4183 buf
->st_mode
= S_IFCHR
;
4186 /* We produce the fallback owner and group data, based on the
4187 current user that runs Emacs, in the following cases:
4189 . caller didn't request owner and group info
4190 . this is Windows 9X
4191 . getting security by handle failed, and we need to produce
4192 information for the target of a symlink (this is better
4193 than producing a potentially misleading info about the
4196 If getting security by handle fails, and we don't need to
4197 resolve symlinks, we try getting security by name. */
4198 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4199 get_file_owner_and_group (NULL
, buf
);
4202 psd
= get_file_security_desc_by_handle (fh
);
4205 get_file_owner_and_group (psd
, buf
);
4208 else if (!(is_a_symlink
&& follow_symlinks
))
4210 psd
= get_file_security_desc_by_name (name
);
4211 get_file_owner_and_group (psd
, buf
);
4215 get_file_owner_and_group (NULL
, buf
);
4221 no_true_file_attributes
:
4222 /* Plan B: Either getting a handle on the file failed, or the
4223 caller explicitly asked us to not bother making this
4224 information more accurate.
4226 Implementation note: In Plan B, we never bother to resolve
4227 symlinks, even if we got here because we tried Plan A and
4228 failed. That's because, even if the caller asked for extra
4229 precision by setting Vw32_get_true_file_attributes to t,
4230 resolving symlinks requires acquiring a file handle to the
4231 symlink, which we already know will fail. And if the user
4232 did not ask for extra precision, resolving symlinks will fly
4233 in the face of that request, since the user then wants the
4234 lightweight version of the code. */
4235 dbcs_p
= max_filename_mbslen () > 1;
4236 rootdir
= (path
>= save_name
+ len
- 1
4237 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4239 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4240 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4241 if (IS_DIRECTORY_SEP (r
[0])
4242 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4245 /* Note: If NAME is a symlink to the root of a UNC volume
4246 (i.e. "\\SERVER"), we will not detect that here, and we will
4247 return data about the symlink as result of FindFirst below.
4248 This is unfortunate, but that marginal use case does not
4249 justify a call to chase_symlinks which would impose a penalty
4250 on all the other use cases. (We get here for symlinks to
4251 roots of UNC volumes because CreateFile above fails for them,
4252 unlike with symlinks to root directories X:\ of drives.) */
4253 if (is_unc_volume (name
))
4255 fattrs
= unc_volume_file_attributes (name
);
4259 ctime
= atime
= wtime
= utc_base_ft
;
4265 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4266 strcat (name
, "\\");
4270 char *end
= name
+ len
;
4271 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4273 if (!IS_DIRECTORY_SEP (*n
))
4274 strcat (name
, "\\");
4276 if (GetDriveType (name
) < 2)
4282 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4283 ctime
= atime
= wtime
= utc_base_ft
;
4289 if (IS_DIRECTORY_SEP (name
[len
-1]))
4294 char *end
= name
+ len
;
4295 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4297 if (IS_DIRECTORY_SEP (*n
))
4301 /* (This is hacky, but helps when doing file completions on
4302 network drives.) Optimize by using information available from
4303 active readdir if possible. */
4304 len
= strlen (dir_pathname
);
4307 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4312 char *end
= dir_pathname
+ len
;
4313 char *n
= CharPrevExA (file_name_codepage
, dir_pathname
, end
, 0);
4315 if (IS_DIRECTORY_SEP (*n
))
4318 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4319 && !(is_a_symlink
&& follow_symlinks
)
4320 && strnicmp (save_name
, dir_pathname
, len
) == 0
4321 && IS_DIRECTORY_SEP (name
[len
])
4322 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4324 /* This was the last entry returned by readdir. */
4325 wfd
= dir_find_data
;
4329 logon_network_drive (name
);
4331 fh
= FindFirstFile (name
, &wfd
);
4332 if (fh
== INVALID_HANDLE_VALUE
)
4339 /* Note: if NAME is a symlink, the information we get from
4340 FindFirstFile is for the symlink, not its target. */
4341 fattrs
= wfd
.dwFileAttributes
;
4342 ctime
= wfd
.ftCreationTime
;
4343 atime
= wfd
.ftLastAccessTime
;
4344 wtime
= wfd
.ftLastWriteTime
;
4345 fs_high
= wfd
.nFileSizeHigh
;
4346 fs_low
= wfd
.nFileSizeLow
;
4349 serialnum
= volume_info
.serialnum
;
4351 if (is_a_symlink
&& !follow_symlinks
)
4352 buf
->st_mode
= S_IFLNK
;
4353 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4354 buf
->st_mode
= S_IFDIR
;
4356 buf
->st_mode
= S_IFREG
;
4358 get_file_owner_and_group (NULL
, buf
);
4362 /* Not sure if there is any point in this. */
4363 if (!NILP (Vw32_generate_fake_inodes
))
4364 fake_inode
= generate_inode_val (name
);
4365 else if (fake_inode
== 0)
4367 /* For want of something better, try to make everything unique. */
4368 static DWORD gen_num
= 0;
4369 fake_inode
= ++gen_num
;
4373 buf
->st_ino
= fake_inode
;
4375 buf
->st_dev
= serialnum
;
4376 buf
->st_rdev
= serialnum
;
4378 buf
->st_size
= fs_high
;
4379 buf
->st_size
<<= 32;
4380 buf
->st_size
+= fs_low
;
4381 buf
->st_nlink
= nlinks
;
4383 /* Convert timestamps to Unix format. */
4384 buf
->st_mtime
= convert_time (wtime
);
4385 buf
->st_atime
= convert_time (atime
);
4386 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4387 buf
->st_ctime
= convert_time (ctime
);
4388 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4390 /* determine rwx permissions */
4391 if (is_a_symlink
&& !follow_symlinks
)
4392 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4395 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4396 permission
= S_IREAD
;
4398 permission
= S_IREAD
| S_IWRITE
;
4400 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4401 permission
|= S_IEXEC
;
4402 else if (is_exec (name
))
4403 permission
|= S_IEXEC
;
4406 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4412 stat (const char * path
, struct stat
* buf
)
4414 return stat_worker (path
, buf
, 1);
4418 lstat (const char * path
, struct stat
* buf
)
4420 return stat_worker (path
, buf
, 0);
4424 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
4426 /* Rely on a hack: an open directory is modeled as file descriptor 0.
4427 This is good enough for the current usage in Emacs, but is fragile.
4429 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
4430 Gnulib does this and can serve as a model. */
4431 char fullname
[MAX_PATH
];
4435 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
4438 errno
= ENAMETOOLONG
;
4444 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
4447 /* Provide fstat and utime as well as stat for consistent handling of
4450 fstat (int desc
, struct stat
* buf
)
4452 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4453 BY_HANDLE_FILE_INFORMATION info
;
4454 unsigned __int64 fake_inode
;
4457 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4459 case FILE_TYPE_DISK
:
4460 buf
->st_mode
= S_IFREG
;
4461 if (!GetFileInformationByHandle (fh
, &info
))
4467 case FILE_TYPE_PIPE
:
4468 buf
->st_mode
= S_IFIFO
;
4470 case FILE_TYPE_CHAR
:
4471 case FILE_TYPE_UNKNOWN
:
4473 buf
->st_mode
= S_IFCHR
;
4475 memset (&info
, 0, sizeof (info
));
4476 info
.dwFileAttributes
= 0;
4477 info
.ftCreationTime
= utc_base_ft
;
4478 info
.ftLastAccessTime
= utc_base_ft
;
4479 info
.ftLastWriteTime
= utc_base_ft
;
4482 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4483 buf
->st_mode
= S_IFDIR
;
4485 buf
->st_nlink
= info
.nNumberOfLinks
;
4486 /* Might as well use file index to fake inode values, but this
4487 is not guaranteed to be unique unless we keep a handle open
4488 all the time (even then there are situations where it is
4489 not unique). Reputedly, there are at most 48 bits of info
4490 (on NTFS, presumably less on FAT). */
4491 fake_inode
= info
.nFileIndexHigh
;
4493 fake_inode
+= info
.nFileIndexLow
;
4495 /* MSVC defines _ino_t to be short; other libc's might not. */
4496 if (sizeof (buf
->st_ino
) == 2)
4497 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4499 buf
->st_ino
= fake_inode
;
4501 /* If the caller so requested, get the true file owner and group.
4502 Otherwise, consider the file to belong to the current user. */
4503 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4504 get_file_owner_and_group (NULL
, buf
);
4507 PSECURITY_DESCRIPTOR psd
= NULL
;
4509 psd
= get_file_security_desc_by_handle (fh
);
4512 get_file_owner_and_group (psd
, buf
);
4516 get_file_owner_and_group (NULL
, buf
);
4519 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4520 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4522 buf
->st_size
= info
.nFileSizeHigh
;
4523 buf
->st_size
<<= 32;
4524 buf
->st_size
+= info
.nFileSizeLow
;
4526 /* Convert timestamps to Unix format. */
4527 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4528 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4529 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4530 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4531 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4533 /* determine rwx permissions */
4534 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4535 permission
= S_IREAD
;
4537 permission
= S_IREAD
| S_IWRITE
;
4539 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4540 permission
|= S_IEXEC
;
4543 #if 0 /* no way of knowing the filename */
4544 char * p
= strrchr (name
, '.');
4546 (xstrcasecmp (p
, ".exe") == 0 ||
4547 xstrcasecmp (p
, ".com") == 0 ||
4548 xstrcasecmp (p
, ".bat") == 0 ||
4549 xstrcasecmp (p
, ".cmd") == 0))
4550 permission
|= S_IEXEC
;
4554 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4559 /* A version of 'utime' which handles directories as well as
4563 utime (const char *name
, struct utimbuf
*times
)
4565 struct utimbuf deftime
;
4572 deftime
.modtime
= deftime
.actime
= time (NULL
);
4576 if (w32_unicode_filenames
)
4578 wchar_t name_utf16
[MAX_PATH
];
4580 if (filename_to_utf16 (name
, name_utf16
) != 0)
4581 return -1; /* errno set by filename_to_utf16 */
4583 /* Need write access to set times. */
4584 fh
= CreateFileW (name_utf16
, FILE_WRITE_ATTRIBUTES
,
4585 /* If NAME specifies a directory, FILE_SHARE_DELETE
4586 allows other processes to delete files inside it,
4587 while we have the directory open. */
4588 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4589 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4593 char name_ansi
[MAX_PATH
];
4595 if (filename_to_ansi (name
, name_ansi
) != 0)
4596 return -1; /* errno set by filename_to_ansi */
4598 fh
= CreateFileA (name_ansi
, FILE_WRITE_ATTRIBUTES
,
4599 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4600 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4602 if (fh
!= INVALID_HANDLE_VALUE
)
4604 convert_from_time_t (times
->actime
, &atime
);
4605 convert_from_time_t (times
->modtime
, &mtime
);
4606 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4616 DWORD err
= GetLastError ();
4620 case ERROR_FILE_NOT_FOUND
:
4621 case ERROR_PATH_NOT_FOUND
:
4622 case ERROR_INVALID_DRIVE
:
4623 case ERROR_BAD_NETPATH
:
4624 case ERROR_DEV_NOT_EXIST
:
4625 /* ERROR_INVALID_NAME is the error CreateFile sets when the
4626 file name includes ?s, i.e. translation to ANSI failed. */
4627 case ERROR_INVALID_NAME
:
4630 case ERROR_TOO_MANY_OPEN_FILES
:
4633 case ERROR_ACCESS_DENIED
:
4634 case ERROR_SHARING_VIOLATION
:
4647 /* Symlink-related functions. */
4648 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4649 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4653 symlink (char const *filename
, char const *linkname
)
4655 char linkfn
[MAX_PATH
], *tgtfn
;
4657 int dir_access
, filename_ends_in_slash
;
4660 /* Diagnostics follows Posix as much as possible. */
4661 if (filename
== NULL
|| linkname
== NULL
)
4671 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4673 errno
= ENAMETOOLONG
;
4677 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4678 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4684 dbcs_p
= max_filename_mbslen () > 1;
4686 /* Note: since empty FILENAME was already rejected, we can safely
4687 refer to FILENAME[1]. */
4688 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4690 /* Non-absolute FILENAME is understood as being relative to
4691 LINKNAME's directory. We need to prepend that directory to
4692 FILENAME to get correct results from faccessat below, since
4693 otherwise it will interpret FILENAME relative to the
4694 directory where the Emacs process runs. Note that
4695 make-symbolic-link always makes sure LINKNAME is a fully
4696 expanded file name. */
4698 char *p
= linkfn
+ strlen (linkfn
);
4702 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4707 char *p1
= CharPrevExA (file_name_codepage
, linkfn
, p
, 0);
4709 while (p
> linkfn
&& !IS_ANY_SEP (*p1
))
4712 p1
= CharPrevExA (file_name_codepage
, linkfn
, p1
, 0);
4716 strncpy (tem
, linkfn
, p
- linkfn
);
4717 tem
[p
- linkfn
] = '\0';
4718 strcat (tem
, filename
);
4719 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4722 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4724 /* Since Windows distinguishes between symlinks to directories and
4725 to files, we provide a kludgy feature: if FILENAME doesn't
4726 exist, but ends in a slash, we create a symlink to directory. If
4727 FILENAME exists and is a directory, we always create a symlink to
4730 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4733 const char *end
= filename
+ strlen (filename
);
4734 const char *n
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
4736 filename_ends_in_slash
= IS_DIRECTORY_SEP (*n
);
4738 if (dir_access
== 0 || filename_ends_in_slash
)
4739 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4741 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4742 if (filename_ends_in_slash
)
4743 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4746 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4748 /* ENOSYS is set by create_symbolic_link, when it detects that
4749 the OS doesn't support the CreateSymbolicLink API. */
4750 if (errno
!= ENOSYS
)
4752 DWORD w32err
= GetLastError ();
4756 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4757 TGTFN point to the same file name, go figure. */
4759 case ERROR_FILE_EXISTS
:
4762 case ERROR_ACCESS_DENIED
:
4765 case ERROR_FILE_NOT_FOUND
:
4766 case ERROR_PATH_NOT_FOUND
:
4767 case ERROR_BAD_NETPATH
:
4768 case ERROR_INVALID_REPARSE_DATA
:
4771 case ERROR_DIRECTORY
:
4774 case ERROR_PRIVILEGE_NOT_HELD
:
4775 case ERROR_NOT_ALL_ASSIGNED
:
4778 case ERROR_DISK_FULL
:
4791 /* A quick inexpensive test of whether FILENAME identifies a file that
4792 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4793 must already be in the normalized form returned by
4796 Note: for repeated operations on many files, it is best to test
4797 whether the underlying volume actually supports symlinks, by
4798 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4799 avoid the call to this function if it doesn't. That's because the
4800 call to GetFileAttributes takes a non-negligible time, especially
4801 on non-local or removable filesystems. See stat_worker for an
4802 example of how to do that. */
4804 is_symlink (const char *filename
)
4807 WIN32_FIND_DATA wfd
;
4810 attrs
= GetFileAttributes (filename
);
4813 DWORD w32err
= GetLastError ();
4817 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4819 case ERROR_ACCESS_DENIED
:
4822 case ERROR_FILE_NOT_FOUND
:
4823 case ERROR_PATH_NOT_FOUND
:
4830 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4832 logon_network_drive (filename
);
4833 fh
= FindFirstFile (filename
, &wfd
);
4834 if (fh
== INVALID_HANDLE_VALUE
)
4837 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4838 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4841 /* If NAME identifies a symbolic link, copy into BUF the file name of
4842 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4843 null-terminate the target name, even if it fits. Return the number
4844 of bytes copied, or -1 if NAME is not a symlink or any error was
4845 encountered while resolving it. The file name copied into BUF is
4846 encoded in the current ANSI codepage. */
4848 readlink (const char *name
, char *buf
, size_t buf_size
)
4851 TOKEN_PRIVILEGES privs
;
4852 int restore_privs
= 0;
4867 path
= map_w32_filename (name
, NULL
);
4869 if (strlen (path
) > MAX_PATH
)
4871 errno
= ENAMETOOLONG
;
4876 if (is_windows_9x () == TRUE
4877 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4878 || !is_symlink (path
))
4881 errno
= EINVAL
; /* not a symlink */
4885 /* Done with simple tests, now we're in for some _real_ work. */
4886 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4888 /* Implementation note: From here and onward, don't return early,
4889 since that will fail to restore the original set of privileges of
4890 the calling thread. */
4892 retval
= -1; /* not too optimistic, are we? */
4894 /* Note: In the next call to CreateFile, we use zero as the 2nd
4895 argument because, when the symlink is a hidden/system file,
4896 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4897 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4898 and directory symlinks. */
4899 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4900 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4902 if (sh
!= INVALID_HANDLE_VALUE
)
4904 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4905 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4908 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4909 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4912 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4916 /* Copy the link target name, in wide characters, from
4917 reparse_data, then convert it to multibyte encoding in
4918 the current locale's codepage. */
4920 BYTE lname
[MAX_PATH
];
4923 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4925 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4926 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4927 /* This updates file_name_codepage which we need below. */
4928 int dbcs_p
= max_filename_mbslen () > 1;
4930 /* According to MSDN, PrintNameLength does not include the
4931 terminating null character. */
4932 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4933 memcpy (lwname
, lwname_src
, lwname_len
);
4934 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4936 lname_len
= WideCharToMultiByte (file_name_codepage
, 0, lwname
, -1,
4937 lname
, MAX_PATH
, NULL
, NULL
);
4940 /* WideCharToMultiByte failed. */
4941 DWORD w32err1
= GetLastError ();
4945 case ERROR_INSUFFICIENT_BUFFER
:
4946 errno
= ENAMETOOLONG
;
4948 case ERROR_INVALID_PARAMETER
:
4951 case ERROR_NO_UNICODE_TRANSLATION
:
4961 size_t size_to_copy
= buf_size
;
4962 BYTE
*p
= lname
, *p2
;
4963 BYTE
*pend
= p
+ lname_len
;
4965 /* Normalize like dostounix_filename does, but we don't
4966 want to assume that lname is null-terminated. */
4968 p2
= CharNextExA (file_name_codepage
, p
, 0);
4971 if (*p
&& *p2
== ':' && *p
>= 'A' && *p
<= 'Z')
4982 p
= CharNextExA (file_name_codepage
, p
, 0);
4983 /* CharNextExA doesn't advance at null character. */
4990 /* Testing for null-terminated LNAME is paranoia:
4991 WideCharToMultiByte should always return a
4992 null-terminated string when its 4th argument is -1
4993 and its 3rd argument is null-terminated (which they
4995 if (lname
[lname_len
- 1] == '\0')
4997 if (lname_len
<= buf_size
)
4998 size_to_copy
= lname_len
;
4999 strncpy (buf
, lname
, size_to_copy
);
5001 retval
= size_to_copy
;
5008 /* CreateFile failed. */
5009 DWORD w32err2
= GetLastError ();
5013 case ERROR_FILE_NOT_FOUND
:
5014 case ERROR_PATH_NOT_FOUND
:
5017 case ERROR_ACCESS_DENIED
:
5018 case ERROR_TOO_MANY_OPEN_FILES
:
5028 restore_privilege (&privs
);
5036 readlinkat (int fd
, char const *name
, char *buffer
,
5039 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5040 as in fstatat. FIXME: Add proper support for readlinkat. */
5041 char fullname
[MAX_PATH
];
5045 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
5048 errno
= ENAMETOOLONG
;
5054 return readlink (name
, buffer
, buffer_size
);
5057 /* If FILE is a symlink, return its target (stored in a static
5058 buffer); otherwise return FILE.
5060 This function repeatedly resolves symlinks in the last component of
5061 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5062 until it arrives at a file whose last component is not a symlink,
5063 or some error occurs. It returns the target of the last
5064 successfully resolved symlink in the chain. If it succeeds to
5065 resolve even a single symlink, the value returned is an absolute
5066 file name with backslashes (result of GetFullPathName). By
5067 contrast, if the original FILE is returned, it is unaltered.
5069 Note: This function can set errno even if it succeeds.
5071 Implementation note: we only resolve the last portion ("basename")
5072 of the argument FILE and of each following file in the chain,
5073 disregarding any possible symlinks in its leading directories.
5074 This is because Windows system calls and library functions
5075 transparently resolve symlinks in leading directories and return
5076 correct information, as long as the basename is not a symlink. */
5078 chase_symlinks (const char *file
)
5080 static char target
[MAX_PATH
];
5081 char link
[MAX_PATH
];
5082 ssize_t res
, link_len
;
5086 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
5087 return (char *)file
;
5089 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
5090 return (char *)file
;
5092 dbcs_p
= max_filename_mbslen () > 1;
5096 /* Remove trailing slashes, as we want to resolve the last
5097 non-trivial part of the link name. */
5100 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
5101 link
[link_len
--] = '\0';
5103 else if (link_len
> 3)
5105 char *n
= CharPrevExA (file_name_codepage
, link
, link
+ link_len
, 0);
5107 while (n
>= link
+ 2 && IS_DIRECTORY_SEP (*n
))
5110 n
= CharPrevExA (file_name_codepage
, link
, n
, 0);
5114 res
= readlink (link
, target
, MAX_PATH
);
5118 if (!(IS_DEVICE_SEP (target
[1])
5119 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5121 /* Target is relative. Append it to the directory part of
5122 the symlink, then copy the result back to target. */
5123 char *p
= link
+ link_len
;
5127 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5132 char *p1
= CharPrevExA (file_name_codepage
, link
, p
, 0);
5134 while (p
> link
&& !IS_ANY_SEP (*p1
))
5137 p1
= CharPrevExA (file_name_codepage
, link
, p1
, 0);
5141 strcpy (target
, link
);
5143 /* Resolve any "." and ".." to get a fully-qualified file name
5145 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
5147 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5149 if (loop_count
> 100)
5152 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5153 return (char *)file
;
5158 /* Posix ACL emulation. */
5161 acl_valid (acl_t acl
)
5163 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5167 acl_to_text (acl_t acl
, ssize_t
*size
)
5170 SECURITY_INFORMATION flags
=
5171 OWNER_SECURITY_INFORMATION
|
5172 GROUP_SECURITY_INFORMATION
|
5173 DACL_SECURITY_INFORMATION
;
5174 char *retval
= NULL
;
5180 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5183 /* We don't want to mix heaps, so we duplicate the string in our
5184 heap and free the one allocated by the API. */
5185 retval
= xstrdup (str_acl
);
5188 LocalFree (str_acl
);
5190 else if (errno
!= ENOTSUP
)
5197 acl_from_text (const char *acl_str
)
5199 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5205 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5208 retval
= xmalloc (sd_size
);
5209 memcpy (retval
, psd
, sd_size
);
5212 else if (errno
!= ENOTSUP
)
5219 acl_free (void *ptr
)
5226 acl_get_file (const char *fname
, acl_type_t type
)
5228 PSECURITY_DESCRIPTOR psd
= NULL
;
5229 const char *filename
;
5231 if (type
== ACL_TYPE_ACCESS
)
5234 SECURITY_INFORMATION si
=
5235 OWNER_SECURITY_INFORMATION
|
5236 GROUP_SECURITY_INFORMATION
|
5237 DACL_SECURITY_INFORMATION
;
5240 filename
= map_w32_filename (fname
, NULL
);
5241 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5242 fname
= chase_symlinks (filename
);
5247 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5248 && errno
!= ENOTSUP
)
5250 err
= GetLastError ();
5251 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5253 psd
= xmalloc (sd_len
);
5254 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5261 else if (err
== ERROR_FILE_NOT_FOUND
5262 || err
== ERROR_PATH_NOT_FOUND
)
5270 else if (type
!= ACL_TYPE_DEFAULT
)
5277 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
5279 TOKEN_PRIVILEGES old1
, old2
;
5281 int st
= 0, retval
= -1;
5282 SECURITY_INFORMATION flags
= 0;
5288 const char *filename
;
5290 if (acl_valid (acl
) != 0
5291 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
5297 if (type
== ACL_TYPE_DEFAULT
)
5303 filename
= map_w32_filename (fname
, NULL
);
5304 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5305 fname
= chase_symlinks (filename
);
5309 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5311 flags
|= OWNER_SECURITY_INFORMATION
;
5312 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5314 flags
|= GROUP_SECURITY_INFORMATION
;
5315 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
5318 flags
|= DACL_SECURITY_INFORMATION
;
5322 /* According to KB-245153, setting the owner will succeed if either:
5323 (1) the caller is the user who will be the new owner, and has the
5324 SE_TAKE_OWNERSHIP privilege, or
5325 (2) the caller has the SE_RESTORE privilege, in which case she can
5326 set any valid user or group as the owner
5328 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
5329 privileges, and disregard any failures in obtaining them. If
5330 these privileges cannot be obtained, and do not already exist in
5331 the calling thread's security token, this function could fail
5333 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
5335 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
5340 if (!set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
5342 err
= GetLastError ();
5344 if (errno
== ENOTSUP
)
5346 else if (err
== ERROR_INVALID_OWNER
5347 || err
== ERROR_NOT_ALL_ASSIGNED
5348 || err
== ERROR_ACCESS_DENIED
)
5350 /* Maybe the requested ACL and the one the file already has
5351 are identical, in which case we can silently ignore the
5352 failure. (And no, Windows doesn't.) */
5353 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
5358 char *acl_from
= acl_to_text (current_acl
, NULL
);
5359 char *acl_to
= acl_to_text (acl
, NULL
);
5361 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
5367 acl_free (acl_from
);
5370 acl_free (current_acl
);
5373 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
5387 restore_privilege (&old2
);
5388 restore_privilege (&old1
);
5396 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
5397 have a fixed max size for file names, so we don't need the kind of
5398 alloc/malloc/realloc dance the gnulib version does. We also don't
5399 support FD-relative symlinks. */
5401 careadlinkat (int fd
, char const *filename
,
5402 char *buffer
, size_t buffer_size
,
5403 struct allocator
const *alloc
,
5404 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
5406 char linkname
[MAX_PATH
];
5409 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
5413 char *retval
= buffer
;
5415 linkname
[link_size
++] = '\0';
5416 if (link_size
> buffer_size
)
5417 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
5419 memcpy (retval
, linkname
, link_size
);
5427 /* Support for browsing other processes and their attributes. See
5428 process.c for the Lisp bindings. */
5430 /* Helper wrapper functions. */
5432 static HANDLE WINAPI
5433 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
5435 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
5437 if (g_b_init_create_toolhelp32_snapshot
== 0)
5439 g_b_init_create_toolhelp32_snapshot
= 1;
5440 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
5441 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5442 "CreateToolhelp32Snapshot");
5444 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
5446 return INVALID_HANDLE_VALUE
;
5448 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
5452 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5454 static Process32First_Proc s_pfn_Process32_First
= NULL
;
5456 if (g_b_init_process32_first
== 0)
5458 g_b_init_process32_first
= 1;
5459 s_pfn_Process32_First
= (Process32First_Proc
)
5460 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5463 if (s_pfn_Process32_First
== NULL
)
5467 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5471 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5473 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5475 if (g_b_init_process32_next
== 0)
5477 g_b_init_process32_next
= 1;
5478 s_pfn_Process32_Next
= (Process32Next_Proc
)
5479 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5482 if (s_pfn_Process32_Next
== NULL
)
5486 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5490 open_thread_token (HANDLE ThreadHandle
,
5491 DWORD DesiredAccess
,
5493 PHANDLE TokenHandle
)
5495 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5496 HMODULE hm_advapi32
= NULL
;
5497 if (is_windows_9x () == TRUE
)
5499 SetLastError (ERROR_NOT_SUPPORTED
);
5502 if (g_b_init_open_thread_token
== 0)
5504 g_b_init_open_thread_token
= 1;
5505 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5506 s_pfn_Open_Thread_Token
=
5507 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5509 if (s_pfn_Open_Thread_Token
== NULL
)
5511 SetLastError (ERROR_NOT_SUPPORTED
);
5515 s_pfn_Open_Thread_Token (
5524 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5526 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5527 HMODULE hm_advapi32
= NULL
;
5528 if (is_windows_9x () == TRUE
)
5532 if (g_b_init_impersonate_self
== 0)
5534 g_b_init_impersonate_self
= 1;
5535 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5536 s_pfn_Impersonate_Self
=
5537 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5539 if (s_pfn_Impersonate_Self
== NULL
)
5543 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5547 revert_to_self (void)
5549 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5550 HMODULE hm_advapi32
= NULL
;
5551 if (is_windows_9x () == TRUE
)
5555 if (g_b_init_revert_to_self
== 0)
5557 g_b_init_revert_to_self
= 1;
5558 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5559 s_pfn_Revert_To_Self
=
5560 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5562 if (s_pfn_Revert_To_Self
== NULL
)
5566 return s_pfn_Revert_To_Self ();
5570 get_process_memory_info (HANDLE h_proc
,
5571 PPROCESS_MEMORY_COUNTERS mem_counters
,
5574 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5575 HMODULE hm_psapi
= NULL
;
5576 if (is_windows_9x () == TRUE
)
5580 if (g_b_init_get_process_memory_info
== 0)
5582 g_b_init_get_process_memory_info
= 1;
5583 hm_psapi
= LoadLibrary ("Psapi.dll");
5585 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5586 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5588 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5592 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5596 get_process_working_set_size (HANDLE h_proc
,
5600 static GetProcessWorkingSetSize_Proc
5601 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5603 if (is_windows_9x () == TRUE
)
5607 if (g_b_init_get_process_working_set_size
== 0)
5609 g_b_init_get_process_working_set_size
= 1;
5610 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5611 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5612 "GetProcessWorkingSetSize");
5614 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5618 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5622 global_memory_status (MEMORYSTATUS
*buf
)
5624 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5626 if (is_windows_9x () == TRUE
)
5630 if (g_b_init_global_memory_status
== 0)
5632 g_b_init_global_memory_status
= 1;
5633 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5634 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5635 "GlobalMemoryStatus");
5637 if (s_pfn_Global_Memory_Status
== NULL
)
5641 return s_pfn_Global_Memory_Status (buf
);
5645 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5647 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5649 if (is_windows_9x () == TRUE
)
5653 if (g_b_init_global_memory_status_ex
== 0)
5655 g_b_init_global_memory_status_ex
= 1;
5656 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5657 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5658 "GlobalMemoryStatusEx");
5660 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5664 return s_pfn_Global_Memory_Status_Ex (buf
);
5668 list_system_processes (void)
5670 struct gcpro gcpro1
;
5671 Lisp_Object proclist
= Qnil
;
5674 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5676 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5678 PROCESSENTRY32 proc_entry
;
5684 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5685 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5686 res
= process32_next (h_snapshot
, &proc_entry
))
5688 proc_id
= proc_entry
.th32ProcessID
;
5689 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5692 CloseHandle (h_snapshot
);
5694 proclist
= Fnreverse (proclist
);
5701 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5703 TOKEN_PRIVILEGES priv
;
5704 DWORD priv_size
= sizeof (priv
);
5705 DWORD opriv_size
= sizeof (*old_priv
);
5706 HANDLE h_token
= NULL
;
5707 HANDLE h_thread
= GetCurrentThread ();
5711 res
= open_thread_token (h_thread
,
5712 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5714 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5716 if (impersonate_self (SecurityImpersonation
))
5717 res
= open_thread_token (h_thread
,
5718 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5723 priv
.PrivilegeCount
= 1;
5724 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5725 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5726 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5727 old_priv
, &opriv_size
)
5728 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5732 CloseHandle (h_token
);
5738 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5740 DWORD priv_size
= sizeof (*priv
);
5741 HANDLE h_token
= NULL
;
5744 if (open_thread_token (GetCurrentThread (),
5745 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5748 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5749 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5753 CloseHandle (h_token
);
5759 ltime (ULONGLONG time_100ns
)
5761 ULONGLONG time_sec
= time_100ns
/ 10000000;
5762 int subsec
= time_100ns
% 10000000;
5763 return list4i (time_sec
>> 16, time_sec
& 0xffff,
5764 subsec
/ 10, subsec
% 10 * 100000);
5767 #define U64_TO_LISP_TIME(time) ltime (time)
5770 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5771 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5774 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5775 ULONGLONG tem1
, tem2
, tem3
, tem
;
5778 || !get_process_times_fn
5779 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5780 &ft_kernel
, &ft_user
))
5783 GetSystemTimeAsFileTime (&ft_current
);
5785 FILETIME_TO_U64 (tem1
, ft_kernel
);
5786 *stime
= U64_TO_LISP_TIME (tem1
);
5788 FILETIME_TO_U64 (tem2
, ft_user
);
5789 *utime
= U64_TO_LISP_TIME (tem2
);
5792 *ttime
= U64_TO_LISP_TIME (tem3
);
5794 FILETIME_TO_U64 (tem
, ft_creation
);
5795 /* Process no 4 (System) returns zero creation time. */
5798 *ctime
= U64_TO_LISP_TIME (tem
);
5802 FILETIME_TO_U64 (tem3
, ft_current
);
5803 tem
= (tem3
- utc_base
) - tem
;
5805 *etime
= U64_TO_LISP_TIME (tem
);
5809 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5820 system_process_attributes (Lisp_Object pid
)
5822 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5823 Lisp_Object attrs
= Qnil
;
5824 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5825 HANDLE h_snapshot
, h_proc
;
5828 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5829 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5830 DWORD glength
= sizeof (gname
);
5831 HANDLE token
= NULL
;
5832 SID_NAME_USE user_type
;
5833 unsigned char *buf
= NULL
;
5835 TOKEN_USER user_token
;
5836 TOKEN_PRIMARY_GROUP group_token
;
5839 PROCESS_MEMORY_COUNTERS mem
;
5840 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5841 SIZE_T minrss
, maxrss
;
5843 MEMORY_STATUS_EX memstex
;
5844 double totphys
= 0.0;
5845 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5847 BOOL result
= FALSE
;
5849 CHECK_NUMBER_OR_FLOAT (pid
);
5850 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5852 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5854 GCPRO3 (attrs
, decoded_cmd
, tem
);
5856 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5861 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5862 for (res
= process32_first (h_snapshot
, &pe
); res
;
5863 res
= process32_next (h_snapshot
, &pe
))
5865 if (proc_id
== pe
.th32ProcessID
)
5868 decoded_cmd
= build_string ("Idle");
5871 /* Decode the command name from locale-specific
5873 cmd_str
= build_unibyte_string (pe
.szExeFile
);
5876 code_convert_string_norecord (cmd_str
,
5877 Vlocale_coding_system
, 0);
5879 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5880 attrs
= Fcons (Fcons (Qppid
,
5881 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5883 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5885 attrs
= Fcons (Fcons (Qthcount
,
5886 make_fixnum_or_float (pe
.cntThreads
)),
5893 CloseHandle (h_snapshot
);
5902 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5904 /* If we were denied a handle to the process, try again after
5905 enabling the SeDebugPrivilege in our process. */
5908 TOKEN_PRIVILEGES priv_current
;
5910 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5912 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5914 restore_privilege (&priv_current
);
5920 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5923 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5924 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5926 buf
= xmalloc (blen
);
5927 result
= get_token_information (token
, TokenUser
,
5928 (LPVOID
)buf
, blen
, &needed
);
5931 memcpy (&user_token
, buf
, sizeof (user_token
));
5932 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5934 euid
= get_rid (user_token
.User
.Sid
);
5935 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5940 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5943 strcpy (uname
, "unknown");
5947 ulength
= strlen (uname
);
5953 /* Determine a reasonable euid and gid values. */
5954 if (xstrcasecmp ("administrator", uname
) == 0)
5956 euid
= 500; /* well-known Administrator uid */
5957 egid
= 513; /* well-known None gid */
5961 /* Get group id and name. */
5962 result
= get_token_information (token
, TokenPrimaryGroup
,
5963 (LPVOID
)buf
, blen
, &needed
);
5964 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5966 buf
= xrealloc (buf
, blen
= needed
);
5967 result
= get_token_information (token
, TokenPrimaryGroup
,
5968 (LPVOID
)buf
, blen
, &needed
);
5972 memcpy (&group_token
, buf
, sizeof (group_token
));
5973 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5975 egid
= get_rid (group_token
.PrimaryGroup
);
5976 dlength
= sizeof (domain
);
5978 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5979 gname
, &glength
, NULL
, &dlength
,
5982 w32_add_to_cache (group_token
.PrimaryGroup
,
5986 strcpy (gname
, "None");
5990 glength
= strlen (gname
);
5998 if (!is_windows_9x ())
6000 /* We couldn't open the process token, presumably because of
6001 insufficient access rights. Assume this process is run
6003 strcpy (uname
, "SYSTEM");
6004 strcpy (gname
, "None");
6005 euid
= 18; /* SYSTEM */
6006 egid
= 513; /* None */
6007 glength
= strlen (gname
);
6008 ulength
= strlen (uname
);
6010 /* If we are running under Windows 9X, where security calls are
6011 not supported, we assume all processes are run by the current
6013 else if (GetUserName (uname
, &ulength
))
6015 if (xstrcasecmp ("administrator", uname
) == 0)
6020 strcpy (gname
, "None");
6021 glength
= strlen (gname
);
6022 ulength
= strlen (uname
);
6028 strcpy (uname
, "administrator");
6029 ulength
= strlen (uname
);
6030 strcpy (gname
, "None");
6031 glength
= strlen (gname
);
6034 CloseHandle (token
);
6037 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
6038 tem
= make_unibyte_string (uname
, ulength
);
6039 attrs
= Fcons (Fcons (Quser
,
6040 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6042 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
6043 tem
= make_unibyte_string (gname
, glength
);
6044 attrs
= Fcons (Fcons (Qgroup
,
6045 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6048 if (global_memory_status_ex (&memstex
))
6049 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
6050 totphys
= memstex
.ullTotalPhys
/ 1024.0;
6052 /* Visual Studio 6 cannot convert an unsigned __int64 type to
6053 double, so we need to do this for it... */
6055 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
6056 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
6057 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
6059 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
6061 #endif /* __GNUC__ || _MSC_VER >= 1300 */
6062 else if (global_memory_status (&memst
))
6063 totphys
= memst
.dwTotalPhys
/ 1024.0;
6066 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
6069 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6071 attrs
= Fcons (Fcons (Qmajflt
,
6072 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
6074 attrs
= Fcons (Fcons (Qvsize
,
6075 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
6077 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6079 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6082 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
6084 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6086 attrs
= Fcons (Fcons (Qmajflt
,
6087 make_fixnum_or_float (mem
.PageFaultCount
)),
6089 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6091 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6094 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
6096 DWORD rss
= maxrss
/ 1024;
6098 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
6100 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6103 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
6105 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
6106 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
6107 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
6108 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
6109 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
6110 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
6113 /* FIXME: Retrieve command line by walking the PEB of the process. */
6116 CloseHandle (h_proc
);
6122 /* Wrappers for winsock functions to map between our file descriptors
6123 and winsock's handles; also set h_errno for convenience.
6125 To allow Emacs to run on systems which don't have winsock support
6126 installed, we dynamically link to winsock on startup if present, and
6127 otherwise provide the minimum necessary functionality
6128 (eg. gethostname). */
6130 /* function pointers for relevant socket functions */
6131 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
6132 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
6133 int (PASCAL
*pfn_WSAGetLastError
) (void);
6134 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
6135 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
6136 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
6137 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
6138 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6139 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6140 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
6141 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
6142 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
6143 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
6144 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
6145 int (PASCAL
*pfn_WSACleanup
) (void);
6147 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
6148 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
6149 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
6150 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
6151 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
6152 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
6153 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
6154 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
6155 const char * optval
, int optlen
);
6156 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
6157 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
6159 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
6160 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
6161 struct sockaddr
* from
, int * fromlen
);
6162 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
6163 const struct sockaddr
* to
, int tolen
);
6165 /* SetHandleInformation is only needed to make sockets non-inheritable. */
6166 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
6167 #ifndef HANDLE_FLAG_INHERIT
6168 #define HANDLE_FLAG_INHERIT 1
6172 static int winsock_inuse
;
6177 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
6179 release_listen_threads ();
6180 /* Not sure what would cause WSAENETDOWN, or even if it can happen
6181 after WSAStartup returns successfully, but it seems reasonable
6182 to allow unloading winsock anyway in that case. */
6183 if (pfn_WSACleanup () == 0 ||
6184 pfn_WSAGetLastError () == WSAENETDOWN
)
6186 if (FreeLibrary (winsock_lib
))
6195 init_winsock (int load_now
)
6197 WSADATA winsockData
;
6199 if (winsock_lib
!= NULL
)
6202 pfn_SetHandleInformation
6203 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
6204 "SetHandleInformation");
6206 winsock_lib
= LoadLibrary ("Ws2_32.dll");
6208 if (winsock_lib
!= NULL
)
6210 /* dynamically link to socket functions */
6212 #define LOAD_PROC(fn) \
6213 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
6216 LOAD_PROC (WSAStartup
);
6217 LOAD_PROC (WSASetLastError
);
6218 LOAD_PROC (WSAGetLastError
);
6219 LOAD_PROC (WSAEventSelect
);
6220 LOAD_PROC (WSACreateEvent
);
6221 LOAD_PROC (WSACloseEvent
);
6224 LOAD_PROC (connect
);
6225 LOAD_PROC (ioctlsocket
);
6228 LOAD_PROC (closesocket
);
6229 LOAD_PROC (shutdown
);
6232 LOAD_PROC (inet_addr
);
6233 LOAD_PROC (gethostname
);
6234 LOAD_PROC (gethostbyname
);
6235 LOAD_PROC (getservbyname
);
6236 LOAD_PROC (getpeername
);
6237 LOAD_PROC (WSACleanup
);
6238 LOAD_PROC (setsockopt
);
6240 LOAD_PROC (getsockname
);
6242 LOAD_PROC (recvfrom
);
6246 /* specify version 1.1 of winsock */
6247 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
6249 if (winsockData
.wVersion
!= 0x101)
6254 /* Report that winsock exists and is usable, but leave
6255 socket functions disabled. I am assuming that calling
6256 WSAStartup does not require any network interaction,
6257 and in particular does not cause or require a dial-up
6258 connection to be established. */
6261 FreeLibrary (winsock_lib
);
6269 FreeLibrary (winsock_lib
);
6279 /* Function to map winsock error codes to errno codes for those errno
6280 code defined in errno.h (errno values not defined by errno.h are
6281 already in nt/inc/sys/socket.h). */
6288 if (winsock_lib
== NULL
)
6291 wsa_err
= pfn_WSAGetLastError ();
6295 case WSAEACCES
: errno
= EACCES
; break;
6296 case WSAEBADF
: errno
= EBADF
; break;
6297 case WSAEFAULT
: errno
= EFAULT
; break;
6298 case WSAEINTR
: errno
= EINTR
; break;
6299 case WSAEINVAL
: errno
= EINVAL
; break;
6300 case WSAEMFILE
: errno
= EMFILE
; break;
6301 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
6302 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
6303 default: errno
= wsa_err
; break;
6311 if (winsock_lib
!= NULL
)
6312 pfn_WSASetLastError (0);
6315 /* Extend strerror to handle the winsock-specific error codes. */
6319 } _wsa_errlist
[] = {
6320 {WSAEINTR
, "Interrupted function call"},
6321 {WSAEBADF
, "Bad file descriptor"},
6322 {WSAEACCES
, "Permission denied"},
6323 {WSAEFAULT
, "Bad address"},
6324 {WSAEINVAL
, "Invalid argument"},
6325 {WSAEMFILE
, "Too many open files"},
6327 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
6328 {WSAEINPROGRESS
, "Operation now in progress"},
6329 {WSAEALREADY
, "Operation already in progress"},
6330 {WSAENOTSOCK
, "Socket operation on non-socket"},
6331 {WSAEDESTADDRREQ
, "Destination address required"},
6332 {WSAEMSGSIZE
, "Message too long"},
6333 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
6334 {WSAENOPROTOOPT
, "Bad protocol option"},
6335 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
6336 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
6337 {WSAEOPNOTSUPP
, "Operation not supported"},
6338 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
6339 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
6340 {WSAEADDRINUSE
, "Address already in use"},
6341 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
6342 {WSAENETDOWN
, "Network is down"},
6343 {WSAENETUNREACH
, "Network is unreachable"},
6344 {WSAENETRESET
, "Network dropped connection on reset"},
6345 {WSAECONNABORTED
, "Software caused connection abort"},
6346 {WSAECONNRESET
, "Connection reset by peer"},
6347 {WSAENOBUFS
, "No buffer space available"},
6348 {WSAEISCONN
, "Socket is already connected"},
6349 {WSAENOTCONN
, "Socket is not connected"},
6350 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
6351 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
6352 {WSAETIMEDOUT
, "Connection timed out"},
6353 {WSAECONNREFUSED
, "Connection refused"},
6354 {WSAELOOP
, "Network loop"}, /* not sure */
6355 {WSAENAMETOOLONG
, "Name is too long"},
6356 {WSAEHOSTDOWN
, "Host is down"},
6357 {WSAEHOSTUNREACH
, "No route to host"},
6358 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
6359 {WSAEPROCLIM
, "Too many processes"},
6360 {WSAEUSERS
, "Too many users"}, /* not sure */
6361 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
6362 {WSAESTALE
, "Data is stale"}, /* not sure */
6363 {WSAEREMOTE
, "Remote error"}, /* not sure */
6365 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
6366 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
6367 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
6368 {WSAEDISCON
, "Graceful shutdown in progress"},
6370 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
6371 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
6372 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
6373 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
6374 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
6375 {WSASYSCALLFAILURE
, "System call failure"},
6376 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
6377 {WSATYPE_NOT_FOUND
, "Class type not found"},
6378 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
6379 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
6380 {WSAEREFUSED
, "Operation refused"}, /* not sure */
6383 {WSAHOST_NOT_FOUND
, "Host not found"},
6384 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
6385 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
6386 {WSANO_DATA
, "Valid name, no data record of requested type"},
6392 sys_strerror (int error_no
)
6395 static char unknown_msg
[40];
6397 if (error_no
>= 0 && error_no
< sys_nerr
)
6398 return sys_errlist
[error_no
];
6400 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
6401 if (_wsa_errlist
[i
].errnum
== error_no
)
6402 return _wsa_errlist
[i
].msg
;
6404 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
6408 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6409 but I believe the method of keeping the socket handle separate (and
6410 insuring it is not inheritable) is the correct one. */
6412 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6414 static int socket_to_fd (SOCKET s
);
6417 sys_socket (int af
, int type
, int protocol
)
6421 if (winsock_lib
== NULL
)
6424 return INVALID_SOCKET
;
6429 /* call the real socket function */
6430 s
= pfn_socket (af
, type
, protocol
);
6432 if (s
!= INVALID_SOCKET
)
6433 return socket_to_fd (s
);
6439 /* Convert a SOCKET to a file descriptor. */
6441 socket_to_fd (SOCKET s
)
6446 /* Although under NT 3.5 _open_osfhandle will accept a socket
6447 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6448 that does not work under NT 3.1. However, we can get the same
6449 effect by using a backdoor function to replace an existing
6450 descriptor handle with the one we want. */
6452 /* allocate a file descriptor (with appropriate flags) */
6453 fd
= _open ("NUL:", _O_RDWR
);
6456 /* Make a non-inheritable copy of the socket handle. Note
6457 that it is possible that sockets aren't actually kernel
6458 handles, which appears to be the case on Windows 9x when
6459 the MS Proxy winsock client is installed. */
6461 /* Apparently there is a bug in NT 3.51 with some service
6462 packs, which prevents using DuplicateHandle to make a
6463 socket handle non-inheritable (causes WSACleanup to
6464 hang). The work-around is to use SetHandleInformation
6465 instead if it is available and implemented. */
6466 if (pfn_SetHandleInformation
)
6468 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
6472 HANDLE parent
= GetCurrentProcess ();
6473 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6475 if (DuplicateHandle (parent
,
6481 DUPLICATE_SAME_ACCESS
))
6483 /* It is possible that DuplicateHandle succeeds even
6484 though the socket wasn't really a kernel handle,
6485 because a real handle has the same value. So
6486 test whether the new handle really is a socket. */
6487 long nonblocking
= 0;
6488 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6490 pfn_closesocket (s
);
6495 CloseHandle (new_s
);
6500 eassert (fd
< MAXDESC
);
6501 fd_info
[fd
].hnd
= (HANDLE
) s
;
6503 /* set our own internal flags */
6504 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6510 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6512 /* attach child_process to fd_info */
6513 if (fd_info
[ fd
].cp
!= NULL
)
6515 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6519 fd_info
[ fd
].cp
= cp
;
6522 winsock_inuse
++; /* count open sockets */
6530 pfn_closesocket (s
);
6536 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6538 if (winsock_lib
== NULL
)
6541 return SOCKET_ERROR
;
6545 if (fd_info
[s
].flags
& FILE_SOCKET
)
6547 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6548 if (rc
== SOCKET_ERROR
)
6553 return SOCKET_ERROR
;
6557 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6559 if (winsock_lib
== NULL
)
6562 return SOCKET_ERROR
;
6566 if (fd_info
[s
].flags
& FILE_SOCKET
)
6568 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6569 if (rc
== SOCKET_ERROR
)
6574 return SOCKET_ERROR
;
6578 sys_htons (u_short hostshort
)
6580 return (winsock_lib
!= NULL
) ?
6581 pfn_htons (hostshort
) : hostshort
;
6585 sys_ntohs (u_short netshort
)
6587 return (winsock_lib
!= NULL
) ?
6588 pfn_ntohs (netshort
) : netshort
;
6592 sys_inet_addr (const char * cp
)
6594 return (winsock_lib
!= NULL
) ?
6595 pfn_inet_addr (cp
) : INADDR_NONE
;
6599 sys_gethostname (char * name
, int namelen
)
6601 if (winsock_lib
!= NULL
)
6606 retval
= pfn_gethostname (name
, namelen
);
6607 if (retval
== SOCKET_ERROR
)
6612 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6613 return !GetComputerName (name
, (DWORD
*)&namelen
);
6616 return SOCKET_ERROR
;
6620 sys_gethostbyname (const char * name
)
6622 struct hostent
* host
;
6623 int h_err
= h_errno
;
6625 if (winsock_lib
== NULL
)
6627 h_errno
= NO_RECOVERY
;
6633 host
= pfn_gethostbyname (name
);
6645 sys_getservbyname (const char * name
, const char * proto
)
6647 struct servent
* serv
;
6649 if (winsock_lib
== NULL
)
6656 serv
= pfn_getservbyname (name
, proto
);
6663 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6665 if (winsock_lib
== NULL
)
6668 return SOCKET_ERROR
;
6672 if (fd_info
[s
].flags
& FILE_SOCKET
)
6674 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6675 if (rc
== SOCKET_ERROR
)
6680 return SOCKET_ERROR
;
6684 sys_shutdown (int s
, int how
)
6686 if (winsock_lib
== NULL
)
6689 return SOCKET_ERROR
;
6693 if (fd_info
[s
].flags
& FILE_SOCKET
)
6695 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6696 if (rc
== SOCKET_ERROR
)
6701 return SOCKET_ERROR
;
6705 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6707 if (winsock_lib
== NULL
)
6710 return SOCKET_ERROR
;
6714 if (fd_info
[s
].flags
& FILE_SOCKET
)
6716 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6717 (const char *)optval
, optlen
);
6718 if (rc
== SOCKET_ERROR
)
6723 return SOCKET_ERROR
;
6727 sys_listen (int s
, int backlog
)
6729 if (winsock_lib
== NULL
)
6732 return SOCKET_ERROR
;
6736 if (fd_info
[s
].flags
& FILE_SOCKET
)
6738 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6739 if (rc
== SOCKET_ERROR
)
6742 fd_info
[s
].flags
|= FILE_LISTEN
;
6746 return SOCKET_ERROR
;
6750 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6752 if (winsock_lib
== NULL
)
6755 return SOCKET_ERROR
;
6759 if (fd_info
[s
].flags
& FILE_SOCKET
)
6761 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
6762 if (rc
== SOCKET_ERROR
)
6767 return SOCKET_ERROR
;
6771 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
6773 if (winsock_lib
== NULL
)
6780 if (fd_info
[s
].flags
& FILE_LISTEN
)
6782 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6784 if (t
== INVALID_SOCKET
)
6787 fd
= socket_to_fd (t
);
6791 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6792 ResetEvent (fd_info
[s
].cp
->char_avail
);
6801 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6802 struct sockaddr
* from
, int * fromlen
)
6804 if (winsock_lib
== NULL
)
6807 return SOCKET_ERROR
;
6811 if (fd_info
[s
].flags
& FILE_SOCKET
)
6813 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6814 if (rc
== SOCKET_ERROR
)
6819 return SOCKET_ERROR
;
6823 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6824 const struct sockaddr
* to
, int tolen
)
6826 if (winsock_lib
== NULL
)
6829 return SOCKET_ERROR
;
6833 if (fd_info
[s
].flags
& FILE_SOCKET
)
6835 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6836 if (rc
== SOCKET_ERROR
)
6841 return SOCKET_ERROR
;
6844 /* Windows does not have an fcntl function. Provide an implementation
6845 good enough for Emacs. */
6847 fcntl (int s
, int cmd
, int options
)
6849 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
6850 invoked in a context where fd1 is closed and all descriptors less
6851 than fd1 are open, so sys_dup is an adequate implementation. */
6852 if (cmd
== F_DUPFD_CLOEXEC
)
6855 if (winsock_lib
== NULL
)
6862 if (fd_info
[s
].flags
& FILE_SOCKET
)
6864 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
6866 unsigned long nblock
= 1;
6867 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6868 if (rc
== SOCKET_ERROR
)
6870 /* Keep track of the fact that we set this to non-blocking. */
6871 fd_info
[s
].flags
|= FILE_NDELAY
;
6877 return SOCKET_ERROR
;
6881 return SOCKET_ERROR
;
6885 /* Shadow main io functions: we need to handle pipes and sockets more
6886 intelligently, and implement non-blocking mode as well. */
6899 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6901 child_process
* cp
= fd_info
[fd
].cp
;
6903 fd_info
[fd
].cp
= NULL
;
6905 if (CHILD_ACTIVE (cp
))
6907 /* if last descriptor to active child_process then cleanup */
6909 for (i
= 0; i
< MAXDESC
; i
++)
6913 if (fd_info
[i
].cp
== cp
)
6918 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6920 if (winsock_lib
== NULL
) emacs_abort ();
6922 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6923 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6925 winsock_inuse
--; /* count open sockets */
6927 /* If the process handle is NULL, it's either a socket
6928 or serial connection, or a subprocess that was
6929 already reaped by reap_subprocess, but whose
6930 resources were not yet freed, because its output was
6931 not fully read yet by the time it was reaped. (This
6932 usually happens with async subprocesses whose output
6933 is being read by Emacs.) Otherwise, this process was
6934 not reaped yet, so we set its FD to a negative value
6935 to make sure sys_select will eventually get to
6936 calling the SIGCHLD handler for it, which will then
6937 invoke waitpid and reap_subprocess. */
6938 if (cp
->procinfo
.hProcess
== NULL
)
6946 if (fd
>= 0 && fd
< MAXDESC
)
6947 fd_info
[fd
].flags
= 0;
6949 /* Note that sockets do not need special treatment here (at least on
6950 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6951 closesocket is equivalent to CloseHandle, which is to be expected
6952 because socket handles are fully fledged kernel handles. */
6964 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6966 /* duplicate our internal info as well */
6967 fd_info
[new_fd
] = fd_info
[fd
];
6973 sys_dup2 (int src
, int dst
)
6977 if (dst
< 0 || dst
>= MAXDESC
)
6983 /* make sure we close the destination first if it's a pipe or socket */
6984 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6987 rc
= _dup2 (src
, dst
);
6990 /* duplicate our internal info as well */
6991 fd_info
[dst
] = fd_info
[src
];
6997 pipe2 (int * phandles
, int pipe2_flags
)
7002 eassert (pipe2_flags
== O_CLOEXEC
);
7004 /* make pipe handles non-inheritable; when we spawn a child, we
7005 replace the relevant handle with an inheritable one. Also put
7006 pipes into binary mode; we will do text mode translation ourselves
7008 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
7012 /* Protect against overflow, since Windows can open more handles than
7013 our fd_info array has room for. */
7014 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
7016 _close (phandles
[0]);
7017 _close (phandles
[1]);
7023 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
7024 fd_info
[phandles
[0]].flags
= flags
;
7026 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
7027 fd_info
[phandles
[1]].flags
= flags
;
7034 /* Function to do blocking read of one byte, needed to implement
7035 select. It is only allowed on communication ports, sockets, or
7038 _sys_read_ahead (int fd
)
7043 if (fd
< 0 || fd
>= MAXDESC
)
7044 return STATUS_READ_ERROR
;
7046 cp
= fd_info
[fd
].cp
;
7048 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7049 return STATUS_READ_ERROR
;
7051 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
7052 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
7054 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
7058 cp
->status
= STATUS_READ_IN_PROGRESS
;
7060 if (fd_info
[fd
].flags
& FILE_PIPE
)
7062 rc
= _read (fd
, &cp
->chr
, sizeof (char));
7064 /* Give subprocess time to buffer some more output for us before
7065 reporting that input is available; we need this because Windows 95
7066 connects DOS programs to pipes by making the pipe appear to be
7067 the normal console stdout - as a result most DOS programs will
7068 write to stdout without buffering, ie. one character at a
7069 time. Even some W32 programs do this - "dir" in a command
7070 shell on NT is very slow if we don't do this. */
7073 int wait
= w32_pipe_read_delay
;
7079 /* Yield remainder of our time slice, effectively giving a
7080 temporary priority boost to the child process. */
7084 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7086 HANDLE hnd
= fd_info
[fd
].hnd
;
7087 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7090 /* Configure timeouts for blocking read. */
7091 if (!GetCommTimeouts (hnd
, &ct
))
7093 cp
->status
= STATUS_READ_ERROR
;
7094 return STATUS_READ_ERROR
;
7096 ct
.ReadIntervalTimeout
= 0;
7097 ct
.ReadTotalTimeoutMultiplier
= 0;
7098 ct
.ReadTotalTimeoutConstant
= 0;
7099 if (!SetCommTimeouts (hnd
, &ct
))
7101 cp
->status
= STATUS_READ_ERROR
;
7102 return STATUS_READ_ERROR
;
7105 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
7107 if (GetLastError () != ERROR_IO_PENDING
)
7109 cp
->status
= STATUS_READ_ERROR
;
7110 return STATUS_READ_ERROR
;
7112 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7114 cp
->status
= STATUS_READ_ERROR
;
7115 return STATUS_READ_ERROR
;
7119 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
7121 unsigned long nblock
= 0;
7122 /* We always want this to block, so temporarily disable NDELAY. */
7123 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7124 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7126 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
7128 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7131 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7135 if (rc
== sizeof (char))
7136 cp
->status
= STATUS_READ_SUCCEEDED
;
7138 cp
->status
= STATUS_READ_FAILED
;
7144 _sys_wait_accept (int fd
)
7150 if (fd
< 0 || fd
>= MAXDESC
)
7151 return STATUS_READ_ERROR
;
7153 cp
= fd_info
[fd
].cp
;
7155 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7156 return STATUS_READ_ERROR
;
7158 cp
->status
= STATUS_READ_FAILED
;
7160 hEv
= pfn_WSACreateEvent ();
7161 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
7162 if (rc
!= SOCKET_ERROR
)
7165 rc
= WaitForSingleObject (hEv
, 500);
7167 } while (rc
== WAIT_TIMEOUT
7168 && cp
->status
!= STATUS_READ_ERROR
7170 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
7171 if (rc
== WAIT_OBJECT_0
)
7172 cp
->status
= STATUS_READ_SUCCEEDED
;
7174 pfn_WSACloseEvent (hEv
);
7180 sys_read (int fd
, char * buffer
, unsigned int count
)
7185 char * orig_buffer
= buffer
;
7193 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7195 child_process
*cp
= fd_info
[fd
].cp
;
7197 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
7205 /* re-read CR carried over from last read */
7206 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
7208 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
7212 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
7215 /* presence of a child_process structure means we are operating in
7216 non-blocking mode - otherwise we just call _read directly.
7217 Note that the child_process structure might be missing because
7218 reap_subprocess has been called; in this case the pipe is
7219 already broken, so calling _read on it is okay. */
7222 int current_status
= cp
->status
;
7224 switch (current_status
)
7226 case STATUS_READ_FAILED
:
7227 case STATUS_READ_ERROR
:
7228 /* report normal EOF if nothing in buffer */
7230 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7233 case STATUS_READ_READY
:
7234 case STATUS_READ_IN_PROGRESS
:
7235 DebPrint (("sys_read called when read is in progress\n"));
7236 errno
= EWOULDBLOCK
;
7239 case STATUS_READ_SUCCEEDED
:
7240 /* consume read-ahead char */
7241 *buffer
++ = cp
->chr
;
7244 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7245 ResetEvent (cp
->char_avail
);
7247 case STATUS_READ_ACKNOWLEDGED
:
7251 DebPrint (("sys_read: bad status %d\n", current_status
));
7256 if (fd_info
[fd
].flags
& FILE_PIPE
)
7258 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
7259 to_read
= min (waiting
, (DWORD
) count
);
7262 nchars
+= _read (fd
, buffer
, to_read
);
7264 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7266 HANDLE hnd
= fd_info
[fd
].hnd
;
7267 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7273 /* Configure timeouts for non-blocking read. */
7274 if (!GetCommTimeouts (hnd
, &ct
))
7279 ct
.ReadIntervalTimeout
= MAXDWORD
;
7280 ct
.ReadTotalTimeoutMultiplier
= 0;
7281 ct
.ReadTotalTimeoutConstant
= 0;
7282 if (!SetCommTimeouts (hnd
, &ct
))
7288 if (!ResetEvent (ovl
->hEvent
))
7293 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
7295 if (GetLastError () != ERROR_IO_PENDING
)
7300 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7309 else /* FILE_SOCKET */
7311 if (winsock_lib
== NULL
) emacs_abort ();
7313 /* do the equivalent of a non-blocking read */
7314 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
7315 if (waiting
== 0 && nchars
== 0)
7317 errno
= EWOULDBLOCK
;
7323 /* always use binary mode for sockets */
7324 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
7325 if (res
== SOCKET_ERROR
)
7327 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
7328 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7338 int nread
= _read (fd
, buffer
, count
);
7341 else if (nchars
== 0)
7346 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7347 /* Perform text mode translation if required. */
7348 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7350 nchars
= crlf_to_lf (nchars
, orig_buffer
);
7351 /* If buffer contains only CR, return that. To be absolutely
7352 sure we should attempt to read the next char, but in
7353 practice a CR to be followed by LF would not appear by
7354 itself in the buffer. */
7355 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
7357 fd_info
[fd
].flags
|= FILE_LAST_CR
;
7363 nchars
= _read (fd
, buffer
, count
);
7368 /* From w32xfns.c */
7369 extern HANDLE interrupt_handle
;
7371 /* For now, don't bother with a non-blocking mode */
7373 sys_write (int fd
, const void * buffer
, unsigned int count
)
7383 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7385 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
7391 /* Perform text mode translation if required. */
7392 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7394 char * tmpbuf
= alloca (count
* 2);
7395 unsigned char * src
= (void *)buffer
;
7396 unsigned char * dst
= tmpbuf
;
7401 unsigned char *next
;
7402 /* copy next line or remaining bytes */
7403 next
= _memccpy (dst
, src
, '\n', nbytes
);
7406 /* copied one line ending with '\n' */
7407 int copied
= next
- dst
;
7410 /* insert '\r' before '\n' */
7417 /* copied remaining partial line -> now finished */
7424 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
7426 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
7427 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
7428 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
7431 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
7433 if (GetLastError () != ERROR_IO_PENDING
)
7438 if (detect_input_pending ())
7439 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
7442 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
7443 if (active
== WAIT_OBJECT_0
)
7444 { /* User pressed C-g, cancel write, then leave. Don't bother
7445 cleaning up as we may only get stuck in buggy drivers. */
7446 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
7451 if (active
== WAIT_OBJECT_0
+ 1
7452 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
7459 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
7461 unsigned long nblock
= 0;
7462 if (winsock_lib
== NULL
) emacs_abort ();
7464 /* TODO: implement select() properly so non-blocking I/O works. */
7465 /* For now, make sure the write blocks. */
7466 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7467 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7469 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
7471 /* Set the socket back to non-blocking if it was before,
7472 for other operations that support it. */
7473 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7476 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7479 if (nchars
== SOCKET_ERROR
)
7481 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7482 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7488 /* Some networked filesystems don't like too large writes, so
7489 break them into smaller chunks. See the Comments section of
7490 the MSDN documentation of WriteFile for details behind the
7491 choice of the value of CHUNK below. See also the thread
7492 http://thread.gmane.org/gmane.comp.version-control.git/145294
7493 in the git mailing list. */
7494 const unsigned char *p
= buffer
;
7495 const unsigned chunk
= 30 * 1024 * 1024;
7500 unsigned this_chunk
= count
< chunk
? count
: chunk
;
7501 int n
= _write (fd
, p
, this_chunk
);
7509 else if (n
< this_chunk
)
7520 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
7522 extern Lisp_Object
conv_sockaddr_to_lisp (struct sockaddr
*, int);
7524 /* Return information about network interface IFNAME, or about all
7525 interfaces (if IFNAME is nil). */
7527 network_interface_get_info (Lisp_Object ifname
)
7529 ULONG ainfo_len
= sizeof (IP_ADAPTER_INFO
);
7530 IP_ADAPTER_INFO
*adapter
, *ainfo
= xmalloc (ainfo_len
);
7531 DWORD retval
= get_adapters_info (ainfo
, &ainfo_len
);
7532 Lisp_Object res
= Qnil
;
7534 if (retval
== ERROR_BUFFER_OVERFLOW
)
7536 ainfo
= xrealloc (ainfo
, ainfo_len
);
7537 retval
= get_adapters_info (ainfo
, &ainfo_len
);
7540 if (retval
== ERROR_SUCCESS
)
7542 int eth_count
= 0, tr_count
= 0, fddi_count
= 0, ppp_count
= 0;
7543 int sl_count
= 0, wlan_count
= 0, lo_count
= 0, ifx_count
= 0;
7545 struct sockaddr_in sa
;
7547 /* For the below, we need some winsock functions, so make sure
7548 the winsock DLL is loaded. If we cannot successfully load
7549 it, they will have no use of the information we provide,
7551 if (!winsock_lib
&& !init_winsock (1))
7554 for (adapter
= ainfo
; adapter
; adapter
= adapter
->Next
)
7556 char namebuf
[MAX_ADAPTER_NAME_LENGTH
+ 4];
7558 /* Present Unix-compatible interface names, instead of the
7559 Windows names, which are really GUIDs not readable by
7561 static const char *ifmt
[] = {
7562 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
7577 switch (adapter
->Type
)
7579 case MIB_IF_TYPE_ETHERNET
:
7580 /* Windows before Vista reports wireless adapters as
7581 Ethernet. Work around by looking at the Description
7583 if (strstr (adapter
->Description
, "Wireless "))
7586 if_num
= wlan_count
++;
7590 ifmt_idx
= ETHERNET
;
7591 if_num
= eth_count
++;
7594 case MIB_IF_TYPE_TOKENRING
:
7595 ifmt_idx
= TOKENRING
;
7596 if_num
= tr_count
++;
7598 case MIB_IF_TYPE_FDDI
:
7600 if_num
= fddi_count
++;
7602 case MIB_IF_TYPE_PPP
:
7604 if_num
= ppp_count
++;
7606 case MIB_IF_TYPE_SLIP
:
7608 if_num
= sl_count
++;
7610 case IF_TYPE_IEEE80211
:
7612 if_num
= wlan_count
++;
7614 case MIB_IF_TYPE_LOOPBACK
:
7617 ifmt_idx
= LOOPBACK
;
7618 if_num
= lo_count
++;
7624 ifmt_idx
= OTHER_IF
;
7625 if_num
= ifx_count
++;
7628 if (ifmt_idx
== NONE
)
7630 sprintf (namebuf
, ifmt
[ifmt_idx
], if_num
);
7632 sa
.sin_family
= AF_INET
;
7633 ip_addr
= sys_inet_addr (adapter
->IpAddressList
.IpAddress
.String
);
7634 if (ip_addr
== INADDR_NONE
)
7636 /* Bogus address, skip this interface. */
7639 sa
.sin_addr
.s_addr
= ip_addr
;
7642 res
= Fcons (Fcons (build_string (namebuf
),
7643 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7644 sizeof (struct sockaddr
))),
7646 else if (strcmp (namebuf
, SSDATA (ifname
)) == 0)
7648 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
7649 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
7650 Lisp_Object flags
= Qnil
;
7654 /* Flags. We guess most of them by type, since the
7655 Windows flags are different and hard to get by. */
7656 flags
= Fcons (intern ("up"), flags
);
7657 if (ifmt_idx
== ETHERNET
|| ifmt_idx
== WLAN
)
7659 flags
= Fcons (intern ("broadcast"), flags
);
7660 flags
= Fcons (intern ("multicast"), flags
);
7662 flags
= Fcons (intern ("running"), flags
);
7663 if (ifmt_idx
== PPP
)
7665 flags
= Fcons (intern ("pointopoint"), flags
);
7666 flags
= Fcons (intern ("noarp"), flags
);
7668 if (adapter
->HaveWins
)
7669 flags
= Fcons (intern ("WINS"), flags
);
7670 if (adapter
->DhcpEnabled
)
7671 flags
= Fcons (intern ("dynamic"), flags
);
7673 res
= Fcons (flags
, res
);
7675 /* Hardware address and its family. */
7676 for (n
= 0; n
< adapter
->AddressLength
; n
++)
7677 p
->u
.contents
[n
] = make_number ((int) adapter
->Address
[n
]);
7678 /* Windows does not support AF_LINK or AF_PACKET family
7679 of addresses. Use an arbitrary family number that is
7680 identical to what GNU/Linux returns. */
7681 res
= Fcons (Fcons (make_number (1), hwaddr
), res
);
7684 sa
.sin_family
= AF_INET
;
7685 net_mask
= sys_inet_addr (adapter
->IpAddressList
.IpMask
.String
);
7686 if (net_mask
!= INADDR_NONE
)
7688 sa
.sin_addr
.s_addr
= net_mask
;
7690 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7691 sizeof (struct sockaddr
)),
7695 res
= Fcons (Qnil
, res
);
7697 sa
.sin_family
= AF_INET
;
7698 if (ip_addr
!= INADDR_NONE
)
7700 /* Broadcast address is only reported by
7701 GetAdaptersAddresses, which is of limited
7702 availability. Generate it on our own. */
7703 u_long bcast_addr
= (ip_addr
& net_mask
) | ~net_mask
;
7705 sa
.sin_addr
.s_addr
= bcast_addr
;
7707 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7708 sizeof (struct sockaddr
)),
7712 sa
.sin_addr
.s_addr
= ip_addr
;
7714 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7715 sizeof (struct sockaddr
)),
7719 res
= Fcons (Qnil
, Fcons (Qnil
, res
));
7722 /* GetAdaptersInfo is documented to not report loopback
7723 interfaces, so we generate one out of thin air. */
7726 sa
.sin_family
= AF_INET
;
7730 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
7731 res
= Fcons (Fcons (build_string ("lo"),
7732 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7733 sizeof (struct sockaddr
))),
7736 else if (strcmp (SSDATA (ifname
), "lo") == 0)
7738 res
= Fcons (Fcons (intern ("running"),
7739 Fcons (intern ("loopback"),
7740 Fcons (intern ("up"), Qnil
))), Qnil
);
7741 /* 772 is what 3 different GNU/Linux systems report for
7742 the loopback interface. */
7743 res
= Fcons (Fcons (make_number (772),
7744 Fmake_vector (make_number (6),
7747 sa
.sin_addr
.s_addr
= sys_inet_addr ("255.0.0.0");
7748 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7749 sizeof (struct sockaddr
)),
7751 sa
.sin_addr
.s_addr
= sys_inet_addr ("0.0.0.0");
7752 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7753 sizeof (struct sockaddr
)),
7755 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
7756 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7757 sizeof (struct sockaddr
)),
7770 network_interface_list (void)
7772 return network_interface_get_info (Qnil
);
7776 network_interface_info (Lisp_Object ifname
)
7778 return network_interface_get_info (ifname
);
7782 /* The Windows CRT functions are "optimized for speed", so they don't
7783 check for timezone and DST changes if they were last called less
7784 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7785 all Emacs features that repeatedly call time functions (e.g.,
7786 display-time) are in real danger of missing timezone and DST
7787 changes. Calling tzset before each localtime call fixes that. */
7789 sys_localtime (const time_t *t
)
7792 return localtime (t
);
7797 /* Try loading LIBRARY_ID from the file(s) specified in
7798 Vdynamic_library_alist. If the library is loaded successfully,
7799 return the handle of the DLL, and record the filename in the
7800 property :loaded-from of LIBRARY_ID. If the library could not be
7801 found, or when it was already loaded (because the handle is not
7802 recorded anywhere, and so is lost after use), return NULL.
7804 We could also save the handle in :loaded-from, but currently
7805 there's no use case for it. */
7807 w32_delayed_load (Lisp_Object library_id
)
7809 HMODULE library_dll
= NULL
;
7811 CHECK_SYMBOL (library_id
);
7813 if (CONSP (Vdynamic_library_alist
)
7814 && NILP (Fassq (library_id
, Vlibrary_cache
)))
7816 Lisp_Object found
= Qnil
;
7817 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
7820 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
7822 CHECK_STRING_CAR (dlls
);
7823 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
7825 char name
[MAX_PATH
];
7828 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
7829 found
= Fcons (XCAR (dlls
),
7831 /* Possibly truncated */
7832 ? make_specified_string (name
, -1, len
, 1)
7838 Fput (library_id
, QCloaded_from
, found
);
7846 check_windows_init_file (void)
7848 /* A common indication that Emacs is not installed properly is when
7849 it cannot find the Windows installation file. If this file does
7850 not exist in the expected place, tell the user. */
7852 if (!noninteractive
&& !inhibit_window_system
7853 /* Vload_path is not yet initialized when we are loading
7855 && NILP (Vpurify_flag
))
7857 Lisp_Object init_file
;
7860 init_file
= build_string ("term/w32-win");
7861 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
7864 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
7865 char *init_file_name
= SDATA (init_file
);
7866 char *load_path
= SDATA (load_path_print
);
7867 char *buffer
= alloca (1024
7868 + strlen (init_file_name
)
7869 + strlen (load_path
));
7872 "The Emacs Windows initialization file \"%s.el\" "
7873 "could not be found in your Emacs installation. "
7874 "Emacs checked the following directories for this file:\n"
7876 "When Emacs cannot find this file, it usually means that it "
7877 "was not installed properly, or its distribution file was "
7878 "not unpacked properly.\nSee the README.W32 file in the "
7879 "top-level Emacs directory for more information.",
7880 init_file_name
, load_path
);
7883 "Emacs Abort Dialog",
7884 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
7885 /* Use the low-level system abort. */
7896 term_ntproc (int ignored
)
7902 /* shutdown the socket interface if necessary */
7909 init_ntproc (int dumping
)
7911 sigset_t initial_mask
= 0;
7913 /* Initialize the socket interface now if available and requested by
7914 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7915 delayed until open-network-stream is called (w32-has-winsock can
7916 also be used to dynamically load or reload winsock).
7918 Conveniently, init_environment is called before us, so
7919 PRELOAD_WINSOCK can be set in the registry. */
7921 /* Always initialize this correctly. */
7924 if (getenv ("PRELOAD_WINSOCK") != NULL
)
7925 init_winsock (TRUE
);
7927 /* Initial preparation for subprocess support: replace our standard
7928 handles with non-inheritable versions. */
7931 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
7932 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
7933 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
7935 parent
= GetCurrentProcess ();
7937 /* ignore errors when duplicating and closing; typically the
7938 handles will be invalid when running as a gui program. */
7939 DuplicateHandle (parent
,
7940 GetStdHandle (STD_INPUT_HANDLE
),
7945 DUPLICATE_SAME_ACCESS
);
7947 DuplicateHandle (parent
,
7948 GetStdHandle (STD_OUTPUT_HANDLE
),
7953 DUPLICATE_SAME_ACCESS
);
7955 DuplicateHandle (parent
,
7956 GetStdHandle (STD_ERROR_HANDLE
),
7961 DUPLICATE_SAME_ACCESS
);
7967 if (stdin_save
!= INVALID_HANDLE_VALUE
)
7968 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
7970 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
7973 if (stdout_save
!= INVALID_HANDLE_VALUE
)
7974 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
7976 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7979 if (stderr_save
!= INVALID_HANDLE_VALUE
)
7980 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
7982 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7986 /* unfortunately, atexit depends on implementation of malloc */
7987 /* atexit (term_ntproc); */
7990 /* Make sure we start with all signals unblocked. */
7991 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
7992 signal (SIGABRT
, term_ntproc
);
7996 /* determine which drives are fixed, for GetCachedVolumeInformation */
7998 /* GetDriveType must have trailing backslash. */
7999 char drive
[] = "A:\\";
8001 /* Loop over all possible drive letters */
8002 while (*drive
<= 'Z')
8004 /* Record if this drive letter refers to a fixed drive. */
8005 fixed_drives
[DRIVE_INDEX (*drive
)] =
8006 (GetDriveType (drive
) == DRIVE_FIXED
);
8011 /* Reset the volume info cache. */
8012 volume_cache
= NULL
;
8017 shutdown_handler ensures that buffers' autosave files are
8018 up to date when the user logs off, or the system shuts down.
8021 shutdown_handler (DWORD type
)
8023 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
8024 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
8025 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
8026 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
8028 /* Shut down cleanly, making sure autosave files are up to date. */
8029 shut_down_emacs (0, Qnil
);
8032 /* Allow other handlers to handle this signal. */
8037 globals_of_w32 is used to initialize those global variables that
8038 must always be initialized on startup even when the global variable
8039 initialized is non zero (see the function main in emacs.c).
8042 globals_of_w32 (void)
8044 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
8046 get_process_times_fn
= (GetProcessTimes_Proc
)
8047 GetProcAddress (kernel32
, "GetProcessTimes");
8049 DEFSYM (QCloaded_from
, ":loaded-from");
8051 g_b_init_is_windows_9x
= 0;
8052 g_b_init_open_process_token
= 0;
8053 g_b_init_get_token_information
= 0;
8054 g_b_init_lookup_account_sid
= 0;
8055 g_b_init_get_sid_sub_authority
= 0;
8056 g_b_init_get_sid_sub_authority_count
= 0;
8057 g_b_init_get_security_info
= 0;
8058 g_b_init_get_file_security
= 0;
8059 g_b_init_get_security_descriptor_owner
= 0;
8060 g_b_init_get_security_descriptor_group
= 0;
8061 g_b_init_is_valid_sid
= 0;
8062 g_b_init_create_toolhelp32_snapshot
= 0;
8063 g_b_init_process32_first
= 0;
8064 g_b_init_process32_next
= 0;
8065 g_b_init_open_thread_token
= 0;
8066 g_b_init_impersonate_self
= 0;
8067 g_b_init_revert_to_self
= 0;
8068 g_b_init_get_process_memory_info
= 0;
8069 g_b_init_get_process_working_set_size
= 0;
8070 g_b_init_global_memory_status
= 0;
8071 g_b_init_global_memory_status_ex
= 0;
8072 g_b_init_equal_sid
= 0;
8073 g_b_init_copy_sid
= 0;
8074 g_b_init_get_length_sid
= 0;
8075 g_b_init_get_native_system_info
= 0;
8076 g_b_init_get_system_times
= 0;
8077 g_b_init_create_symbolic_link
= 0;
8078 g_b_init_get_security_descriptor_dacl
= 0;
8079 g_b_init_convert_sd_to_sddl
= 0;
8080 g_b_init_convert_sddl_to_sd
= 0;
8081 g_b_init_is_valid_security_descriptor
= 0;
8082 g_b_init_set_file_security
= 0;
8083 g_b_init_get_adapters_info
= 0;
8084 num_of_processors
= 0;
8085 /* The following sets a handler for shutdown notifications for
8086 console apps. This actually applies to Emacs in both console and
8087 GUI modes, since we had to fool windows into thinking emacs is a
8088 console application to get console mode to work. */
8089 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
8091 /* "None" is the default group name on standalone workstations. */
8092 strcpy (dflt_group_name
, "None");
8094 /* Reset, in case it has some value inherited from dump time. */
8095 w32_stat_get_owner_group
= 0;
8097 /* If w32_unicode_filenames is non-zero, we will be using Unicode
8098 (a.k.a. "wide") APIs to invoke functions that accept file
8100 if (is_windows_9x ())
8101 w32_unicode_filenames
= 0;
8103 w32_unicode_filenames
= 1;
8106 /* For make-serial-process */
8108 serial_open (Lisp_Object port_obj
)
8110 char *port
= SSDATA (port_obj
);
8115 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
8116 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
8117 if (hnd
== INVALID_HANDLE_VALUE
)
8118 error ("Could not open %s", port
);
8119 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
8121 error ("Could not open %s", port
);
8125 error ("Could not create child process");
8127 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
8128 fd_info
[ fd
].hnd
= hnd
;
8129 fd_info
[ fd
].flags
|=
8130 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
8131 if (fd_info
[ fd
].cp
!= NULL
)
8133 error ("fd_info[fd = %d] is already in use", fd
);
8135 fd_info
[ fd
].cp
= cp
;
8136 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
8137 if (cp
->ovl_read
.hEvent
== NULL
)
8138 error ("Could not create read event");
8139 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
8140 if (cp
->ovl_write
.hEvent
== NULL
)
8141 error ("Could not create write event");
8146 /* For serial-process-configure */
8148 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
8150 Lisp_Object childp2
= Qnil
;
8151 Lisp_Object tem
= Qnil
;
8155 char summary
[4] = "???"; /* This usually becomes "8N1". */
8157 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
8158 error ("Not a serial process");
8159 hnd
= fd_info
[ p
->outfd
].hnd
;
8161 childp2
= Fcopy_sequence (p
->childp
);
8163 /* Initialize timeouts for blocking read and blocking write. */
8164 if (!GetCommTimeouts (hnd
, &ct
))
8165 error ("GetCommTimeouts() failed");
8166 ct
.ReadIntervalTimeout
= 0;
8167 ct
.ReadTotalTimeoutMultiplier
= 0;
8168 ct
.ReadTotalTimeoutConstant
= 0;
8169 ct
.WriteTotalTimeoutMultiplier
= 0;
8170 ct
.WriteTotalTimeoutConstant
= 0;
8171 if (!SetCommTimeouts (hnd
, &ct
))
8172 error ("SetCommTimeouts() failed");
8173 /* Read port attributes and prepare default configuration. */
8174 memset (&dcb
, 0, sizeof (dcb
));
8175 dcb
.DCBlength
= sizeof (DCB
);
8176 if (!GetCommState (hnd
, &dcb
))
8177 error ("GetCommState() failed");
8180 dcb
.fAbortOnError
= FALSE
;
8181 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
8186 /* Configure speed. */
8187 if (!NILP (Fplist_member (contact
, QCspeed
)))
8188 tem
= Fplist_get (contact
, QCspeed
);
8190 tem
= Fplist_get (p
->childp
, QCspeed
);
8192 dcb
.BaudRate
= XINT (tem
);
8193 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
8195 /* Configure bytesize. */
8196 if (!NILP (Fplist_member (contact
, QCbytesize
)))
8197 tem
= Fplist_get (contact
, QCbytesize
);
8199 tem
= Fplist_get (p
->childp
, QCbytesize
);
8201 tem
= make_number (8);
8203 if (XINT (tem
) != 7 && XINT (tem
) != 8)
8204 error (":bytesize must be nil (8), 7, or 8");
8205 dcb
.ByteSize
= XINT (tem
);
8206 summary
[0] = XINT (tem
) + '0';
8207 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
8209 /* Configure parity. */
8210 if (!NILP (Fplist_member (contact
, QCparity
)))
8211 tem
= Fplist_get (contact
, QCparity
);
8213 tem
= Fplist_get (p
->childp
, QCparity
);
8214 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
8215 error (":parity must be nil (no parity), `even', or `odd'");
8216 dcb
.fParity
= FALSE
;
8217 dcb
.Parity
= NOPARITY
;
8218 dcb
.fErrorChar
= FALSE
;
8223 else if (EQ (tem
, Qeven
))
8227 dcb
.Parity
= EVENPARITY
;
8228 dcb
.fErrorChar
= TRUE
;
8230 else if (EQ (tem
, Qodd
))
8234 dcb
.Parity
= ODDPARITY
;
8235 dcb
.fErrorChar
= TRUE
;
8237 childp2
= Fplist_put (childp2
, QCparity
, tem
);
8239 /* Configure stopbits. */
8240 if (!NILP (Fplist_member (contact
, QCstopbits
)))
8241 tem
= Fplist_get (contact
, QCstopbits
);
8243 tem
= Fplist_get (p
->childp
, QCstopbits
);
8245 tem
= make_number (1);
8247 if (XINT (tem
) != 1 && XINT (tem
) != 2)
8248 error (":stopbits must be nil (1 stopbit), 1, or 2");
8249 summary
[2] = XINT (tem
) + '0';
8250 if (XINT (tem
) == 1)
8251 dcb
.StopBits
= ONESTOPBIT
;
8252 else if (XINT (tem
) == 2)
8253 dcb
.StopBits
= TWOSTOPBITS
;
8254 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
8256 /* Configure flowcontrol. */
8257 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
8258 tem
= Fplist_get (contact
, QCflowcontrol
);
8260 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
8261 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
8262 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
8263 dcb
.fOutxCtsFlow
= FALSE
;
8264 dcb
.fOutxDsrFlow
= FALSE
;
8265 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
8266 dcb
.fDsrSensitivity
= FALSE
;
8267 dcb
.fTXContinueOnXoff
= FALSE
;
8270 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
8271 dcb
.XonChar
= 17; /* Control-Q */
8272 dcb
.XoffChar
= 19; /* Control-S */
8275 /* Already configured. */
8277 else if (EQ (tem
, Qhw
))
8279 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
8280 dcb
.fOutxCtsFlow
= TRUE
;
8282 else if (EQ (tem
, Qsw
))
8287 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
8289 /* Activate configuration. */
8290 if (!SetCommState (hnd
, &dcb
))
8291 error ("SetCommState() failed");
8293 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
8294 pset_childp (p
, childp2
);
8300 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
8304 struct timespec timeout
;
8305 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
8306 int fd
= process
->infd
;
8308 n
= sys_read (fd
, (char*)buf
, sz
);
8315 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
8316 if (err
== EWOULDBLOCK
)
8319 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
8325 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
8327 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
8328 int fd
= process
->outfd
;
8329 ssize_t n
= sys_write (fd
, buf
, sz
);
8331 /* 0 or more bytes written means everything went fine. */
8335 /* Negative bytes written means we got an error in errno.
8336 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
8337 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
8338 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
8342 #endif /* HAVE_GNUTLS */