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 (const char * name
, const char ** pPath
)
1877 const 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
, (const char **)&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 unixtodos_filename (info
->root_dir
);
2632 info
->next
= volume_cache
;
2633 volume_cache
= info
;
2637 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2638 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2639 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2640 static volume_info_data
*
2641 GetCachedVolumeInformation (char * root_dir
)
2643 volume_info_data
* info
;
2644 char default_root
[ MAX_UTF8_PATH
];
2645 char name
[MAX_PATH
+1];
2646 char type
[MAX_PATH
+1];
2648 /* NULL for root_dir means use root from current directory. */
2649 if (root_dir
== NULL
)
2651 if (w32_unicode_filenames
)
2653 wchar_t curdirw
[MAX_PATH
];
2655 if (GetCurrentDirectoryW (MAX_PATH
, curdirw
) == 0)
2657 filename_from_utf16 (curdirw
, default_root
);
2661 char curdira
[MAX_PATH
];
2663 if (GetCurrentDirectoryA (MAX_PATH
, curdira
) == 0)
2665 filename_from_ansi (curdira
, default_root
);
2667 parse_root (default_root
, (const char **)&root_dir
);
2669 root_dir
= default_root
;
2672 /* Local fixed drives can be cached permanently. Removable drives
2673 cannot be cached permanently, since the volume name and serial
2674 number (if nothing else) can change. Remote drives should be
2675 treated as if they are removable, since there is no sure way to
2676 tell whether they are or not. Also, the UNC association of drive
2677 letters mapped to remote volumes can be changed at any time (even
2678 by other processes) without notice.
2680 As a compromise, so we can benefit from caching info for remote
2681 volumes, we use a simple expiry mechanism to invalidate cache
2682 entries that are more than ten seconds old. */
2685 /* No point doing this, because WNetGetConnection is even slower than
2686 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2687 GetDriveType is about the only call of this type which does not
2688 involve network access, and so is extremely quick). */
2690 /* Map drive letter to UNC if remote. */
2691 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2693 char remote_name
[ 256 ];
2694 char drive
[3] = { root_dir
[0], ':' };
2696 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2698 /* do something */ ;
2702 info
= lookup_volume_info (root_dir
);
2704 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2710 /* Info is not cached, or is stale. */
2711 if (w32_unicode_filenames
)
2713 wchar_t root_w
[MAX_PATH
];
2714 wchar_t name_w
[MAX_PATH
+1];
2715 wchar_t type_w
[MAX_PATH
+1];
2717 filename_to_utf16 (root_dir
, root_w
);
2718 if (!GetVolumeInformationW (root_w
,
2719 name_w
, sizeof (name_w
),
2723 type_w
, sizeof (type_w
)))
2725 /* Hmm... not really 100% correct, as these 2 are not file
2727 filename_from_utf16 (name_w
, name
);
2728 filename_from_utf16 (type_w
, type
);
2732 char root_a
[MAX_PATH
];
2733 char name_a
[MAX_PATH
+1];
2734 char type_a
[MAX_PATH
+1];
2736 filename_to_ansi (root_dir
, root_a
);
2737 if (!GetVolumeInformationA (root_a
,
2738 name_a
, sizeof (name_a
),
2742 type_a
, sizeof (type_a
)))
2744 filename_from_ansi (name_a
, name
);
2745 filename_from_ansi (type_a
, type
);
2748 /* Cache the volume information for future use, overwriting existing
2749 entry if present. */
2752 info
= xmalloc (sizeof (volume_info_data
));
2753 add_volume_info (root_dir
, info
);
2761 info
->name
= xstrdup (name
);
2762 unixtodos_filename (info
->name
);
2763 info
->serialnum
= serialnum
;
2764 info
->maxcomp
= maxcomp
;
2765 info
->flags
= flags
;
2766 info
->type
= xstrdup (type
);
2767 info
->timestamp
= GetTickCount ();
2773 /* Get information on the volume where NAME is held; set path pointer to
2774 start of pathname in NAME (past UNC header\volume header if present),
2775 if pPath is non-NULL.
2777 Note: if NAME includes symlinks, the information is for the volume
2778 of the symlink, not of its target. That's because, even though
2779 GetVolumeInformation returns information about the symlink target
2780 of its argument, we only pass the root directory to
2781 GetVolumeInformation, not the full NAME. */
2783 get_volume_info (const char * name
, const char ** pPath
)
2785 char temp
[MAX_UTF8_PATH
];
2786 char *rootname
= NULL
; /* default to current volume */
2787 volume_info_data
* info
;
2788 int root_len
= parse_root (name
, pPath
);
2793 /* Copy the root name of the volume, if given. */
2796 strncpy (temp
, name
, root_len
);
2797 temp
[root_len
] = '\0';
2798 unixtodos_filename (temp
);
2802 info
= GetCachedVolumeInformation (rootname
);
2805 /* Set global referenced by other functions. */
2806 volume_info
= *info
;
2812 /* Determine if volume is FAT format (ie. only supports short 8.3
2813 names); also set path pointer to start of pathname in name, if
2814 pPath is non-NULL. */
2816 is_fat_volume (const char * name
, const char ** pPath
)
2818 if (get_volume_info (name
, pPath
))
2819 return (volume_info
.maxcomp
== 12);
2823 /* Convert all slashes in a filename to backslashes, and map filename
2824 to a valid 8.3 name if necessary. The result is a pointer to a
2825 static buffer, so CAVEAT EMPTOR! */
2827 map_w32_filename (const char * name
, const char ** pPath
)
2829 static char shortname
[MAX_UTF8_PATH
];
2830 char * str
= shortname
;
2833 const char * save_name
= name
;
2835 if (strlen (name
) >= sizeof (shortname
))
2837 /* Return a filename which will cause callers to fail. */
2838 strcpy (shortname
, "?");
2842 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2844 register int left
= 8; /* maximum number of chars in part */
2845 register int extn
= 0; /* extension added? */
2846 register int dots
= 2; /* maximum number of dots allowed */
2849 *str
++ = *name
++; /* skip past UNC header */
2851 while ((c
= *name
++))
2858 *str
++ = (c
== ':' ? ':' : '\\');
2859 extn
= 0; /* reset extension flags */
2860 dots
= 2; /* max 2 dots */
2861 left
= 8; /* max length 8 for main part */
2866 /* Convert path components of the form .xxx to _xxx,
2867 but leave . and .. as they are. This allows .emacs
2868 to be read as _emacs, for example. */
2872 IS_DIRECTORY_SEP (*name
))
2887 extn
= 1; /* we've got an extension */
2888 left
= 3; /* 3 chars in extension */
2892 /* any embedded dots after the first are converted to _ */
2897 case '#': /* don't lose these, they're important */
2899 str
[-1] = c
; /* replace last character of part */
2902 if ( left
&& 'A' <= c
&& c
<= 'Z' )
2904 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2906 dots
= 0; /* started a path component */
2915 strcpy (shortname
, name
);
2916 unixtodos_filename (shortname
);
2920 *pPath
= shortname
+ (path
- save_name
);
2926 is_exec (const char * name
)
2928 char * p
= strrchr (name
, '.');
2931 && (xstrcasecmp (p
, ".exe") == 0 ||
2932 xstrcasecmp (p
, ".com") == 0 ||
2933 xstrcasecmp (p
, ".bat") == 0 ||
2934 xstrcasecmp (p
, ".cmd") == 0));
2937 /* Emulate the Unix directory procedures opendir, closedir, and
2938 readdir. We rename them to sys_* names because some versions of
2939 MinGW startup code call opendir and readdir to glob wildcards, and
2940 the code that calls them doesn't grok UTF-8 encoded file names we
2941 produce in dirent->d_name[]. */
2943 struct dirent dir_static
; /* simulated directory contents */
2944 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2945 static int dir_is_fat
;
2946 static char dir_pathname
[MAX_UTF8_PATH
];
2947 static WIN32_FIND_DATAW dir_find_data_w
;
2948 static WIN32_FIND_DATAA dir_find_data_a
;
2950 /* Support shares on a network resource as subdirectories of a read-only
2952 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2953 static HANDLE
open_unc_volume (const char *);
2954 static void *read_unc_volume (HANDLE
, wchar_t *, char *, int);
2955 static void close_unc_volume (HANDLE
);
2958 sys_opendir (const char *filename
)
2962 /* Opening is done by FindFirstFile. However, a read is inherent to
2963 this operation, so we defer the open until read time. */
2965 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2967 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2970 /* Note: We don't support traversal of UNC volumes via symlinks.
2971 Doing so would mean punishing 99.99% of use cases by resolving
2972 all the possible symlinks in FILENAME, recursively. */
2973 if (is_unc_volume (filename
))
2975 wnet_enum_handle
= open_unc_volume (filename
);
2976 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2980 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2987 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAX_UTF8_PATH
- 1);
2988 dir_pathname
[MAX_UTF8_PATH
- 1] = '\0';
2989 /* Note: We don't support symlinks to file names on FAT volumes.
2990 Doing so would mean punishing 99.99% of use cases by resolving
2991 all the possible symlinks in FILENAME, recursively. */
2992 dir_is_fat
= is_fat_volume (filename
, NULL
);
2998 sys_closedir (DIR *dirp
)
3000 /* If we have a find-handle open, close it. */
3001 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3003 FindClose (dir_find_handle
);
3004 dir_find_handle
= INVALID_HANDLE_VALUE
;
3006 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3008 close_unc_volume (wnet_enum_handle
);
3009 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3011 xfree ((char *) dirp
);
3015 sys_readdir (DIR *dirp
)
3017 int downcase
= !NILP (Vw32_downcase_file_names
);
3019 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3021 if (!read_unc_volume (wnet_enum_handle
,
3022 dir_find_data_w
.cFileName
,
3023 dir_find_data_a
.cFileName
,
3027 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3028 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3030 char filename
[MAX_UTF8_PATH
+ 2];
3033 strcpy (filename
, dir_pathname
);
3034 ln
= strlen (filename
) - 1;
3035 if (!IS_DIRECTORY_SEP (filename
[ln
]))
3036 strcat (filename
, "\\");
3037 strcat (filename
, "*");
3039 /* Note: No need to resolve symlinks in FILENAME, because
3040 FindFirst opens the directory that is the target of a
3042 if (w32_unicode_filenames
)
3044 wchar_t fnw
[MAX_PATH
];
3046 filename_to_utf16 (filename
, fnw
);
3047 dir_find_handle
= FindFirstFileW (fnw
, &dir_find_data_w
);
3053 filename_to_ansi (filename
, fna
);
3054 dir_find_handle
= FindFirstFileA (fna
, &dir_find_data_a
);
3057 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3060 else if (w32_unicode_filenames
)
3062 if (!FindNextFileW (dir_find_handle
, &dir_find_data_w
))
3067 if (!FindNextFileA (dir_find_handle
, &dir_find_data_a
))
3071 /* Emacs never uses this value, so don't bother making it match
3072 value returned by stat(). */
3073 dir_static
.d_ino
= 1;
3075 if (w32_unicode_filenames
)
3077 if (downcase
|| dir_is_fat
)
3079 wchar_t tem
[MAX_PATH
];
3081 wcscpy (tem
, dir_find_data_w
.cFileName
);
3083 filename_from_utf16 (tem
, dir_static
.d_name
);
3086 filename_from_utf16 (dir_find_data_w
.cFileName
, dir_static
.d_name
);
3092 /* If the file name in cFileName[] includes `?' characters, it
3093 means the original file name used characters that cannot be
3094 represented by the current ANSI codepage. To avoid total
3095 lossage, retrieve the short 8+3 alias of the long file
3097 if (_mbspbrk (dir_find_data_a
.cFileName
, "?"))
3099 strcpy (tem
, dir_find_data_a
.cAlternateFileName
);
3100 /* 8+3 aliases are returned in all caps, which could break
3101 various alists that look at filenames' extensions. */
3104 else if (downcase
|| dir_is_fat
)
3105 strcpy (tem
, dir_find_data_a
.cFileName
);
3107 filename_from_ansi (dir_find_data_a
.cFileName
, dir_static
.d_name
);
3108 if (downcase
|| dir_is_fat
)
3111 filename_from_ansi (tem
, dir_static
.d_name
);
3115 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3116 dir_static
.d_reclen
= sizeof (struct dirent
) - MAX_UTF8_PATH
+ 3 +
3117 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3123 open_unc_volume (const char *path
)
3125 const char *fn
= map_w32_filename (path
, NULL
);
3129 if (w32_unicode_filenames
)
3132 wchar_t fnw
[MAX_PATH
];
3134 nrw
.dwScope
= RESOURCE_GLOBALNET
;
3135 nrw
.dwType
= RESOURCETYPE_DISK
;
3136 nrw
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3137 nrw
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3138 nrw
.lpLocalName
= NULL
;
3139 filename_to_utf16 (fn
, fnw
);
3140 nrw
.lpRemoteName
= fnw
;
3141 nrw
.lpComment
= NULL
;
3142 nrw
.lpProvider
= NULL
;
3144 result
= WNetOpenEnumW (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3145 RESOURCEUSAGE_CONNECTABLE
, &nrw
, &henum
);
3152 nra
.dwScope
= RESOURCE_GLOBALNET
;
3153 nra
.dwType
= RESOURCETYPE_DISK
;
3154 nra
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3155 nra
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3156 nra
.lpLocalName
= NULL
;
3157 filename_to_ansi (fn
, fna
);
3158 nra
.lpRemoteName
= fna
;
3159 nra
.lpComment
= NULL
;
3160 nra
.lpProvider
= NULL
;
3162 result
= WNetOpenEnumA (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3163 RESOURCEUSAGE_CONNECTABLE
, &nra
, &henum
);
3165 if (result
== NO_ERROR
)
3168 return INVALID_HANDLE_VALUE
;
3172 read_unc_volume (HANDLE henum
, wchar_t *fname_w
, char *fname_a
, int size
)
3177 DWORD bufsize
= 512;
3181 if (w32_unicode_filenames
)
3186 buffer
= alloca (bufsize
);
3187 result
= WNetEnumResourceW (henum
, &count
, buffer
, &bufsize
);
3188 if (result
!= NO_ERROR
)
3190 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3191 ptrw
= ((LPNETRESOURCEW
) buffer
)->lpRemoteName
;
3193 while (*ptrw
&& *ptrw
!= L
'/' && *ptrw
!= L
'\\') ptrw
++;
3195 wcsncpy (fname_w
, ptrw
, size
);
3200 int dbcs_p
= max_filename_mbslen () > 1;
3203 buffer
= alloca (bufsize
);
3204 result
= WNetEnumResourceA (henum
, &count
, buffer
, &bufsize
);
3205 if (result
!= NO_ERROR
)
3207 ptra
= ((LPNETRESOURCEA
) buffer
)->lpRemoteName
;
3210 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
)) ptra
++;
3213 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
))
3214 ptra
= CharNextExA (file_name_codepage
, ptra
, 0);
3217 strncpy (fname_a
, ptra
, size
);
3225 close_unc_volume (HANDLE henum
)
3227 if (henum
!= INVALID_HANDLE_VALUE
)
3228 WNetCloseEnum (henum
);
3232 unc_volume_file_attributes (const char *path
)
3237 henum
= open_unc_volume (path
);
3238 if (henum
== INVALID_HANDLE_VALUE
)
3241 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3243 close_unc_volume (henum
);
3248 /* Ensure a network connection is authenticated. */
3250 logon_network_drive (const char *path
)
3252 char share
[MAX_UTF8_PATH
];
3259 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3260 drvtype
= DRIVE_REMOTE
;
3261 else if (path
[0] == '\0' || path
[1] != ':')
3262 drvtype
= GetDriveType (NULL
);
3269 drvtype
= GetDriveType (drive
);
3272 /* Only logon to networked drives. */
3273 if (drvtype
!= DRIVE_REMOTE
)
3277 strncpy (share
, path
, MAX_UTF8_PATH
);
3278 /* Truncate to just server and share name. */
3279 for (p
= share
+ 2; *p
&& p
< share
+ MAX_UTF8_PATH
; p
++)
3281 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3288 if (w32_unicode_filenames
)
3290 NETRESOURCEW resourcew
;
3291 wchar_t share_w
[MAX_PATH
];
3293 resourcew
.dwScope
= RESOURCE_GLOBALNET
;
3294 resourcew
.dwType
= RESOURCETYPE_DISK
;
3295 resourcew
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3296 resourcew
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3297 resourcew
.lpLocalName
= NULL
;
3298 filename_to_utf16 (share
, share_w
);
3299 resourcew
.lpRemoteName
= share_w
;
3300 resourcew
.lpProvider
= NULL
;
3302 val
= WNetAddConnection2W (&resourcew
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3306 NETRESOURCEA resourcea
;
3307 char share_a
[MAX_PATH
];
3309 resourcea
.dwScope
= RESOURCE_GLOBALNET
;
3310 resourcea
.dwType
= RESOURCETYPE_DISK
;
3311 resourcea
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3312 resourcea
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3313 resourcea
.lpLocalName
= NULL
;
3314 filename_to_ansi (share
, share_a
);
3315 resourcea
.lpRemoteName
= share_a
;
3316 resourcea
.lpProvider
= NULL
;
3318 val
= WNetAddConnection2A (&resourcea
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3324 case ERROR_ALREADY_ASSIGNED
:
3326 case ERROR_ACCESS_DENIED
:
3327 case ERROR_LOGON_FAILURE
:
3333 case ERROR_BAD_NET_NAME
:
3334 case ERROR_NO_NET_OR_BAD_PATH
:
3335 case ERROR_NO_NETWORK
:
3336 case ERROR_CANCELLED
:
3343 /* Emulate faccessat(2). */
3345 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3349 if (dirfd
!= AT_FDCWD
3350 && !(IS_DIRECTORY_SEP (path
[0])
3351 || IS_DEVICE_SEP (path
[1])))
3357 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3358 newer versions blow up when passed D_OK. */
3359 path
= map_w32_filename (path
, NULL
);
3360 /* If the last element of PATH is a symlink, we need to resolve it
3361 to get the attributes of its target file. Note: any symlinks in
3362 PATH elements other than the last one are transparently resolved
3363 by GetFileAttributes below. */
3364 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3365 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3366 path
= chase_symlinks (path
);
3368 if (w32_unicode_filenames
)
3370 wchar_t path_w
[MAX_PATH
];
3372 filename_to_utf16 (path
, path_w
);
3373 attributes
= GetFileAttributesW (path_w
);
3377 char path_a
[MAX_PATH
];
3379 filename_to_ansi (path
, path_a
);
3380 attributes
= GetFileAttributesA (path_a
);
3383 if (attributes
== -1)
3385 DWORD w32err
= GetLastError ();
3389 case ERROR_INVALID_NAME
:
3390 case ERROR_BAD_PATHNAME
:
3391 if (is_unc_volume (path
))
3393 attributes
= unc_volume_file_attributes (path
);
3394 if (attributes
== -1)
3402 case ERROR_FILE_NOT_FOUND
:
3403 case ERROR_BAD_NETPATH
:
3412 if ((mode
& X_OK
) != 0
3413 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3418 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3423 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3431 /* A version of 'access' to be used locally with file names in
3432 locale-specific encoding. Does not resolve symlinks and does not
3433 support file names on FAT12 and FAT16 volumes, but that's OK, since
3434 we only invoke this function for files inside the Emacs source or
3435 installation tree, on directories (so any symlinks should have the
3436 directory bit set), and on short file names such as "C:/.emacs". */
3438 sys_access (const char *fname
, int mode
)
3440 char fname_copy
[MAX_PATH
], *p
;
3443 strcpy (fname_copy
, fname
);
3444 /* Do the equivalent of unixtodos_filename. */
3445 for (p
= fname_copy
; *p
; p
= CharNext (p
))
3449 if ((attributes
= GetFileAttributesA (fname_copy
)) == -1)
3451 DWORD w32err
= GetLastError ();
3455 case ERROR_INVALID_NAME
:
3456 case ERROR_BAD_PATHNAME
:
3457 case ERROR_FILE_NOT_FOUND
:
3458 case ERROR_BAD_NETPATH
:
3467 if ((mode
& X_OK
) != 0
3468 && !(is_exec (fname_copy
)
3469 || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3474 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3479 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3487 /* Shadow some MSVC runtime functions to map requests for long filenames
3488 to reasonable short names if necessary. This was originally added to
3489 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3493 sys_chdir (const char * path
)
3495 path
= map_w32_filename (path
, NULL
);
3496 if (w32_unicode_filenames
)
3498 wchar_t newdir_w
[MAX_PATH
];
3500 if (filename_to_utf16 (path
, newdir_w
) == 0)
3501 return _wchdir (newdir_w
);
3506 char newdir_a
[MAX_PATH
];
3508 if (filename_to_ansi (path
, newdir_a
) == 0)
3509 return _chdir (newdir_a
);
3515 sys_chmod (const char * path
, int mode
)
3517 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3518 if (w32_unicode_filenames
)
3520 wchar_t path_w
[MAX_PATH
];
3522 filename_to_utf16 (path
, path_w
);
3523 return _wchmod (path_w
, mode
);
3527 char path_a
[MAX_PATH
];
3529 filename_to_ansi (path
, path_a
);
3530 return _chmod (path_a
, mode
);
3535 sys_creat (const char * path
, int mode
)
3537 path
= map_w32_filename (path
, NULL
);
3538 if (w32_unicode_filenames
)
3540 wchar_t path_w
[MAX_PATH
];
3542 filename_to_utf16 (path
, path_w
);
3543 return _wcreat (path_w
, mode
);
3547 char path_a
[MAX_PATH
];
3549 filename_to_ansi (path
, path_a
);
3550 return _creat (path_a
, mode
);
3555 sys_fopen (const char * path
, const char * mode
)
3559 const char * mode_save
= mode
;
3561 /* Force all file handles to be non-inheritable. This is necessary to
3562 ensure child processes don't unwittingly inherit handles that might
3563 prevent future file access. */
3567 else if (mode
[0] == 'w' || mode
[0] == 'a')
3568 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3572 /* Only do simplistic option parsing. */
3576 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3579 else if (mode
[0] == 'b')
3584 else if (mode
[0] == 't')
3591 path
= map_w32_filename (path
, NULL
);
3592 if (w32_unicode_filenames
)
3594 wchar_t path_w
[MAX_PATH
];
3596 filename_to_utf16 (path
, path_w
);
3597 fd
= _wopen (path_w
, oflag
| _O_NOINHERIT
, 0644);
3601 char path_a
[MAX_PATH
];
3603 filename_to_ansi (path
, path_a
);
3604 fd
= _open (path_a
, oflag
| _O_NOINHERIT
, 0644);
3609 return _fdopen (fd
, mode_save
);
3612 /* This only works on NTFS volumes, but is useful to have. */
3614 sys_link (const char * old
, const char * new)
3618 char oldname
[MAX_UTF8_PATH
], newname
[MAX_UTF8_PATH
];
3619 wchar_t oldname_w
[MAX_PATH
];
3620 char oldname_a
[MAX_PATH
];
3622 if (old
== NULL
|| new == NULL
)
3628 strcpy (oldname
, map_w32_filename (old
, NULL
));
3629 strcpy (newname
, map_w32_filename (new, NULL
));
3631 if (w32_unicode_filenames
)
3633 filename_to_utf16 (oldname
, oldname_w
);
3634 fileh
= CreateFileW (oldname_w
, 0, 0, NULL
, OPEN_EXISTING
,
3635 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3639 filename_to_ansi (oldname
, oldname_a
);
3640 fileh
= CreateFileA (oldname_a
, 0, 0, NULL
, OPEN_EXISTING
,
3641 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3643 if (fileh
!= INVALID_HANDLE_VALUE
)
3647 /* Confusingly, the "alternate" stream name field does not apply
3648 when restoring a hard link, and instead contains the actual
3649 stream data for the link (ie. the name of the link to create).
3650 The WIN32_STREAM_ID structure before the cStreamName field is
3651 the stream header, which is then immediately followed by the
3655 WIN32_STREAM_ID wid
;
3656 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3659 /* We used to pass MB_PRECOMPOSED as the 2nd arg here, but MSDN
3660 indicates that flag is unsupported for CP_UTF8, and OTOH says
3661 it is the default anyway. */
3662 wlen
= MultiByteToWideChar (CP_UTF8
, 0, newname
, -1,
3663 data
.wid
.cStreamName
, MAX_PATH
);
3666 LPVOID context
= NULL
;
3669 data
.wid
.dwStreamId
= BACKUP_LINK
;
3670 data
.wid
.dwStreamAttributes
= 0;
3671 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3672 data
.wid
.Size
.HighPart
= 0;
3673 data
.wid
.dwStreamNameSize
= 0;
3675 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3676 offsetof (WIN32_STREAM_ID
, cStreamName
)
3677 + data
.wid
.Size
.LowPart
,
3678 &wbytes
, FALSE
, FALSE
, &context
)
3679 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3686 DWORD err
= GetLastError ();
3691 case ERROR_ACCESS_DENIED
:
3692 /* This is what happens when OLDNAME is a directory,
3693 since Windows doesn't support hard links to
3694 directories. Posix says to set errno to EPERM in
3696 if (w32_unicode_filenames
)
3697 attributes
= GetFileAttributesW (oldname_w
);
3699 attributes
= GetFileAttributesA (oldname_a
);
3700 if (attributes
!= -1
3701 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
3703 else if (attributes
== -1
3704 && is_unc_volume (oldname
)
3705 && unc_volume_file_attributes (oldname
) != -1)
3710 case ERROR_TOO_MANY_LINKS
:
3713 case ERROR_NOT_SAME_DEVICE
:
3723 CloseHandle (fileh
);
3732 sys_mkdir (const char * path
)
3734 path
= map_w32_filename (path
, NULL
);
3736 if (w32_unicode_filenames
)
3738 wchar_t path_w
[MAX_PATH
];
3740 filename_to_utf16 (path
, path_w
);
3741 return _wmkdir (path_w
);
3745 char path_a
[MAX_PATH
];
3747 filename_to_ansi (path
, path_a
);
3748 return _mkdir (path_a
);
3753 sys_open (const char * path
, int oflag
, int mode
)
3755 const char* mpath
= map_w32_filename (path
, NULL
);
3758 if (w32_unicode_filenames
)
3760 wchar_t mpath_w
[MAX_PATH
];
3762 filename_to_utf16 (mpath
, mpath_w
);
3763 /* If possible, try to open file without _O_CREAT, to be able to
3764 write to existing hidden and system files. Force all file
3765 handles to be non-inheritable. */
3766 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
3767 res
= _wopen (mpath_w
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3769 res
= _wopen (mpath_w
, oflag
| _O_NOINHERIT
, mode
);
3773 char mpath_a
[MAX_PATH
];
3775 filename_to_ansi (mpath
, mpath_a
);
3776 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
3777 res
= _open (mpath_a
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3779 res
= _open (mpath_a
, oflag
| _O_NOINHERIT
, mode
);
3785 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
3788 Standard algorithm for generating a temporary file name seems to be
3789 use pid or tid with a letter on the front (in place of the 6 X's)
3790 and cycle through the letters to find a unique name. We extend
3791 that to allow any reasonable character as the first of the 6 X's,
3792 so that the number of simultaneously used temporary files will be
3796 mkostemp (char * template, int flags
)
3800 unsigned uid
= GetCurrentThreadId ();
3801 int save_errno
= errno
;
3802 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3805 if (template == NULL
)
3808 p
= template + strlen (template);
3810 /* replace up to the last 5 X's with uid in decimal */
3811 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3813 p
[0] = '0' + uid
% 10;
3817 if (i
< 0 && p
[0] == 'X')
3822 p
[0] = first_char
[i
];
3823 if ((fd
= sys_open (template,
3824 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
3825 S_IRUSR
| S_IWUSR
)) >= 0
3833 while (++i
< sizeof (first_char
));
3836 /* Template is badly formed or else we can't generate a unique name. */
3841 fchmod (int fd
, mode_t mode
)
3847 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
3850 char temp
[MAX_PATH
];
3854 /* MoveFile on Windows 95 doesn't correctly change the short file name
3855 alias in a number of circumstances (it is not easy to predict when
3856 just by looking at oldname and newname, unfortunately). In these
3857 cases, renaming through a temporary name avoids the problem.
3859 A second problem on Windows 95 is that renaming through a temp name when
3860 newname is uppercase fails (the final long name ends up in
3861 lowercase, although the short alias might be uppercase) UNLESS the
3862 long temp name is not 8.3.
3864 So, on Windows 95 we always rename through a temp name, and we make sure
3865 the temp name has a long extension to ensure correct renaming. */
3867 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3869 /* volume_info is set indirectly by map_w32_filename. */
3870 oldname_dev
= volume_info
.serialnum
;
3872 if (os_subtype
== OS_9X
)
3878 oldname
= map_w32_filename (oldname
, NULL
);
3879 if ((o
= strrchr (oldname
, '\\')))
3882 o
= (char *) oldname
;
3884 if ((p
= strrchr (temp
, '\\')))
3891 /* Force temp name to require a manufactured 8.3 alias - this
3892 seems to make the second rename work properly. */
3893 sprintf (p
, "_.%s.%u", o
, i
);
3895 result
= rename (oldname
, temp
);
3897 /* This loop must surely terminate! */
3898 while (result
< 0 && errno
== EEXIST
);
3903 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
3904 (at least if it is a file; don't do this for directories).
3906 Since we mustn't do this if we are just changing the case of the
3907 file name (we would end up deleting the file we are trying to
3908 rename!), we let rename detect if the destination file already
3909 exists - that way we avoid the possible pitfalls of trying to
3910 determine ourselves whether two names really refer to the same
3911 file, which is not always possible in the general case. (Consider
3912 all the permutations of shared or subst'd drives, etc.) */
3914 newname
= map_w32_filename (newname
, NULL
);
3916 /* volume_info is set indirectly by map_w32_filename. */
3917 newname_dev
= volume_info
.serialnum
;
3919 result
= rename (temp
, newname
);
3921 if (result
< 0 && force
)
3923 DWORD w32err
= GetLastError ();
3926 && newname_dev
!= oldname_dev
)
3928 /* The implementation of `rename' on Windows does not return
3929 errno = EXDEV when you are moving a directory to a
3930 different storage device (ex. logical disk). It returns
3931 EACCES instead. So here we handle such situations and
3935 if ((attributes
= GetFileAttributes (temp
)) != -1
3936 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3939 else if (errno
== EEXIST
)
3941 if (_chmod (newname
, 0666) != 0)
3943 if (_unlink (newname
) != 0)
3945 result
= rename (temp
, newname
);
3947 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3948 && is_symlink (temp
))
3950 /* This is Windows prohibiting the user from creating a
3951 symlink in another place, since that requires
3961 sys_rename (char const *old
, char const *new)
3963 return sys_rename_replace (old
, new, TRUE
);
3967 sys_rmdir (const char * path
)
3969 return _rmdir (map_w32_filename (path
, NULL
));
3973 sys_unlink (const char * path
)
3975 path
= map_w32_filename (path
, NULL
);
3977 /* On Unix, unlink works without write permission. */
3978 _chmod (path
, 0666);
3979 return _unlink (path
);
3982 static FILETIME utc_base_ft
;
3983 static ULONGLONG utc_base
; /* In 100ns units */
3984 static int init
= 0;
3986 #define FILETIME_TO_U64(result, ft) \
3988 ULARGE_INTEGER uiTemp; \
3989 uiTemp.LowPart = (ft).dwLowDateTime; \
3990 uiTemp.HighPart = (ft).dwHighDateTime; \
3991 result = uiTemp.QuadPart; \
3995 initialize_utc_base (void)
3997 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4006 st
.wMilliseconds
= 0;
4008 SystemTimeToFileTime (&st
, &utc_base_ft
);
4009 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
4013 convert_time (FILETIME ft
)
4019 initialize_utc_base ();
4023 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
4026 FILETIME_TO_U64 (tmp
, ft
);
4027 return (time_t) ((tmp
- utc_base
) / 10000000L);
4031 convert_from_time_t (time_t time
, FILETIME
* pft
)
4037 initialize_utc_base ();
4041 /* time in 100ns units since 1-Jan-1601 */
4042 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
4043 pft
->dwHighDateTime
= tmp
.HighPart
;
4044 pft
->dwLowDateTime
= tmp
.LowPart
;
4047 static PSECURITY_DESCRIPTOR
4048 get_file_security_desc_by_handle (HANDLE h
)
4050 PSECURITY_DESCRIPTOR psd
= NULL
;
4052 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4053 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4055 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
4056 NULL
, NULL
, NULL
, NULL
, &psd
);
4057 if (err
!= ERROR_SUCCESS
)
4063 static PSECURITY_DESCRIPTOR
4064 get_file_security_desc_by_name (const char *fname
)
4066 PSECURITY_DESCRIPTOR psd
= NULL
;
4068 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4069 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4071 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
4073 err
= GetLastError ();
4074 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
4078 psd
= xmalloc (sd_len
);
4079 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4091 unsigned n_subauthorities
;
4093 /* Use the last sub-authority value of the RID, the relative
4094 portion of the SID, as user/group ID. */
4095 n_subauthorities
= *get_sid_sub_authority_count (sid
);
4096 if (n_subauthorities
< 1)
4097 return 0; /* the "World" RID */
4098 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
4101 /* Caching SID and account values for faster lokup. */
4105 struct w32_id
*next
;
4107 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
4110 static struct w32_id
*w32_idlist
;
4113 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
4115 struct w32_id
*tail
, *found
;
4117 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
4119 if (equal_sid ((PSID
)tail
->sid
, sid
))
4128 strcpy (name
, found
->name
);
4136 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
4139 struct w32_id
*new_entry
;
4141 /* We don't want to leave behind stale cache from when Emacs was
4145 sid_len
= get_length_sid (sid
);
4146 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
4149 new_entry
->rid
= id
;
4150 strcpy (new_entry
->name
, name
);
4151 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
4152 new_entry
->next
= w32_idlist
;
4153 w32_idlist
= new_entry
;
4162 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
4166 SID_NAME_USE ignore
;
4168 DWORD name_len
= sizeof (name
);
4170 DWORD domain_len
= sizeof (domain
);
4175 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
4176 else if (what
== GID
)
4177 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
4181 if (!result
|| !is_valid_sid (sid
))
4183 else if (!w32_cached_id (sid
, id
, nm
))
4185 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
4186 domain
, &domain_len
, &ignore
)
4187 || name_len
> UNLEN
+1)
4191 *id
= get_rid (sid
);
4193 w32_add_to_cache (sid
, *id
, name
);
4200 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
4202 int dflt_usr
= 0, dflt_grp
= 0;
4211 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
4213 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
4216 /* Consider files to belong to current user/group, if we cannot get
4217 more accurate information. */
4220 st
->st_uid
= dflt_passwd
.pw_uid
;
4221 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
4225 st
->st_gid
= dflt_passwd
.pw_gid
;
4226 strcpy (st
->st_gname
, dflt_group
.gr_name
);
4230 /* Return non-zero if NAME is a potentially slow filesystem. */
4232 is_slow_fs (const char *name
)
4237 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
4238 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
4239 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
4240 devtype
= GetDriveType (NULL
); /* use root of current drive */
4243 /* GetDriveType needs the root directory of the drive. */
4244 strncpy (drive_root
, name
, 2);
4245 drive_root
[2] = '\\';
4246 drive_root
[3] = '\0';
4247 devtype
= GetDriveType (drive_root
);
4249 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
4252 /* If this is non-zero, the caller wants accurate information about
4253 file's owner and group, which could be expensive to get. */
4254 int w32_stat_get_owner_group
;
4256 /* MSVC stat function can't cope with UNC names and has other bugs, so
4257 replace it with our own. This also allows us to calculate consistent
4258 inode values and owner/group without hacks in the main Emacs code. */
4261 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
4263 char *name
, *save_name
, *r
;
4264 WIN32_FIND_DATA wfd
;
4266 unsigned __int64 fake_inode
= 0;
4269 int rootdir
= FALSE
;
4270 PSECURITY_DESCRIPTOR psd
= NULL
;
4271 int is_a_symlink
= 0;
4272 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
4273 DWORD access_rights
= 0;
4274 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
4275 FILETIME ctime
, atime
, wtime
;
4278 if (path
== NULL
|| buf
== NULL
)
4284 save_name
= name
= (char *) map_w32_filename (path
, &path
);
4285 /* Must be valid filename, no wild cards or other invalid
4286 characters. We use _mbspbrk to support multibyte strings that
4287 might look to strpbrk as if they included literal *, ?, and other
4288 characters mentioned below that are disallowed by Windows
4290 if (_mbspbrk (name
, "*?|<>\""))
4296 /* Remove trailing directory separator, unless name is the root
4297 directory of a drive or UNC volume in which case ensure there
4298 is a trailing separator. */
4299 len
= strlen (name
);
4300 name
= strcpy (alloca (len
+ 2), name
);
4302 /* Avoid a somewhat costly call to is_symlink if the filesystem
4303 doesn't support symlinks. */
4304 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4305 is_a_symlink
= is_symlink (name
);
4307 /* Plan A: Open the file and get all the necessary information via
4308 the resulting handle. This solves several issues in one blow:
4310 . retrieves attributes for the target of a symlink, if needed
4311 . gets attributes of root directories and symlinks pointing to
4312 root directories, thus avoiding the need for special-casing
4313 these and detecting them by examining the file-name format
4314 . retrieves more accurate attributes (e.g., non-zero size for
4315 some directories, esp. directories that are junction points)
4316 . correctly resolves "c:/..", "/.." and similar file names
4317 . avoids run-time penalties for 99% of use cases
4319 Plan A is always tried first, unless the user asked not to (but
4320 if the file is a symlink and we need to follow links, we try Plan
4321 A even if the user asked not to).
4323 If Plan A fails, we go to Plan B (below), where various
4324 potentially expensive techniques must be used to handle "special"
4325 files such as UNC volumes etc. */
4326 if (!(NILP (Vw32_get_true_file_attributes
)
4327 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4328 /* Following symlinks requires getting the info by handle. */
4329 || (is_a_symlink
&& follow_symlinks
))
4331 BY_HANDLE_FILE_INFORMATION info
;
4333 if (is_a_symlink
&& !follow_symlinks
)
4334 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4335 /* READ_CONTROL access rights are required to get security info
4336 by handle. But if the OS doesn't support security in the
4337 first place, we don't need to try. */
4338 if (is_windows_9x () != TRUE
)
4339 access_rights
|= READ_CONTROL
;
4341 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4343 /* If CreateFile fails with READ_CONTROL, try again with zero as
4345 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4346 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
4348 if (fh
== INVALID_HANDLE_VALUE
)
4349 goto no_true_file_attributes
;
4351 /* This is more accurate in terms of getting the correct number
4352 of links, but is quite slow (it is noticeable when Emacs is
4353 making a list of file name completions). */
4354 if (GetFileInformationByHandle (fh
, &info
))
4356 nlinks
= info
.nNumberOfLinks
;
4357 /* Might as well use file index to fake inode values, but this
4358 is not guaranteed to be unique unless we keep a handle open
4359 all the time (even then there are situations where it is
4360 not unique). Reputedly, there are at most 48 bits of info
4361 (on NTFS, presumably less on FAT). */
4362 fake_inode
= info
.nFileIndexHigh
;
4364 fake_inode
+= info
.nFileIndexLow
;
4365 serialnum
= info
.dwVolumeSerialNumber
;
4366 fs_high
= info
.nFileSizeHigh
;
4367 fs_low
= info
.nFileSizeLow
;
4368 ctime
= info
.ftCreationTime
;
4369 atime
= info
.ftLastAccessTime
;
4370 wtime
= info
.ftLastWriteTime
;
4371 fattrs
= info
.dwFileAttributes
;
4375 /* We don't go to Plan B here, because it's not clear that
4376 it's a good idea. The only known use case where
4377 CreateFile succeeds, but GetFileInformationByHandle fails
4378 (with ERROR_INVALID_FUNCTION) is for character devices
4379 such as NUL, PRN, etc. For these, switching to Plan B is
4380 a net loss, because we lose the character device
4381 attribute returned by GetFileType below (FindFirstFile
4382 doesn't set that bit in the attributes), and the other
4383 fields don't make sense for character devices anyway.
4384 Emacs doesn't really care for non-file entities in the
4385 context of l?stat, so neither do we. */
4387 /* w32err is assigned so one could put a breakpoint here and
4388 examine its value, when GetFileInformationByHandle
4390 DWORD w32err
= GetLastError ();
4394 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4400 /* Test for a symlink before testing for a directory, since
4401 symlinks to directories have the directory bit set, but we
4402 don't want them to appear as directories. */
4403 if (is_a_symlink
&& !follow_symlinks
)
4404 buf
->st_mode
= S_IFLNK
;
4405 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4406 buf
->st_mode
= S_IFDIR
;
4409 DWORD ftype
= GetFileType (fh
);
4413 case FILE_TYPE_DISK
:
4414 buf
->st_mode
= S_IFREG
;
4416 case FILE_TYPE_PIPE
:
4417 buf
->st_mode
= S_IFIFO
;
4419 case FILE_TYPE_CHAR
:
4420 case FILE_TYPE_UNKNOWN
:
4422 buf
->st_mode
= S_IFCHR
;
4425 /* We produce the fallback owner and group data, based on the
4426 current user that runs Emacs, in the following cases:
4428 . caller didn't request owner and group info
4429 . this is Windows 9X
4430 . getting security by handle failed, and we need to produce
4431 information for the target of a symlink (this is better
4432 than producing a potentially misleading info about the
4435 If getting security by handle fails, and we don't need to
4436 resolve symlinks, we try getting security by name. */
4437 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4438 get_file_owner_and_group (NULL
, buf
);
4441 psd
= get_file_security_desc_by_handle (fh
);
4444 get_file_owner_and_group (psd
, buf
);
4447 else if (!(is_a_symlink
&& follow_symlinks
))
4449 psd
= get_file_security_desc_by_name (name
);
4450 get_file_owner_and_group (psd
, buf
);
4454 get_file_owner_and_group (NULL
, buf
);
4460 no_true_file_attributes
:
4461 /* Plan B: Either getting a handle on the file failed, or the
4462 caller explicitly asked us to not bother making this
4463 information more accurate.
4465 Implementation note: In Plan B, we never bother to resolve
4466 symlinks, even if we got here because we tried Plan A and
4467 failed. That's because, even if the caller asked for extra
4468 precision by setting Vw32_get_true_file_attributes to t,
4469 resolving symlinks requires acquiring a file handle to the
4470 symlink, which we already know will fail. And if the user
4471 did not ask for extra precision, resolving symlinks will fly
4472 in the face of that request, since the user then wants the
4473 lightweight version of the code. */
4474 dbcs_p
= max_filename_mbslen () > 1;
4475 rootdir
= (path
>= save_name
+ len
- 1
4476 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4478 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4479 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4480 if (IS_DIRECTORY_SEP (r
[0])
4481 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4484 /* Note: If NAME is a symlink to the root of a UNC volume
4485 (i.e. "\\SERVER"), we will not detect that here, and we will
4486 return data about the symlink as result of FindFirst below.
4487 This is unfortunate, but that marginal use case does not
4488 justify a call to chase_symlinks which would impose a penalty
4489 on all the other use cases. (We get here for symlinks to
4490 roots of UNC volumes because CreateFile above fails for them,
4491 unlike with symlinks to root directories X:\ of drives.) */
4492 if (is_unc_volume (name
))
4494 fattrs
= unc_volume_file_attributes (name
);
4498 ctime
= atime
= wtime
= utc_base_ft
;
4504 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4505 strcat (name
, "\\");
4509 char *end
= name
+ len
;
4510 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4512 if (!IS_DIRECTORY_SEP (*n
))
4513 strcat (name
, "\\");
4515 if (GetDriveType (name
) < 2)
4521 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4522 ctime
= atime
= wtime
= utc_base_ft
;
4528 if (IS_DIRECTORY_SEP (name
[len
-1]))
4533 char *end
= name
+ len
;
4534 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4536 if (IS_DIRECTORY_SEP (*n
))
4540 /* (This is hacky, but helps when doing file completions on
4541 network drives.) Optimize by using information available from
4542 active readdir if possible. */
4543 len
= strlen (dir_pathname
);
4546 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4551 char *end
= dir_pathname
+ len
;
4552 char *n
= CharPrevExA (file_name_codepage
, dir_pathname
, end
, 0);
4554 if (IS_DIRECTORY_SEP (*n
))
4557 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4558 && !(is_a_symlink
&& follow_symlinks
)
4559 && strnicmp (save_name
, dir_pathname
, len
) == 0
4560 && IS_DIRECTORY_SEP (name
[len
])
4561 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4563 /* This was the last entry returned by readdir. */
4564 wfd
= dir_find_data_a
; /* FIXME!!! */
4568 logon_network_drive (name
);
4570 fh
= FindFirstFile (name
, &wfd
);
4571 if (fh
== INVALID_HANDLE_VALUE
)
4578 /* Note: if NAME is a symlink, the information we get from
4579 FindFirstFile is for the symlink, not its target. */
4580 fattrs
= wfd
.dwFileAttributes
;
4581 ctime
= wfd
.ftCreationTime
;
4582 atime
= wfd
.ftLastAccessTime
;
4583 wtime
= wfd
.ftLastWriteTime
;
4584 fs_high
= wfd
.nFileSizeHigh
;
4585 fs_low
= wfd
.nFileSizeLow
;
4588 serialnum
= volume_info
.serialnum
;
4590 if (is_a_symlink
&& !follow_symlinks
)
4591 buf
->st_mode
= S_IFLNK
;
4592 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4593 buf
->st_mode
= S_IFDIR
;
4595 buf
->st_mode
= S_IFREG
;
4597 get_file_owner_and_group (NULL
, buf
);
4601 /* Not sure if there is any point in this. */
4602 if (!NILP (Vw32_generate_fake_inodes
))
4603 fake_inode
= generate_inode_val (name
);
4604 else if (fake_inode
== 0)
4606 /* For want of something better, try to make everything unique. */
4607 static DWORD gen_num
= 0;
4608 fake_inode
= ++gen_num
;
4612 buf
->st_ino
= fake_inode
;
4614 buf
->st_dev
= serialnum
;
4615 buf
->st_rdev
= serialnum
;
4617 buf
->st_size
= fs_high
;
4618 buf
->st_size
<<= 32;
4619 buf
->st_size
+= fs_low
;
4620 buf
->st_nlink
= nlinks
;
4622 /* Convert timestamps to Unix format. */
4623 buf
->st_mtime
= convert_time (wtime
);
4624 buf
->st_atime
= convert_time (atime
);
4625 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4626 buf
->st_ctime
= convert_time (ctime
);
4627 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4629 /* determine rwx permissions */
4630 if (is_a_symlink
&& !follow_symlinks
)
4631 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4634 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4635 permission
= S_IREAD
;
4637 permission
= S_IREAD
| S_IWRITE
;
4639 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4640 permission
|= S_IEXEC
;
4641 else if (is_exec (name
))
4642 permission
|= S_IEXEC
;
4645 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4651 stat (const char * path
, struct stat
* buf
)
4653 return stat_worker (path
, buf
, 1);
4657 lstat (const char * path
, struct stat
* buf
)
4659 return stat_worker (path
, buf
, 0);
4663 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
4665 /* Rely on a hack: an open directory is modeled as file descriptor 0.
4666 This is good enough for the current usage in Emacs, but is fragile.
4668 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
4669 Gnulib does this and can serve as a model. */
4670 char fullname
[MAX_PATH
];
4674 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
4677 errno
= ENAMETOOLONG
;
4683 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
4686 /* Provide fstat and utime as well as stat for consistent handling of
4689 fstat (int desc
, struct stat
* buf
)
4691 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4692 BY_HANDLE_FILE_INFORMATION info
;
4693 unsigned __int64 fake_inode
;
4696 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4698 case FILE_TYPE_DISK
:
4699 buf
->st_mode
= S_IFREG
;
4700 if (!GetFileInformationByHandle (fh
, &info
))
4706 case FILE_TYPE_PIPE
:
4707 buf
->st_mode
= S_IFIFO
;
4709 case FILE_TYPE_CHAR
:
4710 case FILE_TYPE_UNKNOWN
:
4712 buf
->st_mode
= S_IFCHR
;
4714 memset (&info
, 0, sizeof (info
));
4715 info
.dwFileAttributes
= 0;
4716 info
.ftCreationTime
= utc_base_ft
;
4717 info
.ftLastAccessTime
= utc_base_ft
;
4718 info
.ftLastWriteTime
= utc_base_ft
;
4721 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4722 buf
->st_mode
= S_IFDIR
;
4724 buf
->st_nlink
= info
.nNumberOfLinks
;
4725 /* Might as well use file index to fake inode values, but this
4726 is not guaranteed to be unique unless we keep a handle open
4727 all the time (even then there are situations where it is
4728 not unique). Reputedly, there are at most 48 bits of info
4729 (on NTFS, presumably less on FAT). */
4730 fake_inode
= info
.nFileIndexHigh
;
4732 fake_inode
+= info
.nFileIndexLow
;
4734 /* MSVC defines _ino_t to be short; other libc's might not. */
4735 if (sizeof (buf
->st_ino
) == 2)
4736 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4738 buf
->st_ino
= fake_inode
;
4740 /* If the caller so requested, get the true file owner and group.
4741 Otherwise, consider the file to belong to the current user. */
4742 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4743 get_file_owner_and_group (NULL
, buf
);
4746 PSECURITY_DESCRIPTOR psd
= NULL
;
4748 psd
= get_file_security_desc_by_handle (fh
);
4751 get_file_owner_and_group (psd
, buf
);
4755 get_file_owner_and_group (NULL
, buf
);
4758 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4759 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4761 buf
->st_size
= info
.nFileSizeHigh
;
4762 buf
->st_size
<<= 32;
4763 buf
->st_size
+= info
.nFileSizeLow
;
4765 /* Convert timestamps to Unix format. */
4766 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4767 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4768 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4769 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4770 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4772 /* determine rwx permissions */
4773 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4774 permission
= S_IREAD
;
4776 permission
= S_IREAD
| S_IWRITE
;
4778 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4779 permission
|= S_IEXEC
;
4782 #if 0 /* no way of knowing the filename */
4783 char * p
= strrchr (name
, '.');
4785 (xstrcasecmp (p
, ".exe") == 0 ||
4786 xstrcasecmp (p
, ".com") == 0 ||
4787 xstrcasecmp (p
, ".bat") == 0 ||
4788 xstrcasecmp (p
, ".cmd") == 0))
4789 permission
|= S_IEXEC
;
4793 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4798 /* A version of 'utime' which handles directories as well as
4802 utime (const char *name
, struct utimbuf
*times
)
4804 struct utimbuf deftime
;
4811 deftime
.modtime
= deftime
.actime
= time (NULL
);
4815 if (w32_unicode_filenames
)
4817 wchar_t name_utf16
[MAX_PATH
];
4819 if (filename_to_utf16 (name
, name_utf16
) != 0)
4820 return -1; /* errno set by filename_to_utf16 */
4822 /* Need write access to set times. */
4823 fh
= CreateFileW (name_utf16
, FILE_WRITE_ATTRIBUTES
,
4824 /* If NAME specifies a directory, FILE_SHARE_DELETE
4825 allows other processes to delete files inside it,
4826 while we have the directory open. */
4827 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4828 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4832 char name_ansi
[MAX_PATH
];
4834 if (filename_to_ansi (name
, name_ansi
) != 0)
4835 return -1; /* errno set by filename_to_ansi */
4837 fh
= CreateFileA (name_ansi
, FILE_WRITE_ATTRIBUTES
,
4838 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4839 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4841 if (fh
!= INVALID_HANDLE_VALUE
)
4843 convert_from_time_t (times
->actime
, &atime
);
4844 convert_from_time_t (times
->modtime
, &mtime
);
4845 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4855 DWORD err
= GetLastError ();
4859 case ERROR_FILE_NOT_FOUND
:
4860 case ERROR_PATH_NOT_FOUND
:
4861 case ERROR_INVALID_DRIVE
:
4862 case ERROR_BAD_NETPATH
:
4863 case ERROR_DEV_NOT_EXIST
:
4864 /* ERROR_INVALID_NAME is the error CreateFile sets when the
4865 file name includes ?s, i.e. translation to ANSI failed. */
4866 case ERROR_INVALID_NAME
:
4869 case ERROR_TOO_MANY_OPEN_FILES
:
4872 case ERROR_ACCESS_DENIED
:
4873 case ERROR_SHARING_VIOLATION
:
4886 /* Symlink-related functions. */
4887 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4888 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4892 symlink (char const *filename
, char const *linkname
)
4894 char linkfn
[MAX_PATH
], *tgtfn
;
4896 int dir_access
, filename_ends_in_slash
;
4899 /* Diagnostics follows Posix as much as possible. */
4900 if (filename
== NULL
|| linkname
== NULL
)
4910 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4912 errno
= ENAMETOOLONG
;
4916 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4917 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4923 dbcs_p
= max_filename_mbslen () > 1;
4925 /* Note: since empty FILENAME was already rejected, we can safely
4926 refer to FILENAME[1]. */
4927 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4929 /* Non-absolute FILENAME is understood as being relative to
4930 LINKNAME's directory. We need to prepend that directory to
4931 FILENAME to get correct results from faccessat below, since
4932 otherwise it will interpret FILENAME relative to the
4933 directory where the Emacs process runs. Note that
4934 make-symbolic-link always makes sure LINKNAME is a fully
4935 expanded file name. */
4937 char *p
= linkfn
+ strlen (linkfn
);
4941 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4946 char *p1
= CharPrevExA (file_name_codepage
, linkfn
, p
, 0);
4948 while (p
> linkfn
&& !IS_ANY_SEP (*p1
))
4951 p1
= CharPrevExA (file_name_codepage
, linkfn
, p1
, 0);
4955 strncpy (tem
, linkfn
, p
- linkfn
);
4956 tem
[p
- linkfn
] = '\0';
4957 strcat (tem
, filename
);
4958 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4961 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4963 /* Since Windows distinguishes between symlinks to directories and
4964 to files, we provide a kludgy feature: if FILENAME doesn't
4965 exist, but ends in a slash, we create a symlink to directory. If
4966 FILENAME exists and is a directory, we always create a symlink to
4969 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4972 const char *end
= filename
+ strlen (filename
);
4973 const char *n
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
4975 filename_ends_in_slash
= IS_DIRECTORY_SEP (*n
);
4977 if (dir_access
== 0 || filename_ends_in_slash
)
4978 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4980 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4981 if (filename_ends_in_slash
)
4982 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4985 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4987 /* ENOSYS is set by create_symbolic_link, when it detects that
4988 the OS doesn't support the CreateSymbolicLink API. */
4989 if (errno
!= ENOSYS
)
4991 DWORD w32err
= GetLastError ();
4995 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4996 TGTFN point to the same file name, go figure. */
4998 case ERROR_FILE_EXISTS
:
5001 case ERROR_ACCESS_DENIED
:
5004 case ERROR_FILE_NOT_FOUND
:
5005 case ERROR_PATH_NOT_FOUND
:
5006 case ERROR_BAD_NETPATH
:
5007 case ERROR_INVALID_REPARSE_DATA
:
5010 case ERROR_DIRECTORY
:
5013 case ERROR_PRIVILEGE_NOT_HELD
:
5014 case ERROR_NOT_ALL_ASSIGNED
:
5017 case ERROR_DISK_FULL
:
5030 /* A quick inexpensive test of whether FILENAME identifies a file that
5031 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
5032 must already be in the normalized form returned by
5035 Note: for repeated operations on many files, it is best to test
5036 whether the underlying volume actually supports symlinks, by
5037 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
5038 avoid the call to this function if it doesn't. That's because the
5039 call to GetFileAttributes takes a non-negligible time, especially
5040 on non-local or removable filesystems. See stat_worker for an
5041 example of how to do that. */
5043 is_symlink (const char *filename
)
5046 WIN32_FIND_DATA wfd
;
5049 attrs
= GetFileAttributes (filename
);
5052 DWORD w32err
= GetLastError ();
5056 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
5058 case ERROR_ACCESS_DENIED
:
5061 case ERROR_FILE_NOT_FOUND
:
5062 case ERROR_PATH_NOT_FOUND
:
5069 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
5071 logon_network_drive (filename
);
5072 fh
= FindFirstFile (filename
, &wfd
);
5073 if (fh
== INVALID_HANDLE_VALUE
)
5076 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5077 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5080 /* If NAME identifies a symbolic link, copy into BUF the file name of
5081 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
5082 null-terminate the target name, even if it fits. Return the number
5083 of bytes copied, or -1 if NAME is not a symlink or any error was
5084 encountered while resolving it. The file name copied into BUF is
5085 encoded in the current ANSI codepage. */
5087 readlink (const char *name
, char *buf
, size_t buf_size
)
5090 TOKEN_PRIVILEGES privs
;
5091 int restore_privs
= 0;
5106 path
= map_w32_filename (name
, NULL
);
5108 if (strlen (path
) > MAX_PATH
)
5110 errno
= ENAMETOOLONG
;
5115 if (is_windows_9x () == TRUE
5116 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
5117 || !is_symlink (path
))
5120 errno
= EINVAL
; /* not a symlink */
5124 /* Done with simple tests, now we're in for some _real_ work. */
5125 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
5127 /* Implementation note: From here and onward, don't return early,
5128 since that will fail to restore the original set of privileges of
5129 the calling thread. */
5131 retval
= -1; /* not too optimistic, are we? */
5133 /* Note: In the next call to CreateFile, we use zero as the 2nd
5134 argument because, when the symlink is a hidden/system file,
5135 e.g. 'C:\Users\All Users', GENERIC_READ fails with
5136 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
5137 and directory symlinks. */
5138 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
5139 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
5141 if (sh
!= INVALID_HANDLE_VALUE
)
5143 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
5144 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
5147 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
5148 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
5151 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
5155 /* Copy the link target name, in wide characters, from
5156 reparse_data, then convert it to multibyte encoding in
5157 the current locale's codepage. */
5159 BYTE lname
[MAX_PATH
];
5162 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
5164 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
5165 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
5166 /* This updates file_name_codepage which we need below. */
5167 int dbcs_p
= max_filename_mbslen () > 1;
5169 /* According to MSDN, PrintNameLength does not include the
5170 terminating null character. */
5171 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
5172 memcpy (lwname
, lwname_src
, lwname_len
);
5173 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
5175 lname_len
= WideCharToMultiByte (file_name_codepage
, 0, lwname
, -1,
5176 lname
, MAX_PATH
, NULL
, NULL
);
5179 /* WideCharToMultiByte failed. */
5180 DWORD w32err1
= GetLastError ();
5184 case ERROR_INSUFFICIENT_BUFFER
:
5185 errno
= ENAMETOOLONG
;
5187 case ERROR_INVALID_PARAMETER
:
5190 case ERROR_NO_UNICODE_TRANSLATION
:
5200 size_t size_to_copy
= buf_size
;
5201 BYTE
*p
= lname
, *p2
;
5202 BYTE
*pend
= p
+ lname_len
;
5204 /* Normalize like dostounix_filename does, but we don't
5205 want to assume that lname is null-terminated. */
5207 p2
= CharNextExA (file_name_codepage
, p
, 0);
5210 if (*p
&& *p2
== ':' && *p
>= 'A' && *p
<= 'Z')
5221 p
= CharNextExA (file_name_codepage
, p
, 0);
5222 /* CharNextExA doesn't advance at null character. */
5229 /* Testing for null-terminated LNAME is paranoia:
5230 WideCharToMultiByte should always return a
5231 null-terminated string when its 4th argument is -1
5232 and its 3rd argument is null-terminated (which they
5234 if (lname
[lname_len
- 1] == '\0')
5236 if (lname_len
<= buf_size
)
5237 size_to_copy
= lname_len
;
5238 strncpy (buf
, lname
, size_to_copy
);
5240 retval
= size_to_copy
;
5247 /* CreateFile failed. */
5248 DWORD w32err2
= GetLastError ();
5252 case ERROR_FILE_NOT_FOUND
:
5253 case ERROR_PATH_NOT_FOUND
:
5256 case ERROR_ACCESS_DENIED
:
5257 case ERROR_TOO_MANY_OPEN_FILES
:
5267 restore_privilege (&privs
);
5275 readlinkat (int fd
, char const *name
, char *buffer
,
5278 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5279 as in fstatat. FIXME: Add proper support for readlinkat. */
5280 char fullname
[MAX_PATH
];
5284 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
5287 errno
= ENAMETOOLONG
;
5293 return readlink (name
, buffer
, buffer_size
);
5296 /* If FILE is a symlink, return its target (stored in a static
5297 buffer); otherwise return FILE.
5299 This function repeatedly resolves symlinks in the last component of
5300 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5301 until it arrives at a file whose last component is not a symlink,
5302 or some error occurs. It returns the target of the last
5303 successfully resolved symlink in the chain. If it succeeds to
5304 resolve even a single symlink, the value returned is an absolute
5305 file name with backslashes (result of GetFullPathName). By
5306 contrast, if the original FILE is returned, it is unaltered.
5308 Note: This function can set errno even if it succeeds.
5310 Implementation note: we only resolve the last portion ("basename")
5311 of the argument FILE and of each following file in the chain,
5312 disregarding any possible symlinks in its leading directories.
5313 This is because Windows system calls and library functions
5314 transparently resolve symlinks in leading directories and return
5315 correct information, as long as the basename is not a symlink. */
5317 chase_symlinks (const char *file
)
5319 static char target
[MAX_PATH
];
5320 char link
[MAX_PATH
];
5321 ssize_t res
, link_len
;
5325 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
5326 return (char *)file
;
5328 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
5329 return (char *)file
;
5331 dbcs_p
= max_filename_mbslen () > 1;
5335 /* Remove trailing slashes, as we want to resolve the last
5336 non-trivial part of the link name. */
5339 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
5340 link
[link_len
--] = '\0';
5342 else if (link_len
> 3)
5344 char *n
= CharPrevExA (file_name_codepage
, link
, link
+ link_len
, 0);
5346 while (n
>= link
+ 2 && IS_DIRECTORY_SEP (*n
))
5349 n
= CharPrevExA (file_name_codepage
, link
, n
, 0);
5353 res
= readlink (link
, target
, MAX_PATH
);
5357 if (!(IS_DEVICE_SEP (target
[1])
5358 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5360 /* Target is relative. Append it to the directory part of
5361 the symlink, then copy the result back to target. */
5362 char *p
= link
+ link_len
;
5366 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5371 char *p1
= CharPrevExA (file_name_codepage
, link
, p
, 0);
5373 while (p
> link
&& !IS_ANY_SEP (*p1
))
5376 p1
= CharPrevExA (file_name_codepage
, link
, p1
, 0);
5380 strcpy (target
, link
);
5382 /* Resolve any "." and ".." to get a fully-qualified file name
5384 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
5386 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5388 if (loop_count
> 100)
5391 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5392 return (char *)file
;
5397 /* Posix ACL emulation. */
5400 acl_valid (acl_t acl
)
5402 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5406 acl_to_text (acl_t acl
, ssize_t
*size
)
5409 SECURITY_INFORMATION flags
=
5410 OWNER_SECURITY_INFORMATION
|
5411 GROUP_SECURITY_INFORMATION
|
5412 DACL_SECURITY_INFORMATION
;
5413 char *retval
= NULL
;
5419 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5422 /* We don't want to mix heaps, so we duplicate the string in our
5423 heap and free the one allocated by the API. */
5424 retval
= xstrdup (str_acl
);
5427 LocalFree (str_acl
);
5429 else if (errno
!= ENOTSUP
)
5436 acl_from_text (const char *acl_str
)
5438 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5444 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5447 retval
= xmalloc (sd_size
);
5448 memcpy (retval
, psd
, sd_size
);
5451 else if (errno
!= ENOTSUP
)
5458 acl_free (void *ptr
)
5465 acl_get_file (const char *fname
, acl_type_t type
)
5467 PSECURITY_DESCRIPTOR psd
= NULL
;
5468 const char *filename
;
5470 if (type
== ACL_TYPE_ACCESS
)
5473 SECURITY_INFORMATION si
=
5474 OWNER_SECURITY_INFORMATION
|
5475 GROUP_SECURITY_INFORMATION
|
5476 DACL_SECURITY_INFORMATION
;
5479 filename
= map_w32_filename (fname
, NULL
);
5480 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5481 fname
= chase_symlinks (filename
);
5486 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5487 && errno
!= ENOTSUP
)
5489 err
= GetLastError ();
5490 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5492 psd
= xmalloc (sd_len
);
5493 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5500 else if (err
== ERROR_FILE_NOT_FOUND
5501 || err
== ERROR_PATH_NOT_FOUND
)
5509 else if (type
!= ACL_TYPE_DEFAULT
)
5516 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
5518 TOKEN_PRIVILEGES old1
, old2
;
5520 int st
= 0, retval
= -1;
5521 SECURITY_INFORMATION flags
= 0;
5527 const char *filename
;
5529 if (acl_valid (acl
) != 0
5530 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
5536 if (type
== ACL_TYPE_DEFAULT
)
5542 filename
= map_w32_filename (fname
, NULL
);
5543 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5544 fname
= chase_symlinks (filename
);
5548 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5550 flags
|= OWNER_SECURITY_INFORMATION
;
5551 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5553 flags
|= GROUP_SECURITY_INFORMATION
;
5554 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
5557 flags
|= DACL_SECURITY_INFORMATION
;
5561 /* According to KB-245153, setting the owner will succeed if either:
5562 (1) the caller is the user who will be the new owner, and has the
5563 SE_TAKE_OWNERSHIP privilege, or
5564 (2) the caller has the SE_RESTORE privilege, in which case she can
5565 set any valid user or group as the owner
5567 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
5568 privileges, and disregard any failures in obtaining them. If
5569 these privileges cannot be obtained, and do not already exist in
5570 the calling thread's security token, this function could fail
5572 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
5574 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
5579 if (!set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
5581 err
= GetLastError ();
5583 if (errno
== ENOTSUP
)
5585 else if (err
== ERROR_INVALID_OWNER
5586 || err
== ERROR_NOT_ALL_ASSIGNED
5587 || err
== ERROR_ACCESS_DENIED
)
5589 /* Maybe the requested ACL and the one the file already has
5590 are identical, in which case we can silently ignore the
5591 failure. (And no, Windows doesn't.) */
5592 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
5597 char *acl_from
= acl_to_text (current_acl
, NULL
);
5598 char *acl_to
= acl_to_text (acl
, NULL
);
5600 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
5606 acl_free (acl_from
);
5609 acl_free (current_acl
);
5612 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
5626 restore_privilege (&old2
);
5627 restore_privilege (&old1
);
5635 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
5636 have a fixed max size for file names, so we don't need the kind of
5637 alloc/malloc/realloc dance the gnulib version does. We also don't
5638 support FD-relative symlinks. */
5640 careadlinkat (int fd
, char const *filename
,
5641 char *buffer
, size_t buffer_size
,
5642 struct allocator
const *alloc
,
5643 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
5645 char linkname
[MAX_PATH
];
5648 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
5652 char *retval
= buffer
;
5654 linkname
[link_size
++] = '\0';
5655 if (link_size
> buffer_size
)
5656 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
5658 memcpy (retval
, linkname
, link_size
);
5666 /* Support for browsing other processes and their attributes. See
5667 process.c for the Lisp bindings. */
5669 /* Helper wrapper functions. */
5671 static HANDLE WINAPI
5672 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
5674 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
5676 if (g_b_init_create_toolhelp32_snapshot
== 0)
5678 g_b_init_create_toolhelp32_snapshot
= 1;
5679 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
5680 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5681 "CreateToolhelp32Snapshot");
5683 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
5685 return INVALID_HANDLE_VALUE
;
5687 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
5691 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5693 static Process32First_Proc s_pfn_Process32_First
= NULL
;
5695 if (g_b_init_process32_first
== 0)
5697 g_b_init_process32_first
= 1;
5698 s_pfn_Process32_First
= (Process32First_Proc
)
5699 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5702 if (s_pfn_Process32_First
== NULL
)
5706 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5710 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5712 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5714 if (g_b_init_process32_next
== 0)
5716 g_b_init_process32_next
= 1;
5717 s_pfn_Process32_Next
= (Process32Next_Proc
)
5718 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5721 if (s_pfn_Process32_Next
== NULL
)
5725 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5729 open_thread_token (HANDLE ThreadHandle
,
5730 DWORD DesiredAccess
,
5732 PHANDLE TokenHandle
)
5734 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5735 HMODULE hm_advapi32
= NULL
;
5736 if (is_windows_9x () == TRUE
)
5738 SetLastError (ERROR_NOT_SUPPORTED
);
5741 if (g_b_init_open_thread_token
== 0)
5743 g_b_init_open_thread_token
= 1;
5744 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5745 s_pfn_Open_Thread_Token
=
5746 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5748 if (s_pfn_Open_Thread_Token
== NULL
)
5750 SetLastError (ERROR_NOT_SUPPORTED
);
5754 s_pfn_Open_Thread_Token (
5763 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5765 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5766 HMODULE hm_advapi32
= NULL
;
5767 if (is_windows_9x () == TRUE
)
5771 if (g_b_init_impersonate_self
== 0)
5773 g_b_init_impersonate_self
= 1;
5774 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5775 s_pfn_Impersonate_Self
=
5776 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5778 if (s_pfn_Impersonate_Self
== NULL
)
5782 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5786 revert_to_self (void)
5788 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5789 HMODULE hm_advapi32
= NULL
;
5790 if (is_windows_9x () == TRUE
)
5794 if (g_b_init_revert_to_self
== 0)
5796 g_b_init_revert_to_self
= 1;
5797 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5798 s_pfn_Revert_To_Self
=
5799 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5801 if (s_pfn_Revert_To_Self
== NULL
)
5805 return s_pfn_Revert_To_Self ();
5809 get_process_memory_info (HANDLE h_proc
,
5810 PPROCESS_MEMORY_COUNTERS mem_counters
,
5813 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5814 HMODULE hm_psapi
= NULL
;
5815 if (is_windows_9x () == TRUE
)
5819 if (g_b_init_get_process_memory_info
== 0)
5821 g_b_init_get_process_memory_info
= 1;
5822 hm_psapi
= LoadLibrary ("Psapi.dll");
5824 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5825 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5827 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5831 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5835 get_process_working_set_size (HANDLE h_proc
,
5839 static GetProcessWorkingSetSize_Proc
5840 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5842 if (is_windows_9x () == TRUE
)
5846 if (g_b_init_get_process_working_set_size
== 0)
5848 g_b_init_get_process_working_set_size
= 1;
5849 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5850 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5851 "GetProcessWorkingSetSize");
5853 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5857 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5861 global_memory_status (MEMORYSTATUS
*buf
)
5863 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5865 if (is_windows_9x () == TRUE
)
5869 if (g_b_init_global_memory_status
== 0)
5871 g_b_init_global_memory_status
= 1;
5872 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5873 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5874 "GlobalMemoryStatus");
5876 if (s_pfn_Global_Memory_Status
== NULL
)
5880 return s_pfn_Global_Memory_Status (buf
);
5884 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5886 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5888 if (is_windows_9x () == TRUE
)
5892 if (g_b_init_global_memory_status_ex
== 0)
5894 g_b_init_global_memory_status_ex
= 1;
5895 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5896 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5897 "GlobalMemoryStatusEx");
5899 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5903 return s_pfn_Global_Memory_Status_Ex (buf
);
5907 list_system_processes (void)
5909 struct gcpro gcpro1
;
5910 Lisp_Object proclist
= Qnil
;
5913 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5915 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5917 PROCESSENTRY32 proc_entry
;
5923 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5924 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5925 res
= process32_next (h_snapshot
, &proc_entry
))
5927 proc_id
= proc_entry
.th32ProcessID
;
5928 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5931 CloseHandle (h_snapshot
);
5933 proclist
= Fnreverse (proclist
);
5940 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5942 TOKEN_PRIVILEGES priv
;
5943 DWORD priv_size
= sizeof (priv
);
5944 DWORD opriv_size
= sizeof (*old_priv
);
5945 HANDLE h_token
= NULL
;
5946 HANDLE h_thread
= GetCurrentThread ();
5950 res
= open_thread_token (h_thread
,
5951 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5953 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5955 if (impersonate_self (SecurityImpersonation
))
5956 res
= open_thread_token (h_thread
,
5957 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5962 priv
.PrivilegeCount
= 1;
5963 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5964 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5965 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5966 old_priv
, &opriv_size
)
5967 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5971 CloseHandle (h_token
);
5977 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5979 DWORD priv_size
= sizeof (*priv
);
5980 HANDLE h_token
= NULL
;
5983 if (open_thread_token (GetCurrentThread (),
5984 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5987 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5988 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5992 CloseHandle (h_token
);
5998 ltime (ULONGLONG time_100ns
)
6000 ULONGLONG time_sec
= time_100ns
/ 10000000;
6001 int subsec
= time_100ns
% 10000000;
6002 return list4i (time_sec
>> 16, time_sec
& 0xffff,
6003 subsec
/ 10, subsec
% 10 * 100000);
6006 #define U64_TO_LISP_TIME(time) ltime (time)
6009 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
6010 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
6013 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
6014 ULONGLONG tem1
, tem2
, tem3
, tem
;
6017 || !get_process_times_fn
6018 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
6019 &ft_kernel
, &ft_user
))
6022 GetSystemTimeAsFileTime (&ft_current
);
6024 FILETIME_TO_U64 (tem1
, ft_kernel
);
6025 *stime
= U64_TO_LISP_TIME (tem1
);
6027 FILETIME_TO_U64 (tem2
, ft_user
);
6028 *utime
= U64_TO_LISP_TIME (tem2
);
6031 *ttime
= U64_TO_LISP_TIME (tem3
);
6033 FILETIME_TO_U64 (tem
, ft_creation
);
6034 /* Process no 4 (System) returns zero creation time. */
6037 *ctime
= U64_TO_LISP_TIME (tem
);
6041 FILETIME_TO_U64 (tem3
, ft_current
);
6042 tem
= (tem3
- utc_base
) - tem
;
6044 *etime
= U64_TO_LISP_TIME (tem
);
6048 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
6059 system_process_attributes (Lisp_Object pid
)
6061 struct gcpro gcpro1
, gcpro2
, gcpro3
;
6062 Lisp_Object attrs
= Qnil
;
6063 Lisp_Object cmd_str
, decoded_cmd
, tem
;
6064 HANDLE h_snapshot
, h_proc
;
6067 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
6068 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
6069 DWORD glength
= sizeof (gname
);
6070 HANDLE token
= NULL
;
6071 SID_NAME_USE user_type
;
6072 unsigned char *buf
= NULL
;
6074 TOKEN_USER user_token
;
6075 TOKEN_PRIMARY_GROUP group_token
;
6078 PROCESS_MEMORY_COUNTERS mem
;
6079 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
6080 SIZE_T minrss
, maxrss
;
6082 MEMORY_STATUS_EX memstex
;
6083 double totphys
= 0.0;
6084 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
6086 BOOL result
= FALSE
;
6088 CHECK_NUMBER_OR_FLOAT (pid
);
6089 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
6091 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6093 GCPRO3 (attrs
, decoded_cmd
, tem
);
6095 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6100 pe
.dwSize
= sizeof (PROCESSENTRY32
);
6101 for (res
= process32_first (h_snapshot
, &pe
); res
;
6102 res
= process32_next (h_snapshot
, &pe
))
6104 if (proc_id
== pe
.th32ProcessID
)
6107 decoded_cmd
= build_string ("Idle");
6110 /* Decode the command name from locale-specific
6112 cmd_str
= build_unibyte_string (pe
.szExeFile
);
6115 code_convert_string_norecord (cmd_str
,
6116 Vlocale_coding_system
, 0);
6118 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
6119 attrs
= Fcons (Fcons (Qppid
,
6120 make_fixnum_or_float (pe
.th32ParentProcessID
)),
6122 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
6124 attrs
= Fcons (Fcons (Qthcount
,
6125 make_fixnum_or_float (pe
.cntThreads
)),
6132 CloseHandle (h_snapshot
);
6141 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6143 /* If we were denied a handle to the process, try again after
6144 enabling the SeDebugPrivilege in our process. */
6147 TOKEN_PRIVILEGES priv_current
;
6149 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
6151 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6153 restore_privilege (&priv_current
);
6159 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
6162 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
6163 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6165 buf
= xmalloc (blen
);
6166 result
= get_token_information (token
, TokenUser
,
6167 (LPVOID
)buf
, blen
, &needed
);
6170 memcpy (&user_token
, buf
, sizeof (user_token
));
6171 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
6173 euid
= get_rid (user_token
.User
.Sid
);
6174 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
6179 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
6182 strcpy (uname
, "unknown");
6186 ulength
= strlen (uname
);
6192 /* Determine a reasonable euid and gid values. */
6193 if (xstrcasecmp ("administrator", uname
) == 0)
6195 euid
= 500; /* well-known Administrator uid */
6196 egid
= 513; /* well-known None gid */
6200 /* Get group id and name. */
6201 result
= get_token_information (token
, TokenPrimaryGroup
,
6202 (LPVOID
)buf
, blen
, &needed
);
6203 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6205 buf
= xrealloc (buf
, blen
= needed
);
6206 result
= get_token_information (token
, TokenPrimaryGroup
,
6207 (LPVOID
)buf
, blen
, &needed
);
6211 memcpy (&group_token
, buf
, sizeof (group_token
));
6212 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
6214 egid
= get_rid (group_token
.PrimaryGroup
);
6215 dlength
= sizeof (domain
);
6217 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
6218 gname
, &glength
, NULL
, &dlength
,
6221 w32_add_to_cache (group_token
.PrimaryGroup
,
6225 strcpy (gname
, "None");
6229 glength
= strlen (gname
);
6237 if (!is_windows_9x ())
6239 /* We couldn't open the process token, presumably because of
6240 insufficient access rights. Assume this process is run
6242 strcpy (uname
, "SYSTEM");
6243 strcpy (gname
, "None");
6244 euid
= 18; /* SYSTEM */
6245 egid
= 513; /* None */
6246 glength
= strlen (gname
);
6247 ulength
= strlen (uname
);
6249 /* If we are running under Windows 9X, where security calls are
6250 not supported, we assume all processes are run by the current
6252 else if (GetUserName (uname
, &ulength
))
6254 if (xstrcasecmp ("administrator", uname
) == 0)
6259 strcpy (gname
, "None");
6260 glength
= strlen (gname
);
6261 ulength
= strlen (uname
);
6267 strcpy (uname
, "administrator");
6268 ulength
= strlen (uname
);
6269 strcpy (gname
, "None");
6270 glength
= strlen (gname
);
6273 CloseHandle (token
);
6276 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
6277 tem
= make_unibyte_string (uname
, ulength
);
6278 attrs
= Fcons (Fcons (Quser
,
6279 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6281 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
6282 tem
= make_unibyte_string (gname
, glength
);
6283 attrs
= Fcons (Fcons (Qgroup
,
6284 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6287 if (global_memory_status_ex (&memstex
))
6288 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
6289 totphys
= memstex
.ullTotalPhys
/ 1024.0;
6291 /* Visual Studio 6 cannot convert an unsigned __int64 type to
6292 double, so we need to do this for it... */
6294 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
6295 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
6296 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
6298 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
6300 #endif /* __GNUC__ || _MSC_VER >= 1300 */
6301 else if (global_memory_status (&memst
))
6302 totphys
= memst
.dwTotalPhys
/ 1024.0;
6305 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
6308 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6310 attrs
= Fcons (Fcons (Qmajflt
,
6311 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
6313 attrs
= Fcons (Fcons (Qvsize
,
6314 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
6316 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6318 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6321 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
6323 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6325 attrs
= Fcons (Fcons (Qmajflt
,
6326 make_fixnum_or_float (mem
.PageFaultCount
)),
6328 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6330 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6333 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
6335 DWORD rss
= maxrss
/ 1024;
6337 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
6339 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6342 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
6344 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
6345 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
6346 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
6347 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
6348 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
6349 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
6352 /* FIXME: Retrieve command line by walking the PEB of the process. */
6355 CloseHandle (h_proc
);
6361 /* Wrappers for winsock functions to map between our file descriptors
6362 and winsock's handles; also set h_errno for convenience.
6364 To allow Emacs to run on systems which don't have winsock support
6365 installed, we dynamically link to winsock on startup if present, and
6366 otherwise provide the minimum necessary functionality
6367 (eg. gethostname). */
6369 /* function pointers for relevant socket functions */
6370 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
6371 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
6372 int (PASCAL
*pfn_WSAGetLastError
) (void);
6373 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
6374 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
6375 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
6376 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
6377 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6378 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6379 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
6380 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
6381 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
6382 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
6383 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
6384 int (PASCAL
*pfn_WSACleanup
) (void);
6386 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
6387 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
6388 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
6389 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
6390 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
6391 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
6392 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
6393 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
6394 const char * optval
, int optlen
);
6395 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
6396 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
6398 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
6399 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
6400 struct sockaddr
* from
, int * fromlen
);
6401 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
6402 const struct sockaddr
* to
, int tolen
);
6404 /* SetHandleInformation is only needed to make sockets non-inheritable. */
6405 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
6406 #ifndef HANDLE_FLAG_INHERIT
6407 #define HANDLE_FLAG_INHERIT 1
6411 static int winsock_inuse
;
6416 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
6418 release_listen_threads ();
6419 /* Not sure what would cause WSAENETDOWN, or even if it can happen
6420 after WSAStartup returns successfully, but it seems reasonable
6421 to allow unloading winsock anyway in that case. */
6422 if (pfn_WSACleanup () == 0 ||
6423 pfn_WSAGetLastError () == WSAENETDOWN
)
6425 if (FreeLibrary (winsock_lib
))
6434 init_winsock (int load_now
)
6436 WSADATA winsockData
;
6438 if (winsock_lib
!= NULL
)
6441 pfn_SetHandleInformation
6442 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
6443 "SetHandleInformation");
6445 winsock_lib
= LoadLibrary ("Ws2_32.dll");
6447 if (winsock_lib
!= NULL
)
6449 /* dynamically link to socket functions */
6451 #define LOAD_PROC(fn) \
6452 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
6455 LOAD_PROC (WSAStartup
);
6456 LOAD_PROC (WSASetLastError
);
6457 LOAD_PROC (WSAGetLastError
);
6458 LOAD_PROC (WSAEventSelect
);
6459 LOAD_PROC (WSACreateEvent
);
6460 LOAD_PROC (WSACloseEvent
);
6463 LOAD_PROC (connect
);
6464 LOAD_PROC (ioctlsocket
);
6467 LOAD_PROC (closesocket
);
6468 LOAD_PROC (shutdown
);
6471 LOAD_PROC (inet_addr
);
6472 LOAD_PROC (gethostname
);
6473 LOAD_PROC (gethostbyname
);
6474 LOAD_PROC (getservbyname
);
6475 LOAD_PROC (getpeername
);
6476 LOAD_PROC (WSACleanup
);
6477 LOAD_PROC (setsockopt
);
6479 LOAD_PROC (getsockname
);
6481 LOAD_PROC (recvfrom
);
6485 /* specify version 1.1 of winsock */
6486 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
6488 if (winsockData
.wVersion
!= 0x101)
6493 /* Report that winsock exists and is usable, but leave
6494 socket functions disabled. I am assuming that calling
6495 WSAStartup does not require any network interaction,
6496 and in particular does not cause or require a dial-up
6497 connection to be established. */
6500 FreeLibrary (winsock_lib
);
6508 FreeLibrary (winsock_lib
);
6518 /* Function to map winsock error codes to errno codes for those errno
6519 code defined in errno.h (errno values not defined by errno.h are
6520 already in nt/inc/sys/socket.h). */
6527 if (winsock_lib
== NULL
)
6530 wsa_err
= pfn_WSAGetLastError ();
6534 case WSAEACCES
: errno
= EACCES
; break;
6535 case WSAEBADF
: errno
= EBADF
; break;
6536 case WSAEFAULT
: errno
= EFAULT
; break;
6537 case WSAEINTR
: errno
= EINTR
; break;
6538 case WSAEINVAL
: errno
= EINVAL
; break;
6539 case WSAEMFILE
: errno
= EMFILE
; break;
6540 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
6541 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
6542 default: errno
= wsa_err
; break;
6550 if (winsock_lib
!= NULL
)
6551 pfn_WSASetLastError (0);
6554 /* Extend strerror to handle the winsock-specific error codes. */
6558 } _wsa_errlist
[] = {
6559 {WSAEINTR
, "Interrupted function call"},
6560 {WSAEBADF
, "Bad file descriptor"},
6561 {WSAEACCES
, "Permission denied"},
6562 {WSAEFAULT
, "Bad address"},
6563 {WSAEINVAL
, "Invalid argument"},
6564 {WSAEMFILE
, "Too many open files"},
6566 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
6567 {WSAEINPROGRESS
, "Operation now in progress"},
6568 {WSAEALREADY
, "Operation already in progress"},
6569 {WSAENOTSOCK
, "Socket operation on non-socket"},
6570 {WSAEDESTADDRREQ
, "Destination address required"},
6571 {WSAEMSGSIZE
, "Message too long"},
6572 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
6573 {WSAENOPROTOOPT
, "Bad protocol option"},
6574 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
6575 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
6576 {WSAEOPNOTSUPP
, "Operation not supported"},
6577 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
6578 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
6579 {WSAEADDRINUSE
, "Address already in use"},
6580 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
6581 {WSAENETDOWN
, "Network is down"},
6582 {WSAENETUNREACH
, "Network is unreachable"},
6583 {WSAENETRESET
, "Network dropped connection on reset"},
6584 {WSAECONNABORTED
, "Software caused connection abort"},
6585 {WSAECONNRESET
, "Connection reset by peer"},
6586 {WSAENOBUFS
, "No buffer space available"},
6587 {WSAEISCONN
, "Socket is already connected"},
6588 {WSAENOTCONN
, "Socket is not connected"},
6589 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
6590 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
6591 {WSAETIMEDOUT
, "Connection timed out"},
6592 {WSAECONNREFUSED
, "Connection refused"},
6593 {WSAELOOP
, "Network loop"}, /* not sure */
6594 {WSAENAMETOOLONG
, "Name is too long"},
6595 {WSAEHOSTDOWN
, "Host is down"},
6596 {WSAEHOSTUNREACH
, "No route to host"},
6597 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
6598 {WSAEPROCLIM
, "Too many processes"},
6599 {WSAEUSERS
, "Too many users"}, /* not sure */
6600 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
6601 {WSAESTALE
, "Data is stale"}, /* not sure */
6602 {WSAEREMOTE
, "Remote error"}, /* not sure */
6604 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
6605 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
6606 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
6607 {WSAEDISCON
, "Graceful shutdown in progress"},
6609 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
6610 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
6611 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
6612 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
6613 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
6614 {WSASYSCALLFAILURE
, "System call failure"},
6615 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
6616 {WSATYPE_NOT_FOUND
, "Class type not found"},
6617 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
6618 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
6619 {WSAEREFUSED
, "Operation refused"}, /* not sure */
6622 {WSAHOST_NOT_FOUND
, "Host not found"},
6623 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
6624 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
6625 {WSANO_DATA
, "Valid name, no data record of requested type"},
6631 sys_strerror (int error_no
)
6634 static char unknown_msg
[40];
6636 if (error_no
>= 0 && error_no
< sys_nerr
)
6637 return sys_errlist
[error_no
];
6639 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
6640 if (_wsa_errlist
[i
].errnum
== error_no
)
6641 return _wsa_errlist
[i
].msg
;
6643 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
6647 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6648 but I believe the method of keeping the socket handle separate (and
6649 insuring it is not inheritable) is the correct one. */
6651 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6653 static int socket_to_fd (SOCKET s
);
6656 sys_socket (int af
, int type
, int protocol
)
6660 if (winsock_lib
== NULL
)
6663 return INVALID_SOCKET
;
6668 /* call the real socket function */
6669 s
= pfn_socket (af
, type
, protocol
);
6671 if (s
!= INVALID_SOCKET
)
6672 return socket_to_fd (s
);
6678 /* Convert a SOCKET to a file descriptor. */
6680 socket_to_fd (SOCKET s
)
6685 /* Although under NT 3.5 _open_osfhandle will accept a socket
6686 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6687 that does not work under NT 3.1. However, we can get the same
6688 effect by using a backdoor function to replace an existing
6689 descriptor handle with the one we want. */
6691 /* allocate a file descriptor (with appropriate flags) */
6692 fd
= _open ("NUL:", _O_RDWR
);
6695 /* Make a non-inheritable copy of the socket handle. Note
6696 that it is possible that sockets aren't actually kernel
6697 handles, which appears to be the case on Windows 9x when
6698 the MS Proxy winsock client is installed. */
6700 /* Apparently there is a bug in NT 3.51 with some service
6701 packs, which prevents using DuplicateHandle to make a
6702 socket handle non-inheritable (causes WSACleanup to
6703 hang). The work-around is to use SetHandleInformation
6704 instead if it is available and implemented. */
6705 if (pfn_SetHandleInformation
)
6707 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
6711 HANDLE parent
= GetCurrentProcess ();
6712 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6714 if (DuplicateHandle (parent
,
6720 DUPLICATE_SAME_ACCESS
))
6722 /* It is possible that DuplicateHandle succeeds even
6723 though the socket wasn't really a kernel handle,
6724 because a real handle has the same value. So
6725 test whether the new handle really is a socket. */
6726 long nonblocking
= 0;
6727 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6729 pfn_closesocket (s
);
6734 CloseHandle (new_s
);
6739 eassert (fd
< MAXDESC
);
6740 fd_info
[fd
].hnd
= (HANDLE
) s
;
6742 /* set our own internal flags */
6743 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6749 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6751 /* attach child_process to fd_info */
6752 if (fd_info
[ fd
].cp
!= NULL
)
6754 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6758 fd_info
[ fd
].cp
= cp
;
6761 winsock_inuse
++; /* count open sockets */
6769 pfn_closesocket (s
);
6775 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6777 if (winsock_lib
== NULL
)
6780 return SOCKET_ERROR
;
6784 if (fd_info
[s
].flags
& FILE_SOCKET
)
6786 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6787 if (rc
== SOCKET_ERROR
)
6792 return SOCKET_ERROR
;
6796 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6798 if (winsock_lib
== NULL
)
6801 return SOCKET_ERROR
;
6805 if (fd_info
[s
].flags
& FILE_SOCKET
)
6807 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6808 if (rc
== SOCKET_ERROR
)
6813 return SOCKET_ERROR
;
6817 sys_htons (u_short hostshort
)
6819 return (winsock_lib
!= NULL
) ?
6820 pfn_htons (hostshort
) : hostshort
;
6824 sys_ntohs (u_short netshort
)
6826 return (winsock_lib
!= NULL
) ?
6827 pfn_ntohs (netshort
) : netshort
;
6831 sys_inet_addr (const char * cp
)
6833 return (winsock_lib
!= NULL
) ?
6834 pfn_inet_addr (cp
) : INADDR_NONE
;
6838 sys_gethostname (char * name
, int namelen
)
6840 if (winsock_lib
!= NULL
)
6845 retval
= pfn_gethostname (name
, namelen
);
6846 if (retval
== SOCKET_ERROR
)
6851 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6852 return !GetComputerName (name
, (DWORD
*)&namelen
);
6855 return SOCKET_ERROR
;
6859 sys_gethostbyname (const char * name
)
6861 struct hostent
* host
;
6862 int h_err
= h_errno
;
6864 if (winsock_lib
== NULL
)
6866 h_errno
= NO_RECOVERY
;
6872 host
= pfn_gethostbyname (name
);
6884 sys_getservbyname (const char * name
, const char * proto
)
6886 struct servent
* serv
;
6888 if (winsock_lib
== NULL
)
6895 serv
= pfn_getservbyname (name
, proto
);
6902 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6904 if (winsock_lib
== NULL
)
6907 return SOCKET_ERROR
;
6911 if (fd_info
[s
].flags
& FILE_SOCKET
)
6913 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6914 if (rc
== SOCKET_ERROR
)
6919 return SOCKET_ERROR
;
6923 sys_shutdown (int s
, int how
)
6925 if (winsock_lib
== NULL
)
6928 return SOCKET_ERROR
;
6932 if (fd_info
[s
].flags
& FILE_SOCKET
)
6934 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6935 if (rc
== SOCKET_ERROR
)
6940 return SOCKET_ERROR
;
6944 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6946 if (winsock_lib
== NULL
)
6949 return SOCKET_ERROR
;
6953 if (fd_info
[s
].flags
& FILE_SOCKET
)
6955 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6956 (const char *)optval
, optlen
);
6957 if (rc
== SOCKET_ERROR
)
6962 return SOCKET_ERROR
;
6966 sys_listen (int s
, int backlog
)
6968 if (winsock_lib
== NULL
)
6971 return SOCKET_ERROR
;
6975 if (fd_info
[s
].flags
& FILE_SOCKET
)
6977 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6978 if (rc
== SOCKET_ERROR
)
6981 fd_info
[s
].flags
|= FILE_LISTEN
;
6985 return SOCKET_ERROR
;
6989 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6991 if (winsock_lib
== NULL
)
6994 return SOCKET_ERROR
;
6998 if (fd_info
[s
].flags
& FILE_SOCKET
)
7000 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
7001 if (rc
== SOCKET_ERROR
)
7006 return SOCKET_ERROR
;
7010 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
7012 if (winsock_lib
== NULL
)
7019 if (fd_info
[s
].flags
& FILE_LISTEN
)
7021 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
7023 if (t
== INVALID_SOCKET
)
7026 fd
= socket_to_fd (t
);
7030 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7031 ResetEvent (fd_info
[s
].cp
->char_avail
);
7040 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
7041 struct sockaddr
* from
, int * fromlen
)
7043 if (winsock_lib
== NULL
)
7046 return SOCKET_ERROR
;
7050 if (fd_info
[s
].flags
& FILE_SOCKET
)
7052 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
7053 if (rc
== SOCKET_ERROR
)
7058 return SOCKET_ERROR
;
7062 sys_sendto (int s
, const char * buf
, int len
, int flags
,
7063 const struct sockaddr
* to
, int tolen
)
7065 if (winsock_lib
== NULL
)
7068 return SOCKET_ERROR
;
7072 if (fd_info
[s
].flags
& FILE_SOCKET
)
7074 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
7075 if (rc
== SOCKET_ERROR
)
7080 return SOCKET_ERROR
;
7083 /* Windows does not have an fcntl function. Provide an implementation
7084 good enough for Emacs. */
7086 fcntl (int s
, int cmd
, int options
)
7088 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
7089 invoked in a context where fd1 is closed and all descriptors less
7090 than fd1 are open, so sys_dup is an adequate implementation. */
7091 if (cmd
== F_DUPFD_CLOEXEC
)
7094 if (winsock_lib
== NULL
)
7101 if (fd_info
[s
].flags
& FILE_SOCKET
)
7103 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7105 unsigned long nblock
= 1;
7106 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
7107 if (rc
== SOCKET_ERROR
)
7109 /* Keep track of the fact that we set this to non-blocking. */
7110 fd_info
[s
].flags
|= FILE_NDELAY
;
7116 return SOCKET_ERROR
;
7120 return SOCKET_ERROR
;
7124 /* Shadow main io functions: we need to handle pipes and sockets more
7125 intelligently, and implement non-blocking mode as well. */
7138 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
7140 child_process
* cp
= fd_info
[fd
].cp
;
7142 fd_info
[fd
].cp
= NULL
;
7144 if (CHILD_ACTIVE (cp
))
7146 /* if last descriptor to active child_process then cleanup */
7148 for (i
= 0; i
< MAXDESC
; i
++)
7152 if (fd_info
[i
].cp
== cp
)
7157 if (fd_info
[fd
].flags
& FILE_SOCKET
)
7159 if (winsock_lib
== NULL
) emacs_abort ();
7161 pfn_shutdown (SOCK_HANDLE (fd
), 2);
7162 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
7164 winsock_inuse
--; /* count open sockets */
7166 /* If the process handle is NULL, it's either a socket
7167 or serial connection, or a subprocess that was
7168 already reaped by reap_subprocess, but whose
7169 resources were not yet freed, because its output was
7170 not fully read yet by the time it was reaped. (This
7171 usually happens with async subprocesses whose output
7172 is being read by Emacs.) Otherwise, this process was
7173 not reaped yet, so we set its FD to a negative value
7174 to make sure sys_select will eventually get to
7175 calling the SIGCHLD handler for it, which will then
7176 invoke waitpid and reap_subprocess. */
7177 if (cp
->procinfo
.hProcess
== NULL
)
7185 if (fd
>= 0 && fd
< MAXDESC
)
7186 fd_info
[fd
].flags
= 0;
7188 /* Note that sockets do not need special treatment here (at least on
7189 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
7190 closesocket is equivalent to CloseHandle, which is to be expected
7191 because socket handles are fully fledged kernel handles. */
7203 if (new_fd
>= 0 && new_fd
< MAXDESC
)
7205 /* duplicate our internal info as well */
7206 fd_info
[new_fd
] = fd_info
[fd
];
7212 sys_dup2 (int src
, int dst
)
7216 if (dst
< 0 || dst
>= MAXDESC
)
7222 /* make sure we close the destination first if it's a pipe or socket */
7223 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
7226 rc
= _dup2 (src
, dst
);
7229 /* duplicate our internal info as well */
7230 fd_info
[dst
] = fd_info
[src
];
7236 pipe2 (int * phandles
, int pipe2_flags
)
7241 eassert (pipe2_flags
== O_CLOEXEC
);
7243 /* make pipe handles non-inheritable; when we spawn a child, we
7244 replace the relevant handle with an inheritable one. Also put
7245 pipes into binary mode; we will do text mode translation ourselves
7247 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
7251 /* Protect against overflow, since Windows can open more handles than
7252 our fd_info array has room for. */
7253 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
7255 _close (phandles
[0]);
7256 _close (phandles
[1]);
7262 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
7263 fd_info
[phandles
[0]].flags
= flags
;
7265 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
7266 fd_info
[phandles
[1]].flags
= flags
;
7273 /* Function to do blocking read of one byte, needed to implement
7274 select. It is only allowed on communication ports, sockets, or
7277 _sys_read_ahead (int fd
)
7282 if (fd
< 0 || fd
>= MAXDESC
)
7283 return STATUS_READ_ERROR
;
7285 cp
= fd_info
[fd
].cp
;
7287 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7288 return STATUS_READ_ERROR
;
7290 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
7291 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
7293 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
7297 cp
->status
= STATUS_READ_IN_PROGRESS
;
7299 if (fd_info
[fd
].flags
& FILE_PIPE
)
7301 rc
= _read (fd
, &cp
->chr
, sizeof (char));
7303 /* Give subprocess time to buffer some more output for us before
7304 reporting that input is available; we need this because Windows 95
7305 connects DOS programs to pipes by making the pipe appear to be
7306 the normal console stdout - as a result most DOS programs will
7307 write to stdout without buffering, ie. one character at a
7308 time. Even some W32 programs do this - "dir" in a command
7309 shell on NT is very slow if we don't do this. */
7312 int wait
= w32_pipe_read_delay
;
7318 /* Yield remainder of our time slice, effectively giving a
7319 temporary priority boost to the child process. */
7323 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7325 HANDLE hnd
= fd_info
[fd
].hnd
;
7326 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7329 /* Configure timeouts for blocking read. */
7330 if (!GetCommTimeouts (hnd
, &ct
))
7332 cp
->status
= STATUS_READ_ERROR
;
7333 return STATUS_READ_ERROR
;
7335 ct
.ReadIntervalTimeout
= 0;
7336 ct
.ReadTotalTimeoutMultiplier
= 0;
7337 ct
.ReadTotalTimeoutConstant
= 0;
7338 if (!SetCommTimeouts (hnd
, &ct
))
7340 cp
->status
= STATUS_READ_ERROR
;
7341 return STATUS_READ_ERROR
;
7344 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
7346 if (GetLastError () != ERROR_IO_PENDING
)
7348 cp
->status
= STATUS_READ_ERROR
;
7349 return STATUS_READ_ERROR
;
7351 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7353 cp
->status
= STATUS_READ_ERROR
;
7354 return STATUS_READ_ERROR
;
7358 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
7360 unsigned long nblock
= 0;
7361 /* We always want this to block, so temporarily disable NDELAY. */
7362 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7363 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7365 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
7367 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7370 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7374 if (rc
== sizeof (char))
7375 cp
->status
= STATUS_READ_SUCCEEDED
;
7377 cp
->status
= STATUS_READ_FAILED
;
7383 _sys_wait_accept (int fd
)
7389 if (fd
< 0 || fd
>= MAXDESC
)
7390 return STATUS_READ_ERROR
;
7392 cp
= fd_info
[fd
].cp
;
7394 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7395 return STATUS_READ_ERROR
;
7397 cp
->status
= STATUS_READ_FAILED
;
7399 hEv
= pfn_WSACreateEvent ();
7400 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
7401 if (rc
!= SOCKET_ERROR
)
7404 rc
= WaitForSingleObject (hEv
, 500);
7406 } while (rc
== WAIT_TIMEOUT
7407 && cp
->status
!= STATUS_READ_ERROR
7409 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
7410 if (rc
== WAIT_OBJECT_0
)
7411 cp
->status
= STATUS_READ_SUCCEEDED
;
7413 pfn_WSACloseEvent (hEv
);
7419 sys_read (int fd
, char * buffer
, unsigned int count
)
7424 char * orig_buffer
= buffer
;
7432 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7434 child_process
*cp
= fd_info
[fd
].cp
;
7436 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
7444 /* re-read CR carried over from last read */
7445 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
7447 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
7451 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
7454 /* presence of a child_process structure means we are operating in
7455 non-blocking mode - otherwise we just call _read directly.
7456 Note that the child_process structure might be missing because
7457 reap_subprocess has been called; in this case the pipe is
7458 already broken, so calling _read on it is okay. */
7461 int current_status
= cp
->status
;
7463 switch (current_status
)
7465 case STATUS_READ_FAILED
:
7466 case STATUS_READ_ERROR
:
7467 /* report normal EOF if nothing in buffer */
7469 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7472 case STATUS_READ_READY
:
7473 case STATUS_READ_IN_PROGRESS
:
7474 DebPrint (("sys_read called when read is in progress\n"));
7475 errno
= EWOULDBLOCK
;
7478 case STATUS_READ_SUCCEEDED
:
7479 /* consume read-ahead char */
7480 *buffer
++ = cp
->chr
;
7483 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7484 ResetEvent (cp
->char_avail
);
7486 case STATUS_READ_ACKNOWLEDGED
:
7490 DebPrint (("sys_read: bad status %d\n", current_status
));
7495 if (fd_info
[fd
].flags
& FILE_PIPE
)
7497 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
7498 to_read
= min (waiting
, (DWORD
) count
);
7501 nchars
+= _read (fd
, buffer
, to_read
);
7503 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7505 HANDLE hnd
= fd_info
[fd
].hnd
;
7506 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7512 /* Configure timeouts for non-blocking read. */
7513 if (!GetCommTimeouts (hnd
, &ct
))
7518 ct
.ReadIntervalTimeout
= MAXDWORD
;
7519 ct
.ReadTotalTimeoutMultiplier
= 0;
7520 ct
.ReadTotalTimeoutConstant
= 0;
7521 if (!SetCommTimeouts (hnd
, &ct
))
7527 if (!ResetEvent (ovl
->hEvent
))
7532 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
7534 if (GetLastError () != ERROR_IO_PENDING
)
7539 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7548 else /* FILE_SOCKET */
7550 if (winsock_lib
== NULL
) emacs_abort ();
7552 /* do the equivalent of a non-blocking read */
7553 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
7554 if (waiting
== 0 && nchars
== 0)
7556 errno
= EWOULDBLOCK
;
7562 /* always use binary mode for sockets */
7563 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
7564 if (res
== SOCKET_ERROR
)
7566 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
7567 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7577 int nread
= _read (fd
, buffer
, count
);
7580 else if (nchars
== 0)
7585 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7586 /* Perform text mode translation if required. */
7587 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7589 nchars
= crlf_to_lf (nchars
, orig_buffer
);
7590 /* If buffer contains only CR, return that. To be absolutely
7591 sure we should attempt to read the next char, but in
7592 practice a CR to be followed by LF would not appear by
7593 itself in the buffer. */
7594 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
7596 fd_info
[fd
].flags
|= FILE_LAST_CR
;
7602 nchars
= _read (fd
, buffer
, count
);
7607 /* From w32xfns.c */
7608 extern HANDLE interrupt_handle
;
7610 /* For now, don't bother with a non-blocking mode */
7612 sys_write (int fd
, const void * buffer
, unsigned int count
)
7622 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7624 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
7630 /* Perform text mode translation if required. */
7631 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7633 char * tmpbuf
= alloca (count
* 2);
7634 unsigned char * src
= (void *)buffer
;
7635 unsigned char * dst
= tmpbuf
;
7640 unsigned char *next
;
7641 /* copy next line or remaining bytes */
7642 next
= _memccpy (dst
, src
, '\n', nbytes
);
7645 /* copied one line ending with '\n' */
7646 int copied
= next
- dst
;
7649 /* insert '\r' before '\n' */
7656 /* copied remaining partial line -> now finished */
7663 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
7665 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
7666 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
7667 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
7670 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
7672 if (GetLastError () != ERROR_IO_PENDING
)
7677 if (detect_input_pending ())
7678 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
7681 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
7682 if (active
== WAIT_OBJECT_0
)
7683 { /* User pressed C-g, cancel write, then leave. Don't bother
7684 cleaning up as we may only get stuck in buggy drivers. */
7685 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
7690 if (active
== WAIT_OBJECT_0
+ 1
7691 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
7698 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
7700 unsigned long nblock
= 0;
7701 if (winsock_lib
== NULL
) emacs_abort ();
7703 /* TODO: implement select() properly so non-blocking I/O works. */
7704 /* For now, make sure the write blocks. */
7705 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7706 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7708 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
7710 /* Set the socket back to non-blocking if it was before,
7711 for other operations that support it. */
7712 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7715 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7718 if (nchars
== SOCKET_ERROR
)
7720 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7721 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7727 /* Some networked filesystems don't like too large writes, so
7728 break them into smaller chunks. See the Comments section of
7729 the MSDN documentation of WriteFile for details behind the
7730 choice of the value of CHUNK below. See also the thread
7731 http://thread.gmane.org/gmane.comp.version-control.git/145294
7732 in the git mailing list. */
7733 const unsigned char *p
= buffer
;
7734 const unsigned chunk
= 30 * 1024 * 1024;
7739 unsigned this_chunk
= count
< chunk
? count
: chunk
;
7740 int n
= _write (fd
, p
, this_chunk
);
7748 else if (n
< this_chunk
)
7759 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
7761 extern Lisp_Object
conv_sockaddr_to_lisp (struct sockaddr
*, int);
7763 /* Return information about network interface IFNAME, or about all
7764 interfaces (if IFNAME is nil). */
7766 network_interface_get_info (Lisp_Object ifname
)
7768 ULONG ainfo_len
= sizeof (IP_ADAPTER_INFO
);
7769 IP_ADAPTER_INFO
*adapter
, *ainfo
= xmalloc (ainfo_len
);
7770 DWORD retval
= get_adapters_info (ainfo
, &ainfo_len
);
7771 Lisp_Object res
= Qnil
;
7773 if (retval
== ERROR_BUFFER_OVERFLOW
)
7775 ainfo
= xrealloc (ainfo
, ainfo_len
);
7776 retval
= get_adapters_info (ainfo
, &ainfo_len
);
7779 if (retval
== ERROR_SUCCESS
)
7781 int eth_count
= 0, tr_count
= 0, fddi_count
= 0, ppp_count
= 0;
7782 int sl_count
= 0, wlan_count
= 0, lo_count
= 0, ifx_count
= 0;
7784 struct sockaddr_in sa
;
7786 /* For the below, we need some winsock functions, so make sure
7787 the winsock DLL is loaded. If we cannot successfully load
7788 it, they will have no use of the information we provide,
7790 if (!winsock_lib
&& !init_winsock (1))
7793 for (adapter
= ainfo
; adapter
; adapter
= adapter
->Next
)
7795 char namebuf
[MAX_ADAPTER_NAME_LENGTH
+ 4];
7797 /* Present Unix-compatible interface names, instead of the
7798 Windows names, which are really GUIDs not readable by
7800 static const char *ifmt
[] = {
7801 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
7816 switch (adapter
->Type
)
7818 case MIB_IF_TYPE_ETHERNET
:
7819 /* Windows before Vista reports wireless adapters as
7820 Ethernet. Work around by looking at the Description
7822 if (strstr (adapter
->Description
, "Wireless "))
7825 if_num
= wlan_count
++;
7829 ifmt_idx
= ETHERNET
;
7830 if_num
= eth_count
++;
7833 case MIB_IF_TYPE_TOKENRING
:
7834 ifmt_idx
= TOKENRING
;
7835 if_num
= tr_count
++;
7837 case MIB_IF_TYPE_FDDI
:
7839 if_num
= fddi_count
++;
7841 case MIB_IF_TYPE_PPP
:
7843 if_num
= ppp_count
++;
7845 case MIB_IF_TYPE_SLIP
:
7847 if_num
= sl_count
++;
7849 case IF_TYPE_IEEE80211
:
7851 if_num
= wlan_count
++;
7853 case MIB_IF_TYPE_LOOPBACK
:
7856 ifmt_idx
= LOOPBACK
;
7857 if_num
= lo_count
++;
7863 ifmt_idx
= OTHER_IF
;
7864 if_num
= ifx_count
++;
7867 if (ifmt_idx
== NONE
)
7869 sprintf (namebuf
, ifmt
[ifmt_idx
], if_num
);
7871 sa
.sin_family
= AF_INET
;
7872 ip_addr
= sys_inet_addr (adapter
->IpAddressList
.IpAddress
.String
);
7873 if (ip_addr
== INADDR_NONE
)
7875 /* Bogus address, skip this interface. */
7878 sa
.sin_addr
.s_addr
= ip_addr
;
7881 res
= Fcons (Fcons (build_string (namebuf
),
7882 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7883 sizeof (struct sockaddr
))),
7885 else if (strcmp (namebuf
, SSDATA (ifname
)) == 0)
7887 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
7888 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
7889 Lisp_Object flags
= Qnil
;
7893 /* Flags. We guess most of them by type, since the
7894 Windows flags are different and hard to get by. */
7895 flags
= Fcons (intern ("up"), flags
);
7896 if (ifmt_idx
== ETHERNET
|| ifmt_idx
== WLAN
)
7898 flags
= Fcons (intern ("broadcast"), flags
);
7899 flags
= Fcons (intern ("multicast"), flags
);
7901 flags
= Fcons (intern ("running"), flags
);
7902 if (ifmt_idx
== PPP
)
7904 flags
= Fcons (intern ("pointopoint"), flags
);
7905 flags
= Fcons (intern ("noarp"), flags
);
7907 if (adapter
->HaveWins
)
7908 flags
= Fcons (intern ("WINS"), flags
);
7909 if (adapter
->DhcpEnabled
)
7910 flags
= Fcons (intern ("dynamic"), flags
);
7912 res
= Fcons (flags
, res
);
7914 /* Hardware address and its family. */
7915 for (n
= 0; n
< adapter
->AddressLength
; n
++)
7916 p
->u
.contents
[n
] = make_number ((int) adapter
->Address
[n
]);
7917 /* Windows does not support AF_LINK or AF_PACKET family
7918 of addresses. Use an arbitrary family number that is
7919 identical to what GNU/Linux returns. */
7920 res
= Fcons (Fcons (make_number (1), hwaddr
), res
);
7923 sa
.sin_family
= AF_INET
;
7924 net_mask
= sys_inet_addr (adapter
->IpAddressList
.IpMask
.String
);
7925 if (net_mask
!= INADDR_NONE
)
7927 sa
.sin_addr
.s_addr
= net_mask
;
7929 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7930 sizeof (struct sockaddr
)),
7934 res
= Fcons (Qnil
, res
);
7936 sa
.sin_family
= AF_INET
;
7937 if (ip_addr
!= INADDR_NONE
)
7939 /* Broadcast address is only reported by
7940 GetAdaptersAddresses, which is of limited
7941 availability. Generate it on our own. */
7942 u_long bcast_addr
= (ip_addr
& net_mask
) | ~net_mask
;
7944 sa
.sin_addr
.s_addr
= bcast_addr
;
7946 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7947 sizeof (struct sockaddr
)),
7951 sa
.sin_addr
.s_addr
= ip_addr
;
7953 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7954 sizeof (struct sockaddr
)),
7958 res
= Fcons (Qnil
, Fcons (Qnil
, res
));
7961 /* GetAdaptersInfo is documented to not report loopback
7962 interfaces, so we generate one out of thin air. */
7965 sa
.sin_family
= AF_INET
;
7969 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
7970 res
= Fcons (Fcons (build_string ("lo"),
7971 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7972 sizeof (struct sockaddr
))),
7975 else if (strcmp (SSDATA (ifname
), "lo") == 0)
7977 res
= Fcons (Fcons (intern ("running"),
7978 Fcons (intern ("loopback"),
7979 Fcons (intern ("up"), Qnil
))), Qnil
);
7980 /* 772 is what 3 different GNU/Linux systems report for
7981 the loopback interface. */
7982 res
= Fcons (Fcons (make_number (772),
7983 Fmake_vector (make_number (6),
7986 sa
.sin_addr
.s_addr
= sys_inet_addr ("255.0.0.0");
7987 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7988 sizeof (struct sockaddr
)),
7990 sa
.sin_addr
.s_addr
= sys_inet_addr ("0.0.0.0");
7991 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7992 sizeof (struct sockaddr
)),
7994 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
7995 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
7996 sizeof (struct sockaddr
)),
8009 network_interface_list (void)
8011 return network_interface_get_info (Qnil
);
8015 network_interface_info (Lisp_Object ifname
)
8017 return network_interface_get_info (ifname
);
8021 /* The Windows CRT functions are "optimized for speed", so they don't
8022 check for timezone and DST changes if they were last called less
8023 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
8024 all Emacs features that repeatedly call time functions (e.g.,
8025 display-time) are in real danger of missing timezone and DST
8026 changes. Calling tzset before each localtime call fixes that. */
8028 sys_localtime (const time_t *t
)
8031 return localtime (t
);
8036 /* Try loading LIBRARY_ID from the file(s) specified in
8037 Vdynamic_library_alist. If the library is loaded successfully,
8038 return the handle of the DLL, and record the filename in the
8039 property :loaded-from of LIBRARY_ID. If the library could not be
8040 found, or when it was already loaded (because the handle is not
8041 recorded anywhere, and so is lost after use), return NULL.
8043 We could also save the handle in :loaded-from, but currently
8044 there's no use case for it. */
8046 w32_delayed_load (Lisp_Object library_id
)
8048 HMODULE library_dll
= NULL
;
8050 CHECK_SYMBOL (library_id
);
8052 if (CONSP (Vdynamic_library_alist
)
8053 && NILP (Fassq (library_id
, Vlibrary_cache
)))
8055 Lisp_Object found
= Qnil
;
8056 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
8059 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
8061 CHECK_STRING_CAR (dlls
);
8062 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
8064 char name
[MAX_PATH
];
8067 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
8068 found
= Fcons (XCAR (dlls
),
8070 /* Possibly truncated */
8071 ? make_specified_string (name
, -1, len
, 1)
8077 Fput (library_id
, QCloaded_from
, found
);
8085 check_windows_init_file (void)
8087 /* A common indication that Emacs is not installed properly is when
8088 it cannot find the Windows installation file. If this file does
8089 not exist in the expected place, tell the user. */
8091 if (!noninteractive
&& !inhibit_window_system
8092 /* Vload_path is not yet initialized when we are loading
8094 && NILP (Vpurify_flag
))
8096 Lisp_Object init_file
;
8099 init_file
= build_string ("term/w32-win");
8100 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
8103 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
8104 char *init_file_name
= SDATA (init_file
);
8105 char *load_path
= SDATA (load_path_print
);
8106 char *buffer
= alloca (1024
8107 + strlen (init_file_name
)
8108 + strlen (load_path
));
8111 "The Emacs Windows initialization file \"%s.el\" "
8112 "could not be found in your Emacs installation. "
8113 "Emacs checked the following directories for this file:\n"
8115 "When Emacs cannot find this file, it usually means that it "
8116 "was not installed properly, or its distribution file was "
8117 "not unpacked properly.\nSee the README.W32 file in the "
8118 "top-level Emacs directory for more information.",
8119 init_file_name
, load_path
);
8122 "Emacs Abort Dialog",
8123 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
8124 /* Use the low-level system abort. */
8135 term_ntproc (int ignored
)
8141 /* shutdown the socket interface if necessary */
8148 init_ntproc (int dumping
)
8150 sigset_t initial_mask
= 0;
8152 /* Initialize the socket interface now if available and requested by
8153 the user by defining PRELOAD_WINSOCK; otherwise loading will be
8154 delayed until open-network-stream is called (w32-has-winsock can
8155 also be used to dynamically load or reload winsock).
8157 Conveniently, init_environment is called before us, so
8158 PRELOAD_WINSOCK can be set in the registry. */
8160 /* Always initialize this correctly. */
8163 if (getenv ("PRELOAD_WINSOCK") != NULL
)
8164 init_winsock (TRUE
);
8166 /* Initial preparation for subprocess support: replace our standard
8167 handles with non-inheritable versions. */
8170 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
8171 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
8172 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
8174 parent
= GetCurrentProcess ();
8176 /* ignore errors when duplicating and closing; typically the
8177 handles will be invalid when running as a gui program. */
8178 DuplicateHandle (parent
,
8179 GetStdHandle (STD_INPUT_HANDLE
),
8184 DUPLICATE_SAME_ACCESS
);
8186 DuplicateHandle (parent
,
8187 GetStdHandle (STD_OUTPUT_HANDLE
),
8192 DUPLICATE_SAME_ACCESS
);
8194 DuplicateHandle (parent
,
8195 GetStdHandle (STD_ERROR_HANDLE
),
8200 DUPLICATE_SAME_ACCESS
);
8206 if (stdin_save
!= INVALID_HANDLE_VALUE
)
8207 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
8209 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
8212 if (stdout_save
!= INVALID_HANDLE_VALUE
)
8213 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
8215 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8218 if (stderr_save
!= INVALID_HANDLE_VALUE
)
8219 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
8221 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8225 /* unfortunately, atexit depends on implementation of malloc */
8226 /* atexit (term_ntproc); */
8229 /* Make sure we start with all signals unblocked. */
8230 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
8231 signal (SIGABRT
, term_ntproc
);
8235 /* determine which drives are fixed, for GetCachedVolumeInformation */
8237 /* GetDriveType must have trailing backslash. */
8238 char drive
[] = "A:\\";
8240 /* Loop over all possible drive letters */
8241 while (*drive
<= 'Z')
8243 /* Record if this drive letter refers to a fixed drive. */
8244 fixed_drives
[DRIVE_INDEX (*drive
)] =
8245 (GetDriveType (drive
) == DRIVE_FIXED
);
8250 /* Reset the volume info cache. */
8251 volume_cache
= NULL
;
8256 shutdown_handler ensures that buffers' autosave files are
8257 up to date when the user logs off, or the system shuts down.
8260 shutdown_handler (DWORD type
)
8262 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
8263 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
8264 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
8265 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
8267 /* Shut down cleanly, making sure autosave files are up to date. */
8268 shut_down_emacs (0, Qnil
);
8271 /* Allow other handlers to handle this signal. */
8276 globals_of_w32 is used to initialize those global variables that
8277 must always be initialized on startup even when the global variable
8278 initialized is non zero (see the function main in emacs.c).
8281 globals_of_w32 (void)
8283 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
8285 get_process_times_fn
= (GetProcessTimes_Proc
)
8286 GetProcAddress (kernel32
, "GetProcessTimes");
8288 DEFSYM (QCloaded_from
, ":loaded-from");
8290 g_b_init_is_windows_9x
= 0;
8291 g_b_init_open_process_token
= 0;
8292 g_b_init_get_token_information
= 0;
8293 g_b_init_lookup_account_sid
= 0;
8294 g_b_init_get_sid_sub_authority
= 0;
8295 g_b_init_get_sid_sub_authority_count
= 0;
8296 g_b_init_get_security_info
= 0;
8297 g_b_init_get_file_security
= 0;
8298 g_b_init_get_security_descriptor_owner
= 0;
8299 g_b_init_get_security_descriptor_group
= 0;
8300 g_b_init_is_valid_sid
= 0;
8301 g_b_init_create_toolhelp32_snapshot
= 0;
8302 g_b_init_process32_first
= 0;
8303 g_b_init_process32_next
= 0;
8304 g_b_init_open_thread_token
= 0;
8305 g_b_init_impersonate_self
= 0;
8306 g_b_init_revert_to_self
= 0;
8307 g_b_init_get_process_memory_info
= 0;
8308 g_b_init_get_process_working_set_size
= 0;
8309 g_b_init_global_memory_status
= 0;
8310 g_b_init_global_memory_status_ex
= 0;
8311 g_b_init_equal_sid
= 0;
8312 g_b_init_copy_sid
= 0;
8313 g_b_init_get_length_sid
= 0;
8314 g_b_init_get_native_system_info
= 0;
8315 g_b_init_get_system_times
= 0;
8316 g_b_init_create_symbolic_link
= 0;
8317 g_b_init_get_security_descriptor_dacl
= 0;
8318 g_b_init_convert_sd_to_sddl
= 0;
8319 g_b_init_convert_sddl_to_sd
= 0;
8320 g_b_init_is_valid_security_descriptor
= 0;
8321 g_b_init_set_file_security
= 0;
8322 g_b_init_get_adapters_info
= 0;
8323 num_of_processors
= 0;
8324 /* The following sets a handler for shutdown notifications for
8325 console apps. This actually applies to Emacs in both console and
8326 GUI modes, since we had to fool windows into thinking emacs is a
8327 console application to get console mode to work. */
8328 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
8330 /* "None" is the default group name on standalone workstations. */
8331 strcpy (dflt_group_name
, "None");
8333 /* Reset, in case it has some value inherited from dump time. */
8334 w32_stat_get_owner_group
= 0;
8336 /* If w32_unicode_filenames is non-zero, we will be using Unicode
8337 (a.k.a. "wide") APIs to invoke functions that accept file
8339 if (is_windows_9x ())
8340 w32_unicode_filenames
= 0;
8342 w32_unicode_filenames
= 1;
8345 /* For make-serial-process */
8347 serial_open (Lisp_Object port_obj
)
8349 char *port
= SSDATA (port_obj
);
8354 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
8355 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
8356 if (hnd
== INVALID_HANDLE_VALUE
)
8357 error ("Could not open %s", port
);
8358 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
8360 error ("Could not open %s", port
);
8364 error ("Could not create child process");
8366 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
8367 fd_info
[ fd
].hnd
= hnd
;
8368 fd_info
[ fd
].flags
|=
8369 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
8370 if (fd_info
[ fd
].cp
!= NULL
)
8372 error ("fd_info[fd = %d] is already in use", fd
);
8374 fd_info
[ fd
].cp
= cp
;
8375 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
8376 if (cp
->ovl_read
.hEvent
== NULL
)
8377 error ("Could not create read event");
8378 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
8379 if (cp
->ovl_write
.hEvent
== NULL
)
8380 error ("Could not create write event");
8385 /* For serial-process-configure */
8387 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
8389 Lisp_Object childp2
= Qnil
;
8390 Lisp_Object tem
= Qnil
;
8394 char summary
[4] = "???"; /* This usually becomes "8N1". */
8396 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
8397 error ("Not a serial process");
8398 hnd
= fd_info
[ p
->outfd
].hnd
;
8400 childp2
= Fcopy_sequence (p
->childp
);
8402 /* Initialize timeouts for blocking read and blocking write. */
8403 if (!GetCommTimeouts (hnd
, &ct
))
8404 error ("GetCommTimeouts() failed");
8405 ct
.ReadIntervalTimeout
= 0;
8406 ct
.ReadTotalTimeoutMultiplier
= 0;
8407 ct
.ReadTotalTimeoutConstant
= 0;
8408 ct
.WriteTotalTimeoutMultiplier
= 0;
8409 ct
.WriteTotalTimeoutConstant
= 0;
8410 if (!SetCommTimeouts (hnd
, &ct
))
8411 error ("SetCommTimeouts() failed");
8412 /* Read port attributes and prepare default configuration. */
8413 memset (&dcb
, 0, sizeof (dcb
));
8414 dcb
.DCBlength
= sizeof (DCB
);
8415 if (!GetCommState (hnd
, &dcb
))
8416 error ("GetCommState() failed");
8419 dcb
.fAbortOnError
= FALSE
;
8420 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
8425 /* Configure speed. */
8426 if (!NILP (Fplist_member (contact
, QCspeed
)))
8427 tem
= Fplist_get (contact
, QCspeed
);
8429 tem
= Fplist_get (p
->childp
, QCspeed
);
8431 dcb
.BaudRate
= XINT (tem
);
8432 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
8434 /* Configure bytesize. */
8435 if (!NILP (Fplist_member (contact
, QCbytesize
)))
8436 tem
= Fplist_get (contact
, QCbytesize
);
8438 tem
= Fplist_get (p
->childp
, QCbytesize
);
8440 tem
= make_number (8);
8442 if (XINT (tem
) != 7 && XINT (tem
) != 8)
8443 error (":bytesize must be nil (8), 7, or 8");
8444 dcb
.ByteSize
= XINT (tem
);
8445 summary
[0] = XINT (tem
) + '0';
8446 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
8448 /* Configure parity. */
8449 if (!NILP (Fplist_member (contact
, QCparity
)))
8450 tem
= Fplist_get (contact
, QCparity
);
8452 tem
= Fplist_get (p
->childp
, QCparity
);
8453 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
8454 error (":parity must be nil (no parity), `even', or `odd'");
8455 dcb
.fParity
= FALSE
;
8456 dcb
.Parity
= NOPARITY
;
8457 dcb
.fErrorChar
= FALSE
;
8462 else if (EQ (tem
, Qeven
))
8466 dcb
.Parity
= EVENPARITY
;
8467 dcb
.fErrorChar
= TRUE
;
8469 else if (EQ (tem
, Qodd
))
8473 dcb
.Parity
= ODDPARITY
;
8474 dcb
.fErrorChar
= TRUE
;
8476 childp2
= Fplist_put (childp2
, QCparity
, tem
);
8478 /* Configure stopbits. */
8479 if (!NILP (Fplist_member (contact
, QCstopbits
)))
8480 tem
= Fplist_get (contact
, QCstopbits
);
8482 tem
= Fplist_get (p
->childp
, QCstopbits
);
8484 tem
= make_number (1);
8486 if (XINT (tem
) != 1 && XINT (tem
) != 2)
8487 error (":stopbits must be nil (1 stopbit), 1, or 2");
8488 summary
[2] = XINT (tem
) + '0';
8489 if (XINT (tem
) == 1)
8490 dcb
.StopBits
= ONESTOPBIT
;
8491 else if (XINT (tem
) == 2)
8492 dcb
.StopBits
= TWOSTOPBITS
;
8493 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
8495 /* Configure flowcontrol. */
8496 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
8497 tem
= Fplist_get (contact
, QCflowcontrol
);
8499 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
8500 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
8501 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
8502 dcb
.fOutxCtsFlow
= FALSE
;
8503 dcb
.fOutxDsrFlow
= FALSE
;
8504 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
8505 dcb
.fDsrSensitivity
= FALSE
;
8506 dcb
.fTXContinueOnXoff
= FALSE
;
8509 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
8510 dcb
.XonChar
= 17; /* Control-Q */
8511 dcb
.XoffChar
= 19; /* Control-S */
8514 /* Already configured. */
8516 else if (EQ (tem
, Qhw
))
8518 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
8519 dcb
.fOutxCtsFlow
= TRUE
;
8521 else if (EQ (tem
, Qsw
))
8526 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
8528 /* Activate configuration. */
8529 if (!SetCommState (hnd
, &dcb
))
8530 error ("SetCommState() failed");
8532 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
8533 pset_childp (p
, childp2
);
8539 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
8543 struct timespec timeout
;
8544 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
8545 int fd
= process
->infd
;
8547 n
= sys_read (fd
, (char*)buf
, sz
);
8554 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
8555 if (err
== EWOULDBLOCK
)
8558 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
8564 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
8566 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
8567 int fd
= process
->outfd
;
8568 ssize_t n
= sys_write (fd
, buf
, sz
);
8570 /* 0 or more bytes written means everything went fine. */
8574 /* Negative bytes written means we got an error in errno.
8575 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
8576 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
8577 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
8581 #endif /* HAVE_GNUTLS */