1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1994-1995, 2000-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
24 #include <mingw_time.h>
25 #include <stddef.h> /* for offsetof */
28 #include <float.h> /* for DBL_EPSILON */
35 #include <time.h> /* must be before nt/inc/sys/time.h, for MinGW64 */
37 #include <sys/utime.h>
40 /* must include CRT headers *before* config.h */
43 #include <mbstring.h> /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
70 #include "epaths.h" /* for SHELL */
75 /* MinGW64 (_W64) defines these in its _mingw.h. */
76 #ifndef _ANONYMOUS_UNION
77 # define _ANONYMOUS_UNION
79 #ifndef _ANONYMOUS_STRUCT
80 # define _ANONYMOUS_STRUCT
83 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
84 use a different name to avoid compilation problems. */
85 typedef struct _MEMORY_STATUS_EX
{
88 DWORDLONG ullTotalPhys
;
89 DWORDLONG ullAvailPhys
;
90 DWORDLONG ullTotalPageFile
;
91 DWORDLONG ullAvailPageFile
;
92 DWORDLONG ullTotalVirtual
;
93 DWORDLONG ullAvailVirtual
;
94 DWORDLONG ullAvailExtendedVirtual
;
95 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
97 /* These are here so that GDB would know about these data types. This
98 allows to attach GDB to Emacs when a fatal exception is triggered
99 and Windows pops up the "application needs to be closed" dialog.
100 At that point, _gnu_exception_handler, the top-level exception
101 handler installed by the MinGW startup code, is somewhere on the
102 call-stack of the main thread, so going to that call frame and
103 looking at the argument to _gnu_exception_handler, which is a
104 PEXCEPTION_POINTERS pointer, can reveal the exception code
105 (excptr->ExceptionRecord->ExceptionCode) and the address where the
106 exception happened (excptr->ExceptionRecord->ExceptionAddress), as
107 well as some additional information specific to the exception. */
108 PEXCEPTION_POINTERS excptr
;
109 PEXCEPTION_RECORD excprec
;
115 #include <tlhelp32.h>
120 #if _WIN32_WINNT < 0x0500
121 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
122 /* This either is not in psapi.h or guarded by higher value of
123 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
124 defines it in psapi.h */
125 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
127 DWORD PageFaultCount
;
128 SIZE_T PeakWorkingSetSize
;
129 SIZE_T WorkingSetSize
;
130 SIZE_T QuotaPeakPagedPoolUsage
;
131 SIZE_T QuotaPagedPoolUsage
;
132 SIZE_T QuotaPeakNonPagedPoolUsage
;
133 SIZE_T QuotaNonPagedPoolUsage
;
134 SIZE_T PagefileUsage
;
135 SIZE_T PeakPagefileUsage
;
137 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
141 #include <winioctl.h>
148 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
149 define them by hand if not already defined. */
150 #ifndef SDDL_REVISION_1
151 #define SDDL_REVISION_1 1
152 #endif /* SDDL_REVISION_1 */
154 #if defined(_MSC_VER) || defined(_W64)
155 /* MSVC and MinGW64 don't provide the definition of
156 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
157 which cannot be included because it triggers conflicts with other
158 Windows API headers. So we define it here by hand. */
160 typedef struct _REPARSE_DATA_BUFFER
{
162 USHORT ReparseDataLength
;
166 USHORT SubstituteNameOffset
;
167 USHORT SubstituteNameLength
;
168 USHORT PrintNameOffset
;
169 USHORT PrintNameLength
;
172 } SymbolicLinkReparseBuffer
;
174 USHORT SubstituteNameOffset
;
175 USHORT SubstituteNameLength
;
176 USHORT PrintNameOffset
;
177 USHORT PrintNameLength
;
179 } MountPointReparseBuffer
;
182 } GenericReparseBuffer
;
184 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
186 #ifndef FILE_DEVICE_FILE_SYSTEM
187 #define FILE_DEVICE_FILE_SYSTEM 9
189 #ifndef METHOD_BUFFERED
190 #define METHOD_BUFFERED 0
192 #ifndef FILE_ANY_ACCESS
193 #define FILE_ANY_ACCESS 0x00000000
196 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
198 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
199 #ifndef FSCTL_GET_REPARSE_POINT
200 #define FSCTL_GET_REPARSE_POINT \
201 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
205 /* TCP connection support. */
206 #include <sys/socket.h>
225 #include <iphlpapi.h> /* should be after winsock2.h */
229 #include "w32common.h"
231 #include "w32select.h"
233 #include "dispextern.h" /* for xstrcasecmp */
234 #include "coding.h" /* for Vlocale_coding_system */
236 #include "careadlinkat.h"
237 #include "allocator.h"
239 /* For serial_configure and serial_open. */
242 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
243 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
245 Lisp_Object QCloaded_from
;
247 void globals_of_w32 (void);
248 static DWORD
get_rid (PSID
);
249 static int is_symlink (const char *);
250 static char * chase_symlinks (const char *);
251 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
252 static int restore_privilege (TOKEN_PRIVILEGES
*);
253 static BOOL WINAPI
revert_to_self (void);
255 static int sys_access (const char *, int);
256 extern void *e_malloc (size_t);
257 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
258 struct timespec
*, void *);
259 extern int sys_dup (int);
264 /* Initialization states.
266 WARNING: If you add any more such variables for additional APIs,
267 you MUST add initialization for them to globals_of_w32
268 below. This is because these variables might get set
269 to non-NULL values during dumping, but the dumped Emacs
270 cannot reuse those values, because it could be run on a
271 different version of the OS, where API addresses are
273 static BOOL g_b_init_is_windows_9x
;
274 static BOOL g_b_init_open_process_token
;
275 static BOOL g_b_init_get_token_information
;
276 static BOOL g_b_init_lookup_account_sid
;
277 static BOOL g_b_init_get_sid_sub_authority
;
278 static BOOL g_b_init_get_sid_sub_authority_count
;
279 static BOOL g_b_init_get_security_info
;
280 static BOOL g_b_init_get_file_security_w
;
281 static BOOL g_b_init_get_file_security_a
;
282 static BOOL g_b_init_get_security_descriptor_owner
;
283 static BOOL g_b_init_get_security_descriptor_group
;
284 static BOOL g_b_init_is_valid_sid
;
285 static BOOL g_b_init_create_toolhelp32_snapshot
;
286 static BOOL g_b_init_process32_first
;
287 static BOOL g_b_init_process32_next
;
288 static BOOL g_b_init_open_thread_token
;
289 static BOOL g_b_init_impersonate_self
;
290 static BOOL g_b_init_revert_to_self
;
291 static BOOL g_b_init_get_process_memory_info
;
292 static BOOL g_b_init_get_process_working_set_size
;
293 static BOOL g_b_init_global_memory_status
;
294 static BOOL g_b_init_global_memory_status_ex
;
295 static BOOL g_b_init_get_length_sid
;
296 static BOOL g_b_init_equal_sid
;
297 static BOOL g_b_init_copy_sid
;
298 static BOOL g_b_init_get_native_system_info
;
299 static BOOL g_b_init_get_system_times
;
300 static BOOL g_b_init_create_symbolic_link_w
;
301 static BOOL g_b_init_create_symbolic_link_a
;
302 static BOOL g_b_init_get_security_descriptor_dacl
;
303 static BOOL g_b_init_convert_sd_to_sddl
;
304 static BOOL g_b_init_convert_sddl_to_sd
;
305 static BOOL g_b_init_is_valid_security_descriptor
;
306 static BOOL g_b_init_set_file_security_w
;
307 static BOOL g_b_init_set_file_security_a
;
308 static BOOL g_b_init_set_named_security_info_w
;
309 static BOOL g_b_init_set_named_security_info_a
;
310 static BOOL g_b_init_get_adapters_info
;
313 BEGIN: Wrapper functions around OpenProcessToken
314 and other functions in advapi32.dll that are only
315 supported in Windows NT / 2k / XP
317 /* ** Function pointer typedefs ** */
318 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
319 HANDLE ProcessHandle
,
321 PHANDLE TokenHandle
);
322 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
324 TOKEN_INFORMATION_CLASS TokenInformationClass
,
325 LPVOID TokenInformation
,
326 DWORD TokenInformationLength
,
327 PDWORD ReturnLength
);
328 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
329 HANDLE process_handle
,
330 LPFILETIME creation_time
,
331 LPFILETIME exit_time
,
332 LPFILETIME kernel_time
,
333 LPFILETIME user_time
);
335 GetProcessTimes_Proc get_process_times_fn
= NULL
;
338 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
340 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
342 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
343 LPCTSTR lpSystemName
,
348 LPDWORD cbDomainName
,
349 PSID_NAME_USE peUse
);
350 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
353 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
355 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
357 SE_OBJECT_TYPE ObjectType
,
358 SECURITY_INFORMATION SecurityInfo
,
363 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
364 typedef BOOL (WINAPI
* GetFileSecurityW_Proc
) (
366 SECURITY_INFORMATION RequestedInformation
,
367 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
369 LPDWORD lpnLengthNeeded
);
370 typedef BOOL (WINAPI
* GetFileSecurityA_Proc
) (
372 SECURITY_INFORMATION RequestedInformation
,
373 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
375 LPDWORD lpnLengthNeeded
);
376 typedef BOOL (WINAPI
*SetFileSecurityW_Proc
) (
378 SECURITY_INFORMATION SecurityInformation
,
379 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
380 typedef BOOL (WINAPI
*SetFileSecurityA_Proc
) (
382 SECURITY_INFORMATION SecurityInformation
,
383 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
384 typedef DWORD (WINAPI
*SetNamedSecurityInfoW_Proc
) (
385 LPCWSTR lpObjectName
,
386 SE_OBJECT_TYPE ObjectType
,
387 SECURITY_INFORMATION SecurityInformation
,
392 typedef DWORD (WINAPI
*SetNamedSecurityInfoA_Proc
) (
394 SE_OBJECT_TYPE ObjectType
,
395 SECURITY_INFORMATION SecurityInformation
,
400 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
401 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
403 LPBOOL lpbOwnerDefaulted
);
404 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
405 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
407 LPBOOL lpbGroupDefaulted
);
408 typedef BOOL (WINAPI
*GetSecurityDescriptorDacl_Proc
) (
409 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
410 LPBOOL lpbDaclPresent
,
412 LPBOOL lpbDaclDefaulted
);
413 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
415 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
417 DWORD th32ProcessID
);
418 typedef BOOL (WINAPI
* Process32First_Proc
) (
420 LPPROCESSENTRY32 lppe
);
421 typedef BOOL (WINAPI
* Process32Next_Proc
) (
423 LPPROCESSENTRY32 lppe
);
424 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
428 PHANDLE TokenHandle
);
429 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
430 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
431 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
432 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
434 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
436 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
438 PSIZE_T lpMinimumWorkingSetSize
,
439 PSIZE_T lpMaximumWorkingSetSize
);
440 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
441 LPMEMORYSTATUS lpBuffer
);
442 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
443 LPMEMORY_STATUS_EX lpBuffer
);
444 typedef BOOL (WINAPI
* CopySid_Proc
) (
445 DWORD nDestinationSidLength
,
446 PSID pDestinationSid
,
448 typedef BOOL (WINAPI
* EqualSid_Proc
) (
451 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
453 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
454 LPSYSTEM_INFO lpSystemInfo
);
455 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
456 LPFILETIME lpIdleTime
,
457 LPFILETIME lpKernelTime
,
458 LPFILETIME lpUserTime
);
459 typedef BOOLEAN (WINAPI
*CreateSymbolicLinkW_Proc
) (
460 LPCWSTR lpSymlinkFileName
,
461 LPCWSTR lpTargetFileName
,
463 typedef BOOLEAN (WINAPI
*CreateSymbolicLinkA_Proc
) (
464 LPCSTR lpSymlinkFileName
,
465 LPCSTR lpTargetFileName
,
467 typedef BOOL (WINAPI
*ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
) (
468 LPCTSTR StringSecurityDescriptor
,
469 DWORD StringSDRevision
,
470 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
471 PULONG SecurityDescriptorSize
);
472 typedef BOOL (WINAPI
*ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
) (
473 PSECURITY_DESCRIPTOR SecurityDescriptor
,
474 DWORD RequestedStringSDRevision
,
475 SECURITY_INFORMATION SecurityInformation
,
476 LPTSTR
*StringSecurityDescriptor
,
477 PULONG StringSecurityDescriptorLen
);
478 typedef BOOL (WINAPI
*IsValidSecurityDescriptor_Proc
) (PSECURITY_DESCRIPTOR
);
479 typedef DWORD (WINAPI
*GetAdaptersInfo_Proc
) (
480 PIP_ADAPTER_INFO pAdapterInfo
,
483 int (WINAPI
*pMultiByteToWideChar
)(UINT
,DWORD
,LPCSTR
,int,LPWSTR
,int);
484 int (WINAPI
*pWideCharToMultiByte
)(UINT
,DWORD
,LPCWSTR
,int,LPSTR
,int,LPCSTR
,LPBOOL
);
486 /* ** A utility function ** */
490 static BOOL s_b_ret
= 0;
491 OSVERSIONINFO os_ver
;
492 if (g_b_init_is_windows_9x
== 0)
494 g_b_init_is_windows_9x
= 1;
495 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
496 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
497 if (GetVersionEx (&os_ver
))
499 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
505 static Lisp_Object
ltime (ULONGLONG
);
507 /* Get total user and system times for get-internal-run-time.
508 Returns a list of integers if the times are provided by the OS
509 (NT derivatives), otherwise it returns the result of current-time. */
511 w32_get_internal_run_time (void)
513 if (get_process_times_fn
)
515 FILETIME create
, exit
, kernel
, user
;
516 HANDLE proc
= GetCurrentProcess ();
517 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
519 LARGE_INTEGER user_int
, kernel_int
, total
;
520 user_int
.LowPart
= user
.dwLowDateTime
;
521 user_int
.HighPart
= user
.dwHighDateTime
;
522 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
523 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
524 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
525 return ltime (total
.QuadPart
);
529 return Fcurrent_time ();
532 /* ** The wrapper functions ** */
535 open_process_token (HANDLE ProcessHandle
,
539 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
540 HMODULE hm_advapi32
= NULL
;
541 if (is_windows_9x () == TRUE
)
545 if (g_b_init_open_process_token
== 0)
547 g_b_init_open_process_token
= 1;
548 hm_advapi32
= LoadLibrary ("Advapi32.dll");
549 s_pfn_Open_Process_Token
=
550 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
552 if (s_pfn_Open_Process_Token
== NULL
)
557 s_pfn_Open_Process_Token (
565 get_token_information (HANDLE TokenHandle
,
566 TOKEN_INFORMATION_CLASS TokenInformationClass
,
567 LPVOID TokenInformation
,
568 DWORD TokenInformationLength
,
571 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
572 HMODULE hm_advapi32
= NULL
;
573 if (is_windows_9x () == TRUE
)
577 if (g_b_init_get_token_information
== 0)
579 g_b_init_get_token_information
= 1;
580 hm_advapi32
= LoadLibrary ("Advapi32.dll");
581 s_pfn_Get_Token_Information
=
582 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
584 if (s_pfn_Get_Token_Information
== NULL
)
589 s_pfn_Get_Token_Information (
591 TokenInformationClass
,
593 TokenInformationLength
,
599 lookup_account_sid (LPCTSTR lpSystemName
,
604 LPDWORD cbDomainName
,
607 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
608 HMODULE hm_advapi32
= NULL
;
609 if (is_windows_9x () == TRUE
)
613 if (g_b_init_lookup_account_sid
== 0)
615 g_b_init_lookup_account_sid
= 1;
616 hm_advapi32
= LoadLibrary ("Advapi32.dll");
617 s_pfn_Lookup_Account_Sid
=
618 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
620 if (s_pfn_Lookup_Account_Sid
== NULL
)
625 s_pfn_Lookup_Account_Sid (
637 get_sid_sub_authority (PSID pSid
, DWORD n
)
639 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
640 static DWORD zero
= 0U;
641 HMODULE hm_advapi32
= NULL
;
642 if (is_windows_9x () == TRUE
)
646 if (g_b_init_get_sid_sub_authority
== 0)
648 g_b_init_get_sid_sub_authority
= 1;
649 hm_advapi32
= LoadLibrary ("Advapi32.dll");
650 s_pfn_Get_Sid_Sub_Authority
=
651 (GetSidSubAuthority_Proc
) GetProcAddress (
652 hm_advapi32
, "GetSidSubAuthority");
654 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
658 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
662 get_sid_sub_authority_count (PSID pSid
)
664 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
665 static UCHAR zero
= 0U;
666 HMODULE hm_advapi32
= NULL
;
667 if (is_windows_9x () == TRUE
)
671 if (g_b_init_get_sid_sub_authority_count
== 0)
673 g_b_init_get_sid_sub_authority_count
= 1;
674 hm_advapi32
= LoadLibrary ("Advapi32.dll");
675 s_pfn_Get_Sid_Sub_Authority_Count
=
676 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
677 hm_advapi32
, "GetSidSubAuthorityCount");
679 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
683 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
687 get_security_info (HANDLE handle
,
688 SE_OBJECT_TYPE ObjectType
,
689 SECURITY_INFORMATION SecurityInfo
,
694 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
696 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
697 HMODULE hm_advapi32
= NULL
;
698 if (is_windows_9x () == TRUE
)
702 if (g_b_init_get_security_info
== 0)
704 g_b_init_get_security_info
= 1;
705 hm_advapi32
= LoadLibrary ("Advapi32.dll");
706 s_pfn_Get_Security_Info
=
707 (GetSecurityInfo_Proc
) GetProcAddress (
708 hm_advapi32
, "GetSecurityInfo");
710 if (s_pfn_Get_Security_Info
== NULL
)
714 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
715 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
716 ppSecurityDescriptor
));
720 get_file_security (const char *lpFileName
,
721 SECURITY_INFORMATION RequestedInformation
,
722 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
724 LPDWORD lpnLengthNeeded
)
726 static GetFileSecurityA_Proc s_pfn_Get_File_SecurityA
= NULL
;
727 static GetFileSecurityW_Proc s_pfn_Get_File_SecurityW
= NULL
;
728 HMODULE hm_advapi32
= NULL
;
729 if (is_windows_9x () == TRUE
)
734 if (w32_unicode_filenames
)
736 wchar_t filename_w
[MAX_PATH
];
738 if (g_b_init_get_file_security_w
== 0)
740 g_b_init_get_file_security_w
= 1;
741 hm_advapi32
= LoadLibrary ("Advapi32.dll");
742 s_pfn_Get_File_SecurityW
=
743 (GetFileSecurityW_Proc
) GetProcAddress (hm_advapi32
,
746 if (s_pfn_Get_File_SecurityW
== NULL
)
751 filename_to_utf16 (lpFileName
, filename_w
);
752 return (s_pfn_Get_File_SecurityW (filename_w
, RequestedInformation
,
753 pSecurityDescriptor
, nLength
,
758 char filename_a
[MAX_PATH
];
760 if (g_b_init_get_file_security_a
== 0)
762 g_b_init_get_file_security_a
= 1;
763 hm_advapi32
= LoadLibrary ("Advapi32.dll");
764 s_pfn_Get_File_SecurityA
=
765 (GetFileSecurityA_Proc
) GetProcAddress (hm_advapi32
,
768 if (s_pfn_Get_File_SecurityA
== NULL
)
773 filename_to_ansi (lpFileName
, filename_a
);
774 return (s_pfn_Get_File_SecurityA (filename_a
, RequestedInformation
,
775 pSecurityDescriptor
, nLength
,
781 set_file_security (const char *lpFileName
,
782 SECURITY_INFORMATION SecurityInformation
,
783 PSECURITY_DESCRIPTOR pSecurityDescriptor
)
785 static SetFileSecurityW_Proc s_pfn_Set_File_SecurityW
= NULL
;
786 static SetFileSecurityA_Proc s_pfn_Set_File_SecurityA
= NULL
;
787 HMODULE hm_advapi32
= NULL
;
788 if (is_windows_9x () == TRUE
)
793 if (w32_unicode_filenames
)
795 wchar_t filename_w
[MAX_PATH
];
797 if (g_b_init_set_file_security_w
== 0)
799 g_b_init_set_file_security_w
= 1;
800 hm_advapi32
= LoadLibrary ("Advapi32.dll");
801 s_pfn_Set_File_SecurityW
=
802 (SetFileSecurityW_Proc
) GetProcAddress (hm_advapi32
,
805 if (s_pfn_Set_File_SecurityW
== NULL
)
810 filename_to_utf16 (lpFileName
, filename_w
);
811 return (s_pfn_Set_File_SecurityW (filename_w
, SecurityInformation
,
812 pSecurityDescriptor
));
816 char filename_a
[MAX_PATH
];
818 if (g_b_init_set_file_security_a
== 0)
820 g_b_init_set_file_security_a
= 1;
821 hm_advapi32
= LoadLibrary ("Advapi32.dll");
822 s_pfn_Set_File_SecurityA
=
823 (SetFileSecurityA_Proc
) GetProcAddress (hm_advapi32
,
826 if (s_pfn_Set_File_SecurityA
== NULL
)
831 filename_to_ansi (lpFileName
, filename_a
);
832 return (s_pfn_Set_File_SecurityA (filename_a
, SecurityInformation
,
833 pSecurityDescriptor
));
838 set_named_security_info (LPCTSTR lpObjectName
,
839 SE_OBJECT_TYPE ObjectType
,
840 SECURITY_INFORMATION SecurityInformation
,
846 static SetNamedSecurityInfoW_Proc s_pfn_Set_Named_Security_InfoW
= NULL
;
847 static SetNamedSecurityInfoA_Proc s_pfn_Set_Named_Security_InfoA
= NULL
;
848 HMODULE hm_advapi32
= NULL
;
849 if (is_windows_9x () == TRUE
)
854 if (w32_unicode_filenames
)
856 wchar_t filename_w
[MAX_PATH
];
858 if (g_b_init_set_named_security_info_w
== 0)
860 g_b_init_set_named_security_info_w
= 1;
861 hm_advapi32
= LoadLibrary ("Advapi32.dll");
862 s_pfn_Set_Named_Security_InfoW
=
863 (SetNamedSecurityInfoW_Proc
) GetProcAddress (hm_advapi32
,
864 "SetNamedSecurityInfoW");
866 if (s_pfn_Set_Named_Security_InfoW
== NULL
)
871 filename_to_utf16 (lpObjectName
, filename_w
);
872 return (s_pfn_Set_Named_Security_InfoW (filename_w
, ObjectType
,
873 SecurityInformation
, psidOwner
,
874 psidGroup
, pDacl
, pSacl
));
878 char filename_a
[MAX_PATH
];
880 if (g_b_init_set_named_security_info_a
== 0)
882 g_b_init_set_named_security_info_a
= 1;
883 hm_advapi32
= LoadLibrary ("Advapi32.dll");
884 s_pfn_Set_Named_Security_InfoA
=
885 (SetNamedSecurityInfoA_Proc
) GetProcAddress (hm_advapi32
,
886 "SetNamedSecurityInfoA");
888 if (s_pfn_Set_Named_Security_InfoA
== NULL
)
893 filename_to_ansi (lpObjectName
, filename_a
);
894 return (s_pfn_Set_Named_Security_InfoA (filename_a
, ObjectType
,
895 SecurityInformation
, psidOwner
,
896 psidGroup
, pDacl
, pSacl
));
901 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
903 LPBOOL lpbOwnerDefaulted
)
905 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
906 HMODULE hm_advapi32
= NULL
;
907 if (is_windows_9x () == TRUE
)
912 if (g_b_init_get_security_descriptor_owner
== 0)
914 g_b_init_get_security_descriptor_owner
= 1;
915 hm_advapi32
= LoadLibrary ("Advapi32.dll");
916 s_pfn_Get_Security_Descriptor_Owner
=
917 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
918 hm_advapi32
, "GetSecurityDescriptorOwner");
920 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
925 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
930 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
932 LPBOOL lpbGroupDefaulted
)
934 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
935 HMODULE hm_advapi32
= NULL
;
936 if (is_windows_9x () == TRUE
)
941 if (g_b_init_get_security_descriptor_group
== 0)
943 g_b_init_get_security_descriptor_group
= 1;
944 hm_advapi32
= LoadLibrary ("Advapi32.dll");
945 s_pfn_Get_Security_Descriptor_Group
=
946 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
947 hm_advapi32
, "GetSecurityDescriptorGroup");
949 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
954 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
959 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
960 LPBOOL lpbDaclPresent
,
962 LPBOOL lpbDaclDefaulted
)
964 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl
= NULL
;
965 HMODULE hm_advapi32
= NULL
;
966 if (is_windows_9x () == TRUE
)
971 if (g_b_init_get_security_descriptor_dacl
== 0)
973 g_b_init_get_security_descriptor_dacl
= 1;
974 hm_advapi32
= LoadLibrary ("Advapi32.dll");
975 s_pfn_Get_Security_Descriptor_Dacl
=
976 (GetSecurityDescriptorDacl_Proc
) GetProcAddress (
977 hm_advapi32
, "GetSecurityDescriptorDacl");
979 if (s_pfn_Get_Security_Descriptor_Dacl
== NULL
)
984 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor
,
985 lpbDaclPresent
, pDacl
,
990 is_valid_sid (PSID sid
)
992 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
993 HMODULE hm_advapi32
= NULL
;
994 if (is_windows_9x () == TRUE
)
998 if (g_b_init_is_valid_sid
== 0)
1000 g_b_init_is_valid_sid
= 1;
1001 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1002 s_pfn_Is_Valid_Sid
=
1003 (IsValidSid_Proc
) GetProcAddress (
1004 hm_advapi32
, "IsValidSid");
1006 if (s_pfn_Is_Valid_Sid
== NULL
)
1010 return (s_pfn_Is_Valid_Sid (sid
));
1014 equal_sid (PSID sid1
, PSID sid2
)
1016 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
1017 HMODULE hm_advapi32
= NULL
;
1018 if (is_windows_9x () == TRUE
)
1022 if (g_b_init_equal_sid
== 0)
1024 g_b_init_equal_sid
= 1;
1025 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1027 (EqualSid_Proc
) GetProcAddress (
1028 hm_advapi32
, "EqualSid");
1030 if (s_pfn_Equal_Sid
== NULL
)
1034 return (s_pfn_Equal_Sid (sid1
, sid2
));
1038 get_length_sid (PSID sid
)
1040 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
1041 HMODULE hm_advapi32
= NULL
;
1042 if (is_windows_9x () == TRUE
)
1046 if (g_b_init_get_length_sid
== 0)
1048 g_b_init_get_length_sid
= 1;
1049 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1050 s_pfn_Get_Length_Sid
=
1051 (GetLengthSid_Proc
) GetProcAddress (
1052 hm_advapi32
, "GetLengthSid");
1054 if (s_pfn_Get_Length_Sid
== NULL
)
1058 return (s_pfn_Get_Length_Sid (sid
));
1062 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
1064 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
1065 HMODULE hm_advapi32
= NULL
;
1066 if (is_windows_9x () == TRUE
)
1070 if (g_b_init_copy_sid
== 0)
1072 g_b_init_copy_sid
= 1;
1073 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1075 (CopySid_Proc
) GetProcAddress (
1076 hm_advapi32
, "CopySid");
1078 if (s_pfn_Copy_Sid
== NULL
)
1082 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
1086 END: Wrapper functions around OpenProcessToken
1087 and other functions in advapi32.dll that are only
1088 supported in Windows NT / 2k / XP
1092 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
1094 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
1095 if (is_windows_9x () != TRUE
)
1097 if (g_b_init_get_native_system_info
== 0)
1099 g_b_init_get_native_system_info
= 1;
1100 s_pfn_Get_Native_System_Info
=
1101 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1102 "GetNativeSystemInfo");
1104 if (s_pfn_Get_Native_System_Info
!= NULL
)
1105 s_pfn_Get_Native_System_Info (lpSystemInfo
);
1108 lpSystemInfo
->dwNumberOfProcessors
= -1;
1112 get_system_times (LPFILETIME lpIdleTime
,
1113 LPFILETIME lpKernelTime
,
1114 LPFILETIME lpUserTime
)
1116 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
1117 if (is_windows_9x () == TRUE
)
1121 if (g_b_init_get_system_times
== 0)
1123 g_b_init_get_system_times
= 1;
1124 s_pfn_Get_System_times
=
1125 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1128 if (s_pfn_Get_System_times
== NULL
)
1130 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
1133 static BOOLEAN WINAPI
1134 create_symbolic_link (LPCSTR lpSymlinkFilename
,
1135 LPCSTR lpTargetFileName
,
1138 static CreateSymbolicLinkW_Proc s_pfn_Create_Symbolic_LinkW
= NULL
;
1139 static CreateSymbolicLinkA_Proc s_pfn_Create_Symbolic_LinkA
= NULL
;
1142 if (is_windows_9x () == TRUE
)
1147 if (w32_unicode_filenames
)
1149 wchar_t symfn_w
[MAX_PATH
], tgtfn_w
[MAX_PATH
];
1151 if (g_b_init_create_symbolic_link_w
== 0)
1153 g_b_init_create_symbolic_link_w
= 1;
1154 s_pfn_Create_Symbolic_LinkW
=
1155 (CreateSymbolicLinkW_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1156 "CreateSymbolicLinkW");
1158 if (s_pfn_Create_Symbolic_LinkW
== NULL
)
1164 filename_to_utf16 (lpSymlinkFilename
, symfn_w
);
1165 filename_to_utf16 (lpTargetFileName
, tgtfn_w
);
1166 retval
= s_pfn_Create_Symbolic_LinkW (symfn_w
, tgtfn_w
, dwFlags
);
1167 /* If we were denied creation of the symlink, try again after
1168 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1171 TOKEN_PRIVILEGES priv_current
;
1173 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
,
1176 retval
= s_pfn_Create_Symbolic_LinkW (symfn_w
, tgtfn_w
, dwFlags
);
1177 restore_privilege (&priv_current
);
1184 char symfn_a
[MAX_PATH
], tgtfn_a
[MAX_PATH
];
1186 if (g_b_init_create_symbolic_link_a
== 0)
1188 g_b_init_create_symbolic_link_a
= 1;
1189 s_pfn_Create_Symbolic_LinkA
=
1190 (CreateSymbolicLinkA_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1191 "CreateSymbolicLinkA");
1193 if (s_pfn_Create_Symbolic_LinkA
== NULL
)
1199 filename_to_ansi (lpSymlinkFilename
, symfn_a
);
1200 filename_to_ansi (lpTargetFileName
, tgtfn_a
);
1201 retval
= s_pfn_Create_Symbolic_LinkA (symfn_a
, tgtfn_a
, dwFlags
);
1202 /* If we were denied creation of the symlink, try again after
1203 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1206 TOKEN_PRIVILEGES priv_current
;
1208 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
,
1211 retval
= s_pfn_Create_Symbolic_LinkA (symfn_a
, tgtfn_a
, dwFlags
);
1212 restore_privilege (&priv_current
);
1221 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor
)
1223 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc
= NULL
;
1225 if (is_windows_9x () == TRUE
)
1231 if (g_b_init_is_valid_security_descriptor
== 0)
1233 g_b_init_is_valid_security_descriptor
= 1;
1234 s_pfn_Is_Valid_Security_Descriptor_Proc
=
1235 (IsValidSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1236 "IsValidSecurityDescriptor");
1238 if (s_pfn_Is_Valid_Security_Descriptor_Proc
== NULL
)
1244 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor
);
1248 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor
,
1249 DWORD RequestedStringSDRevision
,
1250 SECURITY_INFORMATION SecurityInformation
,
1251 LPTSTR
*StringSecurityDescriptor
,
1252 PULONG StringSecurityDescriptorLen
)
1254 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL
= NULL
;
1257 if (is_windows_9x () == TRUE
)
1263 if (g_b_init_convert_sd_to_sddl
== 0)
1265 g_b_init_convert_sd_to_sddl
= 1;
1267 s_pfn_Convert_SD_To_SDDL
=
1268 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1269 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1271 s_pfn_Convert_SD_To_SDDL
=
1272 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1273 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1276 if (s_pfn_Convert_SD_To_SDDL
== NULL
)
1282 retval
= s_pfn_Convert_SD_To_SDDL (SecurityDescriptor
,
1283 RequestedStringSDRevision
,
1284 SecurityInformation
,
1285 StringSecurityDescriptor
,
1286 StringSecurityDescriptorLen
);
1292 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor
,
1293 DWORD StringSDRevision
,
1294 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
1295 PULONG SecurityDescriptorSize
)
1297 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD
= NULL
;
1300 if (is_windows_9x () == TRUE
)
1306 if (g_b_init_convert_sddl_to_sd
== 0)
1308 g_b_init_convert_sddl_to_sd
= 1;
1310 s_pfn_Convert_SDDL_To_SD
=
1311 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1312 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1314 s_pfn_Convert_SDDL_To_SD
=
1315 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1316 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1319 if (s_pfn_Convert_SDDL_To_SD
== NULL
)
1325 retval
= s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor
,
1328 SecurityDescriptorSize
);
1334 get_adapters_info (PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
1336 static GetAdaptersInfo_Proc s_pfn_Get_Adapters_Info
= NULL
;
1337 HMODULE hm_iphlpapi
= NULL
;
1339 if (is_windows_9x () == TRUE
)
1340 return ERROR_NOT_SUPPORTED
;
1342 if (g_b_init_get_adapters_info
== 0)
1344 g_b_init_get_adapters_info
= 1;
1345 hm_iphlpapi
= LoadLibrary ("Iphlpapi.dll");
1347 s_pfn_Get_Adapters_Info
= (GetAdaptersInfo_Proc
)
1348 GetProcAddress (hm_iphlpapi
, "GetAdaptersInfo");
1350 if (s_pfn_Get_Adapters_Info
== NULL
)
1351 return ERROR_NOT_SUPPORTED
;
1352 return s_pfn_Get_Adapters_Info (pAdapterInfo
, pOutBufLen
);
1357 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1358 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1360 This is called from alloc.c:valid_pointer_p. */
1362 w32_valid_pointer_p (void *p
, int size
)
1365 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
1369 unsigned char *buf
= alloca (size
);
1370 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
1381 /* Here's an overview of how the Windows build supports file names
1382 that cannot be encoded by the current system codepage.
1384 From the POV of Lisp and layers of C code above the functions here,
1385 Emacs on Windows pretends that its file names are encoded in UTF-8;
1386 see encode_file and decode_file on coding.c. Any file name that is
1387 passed as a unibyte string to C functions defined here is assumed
1388 to be in UTF-8 encoding. Any file name returned by functions
1389 defined here must be in UTF-8 encoding, with only a few exceptions
1390 reserved for a couple of special cases. (Be sure to use
1391 MAX_UTF8_PATH for char arrays that store UTF-8 encoded file names,
1392 as they can be much longer than MAX_PATH!)
1394 The UTF-8 encoded file names cannot be passed to system APIs, as
1395 Windows does not support that. Therefore, they are converted
1396 either to UTF-16 or to the ANSI codepage, depending on the value of
1397 w32-unicode-filenames, before calling any system APIs or CRT library
1398 functions. The default value of that variable is determined by the
1399 OS on which Emacs runs: nil on Windows 9X and t otherwise, but the
1400 user can change that default (although I don't see why would she
1403 The 4 functions defined below, filename_to_utf16, filename_to_ansi,
1404 filename_from_utf16, and filename_from_ansi, are the workhorses of
1405 these conversions. They rely on Windows native APIs
1406 MultiByteToWideChar and WideCharToMultiByte; we cannot use
1407 functions from coding.c here, because they allocate memory, which
1408 is a bad idea on the level of libc, which is what the functions
1409 here emulate. (If you worry about performance due to constant
1410 conversion back and forth from UTF-8 to UTF-16, then don't: first,
1411 it was measured to take only a few microseconds on a not-so-fast
1412 machine, and second, that's exactly what the ANSI APIs we used
1413 before did anyway, because they are just thin wrappers around the
1416 The variables file-name-coding-system and default-file-name-coding-system
1417 still exist, but are actually used only when a file name needs to
1418 be converted to the ANSI codepage. This happens all the time when
1419 w32-unicode-filenames is nil, but can also happen from time to time
1420 when it is t. Otherwise, these variables have no effect on file-name
1421 encoding when w32-unicode-filenames is t; this is similar to
1422 selection-coding-system.
1424 This arrangement works very well, but it has a few gotchas and
1427 . Lisp code that encodes or decodes file names manually should
1428 normally use 'utf-8' as the coding-system on Windows,
1429 disregarding file-name-coding-system. This is a somewhat
1430 unpleasant consequence, but it cannot be avoided. Fortunately,
1431 very few Lisp packages need to do that.
1433 More generally, passing to library functions (e.g., fopen or
1434 opendir) file names already encoded in the ANSI codepage is
1435 explicitly *verboten*, as all those functions, as shadowed and
1436 emulated here, assume they will receive UTF-8 encoded file names.
1438 For the same reasons, no CRT function or Win32 API can be called
1439 directly in Emacs sources, without either converting the file
1440 names from UTF-8 to UTF-16 or ANSI codepage, or going through
1441 some shadowing function defined here.
1443 . Environment variables stored in Vprocess_environment are encoded
1444 in the ANSI codepage, so if getenv/egetenv is used for a variable
1445 whose value is a file name or a list of directories, it needs to
1446 be converted to UTF-8, before it is used as argument to functions
1447 or decoded into a Lisp string.
1449 . File names passed to external libraries, like the image libraries
1450 and GnuTLS, need special handling. These libraries generally
1451 don't support UTF-16 or UTF-8 file names, so they must get file
1452 names encoded in the ANSI codepage. To facilitate using these
1453 libraries with file names that are not encodable in the ANSI
1454 codepage, use the function ansi_encode_filename, which will try
1455 to use the short 8+3 alias of a file name if that file name is
1456 not encodable in the ANSI codepage. See image.c and gnutls.c for
1457 examples of how this should be done.
1459 . Running subprocesses in non-ASCII directories and with non-ASCII
1460 file arguments is limited to the current codepage (even though
1461 Emacs is perfectly capable of finding an executable program file
1462 in a directory whose name cannot be encoded in the current
1463 codepage). This is because the command-line arguments are
1464 encoded _before_ they get to the w32-specific level, and the
1465 encoding is not known in advance (it doesn't have to be the
1466 current ANSI codepage), so w32proc.c functions cannot re-encode
1467 them in UTF-16. This should be fixed, but will also require
1468 changes in cmdproxy. The current limitation is not terribly bad
1469 anyway, since very few, if any, Windows console programs that are
1470 likely to be invoked by Emacs support UTF-16 encoded command
1473 . For similar reasons, server.el and emacsclient are also limited
1474 to the current ANSI codepage for now.
1476 . Emacs itself can only handle command-line arguments encoded in
1477 the current codepage.
1479 . Turning on w32-unicode-filename on Windows 9X (if it at all
1480 works) requires UNICOWS.DLL, which is thus a requirement even in
1481 non-GUI sessions, something the we previously avoided. */
1485 /* Converting file names from UTF-8 to either UTF-16 or the ANSI
1486 codepage defined by file-name-coding-system. */
1488 /* Current codepage for encoding file names. */
1489 static int file_name_codepage
;
1491 /* Produce a Windows ANSI codepage suitable for encoding file names.
1492 Return the information about that codepage in CP_INFO. */
1494 codepage_for_filenames (CPINFO
*cp_info
)
1496 /* A simple cache to avoid calling GetCPInfo every time we need to
1497 encode/decode a file name. The file-name encoding is not
1498 supposed to be changed too frequently, if ever. */
1499 static Lisp_Object last_file_name_encoding
;
1501 Lisp_Object current_encoding
;
1503 current_encoding
= Vfile_name_coding_system
;
1504 if (NILP (current_encoding
))
1505 current_encoding
= Vdefault_file_name_coding_system
;
1507 if (!EQ (last_file_name_encoding
, current_encoding
))
1509 /* Default to the current ANSI codepage. */
1510 file_name_codepage
= w32_ansi_code_page
;
1512 if (NILP (current_encoding
))
1514 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1515 char *cp
= NULL
, *end
;
1518 if (strncmp (cpname
, "cp", 2) == 0)
1520 else if (strncmp (cpname
, "windows-", 8) == 0)
1526 cpnum
= strtol (cp
, &end
, 10);
1527 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1528 file_name_codepage
= cpnum
;
1532 if (!file_name_codepage
)
1533 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1535 if (!GetCPInfo (file_name_codepage
, &cp
))
1537 file_name_codepage
= CP_ACP
;
1538 if (!GetCPInfo (file_name_codepage
, &cp
))
1545 return file_name_codepage
;
1549 filename_to_utf16 (const char *fn_in
, wchar_t *fn_out
)
1551 int result
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1556 DWORD err
= GetLastError ();
1560 case ERROR_INVALID_FLAGS
:
1561 case ERROR_INVALID_PARAMETER
:
1564 case ERROR_INSUFFICIENT_BUFFER
:
1565 case ERROR_NO_UNICODE_TRANSLATION
:
1576 filename_from_utf16 (const wchar_t *fn_in
, char *fn_out
)
1578 int result
= pWideCharToMultiByte (CP_UTF8
, 0, fn_in
, -1,
1579 fn_out
, MAX_UTF8_PATH
, NULL
, NULL
);
1583 DWORD err
= GetLastError ();
1587 case ERROR_INVALID_FLAGS
:
1588 case ERROR_INVALID_PARAMETER
:
1591 case ERROR_INSUFFICIENT_BUFFER
:
1592 case ERROR_NO_UNICODE_TRANSLATION
:
1603 filename_to_ansi (const char *fn_in
, char *fn_out
)
1605 wchar_t fn_utf16
[MAX_PATH
];
1607 if (filename_to_utf16 (fn_in
, fn_utf16
) == 0)
1610 int codepage
= codepage_for_filenames (NULL
);
1612 result
= pWideCharToMultiByte (codepage
, 0, fn_utf16
, -1,
1613 fn_out
, MAX_PATH
, NULL
, NULL
);
1616 DWORD err
= GetLastError ();
1620 case ERROR_INVALID_FLAGS
:
1621 case ERROR_INVALID_PARAMETER
:
1624 case ERROR_INSUFFICIENT_BUFFER
:
1625 case ERROR_NO_UNICODE_TRANSLATION
:
1638 filename_from_ansi (const char *fn_in
, char *fn_out
)
1640 wchar_t fn_utf16
[MAX_PATH
];
1641 int codepage
= codepage_for_filenames (NULL
);
1642 int result
= pMultiByteToWideChar (codepage
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1643 fn_utf16
, MAX_PATH
);
1647 DWORD err
= GetLastError ();
1651 case ERROR_INVALID_FLAGS
:
1652 case ERROR_INVALID_PARAMETER
:
1655 case ERROR_INSUFFICIENT_BUFFER
:
1656 case ERROR_NO_UNICODE_TRANSLATION
:
1663 return filename_from_utf16 (fn_utf16
, fn_out
);
1668 /* The directory where we started, in UTF-8. */
1669 static char startup_dir
[MAX_UTF8_PATH
];
1671 /* Get the current working directory. */
1673 getcwd (char *dir
, int dirsize
)
1680 if (dirsize
<= strlen (startup_dir
))
1686 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
1690 /* Emacs doesn't actually change directory itself, it stays in the
1691 same directory where it was started. */
1692 strcpy (dir
, startup_dir
);
1697 /* Emulate getloadavg. */
1699 struct load_sample
{
1706 /* Number of processors on this machine. */
1707 static unsigned num_of_processors
;
1709 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1710 static struct load_sample samples
[16*60];
1711 static int first_idx
= -1, last_idx
= -1;
1712 static int max_idx
= ARRAYELTS (samples
);
1717 int next_idx
= from
+ 1;
1719 if (next_idx
>= max_idx
)
1728 int prev_idx
= from
- 1;
1731 prev_idx
= max_idx
- 1;
1737 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
1739 SYSTEM_INFO sysinfo
;
1740 FILETIME ft_idle
, ft_user
, ft_kernel
;
1742 /* Initialize the number of processors on this machine. */
1743 if (num_of_processors
<= 0)
1745 get_native_system_info (&sysinfo
);
1746 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1747 if (num_of_processors
<= 0)
1749 GetSystemInfo (&sysinfo
);
1750 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1752 if (num_of_processors
<= 0)
1753 num_of_processors
= 1;
1756 /* TODO: Take into account threads that are ready to run, by
1757 sampling the "\System\Processor Queue Length" performance
1758 counter. The code below accounts only for threads that are
1759 actually running. */
1761 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1763 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1765 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1766 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1767 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1768 *idle
= uidle
.QuadPart
;
1769 *kernel
= ukernel
.QuadPart
;
1770 *user
= uuser
.QuadPart
;
1780 /* Produce the load average for a given time interval, using the
1781 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1782 1-minute, 5-minute, or 15-minute average, respectively. */
1786 double retval
= -1.0;
1789 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1790 time_t now
= samples
[last_idx
].sample_time
;
1792 if (first_idx
!= last_idx
)
1794 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1796 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1797 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1800 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1801 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1802 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1804 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1807 if (idx
== first_idx
)
1816 getloadavg (double loadavg
[], int nelem
)
1819 ULONGLONG idle
, kernel
, user
;
1820 time_t now
= time (NULL
);
1822 /* If system time jumped back for some reason, delete all samples
1823 whose time is later than the current wall-clock time. This
1824 prevents load average figures from becoming frozen for prolonged
1825 periods of time, when system time is reset backwards. */
1828 while (difftime (now
, samples
[last_idx
].sample_time
) < -1.0)
1830 if (last_idx
== first_idx
)
1832 first_idx
= last_idx
= -1;
1835 last_idx
= buf_prev (last_idx
);
1839 /* Store another sample. We ignore samples that are less than 1 sec
1842 || (difftime (now
, samples
[last_idx
].sample_time
)
1843 >= 1.0 - 2*DBL_EPSILON
*now
))
1845 sample_system_load (&idle
, &kernel
, &user
);
1846 last_idx
= buf_next (last_idx
);
1847 samples
[last_idx
].sample_time
= now
;
1848 samples
[last_idx
].idle
= idle
;
1849 samples
[last_idx
].kernel
= kernel
;
1850 samples
[last_idx
].user
= user
;
1851 /* If the buffer has more that 15 min worth of samples, discard
1853 if (first_idx
== -1)
1854 first_idx
= last_idx
;
1855 while (first_idx
!= last_idx
1856 && (difftime (now
, samples
[first_idx
].sample_time
)
1857 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1858 first_idx
= buf_next (first_idx
);
1861 for (elem
= 0; elem
< nelem
; elem
++)
1863 double avg
= getavg (elem
);
1867 loadavg
[elem
] = avg
;
1873 /* Emulate getpwuid, getpwnam and others. */
1875 #define PASSWD_FIELD_SIZE 256
1877 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1878 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1879 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1880 static char dflt_passwd_dir
[MAX_UTF8_PATH
];
1881 static char dflt_passwd_shell
[MAX_UTF8_PATH
];
1883 static struct passwd dflt_passwd
=
1895 static char dflt_group_name
[GNLEN
+1];
1897 static struct group dflt_group
=
1899 /* When group information is not available, we return this as the
1900 group for all files. */
1908 return dflt_passwd
.pw_uid
;
1914 /* I could imagine arguing for checking to see whether the user is
1915 in the Administrators group and returning a UID of 0 for that
1916 case, but I don't know how wise that would be in the long run. */
1923 return dflt_passwd
.pw_gid
;
1933 getpwuid (unsigned uid
)
1935 if (uid
== dflt_passwd
.pw_uid
)
1936 return &dflt_passwd
;
1941 getgrgid (gid_t gid
)
1947 getpwnam (char *name
)
1951 pw
= getpwuid (getuid ());
1955 if (xstrcasecmp (name
, pw
->pw_name
))
1962 init_user_info (void)
1964 /* Find the user's real name by opening the process token and
1965 looking up the name associated with the user-sid in that token.
1967 Use the relative portion of the identifier authority value from
1968 the user-sid as the user id value (same for group id using the
1969 primary group sid from the process token). */
1971 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1972 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1973 DWORD glength
= sizeof (gname
);
1974 HANDLE token
= NULL
;
1975 SID_NAME_USE user_type
;
1976 unsigned char *buf
= NULL
;
1978 TOKEN_USER user_token
;
1979 TOKEN_PRIMARY_GROUP group_token
;
1982 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1985 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1986 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1988 buf
= xmalloc (blen
);
1989 result
= get_token_information (token
, TokenUser
,
1990 (LPVOID
)buf
, blen
, &needed
);
1993 memcpy (&user_token
, buf
, sizeof (user_token
));
1994 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1996 domain
, &dlength
, &user_type
);
2004 strcpy (dflt_passwd
.pw_name
, uname
);
2005 /* Determine a reasonable uid value. */
2006 if (xstrcasecmp ("administrator", uname
) == 0)
2008 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
2009 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
2013 /* Use the last sub-authority value of the RID, the relative
2014 portion of the SID, as user/group ID. */
2015 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
2017 /* Get group id and name. */
2018 result
= get_token_information (token
, TokenPrimaryGroup
,
2019 (LPVOID
)buf
, blen
, &needed
);
2020 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
2022 buf
= xrealloc (buf
, blen
= needed
);
2023 result
= get_token_information (token
, TokenPrimaryGroup
,
2024 (LPVOID
)buf
, blen
, &needed
);
2028 memcpy (&group_token
, buf
, sizeof (group_token
));
2029 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
2030 dlength
= sizeof (domain
);
2031 /* If we can get at the real Primary Group name, use that.
2032 Otherwise, the default group name was already set to
2033 "None" in globals_of_w32. */
2034 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
2035 gname
, &glength
, NULL
, &dlength
,
2037 strcpy (dflt_group_name
, gname
);
2040 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
2043 /* If security calls are not supported (presumably because we
2044 are running under Windows 9X), fallback to this: */
2045 else if (GetUserName (uname
, &ulength
))
2047 strcpy (dflt_passwd
.pw_name
, uname
);
2048 if (xstrcasecmp ("administrator", uname
) == 0)
2049 dflt_passwd
.pw_uid
= 0;
2051 dflt_passwd
.pw_uid
= 123;
2052 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
2056 strcpy (dflt_passwd
.pw_name
, "unknown");
2057 dflt_passwd
.pw_uid
= 123;
2058 dflt_passwd
.pw_gid
= 123;
2060 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
2062 /* Set dir and shell from environment variables. */
2063 if (w32_unicode_filenames
)
2065 wchar_t *home
= _wgetenv (L
"HOME");
2066 wchar_t *shell
= _wgetenv (L
"SHELL");
2068 /* Ensure HOME and SHELL are defined. */
2073 filename_from_utf16 (home
, dflt_passwd
.pw_dir
);
2074 filename_from_utf16 (shell
, dflt_passwd
.pw_shell
);
2078 char *home
= getenv ("HOME");
2079 char *shell
= getenv ("SHELL");
2085 filename_from_ansi (home
, dflt_passwd
.pw_dir
);
2086 filename_from_ansi (shell
, dflt_passwd
.pw_shell
);
2091 CloseHandle (token
);
2097 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
2098 return ((rand () << 15) | rand ());
2107 /* Return the maximum length in bytes of a multibyte character
2108 sequence encoded in the current ANSI codepage. This is required to
2109 correctly walk the encoded file names one character at a time. */
2111 max_filename_mbslen (void)
2115 codepage_for_filenames (&cp_info
);
2116 return cp_info
.MaxCharSize
;
2119 /* Normalize filename by converting in-place all of its path
2120 separators to the separator specified by PATH_SEP. */
2123 normalize_filename (register char *fp
, char path_sep
)
2127 /* Always lower-case drive letters a-z, even if the filesystem
2128 preserves case in filenames.
2129 This is so filenames can be compared by string comparison
2130 functions that are case-sensitive. Even case-preserving filesystems
2131 do not distinguish case in drive letters. */
2134 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
2142 if ((*fp
== '/' || *fp
== '\\') && *fp
!= path_sep
)
2148 /* Destructively turn backslashes into slashes. */
2150 dostounix_filename (register char *p
)
2152 normalize_filename (p
, '/');
2155 /* Destructively turn slashes into backslashes. */
2157 unixtodos_filename (register char *p
)
2159 normalize_filename (p
, '\\');
2162 /* Remove all CR's that are followed by a LF.
2163 (From msdos.c...probably should figure out a way to share it,
2164 although this code isn't going to ever change.) */
2166 crlf_to_lf (register int n
, register unsigned char *buf
)
2168 unsigned char *np
= buf
;
2169 unsigned char *startp
= buf
;
2170 unsigned char *endp
= buf
+ n
;
2174 while (buf
< endp
- 1)
2178 if (*(++buf
) != 0x0a)
2189 /* Parse the root part of file name, if present. Return length and
2190 optionally store pointer to char after root. */
2192 parse_root (const char * name
, const char ** pPath
)
2194 const char * start
= name
;
2199 /* find the root name of the volume if given */
2200 if (isalpha (name
[0]) && name
[1] == ':')
2202 /* skip past drive specifier */
2204 if (IS_DIRECTORY_SEP (name
[0]))
2207 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2214 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2219 if (IS_DIRECTORY_SEP (name
[0]))
2226 return name
- start
;
2229 /* Get long base name for name; name is assumed to be absolute. */
2231 get_long_basename (char * name
, char * buf
, int size
)
2233 HANDLE dir_handle
= INVALID_HANDLE_VALUE
;
2234 char fname_utf8
[MAX_UTF8_PATH
];
2238 /* Must be valid filename, no wild cards or other invalid characters. */
2239 if (strpbrk (name
, "*?|<>\""))
2242 if (w32_unicode_filenames
)
2244 wchar_t fname_utf16
[MAX_PATH
];
2245 WIN32_FIND_DATAW find_data_wide
;
2247 filename_to_utf16 (name
, fname_utf16
);
2248 dir_handle
= FindFirstFileW (fname_utf16
, &find_data_wide
);
2249 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2250 cstatus
= filename_from_utf16 (find_data_wide
.cFileName
, fname_utf8
);
2254 char fname_ansi
[MAX_PATH
];
2255 WIN32_FIND_DATAA find_data_ansi
;
2257 filename_to_ansi (name
, fname_ansi
);
2258 /* If the ANSI name includes ? characters, it is not encodable
2259 in the ANSI codepage. In that case, we deliver the question
2260 marks to the caller; calling FindFirstFileA in this case
2261 could return some unrelated file name in the same
2263 if (_mbspbrk (fname_ansi
, "?"))
2265 /* Find the basename of fname_ansi. */
2266 char *p
= strrchr (fname_ansi
, '\\');
2272 cstatus
= filename_from_ansi (p
, fname_utf8
);
2276 dir_handle
= FindFirstFileA (fname_ansi
, &find_data_ansi
);
2277 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2278 cstatus
= filename_from_ansi (find_data_ansi
.cFileName
, fname_utf8
);
2282 if (cstatus
== 0 && (len
= strlen (fname_utf8
)) < size
)
2283 memcpy (buf
, fname_utf8
, len
+ 1);
2287 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2288 FindClose (dir_handle
);
2293 /* Get long name for file, if possible (assumed to be absolute). */
2295 w32_get_long_filename (char * name
, char * buf
, int size
)
2300 char full
[ MAX_UTF8_PATH
];
2303 len
= strlen (name
);
2304 if (len
>= MAX_UTF8_PATH
)
2307 /* Use local copy for destructive modification. */
2308 memcpy (full
, name
, len
+1);
2309 unixtodos_filename (full
);
2311 /* Copy root part verbatim. */
2312 len
= parse_root (full
, (const char **)&p
);
2313 memcpy (o
, full
, len
);
2318 while (p
!= NULL
&& *p
)
2321 p
= strchr (q
, '\\');
2323 len
= get_long_basename (full
, o
, size
);
2346 w32_get_short_filename (char * name
, char * buf
, int size
)
2348 if (w32_unicode_filenames
)
2350 wchar_t name_utf16
[MAX_PATH
], short_name
[MAX_PATH
];
2351 unsigned int retval
;
2353 filename_to_utf16 (name
, name_utf16
);
2354 retval
= GetShortPathNameW (name_utf16
, short_name
, size
);
2355 if (retval
&& retval
< size
)
2356 filename_from_utf16 (short_name
, buf
);
2361 char name_ansi
[MAX_PATH
];
2363 filename_to_ansi (name
, name_ansi
);
2364 return GetShortPathNameA (name_ansi
, buf
, size
);
2368 /* Re-encode FILENAME, a UTF-8 encoded unibyte string, using the
2369 MS-Windows ANSI codepage. If FILENAME includes characters not
2370 supported by the ANSI codepage, return the 8+3 alias of FILENAME,
2371 if it exists. This is needed because the w32 build wants to
2372 support file names outside of the system locale, but image
2373 libraries typically don't support wide (a.k.a. "Unicode") APIs
2374 required for that. */
2377 ansi_encode_filename (Lisp_Object filename
)
2379 Lisp_Object encoded_filename
;
2380 char fname
[MAX_PATH
];
2382 filename_to_ansi (SSDATA (filename
), fname
);
2383 if (_mbspbrk (fname
, "?"))
2385 char shortname
[MAX_PATH
];
2387 if (w32_get_short_filename (SDATA (filename
), shortname
, MAX_PATH
))
2389 dostounix_filename (shortname
);
2390 encoded_filename
= build_string (shortname
);
2394 encoded_filename
= build_unibyte_string (fname
);
2395 return encoded_filename
;
2399 is_unc_volume (const char *filename
)
2401 const char *ptr
= filename
;
2403 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
2406 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
2412 /* Emulate the Posix unsetenv. */
2414 unsetenv (const char *name
)
2419 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
2424 name_len
= strlen (name
);
2425 /* MS docs says an environment variable cannot be longer than 32K. */
2426 if (name_len
> 32767)
2431 /* It is safe to use 'alloca' with 32K size, since the stack is at
2432 least 2MB, and we set it to 8MB in the link command line. */
2433 var
= alloca (name_len
+ 2);
2434 strncpy (var
, name
, name_len
);
2435 var
[name_len
++] = '=';
2436 var
[name_len
] = '\0';
2437 return _putenv (var
);
2440 /* MS _putenv doesn't support removing a variable when the argument
2441 does not include the '=' character, so we fix that here. */
2443 sys_putenv (char *str
)
2445 const char *const name_end
= strchr (str
, '=');
2447 if (name_end
== NULL
)
2449 /* Remove the variable from the environment. */
2450 return unsetenv (str
);
2453 return _putenv (str
);
2456 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
2459 w32_get_resource (char *key
, LPDWORD lpdwtype
)
2462 HKEY hrootkey
= NULL
;
2465 /* Check both the current user and the local machine to see if
2466 we have any resources. */
2468 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2472 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2473 && (lpvalue
= xmalloc (cbData
)) != NULL
2474 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2476 RegCloseKey (hrootkey
);
2482 RegCloseKey (hrootkey
);
2485 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2489 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2490 && (lpvalue
= xmalloc (cbData
)) != NULL
2491 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2493 RegCloseKey (hrootkey
);
2499 RegCloseKey (hrootkey
);
2505 /* The argv[] array holds ANSI-encoded strings, and so this function
2506 works with ANS_encoded strings. */
2508 init_environment (char ** argv
)
2510 static const char * const tempdirs
[] = {
2511 "$TMPDIR", "$TEMP", "$TMP", "c:/"
2516 const int imax
= ARRAYELTS (tempdirs
);
2518 /* Implementation note: This function explicitly works with ANSI
2519 file names, not with UTF-8 encoded file names. This is because
2520 this function pushes variables into the Emacs's environment, and
2521 the environment variables are always assumed to be in the
2522 locale-specific encoding. Do NOT call any functions that accept
2523 UTF-8 file names from this function! */
2525 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
2526 temporary files and assume "/tmp" if $TMPDIR is unset, which
2527 will break on DOS/Windows. Refuse to work if we cannot find
2528 a directory, not even "c:/", usable for that purpose. */
2529 for (i
= 0; i
< imax
; i
++)
2531 const char *tmp
= tempdirs
[i
];
2534 tmp
= getenv (tmp
+ 1);
2535 /* Note that `access' can lie to us if the directory resides on a
2536 read-only filesystem, like CD-ROM or a write-protected floppy.
2537 The only way to be really sure is to actually create a file and
2538 see if it succeeds. But I think that's too much to ask. */
2540 /* MSVCRT's _access crashes with D_OK, so we use our replacement. */
2541 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
2543 char * var
= alloca (strlen (tmp
) + 8);
2544 sprintf (var
, "TMPDIR=%s", tmp
);
2545 _putenv (strdup (var
));
2552 Fcons (build_string ("no usable temporary directories found!!"),
2554 "While setting TMPDIR: ");
2556 /* Check for environment variables and use registry settings if they
2557 don't exist. Fallback on default values where applicable. */
2562 char locale_name
[32];
2563 char default_home
[MAX_PATH
];
2566 static const struct env_entry
2572 /* If the default value is NULL, we will use the value from the
2573 outside environment or the Registry, but will not push the
2574 variable into the Emacs environment if it is defined neither
2575 in the Registry nor in the outside environment. */
2577 {"PRELOAD_WINSOCK", NULL
},
2578 {"emacs_dir", "C:/emacs"},
2579 {"EMACSLOADPATH", NULL
},
2580 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2581 {"EMACSDATA", NULL
},
2582 {"EMACSPATH", NULL
},
2589 #define N_ENV_VARS ARRAYELTS (dflt_envvars)
2591 /* We need to copy dflt_envvars[] and work on the copy because we
2592 don't want the dumped Emacs to inherit the values of
2593 environment variables we saw during dumping (which could be on
2594 a different system). The defaults above must be left intact. */
2595 struct env_entry env_vars
[N_ENV_VARS
];
2597 for (i
= 0; i
< N_ENV_VARS
; i
++)
2598 env_vars
[i
] = dflt_envvars
[i
];
2600 /* For backwards compatibility, check if a .emacs file exists in C:/
2601 If not, then we can try to default to the appdata directory under the
2602 user's profile, which is more likely to be writable. */
2603 if (sys_access ("C:/.emacs", F_OK
) != 0)
2605 HRESULT profile_result
;
2606 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2607 of Windows 95 and NT4 that have not been updated to include
2609 ShGetFolderPath_fn get_folder_path
;
2610 get_folder_path
= (ShGetFolderPath_fn
)
2611 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2613 if (get_folder_path
!= NULL
)
2615 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2618 /* If we can't get the appdata dir, revert to old behavior. */
2619 if (profile_result
== S_OK
)
2621 env_vars
[0].def_value
= default_home
;
2627 /* Get default locale info and use it for LANG. */
2628 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2629 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2630 locale_name
, sizeof (locale_name
)))
2632 for (i
= 0; i
< N_ENV_VARS
; i
++)
2634 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2636 env_vars
[i
].def_value
= locale_name
;
2642 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2644 /* Treat emacs_dir specially: set it unconditionally based on our
2648 char modname
[MAX_PATH
];
2650 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2652 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2656 if ((p
= _mbsrchr (modname
, '\\'))
2657 /* From bin means installed Emacs, from src means uninstalled. */
2658 && (xstrcasecmp (p
, "\\bin") == 0 || xstrcasecmp (p
, "\\src") == 0))
2660 char buf
[SET_ENV_BUF_SIZE
];
2661 int within_build_tree
= xstrcasecmp (p
, "\\src") == 0;
2664 for (p
= modname
; *p
; p
= CharNext (p
))
2665 if (*p
== '\\') *p
= '/';
2667 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2668 _putenv (strdup (buf
));
2669 /* If we are running from the Posix-like build tree, define
2670 SHELL to point to our own cmdproxy. The loop below will
2671 then disregard PATH_EXEC and the default value. */
2672 if (within_build_tree
)
2674 _snprintf (buf
, sizeof (buf
) - 1,
2675 "SHELL=%s/nt/cmdproxy.exe", modname
);
2676 _putenv (strdup (buf
));
2681 for (i
= 0; i
< N_ENV_VARS
; i
++)
2683 if (!getenv (env_vars
[i
].name
))
2686 char bufc
[SET_ENV_BUF_SIZE
];
2688 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2689 /* Also ignore empty environment variables. */
2694 if (strcmp (env_vars
[i
].name
, "SHELL") == 0)
2696 /* Look for cmdproxy.exe in every directory in
2697 PATH_EXEC. FIXME: This does not find cmdproxy
2698 in nt/ when we run uninstalled. */
2699 char fname
[MAX_PATH
];
2700 const char *pstart
= PATH_EXEC
, *pend
;
2703 pend
= _mbschr (pstart
, ';');
2705 pend
= pstart
+ strlen (pstart
);
2706 /* Be defensive against series of ;;; characters. */
2709 strncpy (fname
, pstart
, pend
- pstart
);
2710 fname
[pend
- pstart
] = '/';
2711 strcpy (&fname
[pend
- pstart
+ 1], "cmdproxy.exe");
2712 ExpandEnvironmentStrings ((LPSTR
) fname
, bufc
,
2714 if (sys_access (bufc
, F_OK
) == 0)
2727 /* If not found in any directory, use the
2728 default as the last resort. */
2729 lpval
= env_vars
[i
].def_value
;
2730 dwType
= REG_EXPAND_SZ
;
2736 lpval
= env_vars
[i
].def_value
;
2737 dwType
= REG_EXPAND_SZ
;
2739 if (strcmp (env_vars
[i
].name
, "HOME") == 0 && !appdata
)
2740 Vdelayed_warnings_list
2741 = Fcons (listn (CONSTYPE_HEAP
, 2,
2742 intern ("initialization"),
2743 build_string ("Setting HOME to C:\\ by default is deprecated")),
2744 Vdelayed_warnings_list
);
2749 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2751 if (dwType
== REG_EXPAND_SZ
)
2752 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2753 else if (dwType
== REG_SZ
)
2754 strcpy (buf1
, lpval
);
2755 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2757 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2759 _putenv (strdup (buf2
));
2769 /* Rebuild system configuration to reflect invoking system. */
2770 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2772 /* Another special case: on NT, the PATH variable is actually named
2773 "Path" although cmd.exe (perhaps NT itself) arranges for
2774 environment variable lookup and setting to be case insensitive.
2775 However, Emacs assumes a fully case sensitive environment, so we
2776 need to change "Path" to "PATH" to match the expectations of
2777 various elisp packages. We do this by the sneaky method of
2778 modifying the string in the C runtime environ entry.
2780 The same applies to COMSPEC. */
2784 for (envp
= environ
; *envp
; envp
++)
2785 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2786 memcpy (*envp
, "PATH=", 5);
2787 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2788 memcpy (*envp
, "COMSPEC=", 8);
2791 /* Remember the initial working directory for getcwd. */
2792 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2793 Does it matter anywhere in Emacs? */
2794 if (w32_unicode_filenames
)
2796 wchar_t wstartup_dir
[MAX_PATH
];
2798 if (!GetCurrentDirectoryW (MAX_PATH
, wstartup_dir
))
2800 filename_from_utf16 (wstartup_dir
, startup_dir
);
2804 char astartup_dir
[MAX_PATH
];
2806 if (!GetCurrentDirectoryA (MAX_PATH
, astartup_dir
))
2808 filename_from_ansi (astartup_dir
, startup_dir
);
2812 static char modname
[MAX_PATH
];
2814 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2819 /* Determine if there is a middle mouse button, to allow parse_button
2820 to decide whether right mouse events should be mouse-2 or
2822 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2827 /* Called from expand-file-name when default-directory is not a string. */
2830 emacs_root_dir (void)
2832 static char root_dir
[MAX_UTF8_PATH
];
2835 p
= getenv ("emacs_dir");
2838 filename_from_ansi (p
, root_dir
);
2839 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2840 dostounix_filename (root_dir
);
2844 #include <sys/timeb.h>
2846 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2848 gettimeofday (struct timeval
*__restrict tv
, struct timezone
*__restrict tz
)
2853 tv
->tv_sec
= tb
.time
;
2854 tv
->tv_usec
= tb
.millitm
* 1000L;
2855 /* Implementation note: _ftime sometimes doesn't update the dstflag
2856 according to the new timezone when the system timezone is
2857 changed. We could fix that by using GetSystemTime and
2858 GetTimeZoneInformation, but that doesn't seem necessary, since
2859 Emacs always calls gettimeofday with the 2nd argument NULL (see
2860 current_emacs_time). */
2863 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2864 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2869 /* Emulate fdutimens. */
2871 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2872 TIMESPEC[0] and TIMESPEC[1], respectively.
2873 FD must be either negative -- in which case it is ignored --
2874 or a file descriptor that is open on FILE.
2875 If FD is nonnegative, then FILE can be NULL, which means
2876 use just futimes instead of utimes.
2877 If TIMESPEC is null, FAIL.
2878 Return 0 on success, -1 (setting errno) on failure. */
2881 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2888 if (fd
< 0 && !file
)
2893 /* _futime's prototype defines 2nd arg as having the type 'struct
2894 _utimbuf', while utime needs to accept 'struct utimbuf' for
2895 compatibility with Posix. So we need to use 2 different (but
2896 equivalent) types to avoid compiler warnings, sigh. */
2899 struct _utimbuf _ut
;
2901 _ut
.actime
= timespec
[0].tv_sec
;
2902 _ut
.modtime
= timespec
[1].tv_sec
;
2903 return _futime (fd
, &_ut
);
2909 ut
.actime
= timespec
[0].tv_sec
;
2910 ut
.modtime
= timespec
[1].tv_sec
;
2911 /* Call 'utime', which is implemented below, not the MS library
2912 function, which fails on directories. */
2913 return utime (file
, &ut
);
2918 /* ------------------------------------------------------------------------- */
2919 /* IO support and wrapper functions for the Windows API. */
2920 /* ------------------------------------------------------------------------- */
2922 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2923 on network directories, so we handle that case here.
2924 (Ulrich Leodolter, 1/11/95). */
2926 sys_ctime (const time_t *t
)
2928 char *str
= (char *) ctime (t
);
2929 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2932 /* Emulate sleep...we could have done this with a define, but that
2933 would necessitate including windows.h in the files that used it.
2934 This is much easier. */
2936 sys_sleep (int seconds
)
2938 Sleep (seconds
* 1000);
2941 /* Internal MSVC functions for low-level descriptor munging */
2942 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2943 extern int __cdecl
_free_osfhnd (int fd
);
2945 /* parallel array of private info on file handles */
2946 filedesc fd_info
[ MAXDESC
];
2948 typedef struct volume_info_data
{
2949 struct volume_info_data
* next
;
2951 /* time when info was obtained */
2954 /* actual volume info */
2963 /* Global referenced by various functions. */
2964 static volume_info_data volume_info
;
2966 /* Vector to indicate which drives are local and fixed (for which cached
2967 data never expires). */
2968 static BOOL fixed_drives
[26];
2970 /* Consider cached volume information to be stale if older than 10s,
2971 at least for non-local drives. Info for fixed drives is never stale. */
2972 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2973 #define VOLINFO_STILL_VALID( root_dir, info ) \
2974 ( ( isalpha (root_dir[0]) && \
2975 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2976 || GetTickCount () - info->timestamp < 10000 )
2978 /* Cache support functions. */
2980 /* Simple linked list with linear search is sufficient. */
2981 static volume_info_data
*volume_cache
= NULL
;
2983 static volume_info_data
*
2984 lookup_volume_info (char * root_dir
)
2986 volume_info_data
* info
;
2988 for (info
= volume_cache
; info
; info
= info
->next
)
2989 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2995 add_volume_info (char * root_dir
, volume_info_data
* info
)
2997 info
->root_dir
= xstrdup (root_dir
);
2998 unixtodos_filename (info
->root_dir
);
2999 info
->next
= volume_cache
;
3000 volume_cache
= info
;
3004 /* Wrapper for GetVolumeInformation, which uses caching to avoid
3005 performance penalty (~2ms on 486 for local drives, 7.5ms for local
3006 cdrom drive, ~5-10ms or more for remote drives on LAN). */
3007 static volume_info_data
*
3008 GetCachedVolumeInformation (char * root_dir
)
3010 volume_info_data
* info
;
3011 char default_root
[ MAX_UTF8_PATH
];
3012 char name
[MAX_PATH
+1];
3013 char type
[MAX_PATH
+1];
3015 /* NULL for root_dir means use root from current directory. */
3016 if (root_dir
== NULL
)
3018 if (w32_unicode_filenames
)
3020 wchar_t curdirw
[MAX_PATH
];
3022 if (GetCurrentDirectoryW (MAX_PATH
, curdirw
) == 0)
3024 filename_from_utf16 (curdirw
, default_root
);
3028 char curdira
[MAX_PATH
];
3030 if (GetCurrentDirectoryA (MAX_PATH
, curdira
) == 0)
3032 filename_from_ansi (curdira
, default_root
);
3034 parse_root (default_root
, (const char **)&root_dir
);
3036 root_dir
= default_root
;
3039 /* Local fixed drives can be cached permanently. Removable drives
3040 cannot be cached permanently, since the volume name and serial
3041 number (if nothing else) can change. Remote drives should be
3042 treated as if they are removable, since there is no sure way to
3043 tell whether they are or not. Also, the UNC association of drive
3044 letters mapped to remote volumes can be changed at any time (even
3045 by other processes) without notice.
3047 As a compromise, so we can benefit from caching info for remote
3048 volumes, we use a simple expiry mechanism to invalidate cache
3049 entries that are more than ten seconds old. */
3052 /* No point doing this, because WNetGetConnection is even slower than
3053 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
3054 GetDriveType is about the only call of this type which does not
3055 involve network access, and so is extremely quick). */
3057 /* Map drive letter to UNC if remote. */
3058 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
3060 char remote_name
[ 256 ];
3061 char drive
[3] = { root_dir
[0], ':' };
3063 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
3065 /* do something */ ;
3069 info
= lookup_volume_info (root_dir
);
3071 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
3077 /* Info is not cached, or is stale. */
3078 if (w32_unicode_filenames
)
3080 wchar_t root_w
[MAX_PATH
];
3081 wchar_t name_w
[MAX_PATH
+1];
3082 wchar_t type_w
[MAX_PATH
+1];
3084 filename_to_utf16 (root_dir
, root_w
);
3085 if (!GetVolumeInformationW (root_w
,
3086 name_w
, sizeof (name_w
),
3090 type_w
, sizeof (type_w
)))
3092 /* Hmm... not really 100% correct, as these 2 are not file
3094 filename_from_utf16 (name_w
, name
);
3095 filename_from_utf16 (type_w
, type
);
3099 char root_a
[MAX_PATH
];
3100 char name_a
[MAX_PATH
+1];
3101 char type_a
[MAX_PATH
+1];
3103 filename_to_ansi (root_dir
, root_a
);
3104 if (!GetVolumeInformationA (root_a
,
3105 name_a
, sizeof (name_a
),
3109 type_a
, sizeof (type_a
)))
3111 filename_from_ansi (name_a
, name
);
3112 filename_from_ansi (type_a
, type
);
3115 /* Cache the volume information for future use, overwriting existing
3116 entry if present. */
3119 info
= xmalloc (sizeof (volume_info_data
));
3120 add_volume_info (root_dir
, info
);
3128 info
->name
= xstrdup (name
);
3129 unixtodos_filename (info
->name
);
3130 info
->serialnum
= serialnum
;
3131 info
->maxcomp
= maxcomp
;
3132 info
->flags
= flags
;
3133 info
->type
= xstrdup (type
);
3134 info
->timestamp
= GetTickCount ();
3140 /* Get information on the volume where NAME is held; set path pointer to
3141 start of pathname in NAME (past UNC header\volume header if present),
3142 if pPath is non-NULL.
3144 Note: if NAME includes symlinks, the information is for the volume
3145 of the symlink, not of its target. That's because, even though
3146 GetVolumeInformation returns information about the symlink target
3147 of its argument, we only pass the root directory to
3148 GetVolumeInformation, not the full NAME. */
3150 get_volume_info (const char * name
, const char ** pPath
)
3152 char temp
[MAX_UTF8_PATH
];
3153 char *rootname
= NULL
; /* default to current volume */
3154 volume_info_data
* info
;
3155 int root_len
= parse_root (name
, pPath
);
3160 /* Copy the root name of the volume, if given. */
3163 strncpy (temp
, name
, root_len
);
3164 temp
[root_len
] = '\0';
3165 unixtodos_filename (temp
);
3169 info
= GetCachedVolumeInformation (rootname
);
3172 /* Set global referenced by other functions. */
3173 volume_info
= *info
;
3179 /* Determine if volume is FAT format (ie. only supports short 8.3
3180 names); also set path pointer to start of pathname in name, if
3181 pPath is non-NULL. */
3183 is_fat_volume (const char * name
, const char ** pPath
)
3185 if (get_volume_info (name
, pPath
))
3186 return (volume_info
.maxcomp
== 12);
3190 /* Convert all slashes in a filename to backslashes, and map filename
3191 to a valid 8.3 name if necessary. The result is a pointer to a
3192 static buffer, so CAVEAT EMPTOR! */
3194 map_w32_filename (const char * name
, const char ** pPath
)
3196 static char shortname
[MAX_UTF8_PATH
];
3197 char * str
= shortname
;
3200 const char * save_name
= name
;
3202 if (strlen (name
) >= sizeof (shortname
))
3204 /* Return a filename which will cause callers to fail. */
3205 strcpy (shortname
, "?");
3209 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
3211 register int left
= 8; /* maximum number of chars in part */
3212 register int extn
= 0; /* extension added? */
3213 register int dots
= 2; /* maximum number of dots allowed */
3216 *str
++ = *name
++; /* skip past UNC header */
3218 while ((c
= *name
++))
3225 *str
++ = (c
== ':' ? ':' : '\\');
3226 extn
= 0; /* reset extension flags */
3227 dots
= 2; /* max 2 dots */
3228 left
= 8; /* max length 8 for main part */
3233 /* Convert path components of the form .xxx to _xxx,
3234 but leave . and .. as they are. This allows .emacs
3235 to be read as _emacs, for example. */
3239 IS_DIRECTORY_SEP (*name
))
3254 extn
= 1; /* we've got an extension */
3255 left
= 3; /* 3 chars in extension */
3259 /* any embedded dots after the first are converted to _ */
3264 case '#': /* don't lose these, they're important */
3266 str
[-1] = c
; /* replace last character of part */
3269 if ( left
&& 'A' <= c
&& c
<= 'Z' )
3271 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
3273 dots
= 0; /* started a path component */
3282 strcpy (shortname
, name
);
3283 unixtodos_filename (shortname
);
3287 *pPath
= shortname
+ (path
- save_name
);
3293 is_exec (const char * name
)
3295 char * p
= strrchr (name
, '.');
3298 && (xstrcasecmp (p
, ".exe") == 0 ||
3299 xstrcasecmp (p
, ".com") == 0 ||
3300 xstrcasecmp (p
, ".bat") == 0 ||
3301 xstrcasecmp (p
, ".cmd") == 0));
3304 /* Emulate the Unix directory procedures opendir, closedir, and
3305 readdir. We rename them to sys_* names because some versions of
3306 MinGW startup code call opendir and readdir to glob wildcards, and
3307 the code that calls them doesn't grok UTF-8 encoded file names we
3308 produce in dirent->d_name[]. */
3310 struct dirent dir_static
; /* simulated directory contents */
3311 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
3312 static int dir_is_fat
;
3313 static char dir_pathname
[MAX_UTF8_PATH
];
3314 static WIN32_FIND_DATAW dir_find_data_w
;
3315 static WIN32_FIND_DATAA dir_find_data_a
;
3316 #define DIR_FIND_DATA_W 1
3317 #define DIR_FIND_DATA_A 2
3318 static int last_dir_find_data
= -1;
3320 /* Support shares on a network resource as subdirectories of a read-only
3322 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3323 static HANDLE
open_unc_volume (const char *);
3324 static void *read_unc_volume (HANDLE
, wchar_t *, char *, int);
3325 static void close_unc_volume (HANDLE
);
3328 sys_opendir (const char *filename
)
3332 /* Opening is done by FindFirstFile. However, a read is inherent to
3333 this operation, so we defer the open until read time. */
3335 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3337 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3340 /* Note: We don't support traversal of UNC volumes via symlinks.
3341 Doing so would mean punishing 99.99% of use cases by resolving
3342 all the possible symlinks in FILENAME, recursively. */
3343 if (is_unc_volume (filename
))
3345 wnet_enum_handle
= open_unc_volume (filename
);
3346 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
3350 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
3357 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAX_UTF8_PATH
- 1);
3358 dir_pathname
[MAX_UTF8_PATH
- 1] = '\0';
3359 /* Note: We don't support symlinks to file names on FAT volumes.
3360 Doing so would mean punishing 99.99% of use cases by resolving
3361 all the possible symlinks in FILENAME, recursively. */
3362 dir_is_fat
= is_fat_volume (filename
, NULL
);
3368 sys_closedir (DIR *dirp
)
3370 /* If we have a find-handle open, close it. */
3371 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3373 FindClose (dir_find_handle
);
3374 dir_find_handle
= INVALID_HANDLE_VALUE
;
3376 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3378 close_unc_volume (wnet_enum_handle
);
3379 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3381 xfree ((char *) dirp
);
3385 sys_readdir (DIR *dirp
)
3387 int downcase
= !NILP (Vw32_downcase_file_names
);
3389 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3391 if (!read_unc_volume (wnet_enum_handle
,
3392 dir_find_data_w
.cFileName
,
3393 dir_find_data_a
.cFileName
,
3397 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3398 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3400 char filename
[MAX_UTF8_PATH
+ 2];
3403 strcpy (filename
, dir_pathname
);
3404 ln
= strlen (filename
) - 1;
3405 if (!IS_DIRECTORY_SEP (filename
[ln
]))
3406 strcat (filename
, "\\");
3407 strcat (filename
, "*");
3409 /* Note: No need to resolve symlinks in FILENAME, because
3410 FindFirst opens the directory that is the target of a
3412 if (w32_unicode_filenames
)
3414 wchar_t fnw
[MAX_PATH
];
3416 filename_to_utf16 (filename
, fnw
);
3417 dir_find_handle
= FindFirstFileW (fnw
, &dir_find_data_w
);
3423 filename_to_ansi (filename
, fna
);
3424 /* If FILENAME is not representable by the current ANSI
3425 codepage, we don't want FindFirstFileA to interpret the
3426 '?' characters as a wildcard. */
3427 if (_mbspbrk (fna
, "?"))
3428 dir_find_handle
= INVALID_HANDLE_VALUE
;
3430 dir_find_handle
= FindFirstFileA (fna
, &dir_find_data_a
);
3433 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3436 else if (w32_unicode_filenames
)
3438 if (!FindNextFileW (dir_find_handle
, &dir_find_data_w
))
3443 if (!FindNextFileA (dir_find_handle
, &dir_find_data_a
))
3447 /* Emacs never uses this value, so don't bother making it match
3448 value returned by stat(). */
3449 dir_static
.d_ino
= 1;
3451 if (w32_unicode_filenames
)
3453 if (downcase
|| dir_is_fat
)
3455 wchar_t tem
[MAX_PATH
];
3457 wcscpy (tem
, dir_find_data_w
.cFileName
);
3459 filename_from_utf16 (tem
, dir_static
.d_name
);
3462 filename_from_utf16 (dir_find_data_w
.cFileName
, dir_static
.d_name
);
3463 last_dir_find_data
= DIR_FIND_DATA_W
;
3469 /* If the file name in cFileName[] includes `?' characters, it
3470 means the original file name used characters that cannot be
3471 represented by the current ANSI codepage. To avoid total
3472 lossage, retrieve the short 8+3 alias of the long file
3474 if (_mbspbrk (dir_find_data_a
.cFileName
, "?"))
3476 strcpy (tem
, dir_find_data_a
.cAlternateFileName
);
3477 /* 8+3 aliases are returned in all caps, which could break
3478 various alists that look at filenames' extensions. */
3481 else if (downcase
|| dir_is_fat
)
3482 strcpy (tem
, dir_find_data_a
.cFileName
);
3484 filename_from_ansi (dir_find_data_a
.cFileName
, dir_static
.d_name
);
3485 if (downcase
|| dir_is_fat
)
3488 filename_from_ansi (tem
, dir_static
.d_name
);
3490 last_dir_find_data
= DIR_FIND_DATA_A
;
3493 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3494 dir_static
.d_reclen
= sizeof (struct dirent
) - MAX_UTF8_PATH
+ 3 +
3495 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3501 open_unc_volume (const char *path
)
3503 const char *fn
= map_w32_filename (path
, NULL
);
3507 if (w32_unicode_filenames
)
3510 wchar_t fnw
[MAX_PATH
];
3512 nrw
.dwScope
= RESOURCE_GLOBALNET
;
3513 nrw
.dwType
= RESOURCETYPE_DISK
;
3514 nrw
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3515 nrw
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3516 nrw
.lpLocalName
= NULL
;
3517 filename_to_utf16 (fn
, fnw
);
3518 nrw
.lpRemoteName
= fnw
;
3519 nrw
.lpComment
= NULL
;
3520 nrw
.lpProvider
= NULL
;
3522 result
= WNetOpenEnumW (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3523 RESOURCEUSAGE_CONNECTABLE
, &nrw
, &henum
);
3530 nra
.dwScope
= RESOURCE_GLOBALNET
;
3531 nra
.dwType
= RESOURCETYPE_DISK
;
3532 nra
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3533 nra
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3534 nra
.lpLocalName
= NULL
;
3535 filename_to_ansi (fn
, fna
);
3536 nra
.lpRemoteName
= fna
;
3537 nra
.lpComment
= NULL
;
3538 nra
.lpProvider
= NULL
;
3540 result
= WNetOpenEnumA (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3541 RESOURCEUSAGE_CONNECTABLE
, &nra
, &henum
);
3543 if (result
== NO_ERROR
)
3546 return INVALID_HANDLE_VALUE
;
3550 read_unc_volume (HANDLE henum
, wchar_t *fname_w
, char *fname_a
, int size
)
3555 DWORD bufsize
= 512;
3559 if (w32_unicode_filenames
)
3564 buffer
= alloca (bufsize
);
3565 result
= WNetEnumResourceW (henum
, &count
, buffer
, &bufsize
);
3566 if (result
!= NO_ERROR
)
3568 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3569 ptrw
= ((LPNETRESOURCEW
) buffer
)->lpRemoteName
;
3571 while (*ptrw
&& *ptrw
!= L
'/' && *ptrw
!= L
'\\') ptrw
++;
3573 wcsncpy (fname_w
, ptrw
, size
);
3578 int dbcs_p
= max_filename_mbslen () > 1;
3581 buffer
= alloca (bufsize
);
3582 result
= WNetEnumResourceA (henum
, &count
, buffer
, &bufsize
);
3583 if (result
!= NO_ERROR
)
3585 ptra
= ((LPNETRESOURCEA
) buffer
)->lpRemoteName
;
3588 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
)) ptra
++;
3591 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
))
3592 ptra
= CharNextExA (file_name_codepage
, ptra
, 0);
3595 strncpy (fname_a
, ptra
, size
);
3603 close_unc_volume (HANDLE henum
)
3605 if (henum
!= INVALID_HANDLE_VALUE
)
3606 WNetCloseEnum (henum
);
3610 unc_volume_file_attributes (const char *path
)
3615 henum
= open_unc_volume (path
);
3616 if (henum
== INVALID_HANDLE_VALUE
)
3619 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3621 close_unc_volume (henum
);
3626 /* Ensure a network connection is authenticated. */
3628 logon_network_drive (const char *path
)
3630 char share
[MAX_UTF8_PATH
];
3637 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3638 drvtype
= DRIVE_REMOTE
;
3639 else if (path
[0] == '\0' || path
[1] != ':')
3640 drvtype
= GetDriveType (NULL
);
3647 drvtype
= GetDriveType (drive
);
3650 /* Only logon to networked drives. */
3651 if (drvtype
!= DRIVE_REMOTE
)
3655 strncpy (share
, path
, MAX_UTF8_PATH
);
3656 /* Truncate to just server and share name. */
3657 for (p
= share
+ 2; *p
&& p
< share
+ MAX_UTF8_PATH
; p
++)
3659 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3666 if (w32_unicode_filenames
)
3668 NETRESOURCEW resourcew
;
3669 wchar_t share_w
[MAX_PATH
];
3671 resourcew
.dwScope
= RESOURCE_GLOBALNET
;
3672 resourcew
.dwType
= RESOURCETYPE_DISK
;
3673 resourcew
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3674 resourcew
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3675 resourcew
.lpLocalName
= NULL
;
3676 filename_to_utf16 (share
, share_w
);
3677 resourcew
.lpRemoteName
= share_w
;
3678 resourcew
.lpProvider
= NULL
;
3680 val
= WNetAddConnection2W (&resourcew
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3684 NETRESOURCEA resourcea
;
3685 char share_a
[MAX_PATH
];
3687 resourcea
.dwScope
= RESOURCE_GLOBALNET
;
3688 resourcea
.dwType
= RESOURCETYPE_DISK
;
3689 resourcea
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3690 resourcea
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3691 resourcea
.lpLocalName
= NULL
;
3692 filename_to_ansi (share
, share_a
);
3693 resourcea
.lpRemoteName
= share_a
;
3694 resourcea
.lpProvider
= NULL
;
3696 val
= WNetAddConnection2A (&resourcea
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3702 case ERROR_ALREADY_ASSIGNED
:
3704 case ERROR_ACCESS_DENIED
:
3705 case ERROR_LOGON_FAILURE
:
3711 case ERROR_BAD_NET_NAME
:
3712 case ERROR_NO_NET_OR_BAD_PATH
:
3713 case ERROR_NO_NETWORK
:
3714 case ERROR_CANCELLED
:
3721 /* Emulate faccessat(2). */
3723 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3727 if (dirfd
!= AT_FDCWD
3728 && !(IS_DIRECTORY_SEP (path
[0])
3729 || IS_DEVICE_SEP (path
[1])))
3735 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3736 newer versions blow up when passed D_OK. */
3737 path
= map_w32_filename (path
, NULL
);
3738 /* If the last element of PATH is a symlink, we need to resolve it
3739 to get the attributes of its target file. Note: any symlinks in
3740 PATH elements other than the last one are transparently resolved
3741 by GetFileAttributes below. */
3742 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3743 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3744 path
= chase_symlinks (path
);
3746 if (w32_unicode_filenames
)
3748 wchar_t path_w
[MAX_PATH
];
3750 filename_to_utf16 (path
, path_w
);
3751 attributes
= GetFileAttributesW (path_w
);
3755 char path_a
[MAX_PATH
];
3757 filename_to_ansi (path
, path_a
);
3758 attributes
= GetFileAttributesA (path_a
);
3761 if (attributes
== -1)
3763 DWORD w32err
= GetLastError ();
3767 case ERROR_INVALID_NAME
:
3768 case ERROR_BAD_PATHNAME
:
3769 if (is_unc_volume (path
))
3771 attributes
= unc_volume_file_attributes (path
);
3772 if (attributes
== -1)
3780 case ERROR_FILE_NOT_FOUND
:
3781 case ERROR_BAD_NETPATH
:
3790 if ((mode
& X_OK
) != 0
3791 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3796 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3801 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3809 /* A version of 'access' to be used locally with file names in
3810 locale-specific encoding. Does not resolve symlinks and does not
3811 support file names on FAT12 and FAT16 volumes, but that's OK, since
3812 we only invoke this function for files inside the Emacs source or
3813 installation tree, on directories (so any symlinks should have the
3814 directory bit set), and on short file names such as "C:/.emacs". */
3816 sys_access (const char *fname
, int mode
)
3818 char fname_copy
[MAX_PATH
], *p
;
3821 strcpy (fname_copy
, fname
);
3822 /* Do the equivalent of unixtodos_filename. */
3823 for (p
= fname_copy
; *p
; p
= CharNext (p
))
3827 if ((attributes
= GetFileAttributesA (fname_copy
)) == -1)
3829 DWORD w32err
= GetLastError ();
3833 case ERROR_INVALID_NAME
:
3834 case ERROR_BAD_PATHNAME
:
3835 case ERROR_FILE_NOT_FOUND
:
3836 case ERROR_BAD_NETPATH
:
3845 if ((mode
& X_OK
) != 0
3846 && !(is_exec (fname_copy
)
3847 || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3852 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3857 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3865 /* Shadow some MSVC runtime functions to map requests for long filenames
3866 to reasonable short names if necessary. This was originally added to
3867 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3871 sys_chdir (const char * path
)
3873 path
= map_w32_filename (path
, NULL
);
3874 if (w32_unicode_filenames
)
3876 wchar_t newdir_w
[MAX_PATH
];
3878 if (filename_to_utf16 (path
, newdir_w
) == 0)
3879 return _wchdir (newdir_w
);
3884 char newdir_a
[MAX_PATH
];
3886 if (filename_to_ansi (path
, newdir_a
) == 0)
3887 return _chdir (newdir_a
);
3893 sys_chmod (const char * path
, int mode
)
3895 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3896 if (w32_unicode_filenames
)
3898 wchar_t path_w
[MAX_PATH
];
3900 filename_to_utf16 (path
, path_w
);
3901 return _wchmod (path_w
, mode
);
3905 char path_a
[MAX_PATH
];
3907 filename_to_ansi (path
, path_a
);
3908 return _chmod (path_a
, mode
);
3913 sys_creat (const char * path
, int mode
)
3915 path
= map_w32_filename (path
, NULL
);
3916 if (w32_unicode_filenames
)
3918 wchar_t path_w
[MAX_PATH
];
3920 filename_to_utf16 (path
, path_w
);
3921 return _wcreat (path_w
, mode
);
3925 char path_a
[MAX_PATH
];
3927 filename_to_ansi (path
, path_a
);
3928 return _creat (path_a
, mode
);
3933 sys_fopen (const char * path
, const char * mode
)
3937 const char * mode_save
= mode
;
3939 /* Force all file handles to be non-inheritable. This is necessary to
3940 ensure child processes don't unwittingly inherit handles that might
3941 prevent future file access. */
3945 else if (mode
[0] == 'w' || mode
[0] == 'a')
3946 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3950 /* Only do simplistic option parsing. */
3954 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3957 else if (mode
[0] == 'b')
3962 else if (mode
[0] == 't')
3969 path
= map_w32_filename (path
, NULL
);
3970 if (w32_unicode_filenames
)
3972 wchar_t path_w
[MAX_PATH
];
3974 filename_to_utf16 (path
, path_w
);
3975 fd
= _wopen (path_w
, oflag
| _O_NOINHERIT
, 0644);
3979 char path_a
[MAX_PATH
];
3981 filename_to_ansi (path
, path_a
);
3982 fd
= _open (path_a
, oflag
| _O_NOINHERIT
, 0644);
3987 return _fdopen (fd
, mode_save
);
3990 /* This only works on NTFS volumes, but is useful to have. */
3992 sys_link (const char * old
, const char * new)
3996 char oldname
[MAX_UTF8_PATH
], newname
[MAX_UTF8_PATH
];
3997 wchar_t oldname_w
[MAX_PATH
];
3998 char oldname_a
[MAX_PATH
];
4000 if (old
== NULL
|| new == NULL
)
4006 strcpy (oldname
, map_w32_filename (old
, NULL
));
4007 strcpy (newname
, map_w32_filename (new, NULL
));
4009 if (w32_unicode_filenames
)
4011 filename_to_utf16 (oldname
, oldname_w
);
4012 fileh
= CreateFileW (oldname_w
, 0, 0, NULL
, OPEN_EXISTING
,
4013 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4017 filename_to_ansi (oldname
, oldname_a
);
4018 fileh
= CreateFileA (oldname_a
, 0, 0, NULL
, OPEN_EXISTING
,
4019 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4021 if (fileh
!= INVALID_HANDLE_VALUE
)
4025 /* Confusingly, the "alternate" stream name field does not apply
4026 when restoring a hard link, and instead contains the actual
4027 stream data for the link (ie. the name of the link to create).
4028 The WIN32_STREAM_ID structure before the cStreamName field is
4029 the stream header, which is then immediately followed by the
4033 WIN32_STREAM_ID wid
;
4034 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
4037 /* We used to pass MB_PRECOMPOSED as the 2nd arg here, but MSDN
4038 indicates that flag is unsupported for CP_UTF8, and OTOH says
4039 it is the default anyway. */
4040 wlen
= pMultiByteToWideChar (CP_UTF8
, 0, newname
, -1,
4041 data
.wid
.cStreamName
, MAX_PATH
);
4044 LPVOID context
= NULL
;
4047 data
.wid
.dwStreamId
= BACKUP_LINK
;
4048 data
.wid
.dwStreamAttributes
= 0;
4049 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
4050 data
.wid
.Size
.HighPart
= 0;
4051 data
.wid
.dwStreamNameSize
= 0;
4053 if (BackupWrite (fileh
, (LPBYTE
)&data
,
4054 offsetof (WIN32_STREAM_ID
, cStreamName
)
4055 + data
.wid
.Size
.LowPart
,
4056 &wbytes
, FALSE
, FALSE
, &context
)
4057 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
4064 DWORD err
= GetLastError ();
4069 case ERROR_ACCESS_DENIED
:
4070 /* This is what happens when OLDNAME is a directory,
4071 since Windows doesn't support hard links to
4072 directories. Posix says to set errno to EPERM in
4074 if (w32_unicode_filenames
)
4075 attributes
= GetFileAttributesW (oldname_w
);
4077 attributes
= GetFileAttributesA (oldname_a
);
4078 if (attributes
!= -1
4079 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
4081 else if (attributes
== -1
4082 && is_unc_volume (oldname
)
4083 && unc_volume_file_attributes (oldname
) != -1)
4088 case ERROR_TOO_MANY_LINKS
:
4091 case ERROR_NOT_SAME_DEVICE
:
4101 CloseHandle (fileh
);
4110 sys_mkdir (const char * path
)
4112 path
= map_w32_filename (path
, NULL
);
4114 if (w32_unicode_filenames
)
4116 wchar_t path_w
[MAX_PATH
];
4118 filename_to_utf16 (path
, path_w
);
4119 return _wmkdir (path_w
);
4123 char path_a
[MAX_PATH
];
4125 filename_to_ansi (path
, path_a
);
4126 return _mkdir (path_a
);
4131 sys_open (const char * path
, int oflag
, int mode
)
4133 const char* mpath
= map_w32_filename (path
, NULL
);
4136 if (w32_unicode_filenames
)
4138 wchar_t mpath_w
[MAX_PATH
];
4140 filename_to_utf16 (mpath
, mpath_w
);
4141 /* If possible, try to open file without _O_CREAT, to be able to
4142 write to existing hidden and system files. Force all file
4143 handles to be non-inheritable. */
4144 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4145 res
= _wopen (mpath_w
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4147 res
= _wopen (mpath_w
, oflag
| _O_NOINHERIT
, mode
);
4151 char mpath_a
[MAX_PATH
];
4153 filename_to_ansi (mpath
, mpath_a
);
4154 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4155 res
= _open (mpath_a
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4157 res
= _open (mpath_a
, oflag
| _O_NOINHERIT
, mode
);
4163 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
4166 Standard algorithm for generating a temporary file name seems to be
4167 use pid or tid with a letter on the front (in place of the 6 X's)
4168 and cycle through the letters to find a unique name. We extend
4169 that to allow any reasonable character as the first of the 6 X's,
4170 so that the number of simultaneously used temporary files will be
4174 mkostemp (char * template, int flags
)
4178 unsigned uid
= GetCurrentThreadId ();
4179 int save_errno
= errno
;
4180 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
4183 if (template == NULL
)
4186 p
= template + strlen (template);
4188 /* replace up to the last 5 X's with uid in decimal */
4189 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
4191 p
[0] = '0' + uid
% 10;
4195 if (i
< 0 && p
[0] == 'X')
4200 p
[0] = first_char
[i
];
4201 if ((fd
= sys_open (template,
4202 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
4203 S_IRUSR
| S_IWUSR
)) >= 0
4211 while (++i
< sizeof (first_char
));
4214 /* Template is badly formed or else we can't generate a unique name. */
4219 fchmod (int fd
, mode_t mode
)
4225 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
4228 char temp
[MAX_UTF8_PATH
], temp_a
[MAX_PATH
];;
4231 bool have_temp_a
= false;
4233 /* MoveFile on Windows 95 doesn't correctly change the short file name
4234 alias in a number of circumstances (it is not easy to predict when
4235 just by looking at oldname and newname, unfortunately). In these
4236 cases, renaming through a temporary name avoids the problem.
4238 A second problem on Windows 95 is that renaming through a temp name when
4239 newname is uppercase fails (the final long name ends up in
4240 lowercase, although the short alias might be uppercase) UNLESS the
4241 long temp name is not 8.3.
4243 So, on Windows 95 we always rename through a temp name, and we make sure
4244 the temp name has a long extension to ensure correct renaming. */
4246 strcpy (temp
, map_w32_filename (oldname
, NULL
));
4248 /* volume_info is set indirectly by map_w32_filename. */
4249 oldname_dev
= volume_info
.serialnum
;
4251 if (os_subtype
== OS_9X
)
4256 char oldname_a
[MAX_PATH
];
4258 oldname
= map_w32_filename (oldname
, NULL
);
4259 filename_to_ansi (oldname
, oldname_a
);
4260 filename_to_ansi (temp
, temp_a
);
4261 if ((o
= strrchr (oldname_a
, '\\')))
4264 o
= (char *) oldname_a
;
4266 if ((p
= strrchr (temp_a
, '\\')))
4273 /* Force temp name to require a manufactured 8.3 alias - this
4274 seems to make the second rename work properly. */
4275 sprintf (p
, "_.%s.%u", o
, i
);
4277 result
= rename (oldname_a
, temp_a
);
4279 /* This loop must surely terminate! */
4280 while (result
< 0 && errno
== EEXIST
);
4286 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
4287 (at least if it is a file; don't do this for directories).
4289 Since we mustn't do this if we are just changing the case of the
4290 file name (we would end up deleting the file we are trying to
4291 rename!), we let rename detect if the destination file already
4292 exists - that way we avoid the possible pitfalls of trying to
4293 determine ourselves whether two names really refer to the same
4294 file, which is not always possible in the general case. (Consider
4295 all the permutations of shared or subst'd drives, etc.) */
4297 newname
= map_w32_filename (newname
, NULL
);
4299 /* volume_info is set indirectly by map_w32_filename. */
4300 newname_dev
= volume_info
.serialnum
;
4302 if (w32_unicode_filenames
)
4304 wchar_t temp_w
[MAX_PATH
], newname_w
[MAX_PATH
];
4306 filename_to_utf16 (temp
, temp_w
);
4307 filename_to_utf16 (newname
, newname_w
);
4308 result
= _wrename (temp_w
, newname_w
);
4309 if (result
< 0 && force
)
4311 DWORD w32err
= GetLastError ();
4314 && newname_dev
!= oldname_dev
)
4316 /* The implementation of `rename' on Windows does not return
4317 errno = EXDEV when you are moving a directory to a
4318 different storage device (ex. logical disk). It returns
4319 EACCES instead. So here we handle such situations and
4323 if ((attributes
= GetFileAttributesW (temp_w
)) != -1
4324 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4327 else if (errno
== EEXIST
)
4329 if (_wchmod (newname_w
, 0666) != 0)
4331 if (_wunlink (newname_w
) != 0)
4333 result
= _wrename (temp_w
, newname_w
);
4335 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4336 && is_symlink (temp
))
4338 /* This is Windows prohibiting the user from creating a
4339 symlink in another place, since that requires
4347 char newname_a
[MAX_PATH
];
4350 filename_to_ansi (temp
, temp_a
);
4351 filename_to_ansi (newname
, newname_a
);
4352 result
= rename (temp_a
, newname_a
);
4353 if (result
< 0 && force
)
4355 DWORD w32err
= GetLastError ();
4358 && newname_dev
!= oldname_dev
)
4362 if ((attributes
= GetFileAttributesA (temp_a
)) != -1
4363 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4366 else if (errno
== EEXIST
)
4368 if (_chmod (newname_a
, 0666) != 0)
4370 if (_unlink (newname_a
) != 0)
4372 result
= rename (temp_a
, newname_a
);
4374 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4375 && is_symlink (temp
))
4384 sys_rename (char const *old
, char const *new)
4386 return sys_rename_replace (old
, new, TRUE
);
4390 sys_rmdir (const char * path
)
4392 path
= map_w32_filename (path
, NULL
);
4394 if (w32_unicode_filenames
)
4396 wchar_t path_w
[MAX_PATH
];
4398 filename_to_utf16 (path
, path_w
);
4399 return _wrmdir (path_w
);
4403 char path_a
[MAX_PATH
];
4405 filename_to_ansi (path
, path_a
);
4406 return _rmdir (path_a
);
4411 sys_unlink (const char * path
)
4413 path
= map_w32_filename (path
, NULL
);
4415 if (w32_unicode_filenames
)
4417 wchar_t path_w
[MAX_PATH
];
4419 filename_to_utf16 (path
, path_w
);
4420 /* On Unix, unlink works without write permission. */
4421 _wchmod (path_w
, 0666);
4422 return _wunlink (path_w
);
4426 char path_a
[MAX_PATH
];
4428 filename_to_ansi (path
, path_a
);
4429 _chmod (path_a
, 0666);
4430 return _unlink (path_a
);
4434 static FILETIME utc_base_ft
;
4435 static ULONGLONG utc_base
; /* In 100ns units */
4436 static int init
= 0;
4438 #define FILETIME_TO_U64(result, ft) \
4440 ULARGE_INTEGER uiTemp; \
4441 uiTemp.LowPart = (ft).dwLowDateTime; \
4442 uiTemp.HighPart = (ft).dwHighDateTime; \
4443 result = uiTemp.QuadPart; \
4447 initialize_utc_base (void)
4449 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4458 st
.wMilliseconds
= 0;
4460 SystemTimeToFileTime (&st
, &utc_base_ft
);
4461 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
4465 convert_time (FILETIME ft
)
4471 initialize_utc_base ();
4475 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
4478 FILETIME_TO_U64 (tmp
, ft
);
4479 return (time_t) ((tmp
- utc_base
) / 10000000L);
4483 convert_from_time_t (time_t time
, FILETIME
* pft
)
4489 initialize_utc_base ();
4493 /* time in 100ns units since 1-Jan-1601 */
4494 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
4495 pft
->dwHighDateTime
= tmp
.HighPart
;
4496 pft
->dwLowDateTime
= tmp
.LowPart
;
4499 static PSECURITY_DESCRIPTOR
4500 get_file_security_desc_by_handle (HANDLE h
)
4502 PSECURITY_DESCRIPTOR psd
= NULL
;
4504 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4505 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4507 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
4508 NULL
, NULL
, NULL
, NULL
, &psd
);
4509 if (err
!= ERROR_SUCCESS
)
4515 static PSECURITY_DESCRIPTOR
4516 get_file_security_desc_by_name (const char *fname
)
4518 PSECURITY_DESCRIPTOR psd
= NULL
;
4520 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4521 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4523 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
4525 err
= GetLastError ();
4526 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
4530 psd
= xmalloc (sd_len
);
4531 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4543 unsigned n_subauthorities
;
4545 /* Use the last sub-authority value of the RID, the relative
4546 portion of the SID, as user/group ID. */
4547 n_subauthorities
= *get_sid_sub_authority_count (sid
);
4548 if (n_subauthorities
< 1)
4549 return 0; /* the "World" RID */
4550 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
4553 /* Caching SID and account values for faster lokup. */
4557 struct w32_id
*next
;
4559 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
4562 static struct w32_id
*w32_idlist
;
4565 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
4567 struct w32_id
*tail
, *found
;
4569 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
4571 if (equal_sid ((PSID
)tail
->sid
, sid
))
4580 strcpy (name
, found
->name
);
4588 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
4591 struct w32_id
*new_entry
;
4593 /* We don't want to leave behind stale cache from when Emacs was
4597 sid_len
= get_length_sid (sid
);
4598 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
4601 new_entry
->rid
= id
;
4602 strcpy (new_entry
->name
, name
);
4603 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
4604 new_entry
->next
= w32_idlist
;
4605 w32_idlist
= new_entry
;
4614 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
4618 SID_NAME_USE ignore
;
4620 DWORD name_len
= sizeof (name
);
4622 DWORD domain_len
= sizeof (domain
);
4627 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
4628 else if (what
== GID
)
4629 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
4633 if (!result
|| !is_valid_sid (sid
))
4635 else if (!w32_cached_id (sid
, id
, nm
))
4637 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
4638 domain
, &domain_len
, &ignore
)
4639 || name_len
> UNLEN
+1)
4643 *id
= get_rid (sid
);
4645 w32_add_to_cache (sid
, *id
, name
);
4652 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
4654 int dflt_usr
= 0, dflt_grp
= 0;
4663 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
4665 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
4668 /* Consider files to belong to current user/group, if we cannot get
4669 more accurate information. */
4672 st
->st_uid
= dflt_passwd
.pw_uid
;
4673 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
4677 st
->st_gid
= dflt_passwd
.pw_gid
;
4678 strcpy (st
->st_gname
, dflt_group
.gr_name
);
4682 /* Return non-zero if NAME is a potentially slow filesystem. */
4684 is_slow_fs (const char *name
)
4689 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
4690 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
4691 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
4692 devtype
= GetDriveType (NULL
); /* use root of current drive */
4695 /* GetDriveType needs the root directory of the drive. */
4696 strncpy (drive_root
, name
, 2);
4697 drive_root
[2] = '\\';
4698 drive_root
[3] = '\0';
4699 devtype
= GetDriveType (drive_root
);
4701 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
4704 /* If this is non-zero, the caller wants accurate information about
4705 file's owner and group, which could be expensive to get. dired.c
4706 uses this flag when needed for the job at hand. */
4707 int w32_stat_get_owner_group
;
4709 /* MSVC stat function can't cope with UNC names and has other bugs, so
4710 replace it with our own. This also allows us to calculate consistent
4711 inode values and owner/group without hacks in the main Emacs code,
4712 and support file names encoded in UTF-8. */
4715 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
4717 char *name
, *save_name
, *r
;
4718 WIN32_FIND_DATAW wfd_w
;
4719 WIN32_FIND_DATAA wfd_a
;
4721 unsigned __int64 fake_inode
= 0;
4724 int rootdir
= FALSE
;
4725 PSECURITY_DESCRIPTOR psd
= NULL
;
4726 int is_a_symlink
= 0;
4727 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
4728 DWORD access_rights
= 0;
4729 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
4730 FILETIME ctime
, atime
, wtime
;
4731 wchar_t name_w
[MAX_PATH
];
4732 char name_a
[MAX_PATH
];
4734 if (path
== NULL
|| buf
== NULL
)
4740 save_name
= name
= (char *) map_w32_filename (path
, &path
);
4741 /* Must be valid filename, no wild cards or other invalid
4743 if (strpbrk (name
, "*?|<>\""))
4749 len
= strlen (name
);
4750 /* Allocate 1 extra byte so that we could append a slash to a root
4751 directory, down below. */
4752 name
= strcpy (alloca (len
+ 2), name
);
4754 /* Avoid a somewhat costly call to is_symlink if the filesystem
4755 doesn't support symlinks. */
4756 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4757 is_a_symlink
= is_symlink (name
);
4759 /* Plan A: Open the file and get all the necessary information via
4760 the resulting handle. This solves several issues in one blow:
4762 . retrieves attributes for the target of a symlink, if needed
4763 . gets attributes of root directories and symlinks pointing to
4764 root directories, thus avoiding the need for special-casing
4765 these and detecting them by examining the file-name format
4766 . retrieves more accurate attributes (e.g., non-zero size for
4767 some directories, esp. directories that are junction points)
4768 . correctly resolves "c:/..", "/.." and similar file names
4769 . avoids run-time penalties for 99% of use cases
4771 Plan A is always tried first, unless the user asked not to (but
4772 if the file is a symlink and we need to follow links, we try Plan
4773 A even if the user asked not to).
4775 If Plan A fails, we go to Plan B (below), where various
4776 potentially expensive techniques must be used to handle "special"
4777 files such as UNC volumes etc. */
4778 if (!(NILP (Vw32_get_true_file_attributes
)
4779 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4780 /* Following symlinks requires getting the info by handle. */
4781 || (is_a_symlink
&& follow_symlinks
))
4783 BY_HANDLE_FILE_INFORMATION info
;
4785 if (is_a_symlink
&& !follow_symlinks
)
4786 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4787 /* READ_CONTROL access rights are required to get security info
4788 by handle. But if the OS doesn't support security in the
4789 first place, we don't need to try. */
4790 if (is_windows_9x () != TRUE
)
4791 access_rights
|= READ_CONTROL
;
4793 if (w32_unicode_filenames
)
4795 filename_to_utf16 (name
, name_w
);
4796 fh
= CreateFileW (name_w
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4798 /* If CreateFile fails with READ_CONTROL, try again with
4799 zero as access rights. */
4800 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4801 fh
= CreateFileW (name_w
, 0, 0, NULL
, OPEN_EXISTING
,
4806 filename_to_ansi (name
, name_a
);
4807 fh
= CreateFileA (name_a
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4809 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4810 fh
= CreateFileA (name_a
, 0, 0, NULL
, OPEN_EXISTING
,
4813 if (fh
== INVALID_HANDLE_VALUE
)
4814 goto no_true_file_attributes
;
4816 /* This is more accurate in terms of getting the correct number
4817 of links, but is quite slow (it is noticeable when Emacs is
4818 making a list of file name completions). */
4819 if (GetFileInformationByHandle (fh
, &info
))
4821 nlinks
= info
.nNumberOfLinks
;
4822 /* Might as well use file index to fake inode values, but this
4823 is not guaranteed to be unique unless we keep a handle open
4824 all the time (even then there are situations where it is
4825 not unique). Reputedly, there are at most 48 bits of info
4826 (on NTFS, presumably less on FAT). */
4827 fake_inode
= info
.nFileIndexHigh
;
4829 fake_inode
+= info
.nFileIndexLow
;
4830 serialnum
= info
.dwVolumeSerialNumber
;
4831 fs_high
= info
.nFileSizeHigh
;
4832 fs_low
= info
.nFileSizeLow
;
4833 ctime
= info
.ftCreationTime
;
4834 atime
= info
.ftLastAccessTime
;
4835 wtime
= info
.ftLastWriteTime
;
4836 fattrs
= info
.dwFileAttributes
;
4840 /* We don't go to Plan B here, because it's not clear that
4841 it's a good idea. The only known use case where
4842 CreateFile succeeds, but GetFileInformationByHandle fails
4843 (with ERROR_INVALID_FUNCTION) is for character devices
4844 such as NUL, PRN, etc. For these, switching to Plan B is
4845 a net loss, because we lose the character device
4846 attribute returned by GetFileType below (FindFirstFile
4847 doesn't set that bit in the attributes), and the other
4848 fields don't make sense for character devices anyway.
4849 Emacs doesn't really care for non-file entities in the
4850 context of l?stat, so neither do we. */
4852 /* w32err is assigned so one could put a breakpoint here and
4853 examine its value, when GetFileInformationByHandle
4855 DWORD w32err
= GetLastError ();
4859 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4865 /* Test for a symlink before testing for a directory, since
4866 symlinks to directories have the directory bit set, but we
4867 don't want them to appear as directories. */
4868 if (is_a_symlink
&& !follow_symlinks
)
4869 buf
->st_mode
= S_IFLNK
;
4870 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4871 buf
->st_mode
= S_IFDIR
;
4874 DWORD ftype
= GetFileType (fh
);
4878 case FILE_TYPE_DISK
:
4879 buf
->st_mode
= S_IFREG
;
4881 case FILE_TYPE_PIPE
:
4882 buf
->st_mode
= S_IFIFO
;
4884 case FILE_TYPE_CHAR
:
4885 case FILE_TYPE_UNKNOWN
:
4887 buf
->st_mode
= S_IFCHR
;
4890 /* We produce the fallback owner and group data, based on the
4891 current user that runs Emacs, in the following cases:
4893 . caller didn't request owner and group info
4894 . this is Windows 9X
4895 . getting security by handle failed, and we need to produce
4896 information for the target of a symlink (this is better
4897 than producing a potentially misleading info about the
4900 If getting security by handle fails, and we don't need to
4901 resolve symlinks, we try getting security by name. */
4902 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4903 get_file_owner_and_group (NULL
, buf
);
4906 psd
= get_file_security_desc_by_handle (fh
);
4909 get_file_owner_and_group (psd
, buf
);
4912 else if (!(is_a_symlink
&& follow_symlinks
))
4914 psd
= get_file_security_desc_by_name (name
);
4915 get_file_owner_and_group (psd
, buf
);
4919 get_file_owner_and_group (NULL
, buf
);
4925 no_true_file_attributes
:
4926 /* Plan B: Either getting a handle on the file failed, or the
4927 caller explicitly asked us to not bother making this
4928 information more accurate.
4930 Implementation note: In Plan B, we never bother to resolve
4931 symlinks, even if we got here because we tried Plan A and
4932 failed. That's because, even if the caller asked for extra
4933 precision by setting Vw32_get_true_file_attributes to t,
4934 resolving symlinks requires acquiring a file handle to the
4935 symlink, which we already know will fail. And if the user
4936 did not ask for extra precision, resolving symlinks will fly
4937 in the face of that request, since the user then wants the
4938 lightweight version of the code. */
4939 rootdir
= (path
>= save_name
+ len
- 1
4940 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4942 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4943 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4944 if (IS_DIRECTORY_SEP (r
[0])
4945 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4948 /* Note: If NAME is a symlink to the root of a UNC volume
4949 (i.e. "\\SERVER"), we will not detect that here, and we will
4950 return data about the symlink as result of FindFirst below.
4951 This is unfortunate, but that marginal use case does not
4952 justify a call to chase_symlinks which would impose a penalty
4953 on all the other use cases. (We get here for symlinks to
4954 roots of UNC volumes because CreateFile above fails for them,
4955 unlike with symlinks to root directories X:\ of drives.) */
4956 if (is_unc_volume (name
))
4958 fattrs
= unc_volume_file_attributes (name
);
4962 ctime
= atime
= wtime
= utc_base_ft
;
4966 /* Make sure root directories end in a slash. */
4967 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4968 strcat (name
, "\\");
4969 if (GetDriveType (name
) < 2)
4975 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4976 ctime
= atime
= wtime
= utc_base_ft
;
4982 /* Make sure non-root directories do NOT end in a slash,
4983 otherwise FindFirstFile might fail. */
4984 if (IS_DIRECTORY_SEP (name
[len
-1]))
4987 /* (This is hacky, but helps when doing file completions on
4988 network drives.) Optimize by using information available from
4989 active readdir if possible. */
4990 len
= strlen (dir_pathname
);
4991 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4993 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4994 && last_dir_find_data
!= -1
4995 && !(is_a_symlink
&& follow_symlinks
)
4996 /* The 2 file-name comparisons below support only ASCII
4997 characters, and will lose (compare not equal) when
4998 the file names include non-ASCII characters that are
4999 the same but for the case. However, doing this
5000 properly involves: (a) converting both file names to
5001 UTF-16, (b) lower-casing both names using CharLowerW,
5002 and (c) comparing the results; this would be quite a
5003 bit slower, whereas Plan B is for users who want
5004 lightweight albeit inaccurate version of 'stat'. */
5005 && c_strncasecmp (save_name
, dir_pathname
, len
) == 0
5006 && IS_DIRECTORY_SEP (name
[len
])
5007 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
5009 have_wfd
= last_dir_find_data
;
5010 /* This was the last entry returned by readdir. */
5011 if (last_dir_find_data
== DIR_FIND_DATA_W
)
5012 wfd_w
= dir_find_data_w
;
5014 wfd_a
= dir_find_data_a
;
5018 logon_network_drive (name
);
5020 if (w32_unicode_filenames
)
5022 filename_to_utf16 (name
, name_w
);
5023 fh
= FindFirstFileW (name_w
, &wfd_w
);
5024 have_wfd
= DIR_FIND_DATA_W
;
5028 filename_to_ansi (name
, name_a
);
5029 /* If NAME includes characters not representable by
5030 the current ANSI codepage, filename_to_ansi
5031 usually replaces them with a '?'. We don't want
5032 to let FindFirstFileA interpret those as wildcards,
5033 and "succeed", returning us data from some random
5034 file in the same directory. */
5035 if (_mbspbrk (name_a
, "?"))
5036 fh
= INVALID_HANDLE_VALUE
;
5038 fh
= FindFirstFileA (name_a
, &wfd_a
);
5039 have_wfd
= DIR_FIND_DATA_A
;
5041 if (fh
== INVALID_HANDLE_VALUE
)
5048 /* Note: if NAME is a symlink, the information we get from
5049 FindFirstFile is for the symlink, not its target. */
5050 if (have_wfd
== DIR_FIND_DATA_W
)
5052 fattrs
= wfd_w
.dwFileAttributes
;
5053 ctime
= wfd_w
.ftCreationTime
;
5054 atime
= wfd_w
.ftLastAccessTime
;
5055 wtime
= wfd_w
.ftLastWriteTime
;
5056 fs_high
= wfd_w
.nFileSizeHigh
;
5057 fs_low
= wfd_w
.nFileSizeLow
;
5061 fattrs
= wfd_a
.dwFileAttributes
;
5062 ctime
= wfd_a
.ftCreationTime
;
5063 atime
= wfd_a
.ftLastAccessTime
;
5064 wtime
= wfd_a
.ftLastWriteTime
;
5065 fs_high
= wfd_a
.nFileSizeHigh
;
5066 fs_low
= wfd_a
.nFileSizeLow
;
5070 serialnum
= volume_info
.serialnum
;
5072 if (is_a_symlink
&& !follow_symlinks
)
5073 buf
->st_mode
= S_IFLNK
;
5074 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5075 buf
->st_mode
= S_IFDIR
;
5077 buf
->st_mode
= S_IFREG
;
5079 get_file_owner_and_group (NULL
, buf
);
5082 buf
->st_ino
= fake_inode
;
5084 buf
->st_dev
= serialnum
;
5085 buf
->st_rdev
= serialnum
;
5087 buf
->st_size
= fs_high
;
5088 buf
->st_size
<<= 32;
5089 buf
->st_size
+= fs_low
;
5090 buf
->st_nlink
= nlinks
;
5092 /* Convert timestamps to Unix format. */
5093 buf
->st_mtime
= convert_time (wtime
);
5094 buf
->st_atime
= convert_time (atime
);
5095 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5096 buf
->st_ctime
= convert_time (ctime
);
5097 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5099 /* determine rwx permissions */
5100 if (is_a_symlink
&& !follow_symlinks
)
5101 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
5104 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
5105 permission
= S_IREAD
;
5107 permission
= S_IREAD
| S_IWRITE
;
5109 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5110 permission
|= S_IEXEC
;
5111 else if (is_exec (name
))
5112 permission
|= S_IEXEC
;
5115 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5121 stat (const char * path
, struct stat
* buf
)
5123 return stat_worker (path
, buf
, 1);
5127 lstat (const char * path
, struct stat
* buf
)
5129 return stat_worker (path
, buf
, 0);
5133 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
5135 /* Rely on a hack: an open directory is modeled as file descriptor 0.
5136 This is good enough for the current usage in Emacs, but is fragile.
5138 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
5139 Gnulib does this and can serve as a model. */
5140 char fullname
[MAX_UTF8_PATH
];
5144 char lastc
= dir_pathname
[strlen (dir_pathname
) - 1];
5146 if (_snprintf (fullname
, sizeof fullname
, "%s%s%s",
5147 dir_pathname
, IS_DIRECTORY_SEP (lastc
) ? "" : "/", name
)
5150 errno
= ENAMETOOLONG
;
5156 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
5159 /* Provide fstat and utime as well as stat for consistent handling of
5162 fstat (int desc
, struct stat
* buf
)
5164 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
5165 BY_HANDLE_FILE_INFORMATION info
;
5166 unsigned __int64 fake_inode
;
5169 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
5171 case FILE_TYPE_DISK
:
5172 buf
->st_mode
= S_IFREG
;
5173 if (!GetFileInformationByHandle (fh
, &info
))
5179 case FILE_TYPE_PIPE
:
5180 buf
->st_mode
= S_IFIFO
;
5182 case FILE_TYPE_CHAR
:
5183 case FILE_TYPE_UNKNOWN
:
5185 buf
->st_mode
= S_IFCHR
;
5187 memset (&info
, 0, sizeof (info
));
5188 info
.dwFileAttributes
= 0;
5189 info
.ftCreationTime
= utc_base_ft
;
5190 info
.ftLastAccessTime
= utc_base_ft
;
5191 info
.ftLastWriteTime
= utc_base_ft
;
5194 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5195 buf
->st_mode
= S_IFDIR
;
5197 buf
->st_nlink
= info
.nNumberOfLinks
;
5198 /* Might as well use file index to fake inode values, but this
5199 is not guaranteed to be unique unless we keep a handle open
5200 all the time (even then there are situations where it is
5201 not unique). Reputedly, there are at most 48 bits of info
5202 (on NTFS, presumably less on FAT). */
5203 fake_inode
= info
.nFileIndexHigh
;
5205 fake_inode
+= info
.nFileIndexLow
;
5207 /* MSVC defines _ino_t to be short; other libc's might not. */
5208 if (sizeof (buf
->st_ino
) == 2)
5209 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
5211 buf
->st_ino
= fake_inode
;
5213 /* If the caller so requested, get the true file owner and group.
5214 Otherwise, consider the file to belong to the current user. */
5215 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
5216 get_file_owner_and_group (NULL
, buf
);
5219 PSECURITY_DESCRIPTOR psd
= NULL
;
5221 psd
= get_file_security_desc_by_handle (fh
);
5224 get_file_owner_and_group (psd
, buf
);
5228 get_file_owner_and_group (NULL
, buf
);
5231 buf
->st_dev
= info
.dwVolumeSerialNumber
;
5232 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
5234 buf
->st_size
= info
.nFileSizeHigh
;
5235 buf
->st_size
<<= 32;
5236 buf
->st_size
+= info
.nFileSizeLow
;
5238 /* Convert timestamps to Unix format. */
5239 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
5240 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
5241 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5242 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
5243 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5245 /* determine rwx permissions */
5246 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
5247 permission
= S_IREAD
;
5249 permission
= S_IREAD
| S_IWRITE
;
5251 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5252 permission
|= S_IEXEC
;
5255 #if 0 /* no way of knowing the filename */
5256 char * p
= strrchr (name
, '.');
5258 (xstrcasecmp (p
, ".exe") == 0 ||
5259 xstrcasecmp (p
, ".com") == 0 ||
5260 xstrcasecmp (p
, ".bat") == 0 ||
5261 xstrcasecmp (p
, ".cmd") == 0))
5262 permission
|= S_IEXEC
;
5266 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5271 /* A version of 'utime' which handles directories as well as
5275 utime (const char *name
, struct utimbuf
*times
)
5277 struct utimbuf deftime
;
5284 deftime
.modtime
= deftime
.actime
= time (NULL
);
5288 if (w32_unicode_filenames
)
5290 wchar_t name_utf16
[MAX_PATH
];
5292 if (filename_to_utf16 (name
, name_utf16
) != 0)
5293 return -1; /* errno set by filename_to_utf16 */
5295 /* Need write access to set times. */
5296 fh
= CreateFileW (name_utf16
, FILE_WRITE_ATTRIBUTES
,
5297 /* If NAME specifies a directory, FILE_SHARE_DELETE
5298 allows other processes to delete files inside it,
5299 while we have the directory open. */
5300 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5301 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5305 char name_ansi
[MAX_PATH
];
5307 if (filename_to_ansi (name
, name_ansi
) != 0)
5308 return -1; /* errno set by filename_to_ansi */
5310 fh
= CreateFileA (name_ansi
, FILE_WRITE_ATTRIBUTES
,
5311 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5312 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5314 if (fh
!= INVALID_HANDLE_VALUE
)
5316 convert_from_time_t (times
->actime
, &atime
);
5317 convert_from_time_t (times
->modtime
, &mtime
);
5318 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
5328 DWORD err
= GetLastError ();
5332 case ERROR_FILE_NOT_FOUND
:
5333 case ERROR_PATH_NOT_FOUND
:
5334 case ERROR_INVALID_DRIVE
:
5335 case ERROR_BAD_NETPATH
:
5336 case ERROR_DEV_NOT_EXIST
:
5337 /* ERROR_INVALID_NAME is the error CreateFile sets when the
5338 file name includes ?s, i.e. translation to ANSI failed. */
5339 case ERROR_INVALID_NAME
:
5342 case ERROR_TOO_MANY_OPEN_FILES
:
5345 case ERROR_ACCESS_DENIED
:
5346 case ERROR_SHARING_VIOLATION
:
5359 sys_umask (int mode
)
5361 static int current_mask
;
5362 int retval
, arg
= 0;
5364 /* The only bit we really support is the write bit. Files are
5365 always readable on MS-Windows, and the execute bit does not exist
5367 /* FIXME: if the GROUP and OTHER bits are reset, we should use ACLs
5368 to prevent access by other users on NTFS. */
5369 if ((mode
& S_IWRITE
) != 0)
5372 retval
= _umask (arg
);
5373 /* Merge into the return value the bits they've set the last time,
5374 which msvcrt.dll ignores and never returns. Emacs insists on its
5375 notion of mask being identical to what we return. */
5376 retval
|= (current_mask
& ~S_IWRITE
);
5377 current_mask
= mode
;
5383 /* Symlink-related functions. */
5384 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
5385 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
5389 symlink (char const *filename
, char const *linkname
)
5391 char linkfn
[MAX_UTF8_PATH
], *tgtfn
;
5393 int dir_access
, filename_ends_in_slash
;
5395 /* Diagnostics follows Posix as much as possible. */
5396 if (filename
== NULL
|| linkname
== NULL
)
5406 if (strlen (filename
) > MAX_UTF8_PATH
|| strlen (linkname
) > MAX_UTF8_PATH
)
5408 errno
= ENAMETOOLONG
;
5412 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
5413 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
5419 /* Note: since empty FILENAME was already rejected, we can safely
5420 refer to FILENAME[1]. */
5421 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
5423 /* Non-absolute FILENAME is understood as being relative to
5424 LINKNAME's directory. We need to prepend that directory to
5425 FILENAME to get correct results from faccessat below, since
5426 otherwise it will interpret FILENAME relative to the
5427 directory where the Emacs process runs. Note that
5428 make-symbolic-link always makes sure LINKNAME is a fully
5429 expanded file name. */
5430 char tem
[MAX_UTF8_PATH
];
5431 char *p
= linkfn
+ strlen (linkfn
);
5433 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
5436 strncpy (tem
, linkfn
, p
- linkfn
);
5437 tem
[p
- linkfn
] = '\0';
5438 strcat (tem
, filename
);
5439 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
5442 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
5444 /* Since Windows distinguishes between symlinks to directories and
5445 to files, we provide a kludgy feature: if FILENAME doesn't
5446 exist, but ends in a slash, we create a symlink to directory. If
5447 FILENAME exists and is a directory, we always create a symlink to
5449 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
5450 if (dir_access
== 0 || filename_ends_in_slash
)
5451 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
5453 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
5454 if (filename_ends_in_slash
)
5455 tgtfn
[strlen (tgtfn
) - 1] = '\0';
5458 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
5460 /* ENOSYS is set by create_symbolic_link, when it detects that
5461 the OS doesn't support the CreateSymbolicLink API. */
5462 if (errno
!= ENOSYS
)
5464 DWORD w32err
= GetLastError ();
5468 /* ERROR_SUCCESS is sometimes returned when LINKFN and
5469 TGTFN point to the same file name, go figure. */
5471 case ERROR_FILE_EXISTS
:
5474 case ERROR_ACCESS_DENIED
:
5477 case ERROR_FILE_NOT_FOUND
:
5478 case ERROR_PATH_NOT_FOUND
:
5479 case ERROR_BAD_NETPATH
:
5480 case ERROR_INVALID_REPARSE_DATA
:
5483 case ERROR_DIRECTORY
:
5486 case ERROR_PRIVILEGE_NOT_HELD
:
5487 case ERROR_NOT_ALL_ASSIGNED
:
5490 case ERROR_DISK_FULL
:
5503 /* A quick inexpensive test of whether FILENAME identifies a file that
5504 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
5505 must already be in the normalized form returned by
5508 Note: for repeated operations on many files, it is best to test
5509 whether the underlying volume actually supports symlinks, by
5510 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
5511 avoid the call to this function if it doesn't. That's because the
5512 call to GetFileAttributes takes a non-negligible time, especially
5513 on non-local or removable filesystems. See stat_worker for an
5514 example of how to do that. */
5516 is_symlink (const char *filename
)
5519 wchar_t filename_w
[MAX_PATH
];
5520 char filename_a
[MAX_PATH
];
5521 WIN32_FIND_DATAW wfdw
;
5522 WIN32_FIND_DATAA wfda
;
5524 int attrs_mean_symlink
;
5526 if (w32_unicode_filenames
)
5528 filename_to_utf16 (filename
, filename_w
);
5529 attrs
= GetFileAttributesW (filename_w
);
5533 filename_to_ansi (filename
, filename_a
);
5534 attrs
= GetFileAttributesA (filename_a
);
5538 DWORD w32err
= GetLastError ();
5542 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
5544 case ERROR_ACCESS_DENIED
:
5547 case ERROR_FILE_NOT_FOUND
:
5548 case ERROR_PATH_NOT_FOUND
:
5555 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
5557 logon_network_drive (filename
);
5558 if (w32_unicode_filenames
)
5560 fh
= FindFirstFileW (filename_w
, &wfdw
);
5561 attrs_mean_symlink
=
5562 (wfdw
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5563 && (wfdw
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5565 else if (_mbspbrk (filename_a
, "?"))
5567 /* filename_to_ansi failed to convert the file name. */
5573 fh
= FindFirstFileA (filename_a
, &wfda
);
5574 attrs_mean_symlink
=
5575 (wfda
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5576 && (wfda
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5578 if (fh
== INVALID_HANDLE_VALUE
)
5581 return attrs_mean_symlink
;
5584 /* If NAME identifies a symbolic link, copy into BUF the file name of
5585 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
5586 null-terminate the target name, even if it fits. Return the number
5587 of bytes copied, or -1 if NAME is not a symlink or any error was
5588 encountered while resolving it. The file name copied into BUF is
5589 encoded in the current ANSI codepage. */
5591 readlink (const char *name
, char *buf
, size_t buf_size
)
5594 TOKEN_PRIVILEGES privs
;
5595 int restore_privs
= 0;
5598 char resolved
[MAX_UTF8_PATH
];
5611 path
= map_w32_filename (name
, NULL
);
5613 if (strlen (path
) > MAX_UTF8_PATH
)
5615 errno
= ENAMETOOLONG
;
5620 if (is_windows_9x () == TRUE
5621 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
5622 || !is_symlink (path
))
5625 errno
= EINVAL
; /* not a symlink */
5629 /* Done with simple tests, now we're in for some _real_ work. */
5630 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
5632 /* Implementation note: From here and onward, don't return early,
5633 since that will fail to restore the original set of privileges of
5634 the calling thread. */
5636 retval
= -1; /* not too optimistic, are we? */
5638 /* Note: In the next call to CreateFile, we use zero as the 2nd
5639 argument because, when the symlink is a hidden/system file,
5640 e.g. 'C:\Users\All Users', GENERIC_READ fails with
5641 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
5642 and directory symlinks. */
5643 if (w32_unicode_filenames
)
5645 wchar_t path_w
[MAX_PATH
];
5647 filename_to_utf16 (path
, path_w
);
5648 sh
= CreateFileW (path_w
, 0, 0, NULL
, OPEN_EXISTING
,
5649 FILE_FLAG_OPEN_REPARSE_POINT
5650 | FILE_FLAG_BACKUP_SEMANTICS
,
5655 char path_a
[MAX_PATH
];
5657 filename_to_ansi (path
, path_a
);
5658 sh
= CreateFileA (path_a
, 0, 0, NULL
, OPEN_EXISTING
,
5659 FILE_FLAG_OPEN_REPARSE_POINT
5660 | FILE_FLAG_BACKUP_SEMANTICS
,
5663 if (sh
!= INVALID_HANDLE_VALUE
)
5665 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
5666 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
5669 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
5670 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
5673 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
5677 /* Copy the link target name, in wide characters, from
5678 reparse_data, then convert it to multibyte encoding in
5679 the current locale's codepage. */
5683 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
5685 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
5686 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
5687 size_t size_to_copy
= buf_size
;
5689 /* According to MSDN, PrintNameLength does not include the
5690 terminating null character. */
5691 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
5692 memcpy (lwname
, lwname_src
, lwname_len
);
5693 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
5694 filename_from_utf16 (lwname
, resolved
);
5695 dostounix_filename (resolved
);
5696 lname_size
= strlen (resolved
) + 1;
5697 if (lname_size
<= buf_size
)
5698 size_to_copy
= lname_size
;
5699 strncpy (buf
, resolved
, size_to_copy
);
5701 retval
= size_to_copy
;
5707 /* CreateFile failed. */
5708 DWORD w32err2
= GetLastError ();
5712 case ERROR_FILE_NOT_FOUND
:
5713 case ERROR_PATH_NOT_FOUND
:
5716 case ERROR_ACCESS_DENIED
:
5717 case ERROR_TOO_MANY_OPEN_FILES
:
5727 restore_privilege (&privs
);
5735 readlinkat (int fd
, char const *name
, char *buffer
,
5738 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5739 as in fstatat. FIXME: Add proper support for readlinkat. */
5740 char fullname
[MAX_UTF8_PATH
];
5744 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
5747 errno
= ENAMETOOLONG
;
5753 return readlink (name
, buffer
, buffer_size
);
5756 /* If FILE is a symlink, return its target (stored in a static
5757 buffer); otherwise return FILE.
5759 This function repeatedly resolves symlinks in the last component of
5760 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5761 until it arrives at a file whose last component is not a symlink,
5762 or some error occurs. It returns the target of the last
5763 successfully resolved symlink in the chain. If it succeeds to
5764 resolve even a single symlink, the value returned is an absolute
5765 file name with backslashes (result of GetFullPathName). By
5766 contrast, if the original FILE is returned, it is unaltered.
5768 Note: This function can set errno even if it succeeds.
5770 Implementation note: we only resolve the last portion ("basename")
5771 of the argument FILE and of each following file in the chain,
5772 disregarding any possible symlinks in its leading directories.
5773 This is because Windows system calls and library functions
5774 transparently resolve symlinks in leading directories and return
5775 correct information, as long as the basename is not a symlink. */
5777 chase_symlinks (const char *file
)
5779 static char target
[MAX_UTF8_PATH
];
5780 char link
[MAX_UTF8_PATH
];
5781 wchar_t target_w
[MAX_PATH
], link_w
[MAX_PATH
];
5782 char target_a
[MAX_PATH
], link_a
[MAX_PATH
];
5783 ssize_t res
, link_len
;
5786 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
5787 return (char *)file
;
5789 if (w32_unicode_filenames
)
5791 wchar_t file_w
[MAX_PATH
];
5793 filename_to_utf16 (file
, file_w
);
5794 if (GetFullPathNameW (file_w
, MAX_PATH
, link_w
, NULL
) == 0)
5795 return (char *)file
;
5796 filename_from_utf16 (link_w
, link
);
5800 char file_a
[MAX_PATH
];
5802 filename_to_ansi (file
, file_a
);
5803 if (GetFullPathNameA (file_a
, MAX_PATH
, link_a
, NULL
) == 0)
5804 return (char *)file
;
5805 filename_from_ansi (link_a
, link
);
5807 link_len
= strlen (link
);
5812 /* Remove trailing slashes, as we want to resolve the last
5813 non-trivial part of the link name. */
5814 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
5815 link
[link_len
--] = '\0';
5817 res
= readlink (link
, target
, MAX_UTF8_PATH
);
5821 if (!(IS_DEVICE_SEP (target
[1])
5822 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5824 /* Target is relative. Append it to the directory part of
5825 the symlink, then copy the result back to target. */
5826 char *p
= link
+ link_len
;
5828 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5831 strcpy (target
, link
);
5833 /* Resolve any "." and ".." to get a fully-qualified file name
5835 if (w32_unicode_filenames
)
5837 filename_to_utf16 (target
, target_w
);
5838 link_len
= GetFullPathNameW (target_w
, MAX_PATH
, link_w
, NULL
);
5840 filename_from_utf16 (link_w
, link
);
5844 filename_to_ansi (target
, target_a
);
5845 link_len
= GetFullPathNameA (target_a
, MAX_PATH
, link_a
, NULL
);
5847 filename_from_ansi (link_a
, link
);
5849 link_len
= strlen (link
);
5851 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5853 if (loop_count
> 100)
5856 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5857 return (char *)file
;
5862 /* Posix ACL emulation. */
5865 acl_valid (acl_t acl
)
5867 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5871 acl_to_text (acl_t acl
, ssize_t
*size
)
5874 SECURITY_INFORMATION flags
=
5875 OWNER_SECURITY_INFORMATION
|
5876 GROUP_SECURITY_INFORMATION
|
5877 DACL_SECURITY_INFORMATION
;
5878 char *retval
= NULL
;
5884 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5887 /* We don't want to mix heaps, so we duplicate the string in our
5888 heap and free the one allocated by the API. */
5889 retval
= xstrdup (str_acl
);
5892 LocalFree (str_acl
);
5894 else if (errno
!= ENOTSUP
)
5901 acl_from_text (const char *acl_str
)
5903 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5909 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5912 retval
= xmalloc (sd_size
);
5913 memcpy (retval
, psd
, sd_size
);
5916 else if (errno
!= ENOTSUP
)
5923 acl_free (void *ptr
)
5930 acl_get_file (const char *fname
, acl_type_t type
)
5932 PSECURITY_DESCRIPTOR psd
= NULL
;
5933 const char *filename
;
5935 if (type
== ACL_TYPE_ACCESS
)
5938 SECURITY_INFORMATION si
=
5939 OWNER_SECURITY_INFORMATION
|
5940 GROUP_SECURITY_INFORMATION
|
5941 DACL_SECURITY_INFORMATION
;
5944 filename
= map_w32_filename (fname
, NULL
);
5945 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5946 fname
= chase_symlinks (filename
);
5951 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5952 && errno
!= ENOTSUP
)
5954 err
= GetLastError ();
5955 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5957 psd
= xmalloc (sd_len
);
5958 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5965 else if (err
== ERROR_FILE_NOT_FOUND
5966 || err
== ERROR_PATH_NOT_FOUND
5967 /* ERROR_INVALID_NAME is what we get if
5968 w32-unicode-filenames is nil and the file cannot
5969 be encoded in the current ANSI codepage. */
5970 || err
== ERROR_INVALID_NAME
)
5978 else if (type
!= ACL_TYPE_DEFAULT
)
5985 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
5987 TOKEN_PRIVILEGES old1
, old2
;
5989 int st
= 0, retval
= -1;
5990 SECURITY_INFORMATION flags
= 0;
5991 PSID psidOwner
, psidGroup
;
5996 const char *filename
;
5998 if (acl_valid (acl
) != 0
5999 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
6005 if (type
== ACL_TYPE_DEFAULT
)
6011 filename
= map_w32_filename (fname
, NULL
);
6012 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
6013 fname
= chase_symlinks (filename
);
6017 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psidOwner
,
6020 flags
|= OWNER_SECURITY_INFORMATION
;
6021 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psidGroup
,
6024 flags
|= GROUP_SECURITY_INFORMATION
;
6025 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
6028 flags
|= DACL_SECURITY_INFORMATION
;
6032 /* According to KB-245153, setting the owner will succeed if either:
6033 (1) the caller is the user who will be the new owner, and has the
6034 SE_TAKE_OWNERSHIP privilege, or
6035 (2) the caller has the SE_RESTORE privilege, in which case she can
6036 set any valid user or group as the owner
6038 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
6039 privileges, and disregard any failures in obtaining them. If
6040 these privileges cannot be obtained, and do not already exist in
6041 the calling thread's security token, this function could fail
6043 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
6045 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
6050 /* SetFileSecurity is deprecated by MS, and sometimes fails when
6051 DACL inheritance is involved, but it seems to preserve ownership
6052 better than SetNamedSecurityInfo, which is important e.g., in
6054 if (!set_file_security (fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
6056 err
= GetLastError ();
6058 if (errno
!= ENOTSUP
)
6059 err
= set_named_security_info (fname
, SE_FILE_OBJECT
, flags
,
6060 psidOwner
, psidGroup
, pacl
, NULL
);
6063 err
= ERROR_SUCCESS
;
6064 if (err
!= ERROR_SUCCESS
)
6066 if (errno
== ENOTSUP
)
6068 else if (err
== ERROR_INVALID_OWNER
6069 || err
== ERROR_NOT_ALL_ASSIGNED
6070 || err
== ERROR_ACCESS_DENIED
)
6072 /* Maybe the requested ACL and the one the file already has
6073 are identical, in which case we can silently ignore the
6074 failure. (And no, Windows doesn't.) */
6075 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
6080 char *acl_from
= acl_to_text (current_acl
, NULL
);
6081 char *acl_to
= acl_to_text (acl
, NULL
);
6083 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
6089 acl_free (acl_from
);
6092 acl_free (current_acl
);
6095 else if (err
== ERROR_FILE_NOT_FOUND
6096 || err
== ERROR_PATH_NOT_FOUND
6097 /* ERROR_INVALID_NAME is what we get if
6098 w32-unicode-filenames is nil and the file cannot be
6099 encoded in the current ANSI codepage. */
6100 || err
== ERROR_INVALID_NAME
)
6114 restore_privilege (&old2
);
6115 restore_privilege (&old1
);
6123 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
6124 have a fixed max size for file names, so we don't need the kind of
6125 alloc/malloc/realloc dance the gnulib version does. We also don't
6126 support FD-relative symlinks. */
6128 careadlinkat (int fd
, char const *filename
,
6129 char *buffer
, size_t buffer_size
,
6130 struct allocator
const *alloc
,
6131 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
6133 char linkname
[MAX_UTF8_PATH
];
6136 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
6140 char *retval
= buffer
;
6142 linkname
[link_size
++] = '\0';
6143 if (link_size
> buffer_size
)
6144 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
6146 memcpy (retval
, linkname
, link_size
);
6154 w32_copy_file (const char *from
, const char *to
,
6155 int keep_time
, int preserve_ownership
, int copy_acls
)
6159 wchar_t from_w
[MAX_PATH
], to_w
[MAX_PATH
];
6160 char from_a
[MAX_PATH
], to_a
[MAX_PATH
];
6162 /* We ignore preserve_ownership for now. */
6163 preserve_ownership
= preserve_ownership
;
6167 acl
= acl_get_file (from
, ACL_TYPE_ACCESS
);
6168 if (acl
== NULL
&& acl_errno_valid (errno
))
6171 if (w32_unicode_filenames
)
6173 filename_to_utf16 (from
, from_w
);
6174 filename_to_utf16 (to
, to_w
);
6175 copy_result
= CopyFileW (from_w
, to_w
, FALSE
);
6179 filename_to_ansi (from
, from_a
);
6180 filename_to_ansi (to
, to_a
);
6181 copy_result
= CopyFileA (from_a
, to_a
, FALSE
);
6185 /* CopyFile doesn't set errno when it fails. By far the most
6186 "popular" reason is that the target is read-only. */
6187 DWORD err
= GetLastError ();
6191 case ERROR_FILE_NOT_FOUND
:
6194 case ERROR_ACCESS_DENIED
:
6197 case ERROR_ENCRYPTION_FAILED
:
6209 /* CopyFile retains the timestamp by default. However, see
6210 "Community Additions" for CopyFile: it sounds like that is not
6211 entirely true. Testing on Windows XP confirms that modified time
6212 is copied, but creation and last-access times are not.
6214 else if (!keep_time
)
6216 struct timespec now
;
6219 if (w32_unicode_filenames
)
6221 /* Ensure file is writable while its times are set. */
6222 attributes
= GetFileAttributesW (to_w
);
6223 SetFileAttributesW (to_w
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6224 now
= current_timespec ();
6225 if (set_file_times (-1, to
, now
, now
))
6227 /* Restore original attributes. */
6228 SetFileAttributesW (to_w
, attributes
);
6233 /* Restore original attributes. */
6234 SetFileAttributesW (to_w
, attributes
);
6238 attributes
= GetFileAttributesA (to_a
);
6239 SetFileAttributesA (to_a
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6240 now
= current_timespec ();
6241 if (set_file_times (-1, to
, now
, now
))
6243 SetFileAttributesA (to_a
, attributes
);
6248 SetFileAttributesA (to_a
, attributes
);
6254 acl_set_file (to
, ACL_TYPE_ACCESS
, acl
) != 0;
6256 if (fail
&& acl_errno_valid (errno
))
6264 /* Support for browsing other processes and their attributes. See
6265 process.c for the Lisp bindings. */
6267 /* Helper wrapper functions. */
6269 static HANDLE WINAPI
6270 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
6272 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
6274 if (g_b_init_create_toolhelp32_snapshot
== 0)
6276 g_b_init_create_toolhelp32_snapshot
= 1;
6277 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
6278 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6279 "CreateToolhelp32Snapshot");
6281 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
6283 return INVALID_HANDLE_VALUE
;
6285 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
6289 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6291 static Process32First_Proc s_pfn_Process32_First
= NULL
;
6293 if (g_b_init_process32_first
== 0)
6295 g_b_init_process32_first
= 1;
6296 s_pfn_Process32_First
= (Process32First_Proc
)
6297 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6300 if (s_pfn_Process32_First
== NULL
)
6304 return (s_pfn_Process32_First (hSnapshot
, lppe
));
6308 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6310 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
6312 if (g_b_init_process32_next
== 0)
6314 g_b_init_process32_next
= 1;
6315 s_pfn_Process32_Next
= (Process32Next_Proc
)
6316 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6319 if (s_pfn_Process32_Next
== NULL
)
6323 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
6327 open_thread_token (HANDLE ThreadHandle
,
6328 DWORD DesiredAccess
,
6330 PHANDLE TokenHandle
)
6332 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
6333 HMODULE hm_advapi32
= NULL
;
6334 if (is_windows_9x () == TRUE
)
6336 SetLastError (ERROR_NOT_SUPPORTED
);
6339 if (g_b_init_open_thread_token
== 0)
6341 g_b_init_open_thread_token
= 1;
6342 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6343 s_pfn_Open_Thread_Token
=
6344 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
6346 if (s_pfn_Open_Thread_Token
== NULL
)
6348 SetLastError (ERROR_NOT_SUPPORTED
);
6352 s_pfn_Open_Thread_Token (
6361 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
6363 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
6364 HMODULE hm_advapi32
= NULL
;
6365 if (is_windows_9x () == TRUE
)
6369 if (g_b_init_impersonate_self
== 0)
6371 g_b_init_impersonate_self
= 1;
6372 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6373 s_pfn_Impersonate_Self
=
6374 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
6376 if (s_pfn_Impersonate_Self
== NULL
)
6380 return s_pfn_Impersonate_Self (ImpersonationLevel
);
6384 revert_to_self (void)
6386 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
6387 HMODULE hm_advapi32
= NULL
;
6388 if (is_windows_9x () == TRUE
)
6392 if (g_b_init_revert_to_self
== 0)
6394 g_b_init_revert_to_self
= 1;
6395 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6396 s_pfn_Revert_To_Self
=
6397 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
6399 if (s_pfn_Revert_To_Self
== NULL
)
6403 return s_pfn_Revert_To_Self ();
6407 get_process_memory_info (HANDLE h_proc
,
6408 PPROCESS_MEMORY_COUNTERS mem_counters
,
6411 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
6412 HMODULE hm_psapi
= NULL
;
6413 if (is_windows_9x () == TRUE
)
6417 if (g_b_init_get_process_memory_info
== 0)
6419 g_b_init_get_process_memory_info
= 1;
6420 hm_psapi
= LoadLibrary ("Psapi.dll");
6422 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
6423 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
6425 if (s_pfn_Get_Process_Memory_Info
== NULL
)
6429 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
6433 get_process_working_set_size (HANDLE h_proc
,
6437 static GetProcessWorkingSetSize_Proc
6438 s_pfn_Get_Process_Working_Set_Size
= NULL
;
6440 if (is_windows_9x () == TRUE
)
6444 if (g_b_init_get_process_working_set_size
== 0)
6446 g_b_init_get_process_working_set_size
= 1;
6447 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
6448 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6449 "GetProcessWorkingSetSize");
6451 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
6455 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
6459 global_memory_status (MEMORYSTATUS
*buf
)
6461 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
6463 if (is_windows_9x () == TRUE
)
6467 if (g_b_init_global_memory_status
== 0)
6469 g_b_init_global_memory_status
= 1;
6470 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
6471 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6472 "GlobalMemoryStatus");
6474 if (s_pfn_Global_Memory_Status
== NULL
)
6478 return s_pfn_Global_Memory_Status (buf
);
6482 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
6484 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
6486 if (is_windows_9x () == TRUE
)
6490 if (g_b_init_global_memory_status_ex
== 0)
6492 g_b_init_global_memory_status_ex
= 1;
6493 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
6494 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6495 "GlobalMemoryStatusEx");
6497 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
6501 return s_pfn_Global_Memory_Status_Ex (buf
);
6505 list_system_processes (void)
6507 struct gcpro gcpro1
;
6508 Lisp_Object proclist
= Qnil
;
6511 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6513 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6515 PROCESSENTRY32 proc_entry
;
6521 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
6522 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
6523 res
= process32_next (h_snapshot
, &proc_entry
))
6525 proc_id
= proc_entry
.th32ProcessID
;
6526 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
6529 CloseHandle (h_snapshot
);
6531 proclist
= Fnreverse (proclist
);
6538 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
6540 TOKEN_PRIVILEGES priv
;
6541 DWORD priv_size
= sizeof (priv
);
6542 DWORD opriv_size
= sizeof (*old_priv
);
6543 HANDLE h_token
= NULL
;
6544 HANDLE h_thread
= GetCurrentThread ();
6548 res
= open_thread_token (h_thread
,
6549 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6551 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
6553 if (impersonate_self (SecurityImpersonation
))
6554 res
= open_thread_token (h_thread
,
6555 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6560 priv
.PrivilegeCount
= 1;
6561 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
6562 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
6563 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
6564 old_priv
, &opriv_size
)
6565 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6569 CloseHandle (h_token
);
6575 restore_privilege (TOKEN_PRIVILEGES
*priv
)
6577 DWORD priv_size
= sizeof (*priv
);
6578 HANDLE h_token
= NULL
;
6581 if (open_thread_token (GetCurrentThread (),
6582 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6585 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
6586 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6590 CloseHandle (h_token
);
6596 ltime (ULONGLONG time_100ns
)
6598 ULONGLONG time_sec
= time_100ns
/ 10000000;
6599 int subsec
= time_100ns
% 10000000;
6600 return list4i (time_sec
>> 16, time_sec
& 0xffff,
6601 subsec
/ 10, subsec
% 10 * 100000);
6604 #define U64_TO_LISP_TIME(time) ltime (time)
6607 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
6608 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
6611 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
6612 ULONGLONG tem1
, tem2
, tem3
, tem
;
6615 || !get_process_times_fn
6616 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
6617 &ft_kernel
, &ft_user
))
6620 GetSystemTimeAsFileTime (&ft_current
);
6622 FILETIME_TO_U64 (tem1
, ft_kernel
);
6623 *stime
= U64_TO_LISP_TIME (tem1
);
6625 FILETIME_TO_U64 (tem2
, ft_user
);
6626 *utime
= U64_TO_LISP_TIME (tem2
);
6629 *ttime
= U64_TO_LISP_TIME (tem3
);
6631 FILETIME_TO_U64 (tem
, ft_creation
);
6632 /* Process no 4 (System) returns zero creation time. */
6635 *ctime
= U64_TO_LISP_TIME (tem
);
6639 FILETIME_TO_U64 (tem3
, ft_current
);
6640 tem
= (tem3
- utc_base
) - tem
;
6642 *etime
= U64_TO_LISP_TIME (tem
);
6646 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
6657 system_process_attributes (Lisp_Object pid
)
6659 struct gcpro gcpro1
, gcpro2
, gcpro3
;
6660 Lisp_Object attrs
= Qnil
;
6661 Lisp_Object cmd_str
, decoded_cmd
, tem
;
6662 HANDLE h_snapshot
, h_proc
;
6665 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
6666 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
6667 DWORD glength
= sizeof (gname
);
6668 HANDLE token
= NULL
;
6669 SID_NAME_USE user_type
;
6670 unsigned char *buf
= NULL
;
6672 TOKEN_USER user_token
;
6673 TOKEN_PRIMARY_GROUP group_token
;
6676 PROCESS_MEMORY_COUNTERS mem
;
6677 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
6678 SIZE_T minrss
, maxrss
;
6680 MEMORY_STATUS_EX memstex
;
6681 double totphys
= 0.0;
6682 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
6684 BOOL result
= FALSE
;
6686 CHECK_NUMBER_OR_FLOAT (pid
);
6687 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
6689 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6691 GCPRO3 (attrs
, decoded_cmd
, tem
);
6693 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6698 pe
.dwSize
= sizeof (PROCESSENTRY32
);
6699 for (res
= process32_first (h_snapshot
, &pe
); res
;
6700 res
= process32_next (h_snapshot
, &pe
))
6702 if (proc_id
== pe
.th32ProcessID
)
6705 decoded_cmd
= build_string ("Idle");
6708 /* Decode the command name from locale-specific
6710 cmd_str
= build_unibyte_string (pe
.szExeFile
);
6713 code_convert_string_norecord (cmd_str
,
6714 Vlocale_coding_system
, 0);
6716 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
6717 attrs
= Fcons (Fcons (Qppid
,
6718 make_fixnum_or_float (pe
.th32ParentProcessID
)),
6720 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
6722 attrs
= Fcons (Fcons (Qthcount
,
6723 make_fixnum_or_float (pe
.cntThreads
)),
6730 CloseHandle (h_snapshot
);
6739 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6741 /* If we were denied a handle to the process, try again after
6742 enabling the SeDebugPrivilege in our process. */
6745 TOKEN_PRIVILEGES priv_current
;
6747 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
6749 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6751 restore_privilege (&priv_current
);
6757 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
6760 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
6761 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6763 buf
= xmalloc (blen
);
6764 result
= get_token_information (token
, TokenUser
,
6765 (LPVOID
)buf
, blen
, &needed
);
6768 memcpy (&user_token
, buf
, sizeof (user_token
));
6769 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
6771 euid
= get_rid (user_token
.User
.Sid
);
6772 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
6777 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
6780 strcpy (uname
, "unknown");
6784 ulength
= strlen (uname
);
6790 /* Determine a reasonable euid and gid values. */
6791 if (xstrcasecmp ("administrator", uname
) == 0)
6793 euid
= 500; /* well-known Administrator uid */
6794 egid
= 513; /* well-known None gid */
6798 /* Get group id and name. */
6799 result
= get_token_information (token
, TokenPrimaryGroup
,
6800 (LPVOID
)buf
, blen
, &needed
);
6801 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6803 buf
= xrealloc (buf
, blen
= needed
);
6804 result
= get_token_information (token
, TokenPrimaryGroup
,
6805 (LPVOID
)buf
, blen
, &needed
);
6809 memcpy (&group_token
, buf
, sizeof (group_token
));
6810 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
6812 egid
= get_rid (group_token
.PrimaryGroup
);
6813 dlength
= sizeof (domain
);
6815 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
6816 gname
, &glength
, NULL
, &dlength
,
6819 w32_add_to_cache (group_token
.PrimaryGroup
,
6823 strcpy (gname
, "None");
6827 glength
= strlen (gname
);
6835 if (!is_windows_9x ())
6837 /* We couldn't open the process token, presumably because of
6838 insufficient access rights. Assume this process is run
6840 strcpy (uname
, "SYSTEM");
6841 strcpy (gname
, "None");
6842 euid
= 18; /* SYSTEM */
6843 egid
= 513; /* None */
6844 glength
= strlen (gname
);
6845 ulength
= strlen (uname
);
6847 /* If we are running under Windows 9X, where security calls are
6848 not supported, we assume all processes are run by the current
6850 else if (GetUserName (uname
, &ulength
))
6852 if (xstrcasecmp ("administrator", uname
) == 0)
6857 strcpy (gname
, "None");
6858 glength
= strlen (gname
);
6859 ulength
= strlen (uname
);
6865 strcpy (uname
, "administrator");
6866 ulength
= strlen (uname
);
6867 strcpy (gname
, "None");
6868 glength
= strlen (gname
);
6871 CloseHandle (token
);
6874 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
6875 tem
= make_unibyte_string (uname
, ulength
);
6876 attrs
= Fcons (Fcons (Quser
,
6877 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6879 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
6880 tem
= make_unibyte_string (gname
, glength
);
6881 attrs
= Fcons (Fcons (Qgroup
,
6882 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6885 if (global_memory_status_ex (&memstex
))
6886 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
6887 totphys
= memstex
.ullTotalPhys
/ 1024.0;
6889 /* Visual Studio 6 cannot convert an unsigned __int64 type to
6890 double, so we need to do this for it... */
6892 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
6893 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
6894 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
6896 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
6898 #endif /* __GNUC__ || _MSC_VER >= 1300 */
6899 else if (global_memory_status (&memst
))
6900 totphys
= memst
.dwTotalPhys
/ 1024.0;
6903 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
6906 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6908 attrs
= Fcons (Fcons (Qmajflt
,
6909 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
6911 attrs
= Fcons (Fcons (Qvsize
,
6912 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
6914 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6916 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6919 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
6921 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6923 attrs
= Fcons (Fcons (Qmajflt
,
6924 make_fixnum_or_float (mem
.PageFaultCount
)),
6926 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6928 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6931 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
6933 DWORD rss
= maxrss
/ 1024;
6935 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
6937 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6940 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
6942 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
6943 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
6944 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
6945 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
6946 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
6947 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
6950 /* FIXME: Retrieve command line by walking the PEB of the process. */
6953 CloseHandle (h_proc
);
6959 /* Wrappers for winsock functions to map between our file descriptors
6960 and winsock's handles; also set h_errno for convenience.
6962 To allow Emacs to run on systems which don't have winsock support
6963 installed, we dynamically link to winsock on startup if present, and
6964 otherwise provide the minimum necessary functionality
6965 (eg. gethostname). */
6967 /* function pointers for relevant socket functions */
6968 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
6969 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
6970 int (PASCAL
*pfn_WSAGetLastError
) (void);
6971 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
6972 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
6973 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
6974 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
6975 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6976 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6977 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
6978 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
6979 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
6980 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
6981 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
6982 int (PASCAL
*pfn_WSACleanup
) (void);
6984 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
6985 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
6986 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
6987 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
6988 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
6989 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
6990 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
6991 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
6992 const char * optval
, int optlen
);
6993 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
6994 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
6996 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
6997 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
6998 struct sockaddr
* from
, int * fromlen
);
6999 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
7000 const struct sockaddr
* to
, int tolen
);
7002 /* SetHandleInformation is only needed to make sockets non-inheritable. */
7003 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
7004 #ifndef HANDLE_FLAG_INHERIT
7005 #define HANDLE_FLAG_INHERIT 1
7009 static int winsock_inuse
;
7014 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
7016 release_listen_threads ();
7017 /* Not sure what would cause WSAENETDOWN, or even if it can happen
7018 after WSAStartup returns successfully, but it seems reasonable
7019 to allow unloading winsock anyway in that case. */
7020 if (pfn_WSACleanup () == 0 ||
7021 pfn_WSAGetLastError () == WSAENETDOWN
)
7023 if (FreeLibrary (winsock_lib
))
7032 init_winsock (int load_now
)
7034 WSADATA winsockData
;
7036 if (winsock_lib
!= NULL
)
7039 pfn_SetHandleInformation
7040 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
7041 "SetHandleInformation");
7043 winsock_lib
= LoadLibrary ("Ws2_32.dll");
7045 if (winsock_lib
!= NULL
)
7047 /* dynamically link to socket functions */
7049 #define LOAD_PROC(fn) \
7050 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
7053 LOAD_PROC (WSAStartup
);
7054 LOAD_PROC (WSASetLastError
);
7055 LOAD_PROC (WSAGetLastError
);
7056 LOAD_PROC (WSAEventSelect
);
7057 LOAD_PROC (WSACreateEvent
);
7058 LOAD_PROC (WSACloseEvent
);
7061 LOAD_PROC (connect
);
7062 LOAD_PROC (ioctlsocket
);
7065 LOAD_PROC (closesocket
);
7066 LOAD_PROC (shutdown
);
7069 LOAD_PROC (inet_addr
);
7070 LOAD_PROC (gethostname
);
7071 LOAD_PROC (gethostbyname
);
7072 LOAD_PROC (getservbyname
);
7073 LOAD_PROC (getpeername
);
7074 LOAD_PROC (WSACleanup
);
7075 LOAD_PROC (setsockopt
);
7077 LOAD_PROC (getsockname
);
7079 LOAD_PROC (recvfrom
);
7083 /* specify version 1.1 of winsock */
7084 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
7086 if (winsockData
.wVersion
!= 0x101)
7091 /* Report that winsock exists and is usable, but leave
7092 socket functions disabled. I am assuming that calling
7093 WSAStartup does not require any network interaction,
7094 and in particular does not cause or require a dial-up
7095 connection to be established. */
7098 FreeLibrary (winsock_lib
);
7106 FreeLibrary (winsock_lib
);
7116 /* Function to map winsock error codes to errno codes for those errno
7117 code defined in errno.h (errno values not defined by errno.h are
7118 already in nt/inc/sys/socket.h). */
7125 if (winsock_lib
== NULL
)
7128 wsa_err
= pfn_WSAGetLastError ();
7132 case WSAEACCES
: errno
= EACCES
; break;
7133 case WSAEBADF
: errno
= EBADF
; break;
7134 case WSAEFAULT
: errno
= EFAULT
; break;
7135 case WSAEINTR
: errno
= EINTR
; break;
7136 case WSAEINVAL
: errno
= EINVAL
; break;
7137 case WSAEMFILE
: errno
= EMFILE
; break;
7138 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
7139 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
7140 default: errno
= wsa_err
; break;
7148 if (winsock_lib
!= NULL
)
7149 pfn_WSASetLastError (0);
7152 /* Extend strerror to handle the winsock-specific error codes. */
7156 } _wsa_errlist
[] = {
7157 {WSAEINTR
, "Interrupted function call"},
7158 {WSAEBADF
, "Bad file descriptor"},
7159 {WSAEACCES
, "Permission denied"},
7160 {WSAEFAULT
, "Bad address"},
7161 {WSAEINVAL
, "Invalid argument"},
7162 {WSAEMFILE
, "Too many open files"},
7164 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
7165 {WSAEINPROGRESS
, "Operation now in progress"},
7166 {WSAEALREADY
, "Operation already in progress"},
7167 {WSAENOTSOCK
, "Socket operation on non-socket"},
7168 {WSAEDESTADDRREQ
, "Destination address required"},
7169 {WSAEMSGSIZE
, "Message too long"},
7170 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
7171 {WSAENOPROTOOPT
, "Bad protocol option"},
7172 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
7173 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
7174 {WSAEOPNOTSUPP
, "Operation not supported"},
7175 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
7176 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
7177 {WSAEADDRINUSE
, "Address already in use"},
7178 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
7179 {WSAENETDOWN
, "Network is down"},
7180 {WSAENETUNREACH
, "Network is unreachable"},
7181 {WSAENETRESET
, "Network dropped connection on reset"},
7182 {WSAECONNABORTED
, "Software caused connection abort"},
7183 {WSAECONNRESET
, "Connection reset by peer"},
7184 {WSAENOBUFS
, "No buffer space available"},
7185 {WSAEISCONN
, "Socket is already connected"},
7186 {WSAENOTCONN
, "Socket is not connected"},
7187 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
7188 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
7189 {WSAETIMEDOUT
, "Connection timed out"},
7190 {WSAECONNREFUSED
, "Connection refused"},
7191 {WSAELOOP
, "Network loop"}, /* not sure */
7192 {WSAENAMETOOLONG
, "Name is too long"},
7193 {WSAEHOSTDOWN
, "Host is down"},
7194 {WSAEHOSTUNREACH
, "No route to host"},
7195 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
7196 {WSAEPROCLIM
, "Too many processes"},
7197 {WSAEUSERS
, "Too many users"}, /* not sure */
7198 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
7199 {WSAESTALE
, "Data is stale"}, /* not sure */
7200 {WSAEREMOTE
, "Remote error"}, /* not sure */
7202 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
7203 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
7204 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
7205 {WSAEDISCON
, "Graceful shutdown in progress"},
7207 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
7208 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
7209 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
7210 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
7211 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
7212 {WSASYSCALLFAILURE
, "System call failure"},
7213 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
7214 {WSATYPE_NOT_FOUND
, "Class type not found"},
7215 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
7216 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
7217 {WSAEREFUSED
, "Operation refused"}, /* not sure */
7220 {WSAHOST_NOT_FOUND
, "Host not found"},
7221 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
7222 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
7223 {WSANO_DATA
, "Valid name, no data record of requested type"},
7229 sys_strerror (int error_no
)
7232 static char unknown_msg
[40];
7234 if (error_no
>= 0 && error_no
< sys_nerr
)
7235 return sys_errlist
[error_no
];
7237 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
7238 if (_wsa_errlist
[i
].errnum
== error_no
)
7239 return _wsa_errlist
[i
].msg
;
7241 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
7245 /* [andrewi 3-May-96] I've had conflicting results using both methods,
7246 but I believe the method of keeping the socket handle separate (and
7247 insuring it is not inheritable) is the correct one. */
7249 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
7251 static int socket_to_fd (SOCKET s
);
7254 sys_socket (int af
, int type
, int protocol
)
7258 if (winsock_lib
== NULL
)
7261 return INVALID_SOCKET
;
7266 /* call the real socket function */
7267 s
= pfn_socket (af
, type
, protocol
);
7269 if (s
!= INVALID_SOCKET
)
7270 return socket_to_fd (s
);
7276 /* Convert a SOCKET to a file descriptor. */
7278 socket_to_fd (SOCKET s
)
7283 /* Although under NT 3.5 _open_osfhandle will accept a socket
7284 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
7285 that does not work under NT 3.1. However, we can get the same
7286 effect by using a backdoor function to replace an existing
7287 descriptor handle with the one we want. */
7289 /* allocate a file descriptor (with appropriate flags) */
7290 fd
= _open ("NUL:", _O_RDWR
);
7293 /* Make a non-inheritable copy of the socket handle. Note
7294 that it is possible that sockets aren't actually kernel
7295 handles, which appears to be the case on Windows 9x when
7296 the MS Proxy winsock client is installed. */
7298 /* Apparently there is a bug in NT 3.51 with some service
7299 packs, which prevents using DuplicateHandle to make a
7300 socket handle non-inheritable (causes WSACleanup to
7301 hang). The work-around is to use SetHandleInformation
7302 instead if it is available and implemented. */
7303 if (pfn_SetHandleInformation
)
7305 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
7309 HANDLE parent
= GetCurrentProcess ();
7310 HANDLE new_s
= INVALID_HANDLE_VALUE
;
7312 if (DuplicateHandle (parent
,
7318 DUPLICATE_SAME_ACCESS
))
7320 /* It is possible that DuplicateHandle succeeds even
7321 though the socket wasn't really a kernel handle,
7322 because a real handle has the same value. So
7323 test whether the new handle really is a socket. */
7324 long nonblocking
= 0;
7325 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
7327 pfn_closesocket (s
);
7332 CloseHandle (new_s
);
7337 eassert (fd
< MAXDESC
);
7338 fd_info
[fd
].hnd
= (HANDLE
) s
;
7340 /* set our own internal flags */
7341 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
7347 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7349 /* attach child_process to fd_info */
7350 if (fd_info
[ fd
].cp
!= NULL
)
7352 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
7356 fd_info
[ fd
].cp
= cp
;
7359 winsock_inuse
++; /* count open sockets */
7367 pfn_closesocket (s
);
7373 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
7375 if (winsock_lib
== NULL
)
7378 return SOCKET_ERROR
;
7382 if (fd_info
[s
].flags
& FILE_SOCKET
)
7384 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
7385 if (rc
== SOCKET_ERROR
)
7390 return SOCKET_ERROR
;
7394 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
7396 if (winsock_lib
== NULL
)
7399 return SOCKET_ERROR
;
7403 if (fd_info
[s
].flags
& FILE_SOCKET
)
7405 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
7406 if (rc
== SOCKET_ERROR
)
7411 return SOCKET_ERROR
;
7415 sys_htons (u_short hostshort
)
7417 return (winsock_lib
!= NULL
) ?
7418 pfn_htons (hostshort
) : hostshort
;
7422 sys_ntohs (u_short netshort
)
7424 return (winsock_lib
!= NULL
) ?
7425 pfn_ntohs (netshort
) : netshort
;
7429 sys_inet_addr (const char * cp
)
7431 return (winsock_lib
!= NULL
) ?
7432 pfn_inet_addr (cp
) : INADDR_NONE
;
7436 sys_gethostname (char * name
, int namelen
)
7438 if (winsock_lib
!= NULL
)
7443 retval
= pfn_gethostname (name
, namelen
);
7444 if (retval
== SOCKET_ERROR
)
7449 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
7450 return !GetComputerName (name
, (DWORD
*)&namelen
);
7453 return SOCKET_ERROR
;
7457 sys_gethostbyname (const char * name
)
7459 struct hostent
* host
;
7460 int h_err
= h_errno
;
7462 if (winsock_lib
== NULL
)
7464 h_errno
= NO_RECOVERY
;
7470 host
= pfn_gethostbyname (name
);
7482 sys_getservbyname (const char * name
, const char * proto
)
7484 struct servent
* serv
;
7486 if (winsock_lib
== NULL
)
7493 serv
= pfn_getservbyname (name
, proto
);
7500 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
7502 if (winsock_lib
== NULL
)
7505 return SOCKET_ERROR
;
7509 if (fd_info
[s
].flags
& FILE_SOCKET
)
7511 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
7512 if (rc
== SOCKET_ERROR
)
7517 return SOCKET_ERROR
;
7521 sys_shutdown (int s
, int how
)
7523 if (winsock_lib
== NULL
)
7526 return SOCKET_ERROR
;
7530 if (fd_info
[s
].flags
& FILE_SOCKET
)
7532 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
7533 if (rc
== SOCKET_ERROR
)
7538 return SOCKET_ERROR
;
7542 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
7544 if (winsock_lib
== NULL
)
7547 return SOCKET_ERROR
;
7551 if (fd_info
[s
].flags
& FILE_SOCKET
)
7553 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
7554 (const char *)optval
, optlen
);
7555 if (rc
== SOCKET_ERROR
)
7560 return SOCKET_ERROR
;
7564 sys_listen (int s
, int backlog
)
7566 if (winsock_lib
== NULL
)
7569 return SOCKET_ERROR
;
7573 if (fd_info
[s
].flags
& FILE_SOCKET
)
7575 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
7576 if (rc
== SOCKET_ERROR
)
7579 fd_info
[s
].flags
|= FILE_LISTEN
;
7583 return SOCKET_ERROR
;
7587 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
7589 if (winsock_lib
== NULL
)
7592 return SOCKET_ERROR
;
7596 if (fd_info
[s
].flags
& FILE_SOCKET
)
7598 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
7599 if (rc
== SOCKET_ERROR
)
7604 return SOCKET_ERROR
;
7608 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
7610 if (winsock_lib
== NULL
)
7617 if (fd_info
[s
].flags
& FILE_LISTEN
)
7619 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
7621 if (t
== INVALID_SOCKET
)
7624 fd
= socket_to_fd (t
);
7628 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7629 ResetEvent (fd_info
[s
].cp
->char_avail
);
7638 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
7639 struct sockaddr
* from
, int * fromlen
)
7641 if (winsock_lib
== NULL
)
7644 return SOCKET_ERROR
;
7648 if (fd_info
[s
].flags
& FILE_SOCKET
)
7650 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
7651 if (rc
== SOCKET_ERROR
)
7656 return SOCKET_ERROR
;
7660 sys_sendto (int s
, const char * buf
, int len
, int flags
,
7661 const struct sockaddr
* to
, int tolen
)
7663 if (winsock_lib
== NULL
)
7666 return SOCKET_ERROR
;
7670 if (fd_info
[s
].flags
& FILE_SOCKET
)
7672 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
7673 if (rc
== SOCKET_ERROR
)
7678 return SOCKET_ERROR
;
7681 /* Windows does not have an fcntl function. Provide an implementation
7682 good enough for Emacs. */
7684 fcntl (int s
, int cmd
, int options
)
7686 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
7687 invoked in a context where fd1 is closed and all descriptors less
7688 than fd1 are open, so sys_dup is an adequate implementation. */
7689 if (cmd
== F_DUPFD_CLOEXEC
)
7692 if (winsock_lib
== NULL
)
7699 if (fd_info
[s
].flags
& FILE_SOCKET
)
7701 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7703 unsigned long nblock
= 1;
7704 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
7705 if (rc
== SOCKET_ERROR
)
7707 /* Keep track of the fact that we set this to non-blocking. */
7708 fd_info
[s
].flags
|= FILE_NDELAY
;
7714 return SOCKET_ERROR
;
7718 return SOCKET_ERROR
;
7722 /* Shadow main io functions: we need to handle pipes and sockets more
7723 intelligently, and implement non-blocking mode as well. */
7736 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
7738 child_process
* cp
= fd_info
[fd
].cp
;
7740 fd_info
[fd
].cp
= NULL
;
7742 if (CHILD_ACTIVE (cp
))
7744 /* if last descriptor to active child_process then cleanup */
7746 for (i
= 0; i
< MAXDESC
; i
++)
7750 if (fd_info
[i
].cp
== cp
)
7755 if (fd_info
[fd
].flags
& FILE_SOCKET
)
7757 if (winsock_lib
== NULL
) emacs_abort ();
7759 pfn_shutdown (SOCK_HANDLE (fd
), 2);
7760 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
7762 winsock_inuse
--; /* count open sockets */
7764 /* If the process handle is NULL, it's either a socket
7765 or serial connection, or a subprocess that was
7766 already reaped by reap_subprocess, but whose
7767 resources were not yet freed, because its output was
7768 not fully read yet by the time it was reaped. (This
7769 usually happens with async subprocesses whose output
7770 is being read by Emacs.) Otherwise, this process was
7771 not reaped yet, so we set its FD to a negative value
7772 to make sure sys_select will eventually get to
7773 calling the SIGCHLD handler for it, which will then
7774 invoke waitpid and reap_subprocess. */
7775 if (cp
->procinfo
.hProcess
== NULL
)
7783 if (fd
>= 0 && fd
< MAXDESC
)
7784 fd_info
[fd
].flags
= 0;
7786 /* Note that sockets do not need special treatment here (at least on
7787 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
7788 closesocket is equivalent to CloseHandle, which is to be expected
7789 because socket handles are fully fledged kernel handles. */
7801 if (new_fd
>= 0 && new_fd
< MAXDESC
)
7803 /* duplicate our internal info as well */
7804 fd_info
[new_fd
] = fd_info
[fd
];
7810 sys_dup2 (int src
, int dst
)
7814 if (dst
< 0 || dst
>= MAXDESC
)
7820 /* make sure we close the destination first if it's a pipe or socket */
7821 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
7824 rc
= _dup2 (src
, dst
);
7827 /* duplicate our internal info as well */
7828 fd_info
[dst
] = fd_info
[src
];
7834 pipe2 (int * phandles
, int pipe2_flags
)
7839 eassert (pipe2_flags
== O_CLOEXEC
);
7841 /* make pipe handles non-inheritable; when we spawn a child, we
7842 replace the relevant handle with an inheritable one. Also put
7843 pipes into binary mode; we will do text mode translation ourselves
7845 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
7849 /* Protect against overflow, since Windows can open more handles than
7850 our fd_info array has room for. */
7851 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
7853 _close (phandles
[0]);
7854 _close (phandles
[1]);
7860 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
7861 fd_info
[phandles
[0]].flags
= flags
;
7863 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
7864 fd_info
[phandles
[1]].flags
= flags
;
7871 /* Function to do blocking read of one byte, needed to implement
7872 select. It is only allowed on communication ports, sockets, or
7875 _sys_read_ahead (int fd
)
7880 if (fd
< 0 || fd
>= MAXDESC
)
7881 return STATUS_READ_ERROR
;
7883 cp
= fd_info
[fd
].cp
;
7885 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7886 return STATUS_READ_ERROR
;
7888 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
7889 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
7891 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
7895 cp
->status
= STATUS_READ_IN_PROGRESS
;
7897 if (fd_info
[fd
].flags
& FILE_PIPE
)
7899 rc
= _read (fd
, &cp
->chr
, sizeof (char));
7901 /* Give subprocess time to buffer some more output for us before
7902 reporting that input is available; we need this because Windows 95
7903 connects DOS programs to pipes by making the pipe appear to be
7904 the normal console stdout - as a result most DOS programs will
7905 write to stdout without buffering, ie. one character at a
7906 time. Even some W32 programs do this - "dir" in a command
7907 shell on NT is very slow if we don't do this. */
7910 int wait
= w32_pipe_read_delay
;
7916 /* Yield remainder of our time slice, effectively giving a
7917 temporary priority boost to the child process. */
7921 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7923 HANDLE hnd
= fd_info
[fd
].hnd
;
7924 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7927 /* Configure timeouts for blocking read. */
7928 if (!GetCommTimeouts (hnd
, &ct
))
7930 cp
->status
= STATUS_READ_ERROR
;
7931 return STATUS_READ_ERROR
;
7933 ct
.ReadIntervalTimeout
= 0;
7934 ct
.ReadTotalTimeoutMultiplier
= 0;
7935 ct
.ReadTotalTimeoutConstant
= 0;
7936 if (!SetCommTimeouts (hnd
, &ct
))
7938 cp
->status
= STATUS_READ_ERROR
;
7939 return STATUS_READ_ERROR
;
7942 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
7944 if (GetLastError () != ERROR_IO_PENDING
)
7946 cp
->status
= STATUS_READ_ERROR
;
7947 return STATUS_READ_ERROR
;
7949 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7951 cp
->status
= STATUS_READ_ERROR
;
7952 return STATUS_READ_ERROR
;
7956 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
7958 unsigned long nblock
= 0;
7959 /* We always want this to block, so temporarily disable NDELAY. */
7960 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7961 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7963 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
7965 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7968 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7972 if (rc
== sizeof (char))
7973 cp
->status
= STATUS_READ_SUCCEEDED
;
7975 cp
->status
= STATUS_READ_FAILED
;
7981 _sys_wait_accept (int fd
)
7987 if (fd
< 0 || fd
>= MAXDESC
)
7988 return STATUS_READ_ERROR
;
7990 cp
= fd_info
[fd
].cp
;
7992 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7993 return STATUS_READ_ERROR
;
7995 cp
->status
= STATUS_READ_FAILED
;
7997 hEv
= pfn_WSACreateEvent ();
7998 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
7999 if (rc
!= SOCKET_ERROR
)
8002 rc
= WaitForSingleObject (hEv
, 500);
8004 } while (rc
== WAIT_TIMEOUT
8005 && cp
->status
!= STATUS_READ_ERROR
8007 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
8008 if (rc
== WAIT_OBJECT_0
)
8009 cp
->status
= STATUS_READ_SUCCEEDED
;
8011 pfn_WSACloseEvent (hEv
);
8017 sys_read (int fd
, char * buffer
, unsigned int count
)
8022 char * orig_buffer
= buffer
;
8030 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8032 child_process
*cp
= fd_info
[fd
].cp
;
8034 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
8042 /* re-read CR carried over from last read */
8043 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
8045 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
8049 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
8052 /* presence of a child_process structure means we are operating in
8053 non-blocking mode - otherwise we just call _read directly.
8054 Note that the child_process structure might be missing because
8055 reap_subprocess has been called; in this case the pipe is
8056 already broken, so calling _read on it is okay. */
8059 int current_status
= cp
->status
;
8061 switch (current_status
)
8063 case STATUS_READ_FAILED
:
8064 case STATUS_READ_ERROR
:
8065 /* report normal EOF if nothing in buffer */
8067 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8070 case STATUS_READ_READY
:
8071 case STATUS_READ_IN_PROGRESS
:
8072 DebPrint (("sys_read called when read is in progress\n"));
8073 errno
= EWOULDBLOCK
;
8076 case STATUS_READ_SUCCEEDED
:
8077 /* consume read-ahead char */
8078 *buffer
++ = cp
->chr
;
8081 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
8082 ResetEvent (cp
->char_avail
);
8084 case STATUS_READ_ACKNOWLEDGED
:
8088 DebPrint (("sys_read: bad status %d\n", current_status
));
8093 if (fd_info
[fd
].flags
& FILE_PIPE
)
8095 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
8096 to_read
= min (waiting
, (DWORD
) count
);
8099 nchars
+= _read (fd
, buffer
, to_read
);
8101 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
8103 HANDLE hnd
= fd_info
[fd
].hnd
;
8104 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
8110 /* Configure timeouts for non-blocking read. */
8111 if (!GetCommTimeouts (hnd
, &ct
))
8116 ct
.ReadIntervalTimeout
= MAXDWORD
;
8117 ct
.ReadTotalTimeoutMultiplier
= 0;
8118 ct
.ReadTotalTimeoutConstant
= 0;
8119 if (!SetCommTimeouts (hnd
, &ct
))
8125 if (!ResetEvent (ovl
->hEvent
))
8130 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
8132 if (GetLastError () != ERROR_IO_PENDING
)
8137 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
8146 else /* FILE_SOCKET */
8148 if (winsock_lib
== NULL
) emacs_abort ();
8150 /* do the equivalent of a non-blocking read */
8151 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
8152 if (waiting
== 0 && nchars
== 0)
8154 errno
= EWOULDBLOCK
;
8160 /* always use binary mode for sockets */
8161 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
8162 if (res
== SOCKET_ERROR
)
8164 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
8165 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8175 int nread
= _read (fd
, buffer
, count
);
8178 else if (nchars
== 0)
8183 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8184 /* Perform text mode translation if required. */
8185 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8187 nchars
= crlf_to_lf (nchars
, orig_buffer
);
8188 /* If buffer contains only CR, return that. To be absolutely
8189 sure we should attempt to read the next char, but in
8190 practice a CR to be followed by LF would not appear by
8191 itself in the buffer. */
8192 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
8194 fd_info
[fd
].flags
|= FILE_LAST_CR
;
8200 nchars
= _read (fd
, buffer
, count
);
8205 /* From w32xfns.c */
8206 extern HANDLE interrupt_handle
;
8208 /* For now, don't bother with a non-blocking mode */
8210 sys_write (int fd
, const void * buffer
, unsigned int count
)
8220 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8222 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
8228 /* Perform text mode translation if required. */
8229 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8231 char * tmpbuf
= alloca (count
* 2);
8232 unsigned char * src
= (void *)buffer
;
8233 unsigned char * dst
= tmpbuf
;
8238 unsigned char *next
;
8239 /* copy next line or remaining bytes */
8240 next
= _memccpy (dst
, src
, '\n', nbytes
);
8243 /* copied one line ending with '\n' */
8244 int copied
= next
- dst
;
8247 /* insert '\r' before '\n' */
8254 /* copied remaining partial line -> now finished */
8261 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
8263 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
8264 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
8265 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
8268 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
8270 if (GetLastError () != ERROR_IO_PENDING
)
8275 if (detect_input_pending ())
8276 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
8279 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
8280 if (active
== WAIT_OBJECT_0
)
8281 { /* User pressed C-g, cancel write, then leave. Don't bother
8282 cleaning up as we may only get stuck in buggy drivers. */
8283 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
8288 if (active
== WAIT_OBJECT_0
+ 1
8289 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
8296 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
8298 unsigned long nblock
= 0;
8299 if (winsock_lib
== NULL
) emacs_abort ();
8301 /* TODO: implement select() properly so non-blocking I/O works. */
8302 /* For now, make sure the write blocks. */
8303 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8304 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8306 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
8308 /* Set the socket back to non-blocking if it was before,
8309 for other operations that support it. */
8310 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8313 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8316 if (nchars
== SOCKET_ERROR
)
8318 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
8319 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8325 /* Some networked filesystems don't like too large writes, so
8326 break them into smaller chunks. See the Comments section of
8327 the MSDN documentation of WriteFile for details behind the
8328 choice of the value of CHUNK below. See also the thread
8329 http://thread.gmane.org/gmane.comp.version-control.git/145294
8330 in the git mailing list. */
8331 const unsigned char *p
= buffer
;
8332 const unsigned chunk
= 30 * 1024 * 1024;
8337 unsigned this_chunk
= count
< chunk
? count
: chunk
;
8338 int n
= _write (fd
, p
, this_chunk
);
8346 else if (n
< this_chunk
)
8357 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
8359 extern Lisp_Object
conv_sockaddr_to_lisp (struct sockaddr
*, int);
8361 /* Return information about network interface IFNAME, or about all
8362 interfaces (if IFNAME is nil). */
8364 network_interface_get_info (Lisp_Object ifname
)
8366 ULONG ainfo_len
= sizeof (IP_ADAPTER_INFO
);
8367 IP_ADAPTER_INFO
*adapter
, *ainfo
= xmalloc (ainfo_len
);
8368 DWORD retval
= get_adapters_info (ainfo
, &ainfo_len
);
8369 Lisp_Object res
= Qnil
;
8371 if (retval
== ERROR_BUFFER_OVERFLOW
)
8373 ainfo
= xrealloc (ainfo
, ainfo_len
);
8374 retval
= get_adapters_info (ainfo
, &ainfo_len
);
8377 if (retval
== ERROR_SUCCESS
)
8379 int eth_count
= 0, tr_count
= 0, fddi_count
= 0, ppp_count
= 0;
8380 int sl_count
= 0, wlan_count
= 0, lo_count
= 0, ifx_count
= 0;
8382 struct sockaddr_in sa
;
8384 /* For the below, we need some winsock functions, so make sure
8385 the winsock DLL is loaded. If we cannot successfully load
8386 it, they will have no use of the information we provide,
8388 if (!winsock_lib
&& !init_winsock (1))
8391 for (adapter
= ainfo
; adapter
; adapter
= adapter
->Next
)
8393 char namebuf
[MAX_ADAPTER_NAME_LENGTH
+ 4];
8395 /* Present Unix-compatible interface names, instead of the
8396 Windows names, which are really GUIDs not readable by
8398 static const char *ifmt
[] = {
8399 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
8414 switch (adapter
->Type
)
8416 case MIB_IF_TYPE_ETHERNET
:
8417 /* Windows before Vista reports wireless adapters as
8418 Ethernet. Work around by looking at the Description
8420 if (strstr (adapter
->Description
, "Wireless "))
8423 if_num
= wlan_count
++;
8427 ifmt_idx
= ETHERNET
;
8428 if_num
= eth_count
++;
8431 case MIB_IF_TYPE_TOKENRING
:
8432 ifmt_idx
= TOKENRING
;
8433 if_num
= tr_count
++;
8435 case MIB_IF_TYPE_FDDI
:
8437 if_num
= fddi_count
++;
8439 case MIB_IF_TYPE_PPP
:
8441 if_num
= ppp_count
++;
8443 case MIB_IF_TYPE_SLIP
:
8445 if_num
= sl_count
++;
8447 case IF_TYPE_IEEE80211
:
8449 if_num
= wlan_count
++;
8451 case MIB_IF_TYPE_LOOPBACK
:
8454 ifmt_idx
= LOOPBACK
;
8455 if_num
= lo_count
++;
8461 ifmt_idx
= OTHER_IF
;
8462 if_num
= ifx_count
++;
8465 if (ifmt_idx
== NONE
)
8467 sprintf (namebuf
, ifmt
[ifmt_idx
], if_num
);
8469 sa
.sin_family
= AF_INET
;
8470 ip_addr
= sys_inet_addr (adapter
->IpAddressList
.IpAddress
.String
);
8471 if (ip_addr
== INADDR_NONE
)
8473 /* Bogus address, skip this interface. */
8476 sa
.sin_addr
.s_addr
= ip_addr
;
8479 res
= Fcons (Fcons (build_string (namebuf
),
8480 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8481 sizeof (struct sockaddr
))),
8483 else if (strcmp (namebuf
, SSDATA (ifname
)) == 0)
8485 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
8486 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
8487 Lisp_Object flags
= Qnil
;
8491 /* Flags. We guess most of them by type, since the
8492 Windows flags are different and hard to get by. */
8493 flags
= Fcons (intern ("up"), flags
);
8494 if (ifmt_idx
== ETHERNET
|| ifmt_idx
== WLAN
)
8496 flags
= Fcons (intern ("broadcast"), flags
);
8497 flags
= Fcons (intern ("multicast"), flags
);
8499 flags
= Fcons (intern ("running"), flags
);
8500 if (ifmt_idx
== PPP
)
8502 flags
= Fcons (intern ("pointopoint"), flags
);
8503 flags
= Fcons (intern ("noarp"), flags
);
8505 if (adapter
->HaveWins
)
8506 flags
= Fcons (intern ("WINS"), flags
);
8507 if (adapter
->DhcpEnabled
)
8508 flags
= Fcons (intern ("dynamic"), flags
);
8510 res
= Fcons (flags
, res
);
8512 /* Hardware address and its family. */
8513 for (n
= 0; n
< adapter
->AddressLength
; n
++)
8514 p
->contents
[n
] = make_number ((int) adapter
->Address
[n
]);
8515 /* Windows does not support AF_LINK or AF_PACKET family
8516 of addresses. Use an arbitrary family number that is
8517 identical to what GNU/Linux returns. */
8518 res
= Fcons (Fcons (make_number (1), hwaddr
), res
);
8521 sa
.sin_family
= AF_INET
;
8522 net_mask
= sys_inet_addr (adapter
->IpAddressList
.IpMask
.String
);
8523 if (net_mask
!= INADDR_NONE
)
8525 sa
.sin_addr
.s_addr
= net_mask
;
8527 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8528 sizeof (struct sockaddr
)),
8532 res
= Fcons (Qnil
, res
);
8534 sa
.sin_family
= AF_INET
;
8535 if (ip_addr
!= INADDR_NONE
)
8537 /* Broadcast address is only reported by
8538 GetAdaptersAddresses, which is of limited
8539 availability. Generate it on our own. */
8540 u_long bcast_addr
= (ip_addr
& net_mask
) | ~net_mask
;
8542 sa
.sin_addr
.s_addr
= bcast_addr
;
8544 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8545 sizeof (struct sockaddr
)),
8549 sa
.sin_addr
.s_addr
= ip_addr
;
8551 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8552 sizeof (struct sockaddr
)),
8556 res
= Fcons (Qnil
, Fcons (Qnil
, res
));
8559 /* GetAdaptersInfo is documented to not report loopback
8560 interfaces, so we generate one out of thin air. */
8563 sa
.sin_family
= AF_INET
;
8567 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8568 res
= Fcons (Fcons (build_string ("lo"),
8569 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8570 sizeof (struct sockaddr
))),
8573 else if (strcmp (SSDATA (ifname
), "lo") == 0)
8575 res
= Fcons (Fcons (intern ("running"),
8576 Fcons (intern ("loopback"),
8577 Fcons (intern ("up"), Qnil
))), Qnil
);
8578 /* 772 is what 3 different GNU/Linux systems report for
8579 the loopback interface. */
8580 res
= Fcons (Fcons (make_number (772),
8581 Fmake_vector (make_number (6),
8584 sa
.sin_addr
.s_addr
= sys_inet_addr ("255.0.0.0");
8585 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8586 sizeof (struct sockaddr
)),
8588 sa
.sin_addr
.s_addr
= sys_inet_addr ("0.0.0.0");
8589 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8590 sizeof (struct sockaddr
)),
8592 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8593 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8594 sizeof (struct sockaddr
)),
8607 network_interface_list (void)
8609 return network_interface_get_info (Qnil
);
8613 network_interface_info (Lisp_Object ifname
)
8615 return network_interface_get_info (ifname
);
8619 /* The Windows CRT functions are "optimized for speed", so they don't
8620 check for timezone and DST changes if they were last called less
8621 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
8622 all Emacs features that repeatedly call time functions (e.g.,
8623 display-time) are in real danger of missing timezone and DST
8624 changes. Calling tzset before each localtime call fixes that. */
8626 sys_localtime (const time_t *t
)
8629 return localtime (t
);
8634 /* Try loading LIBRARY_ID from the file(s) specified in
8635 Vdynamic_library_alist. If the library is loaded successfully,
8636 return the handle of the DLL, and record the filename in the
8637 property :loaded-from of LIBRARY_ID. If the library could not be
8638 found, or when it was already loaded (because the handle is not
8639 recorded anywhere, and so is lost after use), return NULL.
8641 We could also save the handle in :loaded-from, but currently
8642 there's no use case for it. */
8644 w32_delayed_load (Lisp_Object library_id
)
8646 HMODULE dll_handle
= NULL
;
8648 CHECK_SYMBOL (library_id
);
8650 if (CONSP (Vdynamic_library_alist
)
8651 && NILP (Fassq (library_id
, Vlibrary_cache
)))
8653 Lisp_Object found
= Qnil
;
8654 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
8657 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
8659 Lisp_Object dll
= XCAR (dlls
);
8660 char name
[MAX_UTF8_PATH
];
8664 dll
= ENCODE_FILE (dll
);
8665 if (w32_unicode_filenames
)
8667 wchar_t name_w
[MAX_PATH
];
8669 filename_to_utf16 (SSDATA (dll
), name_w
);
8670 dll_handle
= LoadLibraryW (name_w
);
8673 res
= GetModuleFileNameW (dll_handle
, name_w
,
8676 filename_from_utf16 (name_w
, name
);
8681 char name_a
[MAX_PATH
];
8683 filename_to_ansi (SSDATA (dll
), name_a
);
8684 dll_handle
= LoadLibraryA (name_a
);
8687 res
= GetModuleFileNameA (dll_handle
, name_a
,
8690 filename_from_ansi (name_a
, name
);
8695 ptrdiff_t len
= strlen (name
);
8698 /* Possibly truncated */
8699 ? make_specified_string (name
, -1, len
, 1)
8701 /* This prevents thread start and end notifications
8702 from being sent to the DLL, for every thread we
8703 start. We don't need those notifications because
8704 threads we create never use any of these DLLs, only
8705 the main thread uses them. This is supposed to
8706 speed up thread creation. */
8707 DisableThreadLibraryCalls (dll_handle
);
8712 Fput (library_id
, QCloaded_from
, found
);
8720 check_windows_init_file (void)
8722 /* A common indication that Emacs is not installed properly is when
8723 it cannot find the Windows installation file. If this file does
8724 not exist in the expected place, tell the user. */
8726 if (!noninteractive
&& !inhibit_window_system
8727 /* Vload_path is not yet initialized when we are loading
8729 && NILP (Vpurify_flag
))
8731 Lisp_Object init_file
;
8734 /* Implementation note: this function runs early during Emacs
8735 startup, before startup.el is run. So Vload_path is still in
8736 its initial unibyte form, but it holds UTF-8 encoded file
8737 names, since init_callproc was already called. So we do not
8738 need to ENCODE_FILE here, but we do need to convert the file
8739 names from UTF-8 to ANSI. */
8740 init_file
= build_string ("term/w32-win");
8741 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
, 0);
8744 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
8745 char *init_file_name
= SDATA (init_file
);
8746 char *load_path
= SDATA (load_path_print
);
8747 char *buffer
= alloca (1024
8748 + strlen (init_file_name
)
8749 + strlen (load_path
));
8754 "The Emacs Windows initialization file \"%s.el\" "
8755 "could not be found in your Emacs installation. "
8756 "Emacs checked the following directories for this file:\n"
8758 "When Emacs cannot find this file, it usually means that it "
8759 "was not installed properly, or its distribution file was "
8760 "not unpacked properly.\nSee the README.W32 file in the "
8761 "top-level Emacs directory for more information.",
8762 init_file_name
, load_path
);
8763 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
,
8767 wchar_t *msg_w
= alloca ((needed
+ 1) * sizeof (wchar_t));
8769 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
, -1,
8771 needed
= pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1,
8772 NULL
, 0, NULL
, NULL
);
8775 char *msg_a
= alloca (needed
+ 1);
8777 pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1, msg_a
, needed
,
8784 "Emacs Abort Dialog",
8785 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
8786 /* Use the low-level system abort. */
8797 term_ntproc (int ignored
)
8803 /* shutdown the socket interface if necessary */
8810 init_ntproc (int dumping
)
8812 sigset_t initial_mask
= 0;
8814 /* Initialize the socket interface now if available and requested by
8815 the user by defining PRELOAD_WINSOCK; otherwise loading will be
8816 delayed until open-network-stream is called (w32-has-winsock can
8817 also be used to dynamically load or reload winsock).
8819 Conveniently, init_environment is called before us, so
8820 PRELOAD_WINSOCK can be set in the registry. */
8822 /* Always initialize this correctly. */
8825 if (getenv ("PRELOAD_WINSOCK") != NULL
)
8826 init_winsock (TRUE
);
8828 /* Initial preparation for subprocess support: replace our standard
8829 handles with non-inheritable versions. */
8832 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
8833 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
8834 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
8836 parent
= GetCurrentProcess ();
8838 /* ignore errors when duplicating and closing; typically the
8839 handles will be invalid when running as a gui program. */
8840 DuplicateHandle (parent
,
8841 GetStdHandle (STD_INPUT_HANDLE
),
8846 DUPLICATE_SAME_ACCESS
);
8848 DuplicateHandle (parent
,
8849 GetStdHandle (STD_OUTPUT_HANDLE
),
8854 DUPLICATE_SAME_ACCESS
);
8856 DuplicateHandle (parent
,
8857 GetStdHandle (STD_ERROR_HANDLE
),
8862 DUPLICATE_SAME_ACCESS
);
8868 if (stdin_save
!= INVALID_HANDLE_VALUE
)
8869 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
8871 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
8874 if (stdout_save
!= INVALID_HANDLE_VALUE
)
8875 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
8877 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8880 if (stderr_save
!= INVALID_HANDLE_VALUE
)
8881 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
8883 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8887 /* unfortunately, atexit depends on implementation of malloc */
8888 /* atexit (term_ntproc); */
8891 /* Make sure we start with all signals unblocked. */
8892 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
8893 signal (SIGABRT
, term_ntproc
);
8897 /* determine which drives are fixed, for GetCachedVolumeInformation */
8899 /* GetDriveType must have trailing backslash. */
8900 char drive
[] = "A:\\";
8902 /* Loop over all possible drive letters */
8903 while (*drive
<= 'Z')
8905 /* Record if this drive letter refers to a fixed drive. */
8906 fixed_drives
[DRIVE_INDEX (*drive
)] =
8907 (GetDriveType (drive
) == DRIVE_FIXED
);
8912 /* Reset the volume info cache. */
8913 volume_cache
= NULL
;
8918 shutdown_handler ensures that buffers' autosave files are
8919 up to date when the user logs off, or the system shuts down.
8922 shutdown_handler (DWORD type
)
8924 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
8925 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
8926 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
8927 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
8929 /* Shut down cleanly, making sure autosave files are up to date. */
8930 shut_down_emacs (0, Qnil
);
8933 /* Allow other handlers to handle this signal. */
8937 /* On Windows 9X, load UNICOWS.DLL and return its handle, or die. On
8938 NT, return a handle to GDI32.DLL. */
8940 maybe_load_unicows_dll (void)
8942 if (os_subtype
== OS_9X
)
8944 HANDLE ret
= LoadLibrary ("Unicows.dll");
8947 /* These two functions are present on Windows 9X as stubs
8948 that always fail. We need the real implementations from
8949 UNICOWS.DLL, so we must call these functions through
8950 pointers, and assign the correct addresses to these
8951 pointers at program startup (see emacs.c, which calls
8952 this function early on). */
8953 pMultiByteToWideChar
= GetProcAddress (ret
, "MultiByteToWideChar");
8954 pWideCharToMultiByte
= GetProcAddress (ret
, "WideCharToMultiByte");
8961 button
= MessageBox (NULL
,
8962 "Emacs cannot load the UNICOWS.DLL library.\n"
8963 "This library is essential for using Emacs\n"
8964 "on this system. You need to install it.\n\n"
8965 "Emacs will exit when you click OK.",
8966 "Emacs cannot load UNICOWS.DLL",
8967 MB_ICONERROR
| MB_TASKMODAL
8968 | MB_SETFOREGROUND
| MB_OK
);
8979 /* On NT family of Windows, these two functions are always
8980 linked in, so we just assign their addresses to the 2
8981 pointers; no need for the LoadLibrary dance. */
8982 pMultiByteToWideChar
= MultiByteToWideChar
;
8983 pWideCharToMultiByte
= WideCharToMultiByte
;
8984 return LoadLibrary ("Gdi32.dll");
8989 globals_of_w32 is used to initialize those global variables that
8990 must always be initialized on startup even when the global variable
8991 initialized is non zero (see the function main in emacs.c).
8994 globals_of_w32 (void)
8996 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
8998 get_process_times_fn
= (GetProcessTimes_Proc
)
8999 GetProcAddress (kernel32
, "GetProcessTimes");
9001 DEFSYM (QCloaded_from
, ":loaded-from");
9003 g_b_init_is_windows_9x
= 0;
9004 g_b_init_open_process_token
= 0;
9005 g_b_init_get_token_information
= 0;
9006 g_b_init_lookup_account_sid
= 0;
9007 g_b_init_get_sid_sub_authority
= 0;
9008 g_b_init_get_sid_sub_authority_count
= 0;
9009 g_b_init_get_security_info
= 0;
9010 g_b_init_get_file_security_w
= 0;
9011 g_b_init_get_file_security_a
= 0;
9012 g_b_init_get_security_descriptor_owner
= 0;
9013 g_b_init_get_security_descriptor_group
= 0;
9014 g_b_init_is_valid_sid
= 0;
9015 g_b_init_create_toolhelp32_snapshot
= 0;
9016 g_b_init_process32_first
= 0;
9017 g_b_init_process32_next
= 0;
9018 g_b_init_open_thread_token
= 0;
9019 g_b_init_impersonate_self
= 0;
9020 g_b_init_revert_to_self
= 0;
9021 g_b_init_get_process_memory_info
= 0;
9022 g_b_init_get_process_working_set_size
= 0;
9023 g_b_init_global_memory_status
= 0;
9024 g_b_init_global_memory_status_ex
= 0;
9025 g_b_init_equal_sid
= 0;
9026 g_b_init_copy_sid
= 0;
9027 g_b_init_get_length_sid
= 0;
9028 g_b_init_get_native_system_info
= 0;
9029 g_b_init_get_system_times
= 0;
9030 g_b_init_create_symbolic_link_w
= 0;
9031 g_b_init_create_symbolic_link_a
= 0;
9032 g_b_init_get_security_descriptor_dacl
= 0;
9033 g_b_init_convert_sd_to_sddl
= 0;
9034 g_b_init_convert_sddl_to_sd
= 0;
9035 g_b_init_is_valid_security_descriptor
= 0;
9036 g_b_init_set_file_security_w
= 0;
9037 g_b_init_set_file_security_a
= 0;
9038 g_b_init_set_named_security_info_w
= 0;
9039 g_b_init_set_named_security_info_a
= 0;
9040 g_b_init_get_adapters_info
= 0;
9041 num_of_processors
= 0;
9042 /* The following sets a handler for shutdown notifications for
9043 console apps. This actually applies to Emacs in both console and
9044 GUI modes, since we had to fool windows into thinking emacs is a
9045 console application to get console mode to work. */
9046 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
9048 /* "None" is the default group name on standalone workstations. */
9049 strcpy (dflt_group_name
, "None");
9051 /* Reset, in case it has some value inherited from dump time. */
9052 w32_stat_get_owner_group
= 0;
9054 /* If w32_unicode_filenames is non-zero, we will be using Unicode
9055 (a.k.a. "wide") APIs to invoke functions that accept file
9057 if (is_windows_9x ())
9058 w32_unicode_filenames
= 0;
9060 w32_unicode_filenames
= 1;
9063 /* For make-serial-process */
9065 serial_open (Lisp_Object port_obj
)
9067 char *port
= SSDATA (port_obj
);
9072 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
9073 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
9074 if (hnd
== INVALID_HANDLE_VALUE
)
9075 error ("Could not open %s", port
);
9076 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
9078 error ("Could not open %s", port
);
9082 error ("Could not create child process");
9084 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
9085 fd_info
[ fd
].hnd
= hnd
;
9086 fd_info
[ fd
].flags
|=
9087 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
9088 if (fd_info
[ fd
].cp
!= NULL
)
9090 error ("fd_info[fd = %d] is already in use", fd
);
9092 fd_info
[ fd
].cp
= cp
;
9093 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9094 if (cp
->ovl_read
.hEvent
== NULL
)
9095 error ("Could not create read event");
9096 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9097 if (cp
->ovl_write
.hEvent
== NULL
)
9098 error ("Could not create write event");
9103 /* For serial-process-configure */
9105 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
9107 Lisp_Object childp2
= Qnil
;
9108 Lisp_Object tem
= Qnil
;
9112 char summary
[4] = "???"; /* This usually becomes "8N1". */
9114 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
9115 error ("Not a serial process");
9116 hnd
= fd_info
[ p
->outfd
].hnd
;
9118 childp2
= Fcopy_sequence (p
->childp
);
9120 /* Initialize timeouts for blocking read and blocking write. */
9121 if (!GetCommTimeouts (hnd
, &ct
))
9122 error ("GetCommTimeouts() failed");
9123 ct
.ReadIntervalTimeout
= 0;
9124 ct
.ReadTotalTimeoutMultiplier
= 0;
9125 ct
.ReadTotalTimeoutConstant
= 0;
9126 ct
.WriteTotalTimeoutMultiplier
= 0;
9127 ct
.WriteTotalTimeoutConstant
= 0;
9128 if (!SetCommTimeouts (hnd
, &ct
))
9129 error ("SetCommTimeouts() failed");
9130 /* Read port attributes and prepare default configuration. */
9131 memset (&dcb
, 0, sizeof (dcb
));
9132 dcb
.DCBlength
= sizeof (DCB
);
9133 if (!GetCommState (hnd
, &dcb
))
9134 error ("GetCommState() failed");
9137 dcb
.fAbortOnError
= FALSE
;
9138 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
9143 /* Configure speed. */
9144 if (!NILP (Fplist_member (contact
, QCspeed
)))
9145 tem
= Fplist_get (contact
, QCspeed
);
9147 tem
= Fplist_get (p
->childp
, QCspeed
);
9149 dcb
.BaudRate
= XINT (tem
);
9150 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
9152 /* Configure bytesize. */
9153 if (!NILP (Fplist_member (contact
, QCbytesize
)))
9154 tem
= Fplist_get (contact
, QCbytesize
);
9156 tem
= Fplist_get (p
->childp
, QCbytesize
);
9158 tem
= make_number (8);
9160 if (XINT (tem
) != 7 && XINT (tem
) != 8)
9161 error (":bytesize must be nil (8), 7, or 8");
9162 dcb
.ByteSize
= XINT (tem
);
9163 summary
[0] = XINT (tem
) + '0';
9164 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
9166 /* Configure parity. */
9167 if (!NILP (Fplist_member (contact
, QCparity
)))
9168 tem
= Fplist_get (contact
, QCparity
);
9170 tem
= Fplist_get (p
->childp
, QCparity
);
9171 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
9172 error (":parity must be nil (no parity), `even', or `odd'");
9173 dcb
.fParity
= FALSE
;
9174 dcb
.Parity
= NOPARITY
;
9175 dcb
.fErrorChar
= FALSE
;
9180 else if (EQ (tem
, Qeven
))
9184 dcb
.Parity
= EVENPARITY
;
9185 dcb
.fErrorChar
= TRUE
;
9187 else if (EQ (tem
, Qodd
))
9191 dcb
.Parity
= ODDPARITY
;
9192 dcb
.fErrorChar
= TRUE
;
9194 childp2
= Fplist_put (childp2
, QCparity
, tem
);
9196 /* Configure stopbits. */
9197 if (!NILP (Fplist_member (contact
, QCstopbits
)))
9198 tem
= Fplist_get (contact
, QCstopbits
);
9200 tem
= Fplist_get (p
->childp
, QCstopbits
);
9202 tem
= make_number (1);
9204 if (XINT (tem
) != 1 && XINT (tem
) != 2)
9205 error (":stopbits must be nil (1 stopbit), 1, or 2");
9206 summary
[2] = XINT (tem
) + '0';
9207 if (XINT (tem
) == 1)
9208 dcb
.StopBits
= ONESTOPBIT
;
9209 else if (XINT (tem
) == 2)
9210 dcb
.StopBits
= TWOSTOPBITS
;
9211 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
9213 /* Configure flowcontrol. */
9214 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
9215 tem
= Fplist_get (contact
, QCflowcontrol
);
9217 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
9218 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
9219 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
9220 dcb
.fOutxCtsFlow
= FALSE
;
9221 dcb
.fOutxDsrFlow
= FALSE
;
9222 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
9223 dcb
.fDsrSensitivity
= FALSE
;
9224 dcb
.fTXContinueOnXoff
= FALSE
;
9227 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
9228 dcb
.XonChar
= 17; /* Control-Q */
9229 dcb
.XoffChar
= 19; /* Control-S */
9232 /* Already configured. */
9234 else if (EQ (tem
, Qhw
))
9236 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
9237 dcb
.fOutxCtsFlow
= TRUE
;
9239 else if (EQ (tem
, Qsw
))
9244 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
9246 /* Activate configuration. */
9247 if (!SetCommState (hnd
, &dcb
))
9248 error ("SetCommState() failed");
9250 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
9251 pset_childp (p
, childp2
);
9257 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
9260 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9261 int fd
= process
->infd
;
9263 n
= sys_read (fd
, (char*)buf
, sz
);
9270 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9271 if (err
== EWOULDBLOCK
)
9274 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
9280 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
9282 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9283 int fd
= process
->outfd
;
9284 ssize_t n
= sys_write (fd
, buf
, sz
);
9286 /* 0 or more bytes written means everything went fine. */
9290 /* Negative bytes written means we got an error in errno.
9291 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9292 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
9293 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
9297 #endif /* HAVE_GNUTLS */