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 #if defined(__GNUC__) && !defined(_W64)
77 #define _ANONYMOUS_UNION
78 #define _ANONYMOUS_STRUCT
81 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
82 use a different name to avoid compilation problems. */
83 typedef struct _MEMORY_STATUS_EX
{
86 DWORDLONG ullTotalPhys
;
87 DWORDLONG ullAvailPhys
;
88 DWORDLONG ullTotalPageFile
;
89 DWORDLONG ullAvailPageFile
;
90 DWORDLONG ullTotalVirtual
;
91 DWORDLONG ullAvailVirtual
;
92 DWORDLONG ullAvailExtendedVirtual
;
93 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
95 /* These are here so that GDB would know about these data types. This
96 allows to attach GDB to Emacs when a fatal exception is triggered
97 and Windows pops up the "application needs to be closed" dialog.
98 At that point, _gnu_exception_handler, the top-level exception
99 handler installed by the MinGW startup code, is somewhere on the
100 call-stack of the main thread, so going to that call frame and
101 looking at the argument to _gnu_exception_handler, which is a
102 PEXCEPTION_POINTERS pointer, can reveal the exception code
103 (excptr->ExceptionRecord->ExceptionCode) and the address where the
104 exception happened (excptr->ExceptionRecord->ExceptionAddress), as
105 well as some additional information specific to the exception. */
106 PEXCEPTION_POINTERS excptr
;
107 PEXCEPTION_RECORD excprec
;
113 #include <tlhelp32.h>
118 #if _WIN32_WINNT < 0x0500
119 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
120 /* This either is not in psapi.h or guarded by higher value of
121 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
122 defines it in psapi.h */
123 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
125 DWORD PageFaultCount
;
126 SIZE_T PeakWorkingSetSize
;
127 SIZE_T WorkingSetSize
;
128 SIZE_T QuotaPeakPagedPoolUsage
;
129 SIZE_T QuotaPagedPoolUsage
;
130 SIZE_T QuotaPeakNonPagedPoolUsage
;
131 SIZE_T QuotaNonPagedPoolUsage
;
132 SIZE_T PagefileUsage
;
133 SIZE_T PeakPagefileUsage
;
135 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
139 #include <winioctl.h>
146 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
147 define them by hand if not already defined. */
148 #ifndef SDDL_REVISION_1
149 #define SDDL_REVISION_1 1
150 #endif /* SDDL_REVISION_1 */
152 #if defined(_MSC_VER) || defined(_W64)
153 /* MSVC and MinGW64 don't provide the definition of
154 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
155 which cannot be included because it triggers conflicts with other
156 Windows API headers. So we define it here by hand. */
158 typedef struct _REPARSE_DATA_BUFFER
{
160 USHORT ReparseDataLength
;
164 USHORT SubstituteNameOffset
;
165 USHORT SubstituteNameLength
;
166 USHORT PrintNameOffset
;
167 USHORT PrintNameLength
;
170 } SymbolicLinkReparseBuffer
;
172 USHORT SubstituteNameOffset
;
173 USHORT SubstituteNameLength
;
174 USHORT PrintNameOffset
;
175 USHORT PrintNameLength
;
177 } MountPointReparseBuffer
;
180 } GenericReparseBuffer
;
182 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
184 #ifndef FILE_DEVICE_FILE_SYSTEM
185 #define FILE_DEVICE_FILE_SYSTEM 9
187 #ifndef METHOD_BUFFERED
188 #define METHOD_BUFFERED 0
190 #ifndef FILE_ANY_ACCESS
191 #define FILE_ANY_ACCESS 0x00000000
194 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
196 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
197 #ifndef FSCTL_GET_REPARSE_POINT
198 #define FSCTL_GET_REPARSE_POINT \
199 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
203 /* TCP connection support. */
204 #include <sys/socket.h>
223 #include <iphlpapi.h> /* should be after winsock2.h */
227 #include "w32common.h"
229 #include "w32select.h"
231 #include "dispextern.h" /* for xstrcasecmp */
232 #include "coding.h" /* for Vlocale_coding_system */
234 #include "careadlinkat.h"
235 #include "allocator.h"
237 /* For serial_configure and serial_open. */
240 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
241 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
243 Lisp_Object QCloaded_from
;
245 void globals_of_w32 (void);
246 static DWORD
get_rid (PSID
);
247 static int is_symlink (const char *);
248 static char * chase_symlinks (const char *);
249 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
250 static int restore_privilege (TOKEN_PRIVILEGES
*);
251 static BOOL WINAPI
revert_to_self (void);
253 static int sys_access (const char *, int);
254 extern void *e_malloc (size_t);
255 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
256 struct timespec
*, void *);
257 extern int sys_dup (int);
262 /* Initialization states.
264 WARNING: If you add any more such variables for additional APIs,
265 you MUST add initialization for them to globals_of_w32
266 below. This is because these variables might get set
267 to non-NULL values during dumping, but the dumped Emacs
268 cannot reuse those values, because it could be run on a
269 different version of the OS, where API addresses are
271 static BOOL g_b_init_is_windows_9x
;
272 static BOOL g_b_init_open_process_token
;
273 static BOOL g_b_init_get_token_information
;
274 static BOOL g_b_init_lookup_account_sid
;
275 static BOOL g_b_init_get_sid_sub_authority
;
276 static BOOL g_b_init_get_sid_sub_authority_count
;
277 static BOOL g_b_init_get_security_info
;
278 static BOOL g_b_init_get_file_security_w
;
279 static BOOL g_b_init_get_file_security_a
;
280 static BOOL g_b_init_get_security_descriptor_owner
;
281 static BOOL g_b_init_get_security_descriptor_group
;
282 static BOOL g_b_init_is_valid_sid
;
283 static BOOL g_b_init_create_toolhelp32_snapshot
;
284 static BOOL g_b_init_process32_first
;
285 static BOOL g_b_init_process32_next
;
286 static BOOL g_b_init_open_thread_token
;
287 static BOOL g_b_init_impersonate_self
;
288 static BOOL g_b_init_revert_to_self
;
289 static BOOL g_b_init_get_process_memory_info
;
290 static BOOL g_b_init_get_process_working_set_size
;
291 static BOOL g_b_init_global_memory_status
;
292 static BOOL g_b_init_global_memory_status_ex
;
293 static BOOL g_b_init_get_length_sid
;
294 static BOOL g_b_init_equal_sid
;
295 static BOOL g_b_init_copy_sid
;
296 static BOOL g_b_init_get_native_system_info
;
297 static BOOL g_b_init_get_system_times
;
298 static BOOL g_b_init_create_symbolic_link_w
;
299 static BOOL g_b_init_create_symbolic_link_a
;
300 static BOOL g_b_init_get_security_descriptor_dacl
;
301 static BOOL g_b_init_convert_sd_to_sddl
;
302 static BOOL g_b_init_convert_sddl_to_sd
;
303 static BOOL g_b_init_is_valid_security_descriptor
;
304 static BOOL g_b_init_set_file_security_w
;
305 static BOOL g_b_init_set_file_security_a
;
306 static BOOL g_b_init_set_named_security_info_w
;
307 static BOOL g_b_init_set_named_security_info_a
;
308 static BOOL g_b_init_get_adapters_info
;
311 BEGIN: Wrapper functions around OpenProcessToken
312 and other functions in advapi32.dll that are only
313 supported in Windows NT / 2k / XP
315 /* ** Function pointer typedefs ** */
316 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
317 HANDLE ProcessHandle
,
319 PHANDLE TokenHandle
);
320 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
322 TOKEN_INFORMATION_CLASS TokenInformationClass
,
323 LPVOID TokenInformation
,
324 DWORD TokenInformationLength
,
325 PDWORD ReturnLength
);
326 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
327 HANDLE process_handle
,
328 LPFILETIME creation_time
,
329 LPFILETIME exit_time
,
330 LPFILETIME kernel_time
,
331 LPFILETIME user_time
);
333 GetProcessTimes_Proc get_process_times_fn
= NULL
;
336 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
338 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
340 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
341 LPCTSTR lpSystemName
,
346 LPDWORD cbDomainName
,
347 PSID_NAME_USE peUse
);
348 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
351 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
353 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
355 SE_OBJECT_TYPE ObjectType
,
356 SECURITY_INFORMATION SecurityInfo
,
361 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
362 typedef BOOL (WINAPI
* GetFileSecurityW_Proc
) (
364 SECURITY_INFORMATION RequestedInformation
,
365 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
367 LPDWORD lpnLengthNeeded
);
368 typedef BOOL (WINAPI
* GetFileSecurityA_Proc
) (
370 SECURITY_INFORMATION RequestedInformation
,
371 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
373 LPDWORD lpnLengthNeeded
);
374 typedef BOOL (WINAPI
*SetFileSecurityW_Proc
) (
376 SECURITY_INFORMATION SecurityInformation
,
377 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
378 typedef BOOL (WINAPI
*SetFileSecurityA_Proc
) (
380 SECURITY_INFORMATION SecurityInformation
,
381 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
382 typedef DWORD (WINAPI
*SetNamedSecurityInfoW_Proc
) (
383 LPCWSTR lpObjectName
,
384 SE_OBJECT_TYPE ObjectType
,
385 SECURITY_INFORMATION SecurityInformation
,
390 typedef DWORD (WINAPI
*SetNamedSecurityInfoA_Proc
) (
392 SE_OBJECT_TYPE ObjectType
,
393 SECURITY_INFORMATION SecurityInformation
,
398 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
399 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
401 LPBOOL lpbOwnerDefaulted
);
402 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
403 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
405 LPBOOL lpbGroupDefaulted
);
406 typedef BOOL (WINAPI
*GetSecurityDescriptorDacl_Proc
) (
407 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
408 LPBOOL lpbDaclPresent
,
410 LPBOOL lpbDaclDefaulted
);
411 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
413 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
415 DWORD th32ProcessID
);
416 typedef BOOL (WINAPI
* Process32First_Proc
) (
418 LPPROCESSENTRY32 lppe
);
419 typedef BOOL (WINAPI
* Process32Next_Proc
) (
421 LPPROCESSENTRY32 lppe
);
422 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
426 PHANDLE TokenHandle
);
427 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
428 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
429 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
430 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
432 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
434 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
436 PSIZE_T lpMinimumWorkingSetSize
,
437 PSIZE_T lpMaximumWorkingSetSize
);
438 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
439 LPMEMORYSTATUS lpBuffer
);
440 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
441 LPMEMORY_STATUS_EX lpBuffer
);
442 typedef BOOL (WINAPI
* CopySid_Proc
) (
443 DWORD nDestinationSidLength
,
444 PSID pDestinationSid
,
446 typedef BOOL (WINAPI
* EqualSid_Proc
) (
449 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
451 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
452 LPSYSTEM_INFO lpSystemInfo
);
453 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
454 LPFILETIME lpIdleTime
,
455 LPFILETIME lpKernelTime
,
456 LPFILETIME lpUserTime
);
457 typedef BOOLEAN (WINAPI
*CreateSymbolicLinkW_Proc
) (
458 LPCWSTR lpSymlinkFileName
,
459 LPCWSTR lpTargetFileName
,
461 typedef BOOLEAN (WINAPI
*CreateSymbolicLinkA_Proc
) (
462 LPCSTR lpSymlinkFileName
,
463 LPCSTR lpTargetFileName
,
465 typedef BOOL (WINAPI
*ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
) (
466 LPCTSTR StringSecurityDescriptor
,
467 DWORD StringSDRevision
,
468 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
469 PULONG SecurityDescriptorSize
);
470 typedef BOOL (WINAPI
*ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
) (
471 PSECURITY_DESCRIPTOR SecurityDescriptor
,
472 DWORD RequestedStringSDRevision
,
473 SECURITY_INFORMATION SecurityInformation
,
474 LPTSTR
*StringSecurityDescriptor
,
475 PULONG StringSecurityDescriptorLen
);
476 typedef BOOL (WINAPI
*IsValidSecurityDescriptor_Proc
) (PSECURITY_DESCRIPTOR
);
477 typedef DWORD (WINAPI
*GetAdaptersInfo_Proc
) (
478 PIP_ADAPTER_INFO pAdapterInfo
,
481 int (WINAPI
*pMultiByteToWideChar
)(UINT
,DWORD
,LPCSTR
,int,LPWSTR
,int);
482 int (WINAPI
*pWideCharToMultiByte
)(UINT
,DWORD
,LPCWSTR
,int,LPSTR
,int,LPCSTR
,LPBOOL
);
484 /* ** A utility function ** */
488 static BOOL s_b_ret
= 0;
489 OSVERSIONINFO os_ver
;
490 if (g_b_init_is_windows_9x
== 0)
492 g_b_init_is_windows_9x
= 1;
493 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
494 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
495 if (GetVersionEx (&os_ver
))
497 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
503 static Lisp_Object
ltime (ULONGLONG
);
505 /* Get total user and system times for get-internal-run-time.
506 Returns a list of integers if the times are provided by the OS
507 (NT derivatives), otherwise it returns the result of current-time. */
509 w32_get_internal_run_time (void)
511 if (get_process_times_fn
)
513 FILETIME create
, exit
, kernel
, user
;
514 HANDLE proc
= GetCurrentProcess ();
515 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
517 LARGE_INTEGER user_int
, kernel_int
, total
;
518 user_int
.LowPart
= user
.dwLowDateTime
;
519 user_int
.HighPart
= user
.dwHighDateTime
;
520 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
521 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
522 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
523 return ltime (total
.QuadPart
);
527 return Fcurrent_time ();
530 /* ** The wrapper functions ** */
533 open_process_token (HANDLE ProcessHandle
,
537 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
538 HMODULE hm_advapi32
= NULL
;
539 if (is_windows_9x () == TRUE
)
543 if (g_b_init_open_process_token
== 0)
545 g_b_init_open_process_token
= 1;
546 hm_advapi32
= LoadLibrary ("Advapi32.dll");
547 s_pfn_Open_Process_Token
=
548 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
550 if (s_pfn_Open_Process_Token
== NULL
)
555 s_pfn_Open_Process_Token (
563 get_token_information (HANDLE TokenHandle
,
564 TOKEN_INFORMATION_CLASS TokenInformationClass
,
565 LPVOID TokenInformation
,
566 DWORD TokenInformationLength
,
569 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
570 HMODULE hm_advapi32
= NULL
;
571 if (is_windows_9x () == TRUE
)
575 if (g_b_init_get_token_information
== 0)
577 g_b_init_get_token_information
= 1;
578 hm_advapi32
= LoadLibrary ("Advapi32.dll");
579 s_pfn_Get_Token_Information
=
580 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
582 if (s_pfn_Get_Token_Information
== NULL
)
587 s_pfn_Get_Token_Information (
589 TokenInformationClass
,
591 TokenInformationLength
,
597 lookup_account_sid (LPCTSTR lpSystemName
,
602 LPDWORD cbDomainName
,
605 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
606 HMODULE hm_advapi32
= NULL
;
607 if (is_windows_9x () == TRUE
)
611 if (g_b_init_lookup_account_sid
== 0)
613 g_b_init_lookup_account_sid
= 1;
614 hm_advapi32
= LoadLibrary ("Advapi32.dll");
615 s_pfn_Lookup_Account_Sid
=
616 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
618 if (s_pfn_Lookup_Account_Sid
== NULL
)
623 s_pfn_Lookup_Account_Sid (
635 get_sid_sub_authority (PSID pSid
, DWORD n
)
637 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
638 static DWORD zero
= 0U;
639 HMODULE hm_advapi32
= NULL
;
640 if (is_windows_9x () == TRUE
)
644 if (g_b_init_get_sid_sub_authority
== 0)
646 g_b_init_get_sid_sub_authority
= 1;
647 hm_advapi32
= LoadLibrary ("Advapi32.dll");
648 s_pfn_Get_Sid_Sub_Authority
=
649 (GetSidSubAuthority_Proc
) GetProcAddress (
650 hm_advapi32
, "GetSidSubAuthority");
652 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
656 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
660 get_sid_sub_authority_count (PSID pSid
)
662 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
663 static UCHAR zero
= 0U;
664 HMODULE hm_advapi32
= NULL
;
665 if (is_windows_9x () == TRUE
)
669 if (g_b_init_get_sid_sub_authority_count
== 0)
671 g_b_init_get_sid_sub_authority_count
= 1;
672 hm_advapi32
= LoadLibrary ("Advapi32.dll");
673 s_pfn_Get_Sid_Sub_Authority_Count
=
674 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
675 hm_advapi32
, "GetSidSubAuthorityCount");
677 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
681 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
685 get_security_info (HANDLE handle
,
686 SE_OBJECT_TYPE ObjectType
,
687 SECURITY_INFORMATION SecurityInfo
,
692 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
694 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
695 HMODULE hm_advapi32
= NULL
;
696 if (is_windows_9x () == TRUE
)
700 if (g_b_init_get_security_info
== 0)
702 g_b_init_get_security_info
= 1;
703 hm_advapi32
= LoadLibrary ("Advapi32.dll");
704 s_pfn_Get_Security_Info
=
705 (GetSecurityInfo_Proc
) GetProcAddress (
706 hm_advapi32
, "GetSecurityInfo");
708 if (s_pfn_Get_Security_Info
== NULL
)
712 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
713 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
714 ppSecurityDescriptor
));
718 get_file_security (const char *lpFileName
,
719 SECURITY_INFORMATION RequestedInformation
,
720 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
722 LPDWORD lpnLengthNeeded
)
724 static GetFileSecurityA_Proc s_pfn_Get_File_SecurityA
= NULL
;
725 static GetFileSecurityW_Proc s_pfn_Get_File_SecurityW
= NULL
;
726 HMODULE hm_advapi32
= NULL
;
727 if (is_windows_9x () == TRUE
)
732 if (w32_unicode_filenames
)
734 wchar_t filename_w
[MAX_PATH
];
736 if (g_b_init_get_file_security_w
== 0)
738 g_b_init_get_file_security_w
= 1;
739 hm_advapi32
= LoadLibrary ("Advapi32.dll");
740 s_pfn_Get_File_SecurityW
=
741 (GetFileSecurityW_Proc
) GetProcAddress (hm_advapi32
,
744 if (s_pfn_Get_File_SecurityW
== NULL
)
749 filename_to_utf16 (lpFileName
, filename_w
);
750 return (s_pfn_Get_File_SecurityW (filename_w
, RequestedInformation
,
751 pSecurityDescriptor
, nLength
,
756 char filename_a
[MAX_PATH
];
758 if (g_b_init_get_file_security_a
== 0)
760 g_b_init_get_file_security_a
= 1;
761 hm_advapi32
= LoadLibrary ("Advapi32.dll");
762 s_pfn_Get_File_SecurityA
=
763 (GetFileSecurityA_Proc
) GetProcAddress (hm_advapi32
,
766 if (s_pfn_Get_File_SecurityA
== NULL
)
771 filename_to_ansi (lpFileName
, filename_a
);
772 return (s_pfn_Get_File_SecurityA (filename_a
, RequestedInformation
,
773 pSecurityDescriptor
, nLength
,
779 set_file_security (const char *lpFileName
,
780 SECURITY_INFORMATION SecurityInformation
,
781 PSECURITY_DESCRIPTOR pSecurityDescriptor
)
783 static SetFileSecurityW_Proc s_pfn_Set_File_SecurityW
= NULL
;
784 static SetFileSecurityA_Proc s_pfn_Set_File_SecurityA
= NULL
;
785 HMODULE hm_advapi32
= NULL
;
786 if (is_windows_9x () == TRUE
)
791 if (w32_unicode_filenames
)
793 wchar_t filename_w
[MAX_PATH
];
795 if (g_b_init_set_file_security_w
== 0)
797 g_b_init_set_file_security_w
= 1;
798 hm_advapi32
= LoadLibrary ("Advapi32.dll");
799 s_pfn_Set_File_SecurityW
=
800 (SetFileSecurityW_Proc
) GetProcAddress (hm_advapi32
,
803 if (s_pfn_Set_File_SecurityW
== NULL
)
808 filename_to_utf16 (lpFileName
, filename_w
);
809 return (s_pfn_Set_File_SecurityW (filename_w
, SecurityInformation
,
810 pSecurityDescriptor
));
814 char filename_a
[MAX_PATH
];
816 if (g_b_init_set_file_security_a
== 0)
818 g_b_init_set_file_security_a
= 1;
819 hm_advapi32
= LoadLibrary ("Advapi32.dll");
820 s_pfn_Set_File_SecurityA
=
821 (SetFileSecurityA_Proc
) GetProcAddress (hm_advapi32
,
824 if (s_pfn_Set_File_SecurityA
== NULL
)
829 filename_to_ansi (lpFileName
, filename_a
);
830 return (s_pfn_Set_File_SecurityA (filename_a
, SecurityInformation
,
831 pSecurityDescriptor
));
836 set_named_security_info (LPCTSTR lpObjectName
,
837 SE_OBJECT_TYPE ObjectType
,
838 SECURITY_INFORMATION SecurityInformation
,
844 static SetNamedSecurityInfoW_Proc s_pfn_Set_Named_Security_InfoW
= NULL
;
845 static SetNamedSecurityInfoA_Proc s_pfn_Set_Named_Security_InfoA
= NULL
;
846 HMODULE hm_advapi32
= NULL
;
847 if (is_windows_9x () == TRUE
)
852 if (w32_unicode_filenames
)
854 wchar_t filename_w
[MAX_PATH
];
856 if (g_b_init_set_named_security_info_w
== 0)
858 g_b_init_set_named_security_info_w
= 1;
859 hm_advapi32
= LoadLibrary ("Advapi32.dll");
860 s_pfn_Set_Named_Security_InfoW
=
861 (SetNamedSecurityInfoW_Proc
) GetProcAddress (hm_advapi32
,
862 "SetNamedSecurityInfoW");
864 if (s_pfn_Set_Named_Security_InfoW
== NULL
)
869 filename_to_utf16 (lpObjectName
, filename_w
);
870 return (s_pfn_Set_Named_Security_InfoW (filename_w
, ObjectType
,
871 SecurityInformation
, psidOwner
,
872 psidGroup
, pDacl
, pSacl
));
876 char filename_a
[MAX_PATH
];
878 if (g_b_init_set_named_security_info_a
== 0)
880 g_b_init_set_named_security_info_a
= 1;
881 hm_advapi32
= LoadLibrary ("Advapi32.dll");
882 s_pfn_Set_Named_Security_InfoA
=
883 (SetNamedSecurityInfoA_Proc
) GetProcAddress (hm_advapi32
,
884 "SetNamedSecurityInfoA");
886 if (s_pfn_Set_Named_Security_InfoA
== NULL
)
891 filename_to_ansi (lpObjectName
, filename_a
);
892 return (s_pfn_Set_Named_Security_InfoA (filename_a
, ObjectType
,
893 SecurityInformation
, psidOwner
,
894 psidGroup
, pDacl
, pSacl
));
899 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
901 LPBOOL lpbOwnerDefaulted
)
903 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
904 HMODULE hm_advapi32
= NULL
;
905 if (is_windows_9x () == TRUE
)
910 if (g_b_init_get_security_descriptor_owner
== 0)
912 g_b_init_get_security_descriptor_owner
= 1;
913 hm_advapi32
= LoadLibrary ("Advapi32.dll");
914 s_pfn_Get_Security_Descriptor_Owner
=
915 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
916 hm_advapi32
, "GetSecurityDescriptorOwner");
918 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
923 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
928 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
930 LPBOOL lpbGroupDefaulted
)
932 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
933 HMODULE hm_advapi32
= NULL
;
934 if (is_windows_9x () == TRUE
)
939 if (g_b_init_get_security_descriptor_group
== 0)
941 g_b_init_get_security_descriptor_group
= 1;
942 hm_advapi32
= LoadLibrary ("Advapi32.dll");
943 s_pfn_Get_Security_Descriptor_Group
=
944 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
945 hm_advapi32
, "GetSecurityDescriptorGroup");
947 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
952 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
957 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
958 LPBOOL lpbDaclPresent
,
960 LPBOOL lpbDaclDefaulted
)
962 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl
= NULL
;
963 HMODULE hm_advapi32
= NULL
;
964 if (is_windows_9x () == TRUE
)
969 if (g_b_init_get_security_descriptor_dacl
== 0)
971 g_b_init_get_security_descriptor_dacl
= 1;
972 hm_advapi32
= LoadLibrary ("Advapi32.dll");
973 s_pfn_Get_Security_Descriptor_Dacl
=
974 (GetSecurityDescriptorDacl_Proc
) GetProcAddress (
975 hm_advapi32
, "GetSecurityDescriptorDacl");
977 if (s_pfn_Get_Security_Descriptor_Dacl
== NULL
)
982 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor
,
983 lpbDaclPresent
, pDacl
,
988 is_valid_sid (PSID sid
)
990 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
991 HMODULE hm_advapi32
= NULL
;
992 if (is_windows_9x () == TRUE
)
996 if (g_b_init_is_valid_sid
== 0)
998 g_b_init_is_valid_sid
= 1;
999 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1000 s_pfn_Is_Valid_Sid
=
1001 (IsValidSid_Proc
) GetProcAddress (
1002 hm_advapi32
, "IsValidSid");
1004 if (s_pfn_Is_Valid_Sid
== NULL
)
1008 return (s_pfn_Is_Valid_Sid (sid
));
1012 equal_sid (PSID sid1
, PSID sid2
)
1014 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
1015 HMODULE hm_advapi32
= NULL
;
1016 if (is_windows_9x () == TRUE
)
1020 if (g_b_init_equal_sid
== 0)
1022 g_b_init_equal_sid
= 1;
1023 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1025 (EqualSid_Proc
) GetProcAddress (
1026 hm_advapi32
, "EqualSid");
1028 if (s_pfn_Equal_Sid
== NULL
)
1032 return (s_pfn_Equal_Sid (sid1
, sid2
));
1036 get_length_sid (PSID sid
)
1038 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
1039 HMODULE hm_advapi32
= NULL
;
1040 if (is_windows_9x () == TRUE
)
1044 if (g_b_init_get_length_sid
== 0)
1046 g_b_init_get_length_sid
= 1;
1047 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1048 s_pfn_Get_Length_Sid
=
1049 (GetLengthSid_Proc
) GetProcAddress (
1050 hm_advapi32
, "GetLengthSid");
1052 if (s_pfn_Get_Length_Sid
== NULL
)
1056 return (s_pfn_Get_Length_Sid (sid
));
1060 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
1062 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
1063 HMODULE hm_advapi32
= NULL
;
1064 if (is_windows_9x () == TRUE
)
1068 if (g_b_init_copy_sid
== 0)
1070 g_b_init_copy_sid
= 1;
1071 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1073 (CopySid_Proc
) GetProcAddress (
1074 hm_advapi32
, "CopySid");
1076 if (s_pfn_Copy_Sid
== NULL
)
1080 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
1084 END: Wrapper functions around OpenProcessToken
1085 and other functions in advapi32.dll that are only
1086 supported in Windows NT / 2k / XP
1090 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
1092 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
1093 if (is_windows_9x () != TRUE
)
1095 if (g_b_init_get_native_system_info
== 0)
1097 g_b_init_get_native_system_info
= 1;
1098 s_pfn_Get_Native_System_Info
=
1099 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1100 "GetNativeSystemInfo");
1102 if (s_pfn_Get_Native_System_Info
!= NULL
)
1103 s_pfn_Get_Native_System_Info (lpSystemInfo
);
1106 lpSystemInfo
->dwNumberOfProcessors
= -1;
1110 get_system_times (LPFILETIME lpIdleTime
,
1111 LPFILETIME lpKernelTime
,
1112 LPFILETIME lpUserTime
)
1114 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
1115 if (is_windows_9x () == TRUE
)
1119 if (g_b_init_get_system_times
== 0)
1121 g_b_init_get_system_times
= 1;
1122 s_pfn_Get_System_times
=
1123 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1126 if (s_pfn_Get_System_times
== NULL
)
1128 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
1131 static BOOLEAN WINAPI
1132 create_symbolic_link (LPCSTR lpSymlinkFilename
,
1133 LPCSTR lpTargetFileName
,
1136 static CreateSymbolicLinkW_Proc s_pfn_Create_Symbolic_LinkW
= NULL
;
1137 static CreateSymbolicLinkA_Proc s_pfn_Create_Symbolic_LinkA
= NULL
;
1140 if (is_windows_9x () == TRUE
)
1145 if (w32_unicode_filenames
)
1147 wchar_t symfn_w
[MAX_PATH
], tgtfn_w
[MAX_PATH
];
1149 if (g_b_init_create_symbolic_link_w
== 0)
1151 g_b_init_create_symbolic_link_w
= 1;
1152 s_pfn_Create_Symbolic_LinkW
=
1153 (CreateSymbolicLinkW_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1154 "CreateSymbolicLinkW");
1156 if (s_pfn_Create_Symbolic_LinkW
== NULL
)
1162 filename_to_utf16 (lpSymlinkFilename
, symfn_w
);
1163 filename_to_utf16 (lpTargetFileName
, tgtfn_w
);
1164 retval
= s_pfn_Create_Symbolic_LinkW (symfn_w
, tgtfn_w
, dwFlags
);
1165 /* If we were denied creation of the symlink, try again after
1166 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1169 TOKEN_PRIVILEGES priv_current
;
1171 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
,
1174 retval
= s_pfn_Create_Symbolic_LinkW (symfn_w
, tgtfn_w
, dwFlags
);
1175 restore_privilege (&priv_current
);
1182 char symfn_a
[MAX_PATH
], tgtfn_a
[MAX_PATH
];
1184 if (g_b_init_create_symbolic_link_a
== 0)
1186 g_b_init_create_symbolic_link_a
= 1;
1187 s_pfn_Create_Symbolic_LinkA
=
1188 (CreateSymbolicLinkA_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1189 "CreateSymbolicLinkA");
1191 if (s_pfn_Create_Symbolic_LinkA
== NULL
)
1197 filename_to_ansi (lpSymlinkFilename
, symfn_a
);
1198 filename_to_ansi (lpTargetFileName
, tgtfn_a
);
1199 retval
= s_pfn_Create_Symbolic_LinkA (symfn_a
, tgtfn_a
, dwFlags
);
1200 /* If we were denied creation of the symlink, try again after
1201 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1204 TOKEN_PRIVILEGES priv_current
;
1206 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
,
1209 retval
= s_pfn_Create_Symbolic_LinkA (symfn_a
, tgtfn_a
, dwFlags
);
1210 restore_privilege (&priv_current
);
1219 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor
)
1221 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc
= NULL
;
1223 if (is_windows_9x () == TRUE
)
1229 if (g_b_init_is_valid_security_descriptor
== 0)
1231 g_b_init_is_valid_security_descriptor
= 1;
1232 s_pfn_Is_Valid_Security_Descriptor_Proc
=
1233 (IsValidSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1234 "IsValidSecurityDescriptor");
1236 if (s_pfn_Is_Valid_Security_Descriptor_Proc
== NULL
)
1242 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor
);
1246 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor
,
1247 DWORD RequestedStringSDRevision
,
1248 SECURITY_INFORMATION SecurityInformation
,
1249 LPTSTR
*StringSecurityDescriptor
,
1250 PULONG StringSecurityDescriptorLen
)
1252 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL
= NULL
;
1255 if (is_windows_9x () == TRUE
)
1261 if (g_b_init_convert_sd_to_sddl
== 0)
1263 g_b_init_convert_sd_to_sddl
= 1;
1265 s_pfn_Convert_SD_To_SDDL
=
1266 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1267 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1269 s_pfn_Convert_SD_To_SDDL
=
1270 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1271 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1274 if (s_pfn_Convert_SD_To_SDDL
== NULL
)
1280 retval
= s_pfn_Convert_SD_To_SDDL (SecurityDescriptor
,
1281 RequestedStringSDRevision
,
1282 SecurityInformation
,
1283 StringSecurityDescriptor
,
1284 StringSecurityDescriptorLen
);
1290 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor
,
1291 DWORD StringSDRevision
,
1292 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
1293 PULONG SecurityDescriptorSize
)
1295 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD
= NULL
;
1298 if (is_windows_9x () == TRUE
)
1304 if (g_b_init_convert_sddl_to_sd
== 0)
1306 g_b_init_convert_sddl_to_sd
= 1;
1308 s_pfn_Convert_SDDL_To_SD
=
1309 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1310 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1312 s_pfn_Convert_SDDL_To_SD
=
1313 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1314 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1317 if (s_pfn_Convert_SDDL_To_SD
== NULL
)
1323 retval
= s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor
,
1326 SecurityDescriptorSize
);
1332 get_adapters_info (PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
1334 static GetAdaptersInfo_Proc s_pfn_Get_Adapters_Info
= NULL
;
1335 HMODULE hm_iphlpapi
= NULL
;
1337 if (is_windows_9x () == TRUE
)
1338 return ERROR_NOT_SUPPORTED
;
1340 if (g_b_init_get_adapters_info
== 0)
1342 g_b_init_get_adapters_info
= 1;
1343 hm_iphlpapi
= LoadLibrary ("Iphlpapi.dll");
1345 s_pfn_Get_Adapters_Info
= (GetAdaptersInfo_Proc
)
1346 GetProcAddress (hm_iphlpapi
, "GetAdaptersInfo");
1348 if (s_pfn_Get_Adapters_Info
== NULL
)
1349 return ERROR_NOT_SUPPORTED
;
1350 return s_pfn_Get_Adapters_Info (pAdapterInfo
, pOutBufLen
);
1355 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1356 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1358 This is called from alloc.c:valid_pointer_p. */
1360 w32_valid_pointer_p (void *p
, int size
)
1363 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
1367 unsigned char *buf
= alloca (size
);
1368 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
1379 /* Here's an overview of how the Windows build supports file names
1380 that cannot be encoded by the current system codepage.
1382 From the POV of Lisp and layers of C code above the functions here,
1383 Emacs on Windows pretends that its file names are encoded in UTF-8;
1384 see encode_file and decode_file on coding.c. Any file name that is
1385 passed as a unibyte string to C functions defined here is assumed
1386 to be in UTF-8 encoding. Any file name returned by functions
1387 defined here must be in UTF-8 encoding, with only a few exceptions
1388 reserved for a couple of special cases. (Be sure to use
1389 MAX_UTF8_PATH for char arrays that store UTF-8 encoded file names,
1390 as they can be much longer than MAX_PATH!)
1392 The UTF-8 encoded file names cannot be passed to system APIs, as
1393 Windows does not support that. Therefore, they are converted
1394 either to UTF-16 or to the ANSI codepage, depending on the value of
1395 w32-unicode-filenames, before calling any system APIs or CRT library
1396 functions. The default value of that variable is determined by the
1397 OS on which Emacs runs: nil on Windows 9X and t otherwise, but the
1398 user can change that default (although I don't see why would she
1401 The 4 functions defined below, filename_to_utf16, filename_to_ansi,
1402 filename_from_utf16, and filename_from_ansi, are the workhorses of
1403 these conversions. They rely on Windows native APIs
1404 MultiByteToWideChar and WideCharToMultiByte; we cannot use
1405 functions from coding.c here, because they allocate memory, which
1406 is a bad idea on the level of libc, which is what the functions
1407 here emulate. (If you worry about performance due to constant
1408 conversion back and forth from UTF-8 to UTF-16, then don't: first,
1409 it was measured to take only a few microseconds on a not-so-fast
1410 machine, and second, that's exactly what the ANSI APIs we used
1411 before did anyway, because they are just thin wrappers around the
1414 The variables file-name-coding-system and default-file-name-coding-system
1415 still exist, but are actually used only when a file name needs to
1416 be converted to the ANSI codepage. This happens all the time when
1417 w32-unicode-filenames is nil, but can also happen from time to time
1418 when it is t. Otherwise, these variables have no effect on file-name
1419 encoding when w32-unicode-filenames is t; this is similar to
1420 selection-coding-system.
1422 This arrangement works very well, but it has a few gotchas and
1425 . Lisp code that encodes or decodes file names manually should
1426 normally use 'utf-8' as the coding-system on Windows,
1427 disregarding file-name-coding-system. This is a somewhat
1428 unpleasant consequence, but it cannot be avoided. Fortunately,
1429 very few Lisp packages need to do that.
1431 More generally, passing to library functions (e.g., fopen or
1432 opendir) file names already encoded in the ANSI codepage is
1433 explicitly *verboten*, as all those functions, as shadowed and
1434 emulated here, assume they will receive UTF-8 encoded file names.
1436 For the same reasons, no CRT function or Win32 API can be called
1437 directly in Emacs sources, without either converting the file
1438 names from UTF-8 to UTF-16 or ANSI codepage, or going through
1439 some shadowing function defined here.
1441 . Environment variables stored in Vprocess_environment are encoded
1442 in the ANSI codepage, so if getenv/egetenv is used for a variable
1443 whose value is a file name or a list of directories, it needs to
1444 be converted to UTF-8, before it is used as argument to functions
1445 or decoded into a Lisp string.
1447 . File names passed to external libraries, like the image libraries
1448 and GnuTLS, need special handling. These libraries generally
1449 don't support UTF-16 or UTF-8 file names, so they must get file
1450 names encoded in the ANSI codepage. To facilitate using these
1451 libraries with file names that are not encodable in the ANSI
1452 codepage, use the function ansi_encode_filename, which will try
1453 to use the short 8+3 alias of a file name if that file name is
1454 not encodable in the ANSI codepage. See image.c and gnutls.c for
1455 examples of how this should be done.
1457 . Running subprocesses in non-ASCII directories and with non-ASCII
1458 file arguments is limited to the current codepage (even though
1459 Emacs is perfectly capable of finding an executable program file
1460 in a directory whose name cannot be encoded in the current
1461 codepage). This is because the command-line arguments are
1462 encoded _before_ they get to the w32-specific level, and the
1463 encoding is not known in advance (it doesn't have to be the
1464 current ANSI codepage), so w32proc.c functions cannot re-encode
1465 them in UTF-16. This should be fixed, but will also require
1466 changes in cmdproxy. The current limitation is not terribly bad
1467 anyway, since very few, if any, Windows console programs that are
1468 likely to be invoked by Emacs support UTF-16 encoded command
1471 . For similar reasons, server.el and emacsclient are also limited
1472 to the current ANSI codepage for now.
1474 . Emacs itself can only handle command-line arguments encoded in
1475 the current codepage.
1477 . Turning on w32-unicode-filename on Windows 9X (if it at all
1478 works) requires UNICOWS.DLL, which is thus a requirement even in
1479 non-GUI sessions, something the we previously avoided. */
1483 /* Converting file names from UTF-8 to either UTF-16 or the ANSI
1484 codepage defined by file-name-coding-system. */
1486 /* Current codepage for encoding file names. */
1487 static int file_name_codepage
;
1489 /* Produce a Windows ANSI codepage suitable for encoding file names.
1490 Return the information about that codepage in CP_INFO. */
1492 codepage_for_filenames (CPINFO
*cp_info
)
1494 /* A simple cache to avoid calling GetCPInfo every time we need to
1495 encode/decode a file name. The file-name encoding is not
1496 supposed to be changed too frequently, if ever. */
1497 static Lisp_Object last_file_name_encoding
;
1499 Lisp_Object current_encoding
;
1501 current_encoding
= Vfile_name_coding_system
;
1502 if (NILP (current_encoding
))
1503 current_encoding
= Vdefault_file_name_coding_system
;
1505 if (!EQ (last_file_name_encoding
, current_encoding
))
1507 /* Default to the current ANSI codepage. */
1508 file_name_codepage
= w32_ansi_code_page
;
1510 if (NILP (current_encoding
))
1512 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1513 char *cp
= NULL
, *end
;
1516 if (strncmp (cpname
, "cp", 2) == 0)
1518 else if (strncmp (cpname
, "windows-", 8) == 0)
1524 cpnum
= strtol (cp
, &end
, 10);
1525 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1526 file_name_codepage
= cpnum
;
1530 if (!file_name_codepage
)
1531 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1533 if (!GetCPInfo (file_name_codepage
, &cp
))
1535 file_name_codepage
= CP_ACP
;
1536 if (!GetCPInfo (file_name_codepage
, &cp
))
1543 return file_name_codepage
;
1547 filename_to_utf16 (const char *fn_in
, wchar_t *fn_out
)
1549 int result
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1554 DWORD err
= GetLastError ();
1558 case ERROR_INVALID_FLAGS
:
1559 case ERROR_INVALID_PARAMETER
:
1562 case ERROR_INSUFFICIENT_BUFFER
:
1563 case ERROR_NO_UNICODE_TRANSLATION
:
1574 filename_from_utf16 (const wchar_t *fn_in
, char *fn_out
)
1576 int result
= pWideCharToMultiByte (CP_UTF8
, 0, fn_in
, -1,
1577 fn_out
, MAX_UTF8_PATH
, NULL
, NULL
);
1581 DWORD err
= GetLastError ();
1585 case ERROR_INVALID_FLAGS
:
1586 case ERROR_INVALID_PARAMETER
:
1589 case ERROR_INSUFFICIENT_BUFFER
:
1590 case ERROR_NO_UNICODE_TRANSLATION
:
1601 filename_to_ansi (const char *fn_in
, char *fn_out
)
1603 wchar_t fn_utf16
[MAX_PATH
];
1605 if (filename_to_utf16 (fn_in
, fn_utf16
) == 0)
1608 int codepage
= codepage_for_filenames (NULL
);
1610 result
= pWideCharToMultiByte (codepage
, 0, fn_utf16
, -1,
1611 fn_out
, MAX_PATH
, NULL
, NULL
);
1614 DWORD err
= GetLastError ();
1618 case ERROR_INVALID_FLAGS
:
1619 case ERROR_INVALID_PARAMETER
:
1622 case ERROR_INSUFFICIENT_BUFFER
:
1623 case ERROR_NO_UNICODE_TRANSLATION
:
1636 filename_from_ansi (const char *fn_in
, char *fn_out
)
1638 wchar_t fn_utf16
[MAX_PATH
];
1639 int codepage
= codepage_for_filenames (NULL
);
1640 int result
= pMultiByteToWideChar (codepage
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1641 fn_utf16
, MAX_PATH
);
1645 DWORD err
= GetLastError ();
1649 case ERROR_INVALID_FLAGS
:
1650 case ERROR_INVALID_PARAMETER
:
1653 case ERROR_INSUFFICIENT_BUFFER
:
1654 case ERROR_NO_UNICODE_TRANSLATION
:
1661 return filename_from_utf16 (fn_utf16
, fn_out
);
1666 /* The directory where we started, in UTF-8. */
1667 static char startup_dir
[MAX_UTF8_PATH
];
1669 /* Get the current working directory. */
1671 getcwd (char *dir
, int dirsize
)
1678 if (dirsize
<= strlen (startup_dir
))
1684 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
1688 /* Emacs doesn't actually change directory itself, it stays in the
1689 same directory where it was started. */
1690 strcpy (dir
, startup_dir
);
1695 /* Emulate getloadavg. */
1697 struct load_sample
{
1704 /* Number of processors on this machine. */
1705 static unsigned num_of_processors
;
1707 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1708 static struct load_sample samples
[16*60];
1709 static int first_idx
= -1, last_idx
= -1;
1710 static int max_idx
= ARRAYELTS (samples
);
1715 int next_idx
= from
+ 1;
1717 if (next_idx
>= max_idx
)
1726 int prev_idx
= from
- 1;
1729 prev_idx
= max_idx
- 1;
1735 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
1737 SYSTEM_INFO sysinfo
;
1738 FILETIME ft_idle
, ft_user
, ft_kernel
;
1740 /* Initialize the number of processors on this machine. */
1741 if (num_of_processors
<= 0)
1743 get_native_system_info (&sysinfo
);
1744 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1745 if (num_of_processors
<= 0)
1747 GetSystemInfo (&sysinfo
);
1748 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1750 if (num_of_processors
<= 0)
1751 num_of_processors
= 1;
1754 /* TODO: Take into account threads that are ready to run, by
1755 sampling the "\System\Processor Queue Length" performance
1756 counter. The code below accounts only for threads that are
1757 actually running. */
1759 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1761 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1763 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1764 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1765 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1766 *idle
= uidle
.QuadPart
;
1767 *kernel
= ukernel
.QuadPart
;
1768 *user
= uuser
.QuadPart
;
1778 /* Produce the load average for a given time interval, using the
1779 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1780 1-minute, 5-minute, or 15-minute average, respectively. */
1784 double retval
= -1.0;
1787 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1788 time_t now
= samples
[last_idx
].sample_time
;
1790 if (first_idx
!= last_idx
)
1792 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1794 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1795 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1798 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1799 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1800 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1802 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1805 if (idx
== first_idx
)
1814 getloadavg (double loadavg
[], int nelem
)
1817 ULONGLONG idle
, kernel
, user
;
1818 time_t now
= time (NULL
);
1820 /* If system time jumped back for some reason, delete all samples
1821 whose time is later than the current wall-clock time. This
1822 prevents load average figures from becoming frozen for prolonged
1823 periods of time, when system time is reset backwards. */
1826 while (difftime (now
, samples
[last_idx
].sample_time
) < -1.0)
1828 if (last_idx
== first_idx
)
1830 first_idx
= last_idx
= -1;
1833 last_idx
= buf_prev (last_idx
);
1837 /* Store another sample. We ignore samples that are less than 1 sec
1840 || (difftime (now
, samples
[last_idx
].sample_time
)
1841 >= 1.0 - 2*DBL_EPSILON
*now
))
1843 sample_system_load (&idle
, &kernel
, &user
);
1844 last_idx
= buf_next (last_idx
);
1845 samples
[last_idx
].sample_time
= now
;
1846 samples
[last_idx
].idle
= idle
;
1847 samples
[last_idx
].kernel
= kernel
;
1848 samples
[last_idx
].user
= user
;
1849 /* If the buffer has more that 15 min worth of samples, discard
1851 if (first_idx
== -1)
1852 first_idx
= last_idx
;
1853 while (first_idx
!= last_idx
1854 && (difftime (now
, samples
[first_idx
].sample_time
)
1855 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1856 first_idx
= buf_next (first_idx
);
1859 for (elem
= 0; elem
< nelem
; elem
++)
1861 double avg
= getavg (elem
);
1865 loadavg
[elem
] = avg
;
1871 /* Emulate getpwuid, getpwnam and others. */
1873 #define PASSWD_FIELD_SIZE 256
1875 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1876 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1877 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1878 static char dflt_passwd_dir
[MAX_UTF8_PATH
];
1879 static char dflt_passwd_shell
[MAX_UTF8_PATH
];
1881 static struct passwd dflt_passwd
=
1893 static char dflt_group_name
[GNLEN
+1];
1895 static struct group dflt_group
=
1897 /* When group information is not available, we return this as the
1898 group for all files. */
1906 return dflt_passwd
.pw_uid
;
1912 /* I could imagine arguing for checking to see whether the user is
1913 in the Administrators group and returning a UID of 0 for that
1914 case, but I don't know how wise that would be in the long run. */
1921 return dflt_passwd
.pw_gid
;
1931 getpwuid (unsigned uid
)
1933 if (uid
== dflt_passwd
.pw_uid
)
1934 return &dflt_passwd
;
1939 getgrgid (gid_t gid
)
1945 getpwnam (char *name
)
1949 pw
= getpwuid (getuid ());
1953 if (xstrcasecmp (name
, pw
->pw_name
))
1960 init_user_info (void)
1962 /* Find the user's real name by opening the process token and
1963 looking up the name associated with the user-sid in that token.
1965 Use the relative portion of the identifier authority value from
1966 the user-sid as the user id value (same for group id using the
1967 primary group sid from the process token). */
1969 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1970 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1971 DWORD glength
= sizeof (gname
);
1972 HANDLE token
= NULL
;
1973 SID_NAME_USE user_type
;
1974 unsigned char *buf
= NULL
;
1976 TOKEN_USER user_token
;
1977 TOKEN_PRIMARY_GROUP group_token
;
1980 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1983 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1984 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1986 buf
= xmalloc (blen
);
1987 result
= get_token_information (token
, TokenUser
,
1988 (LPVOID
)buf
, blen
, &needed
);
1991 memcpy (&user_token
, buf
, sizeof (user_token
));
1992 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1994 domain
, &dlength
, &user_type
);
2002 strcpy (dflt_passwd
.pw_name
, uname
);
2003 /* Determine a reasonable uid value. */
2004 if (xstrcasecmp ("administrator", uname
) == 0)
2006 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
2007 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
2011 /* Use the last sub-authority value of the RID, the relative
2012 portion of the SID, as user/group ID. */
2013 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
2015 /* Get group id and name. */
2016 result
= get_token_information (token
, TokenPrimaryGroup
,
2017 (LPVOID
)buf
, blen
, &needed
);
2018 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
2020 buf
= xrealloc (buf
, blen
= needed
);
2021 result
= get_token_information (token
, TokenPrimaryGroup
,
2022 (LPVOID
)buf
, blen
, &needed
);
2026 memcpy (&group_token
, buf
, sizeof (group_token
));
2027 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
2028 dlength
= sizeof (domain
);
2029 /* If we can get at the real Primary Group name, use that.
2030 Otherwise, the default group name was already set to
2031 "None" in globals_of_w32. */
2032 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
2033 gname
, &glength
, NULL
, &dlength
,
2035 strcpy (dflt_group_name
, gname
);
2038 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
2041 /* If security calls are not supported (presumably because we
2042 are running under Windows 9X), fallback to this: */
2043 else if (GetUserName (uname
, &ulength
))
2045 strcpy (dflt_passwd
.pw_name
, uname
);
2046 if (xstrcasecmp ("administrator", uname
) == 0)
2047 dflt_passwd
.pw_uid
= 0;
2049 dflt_passwd
.pw_uid
= 123;
2050 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
2054 strcpy (dflt_passwd
.pw_name
, "unknown");
2055 dflt_passwd
.pw_uid
= 123;
2056 dflt_passwd
.pw_gid
= 123;
2058 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
2060 /* Set dir and shell from environment variables. */
2061 if (w32_unicode_filenames
)
2063 wchar_t *home
= _wgetenv (L
"HOME");
2064 wchar_t *shell
= _wgetenv (L
"SHELL");
2066 /* Ensure HOME and SHELL are defined. */
2071 filename_from_utf16 (home
, dflt_passwd
.pw_dir
);
2072 filename_from_utf16 (shell
, dflt_passwd
.pw_shell
);
2076 char *home
= getenv ("HOME");
2077 char *shell
= getenv ("SHELL");
2083 filename_from_ansi (home
, dflt_passwd
.pw_dir
);
2084 filename_from_ansi (shell
, dflt_passwd
.pw_shell
);
2089 CloseHandle (token
);
2095 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
2096 return ((rand () << 15) | rand ());
2105 /* Return the maximum length in bytes of a multibyte character
2106 sequence encoded in the current ANSI codepage. This is required to
2107 correctly walk the encoded file names one character at a time. */
2109 max_filename_mbslen (void)
2113 codepage_for_filenames (&cp_info
);
2114 return cp_info
.MaxCharSize
;
2117 /* Normalize filename by converting in-place all of its path
2118 separators to the separator specified by PATH_SEP. */
2121 normalize_filename (register char *fp
, char path_sep
)
2125 /* Always lower-case drive letters a-z, even if the filesystem
2126 preserves case in filenames.
2127 This is so filenames can be compared by string comparison
2128 functions that are case-sensitive. Even case-preserving filesystems
2129 do not distinguish case in drive letters. */
2132 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
2140 if ((*fp
== '/' || *fp
== '\\') && *fp
!= path_sep
)
2146 /* Destructively turn backslashes into slashes. */
2148 dostounix_filename (register char *p
)
2150 normalize_filename (p
, '/');
2153 /* Destructively turn slashes into backslashes. */
2155 unixtodos_filename (register char *p
)
2157 normalize_filename (p
, '\\');
2160 /* Remove all CR's that are followed by a LF.
2161 (From msdos.c...probably should figure out a way to share it,
2162 although this code isn't going to ever change.) */
2164 crlf_to_lf (register int n
, register unsigned char *buf
)
2166 unsigned char *np
= buf
;
2167 unsigned char *startp
= buf
;
2168 unsigned char *endp
= buf
+ n
;
2172 while (buf
< endp
- 1)
2176 if (*(++buf
) != 0x0a)
2187 /* Parse the root part of file name, if present. Return length and
2188 optionally store pointer to char after root. */
2190 parse_root (const char * name
, const char ** pPath
)
2192 const char * start
= name
;
2197 /* find the root name of the volume if given */
2198 if (isalpha (name
[0]) && name
[1] == ':')
2200 /* skip past drive specifier */
2202 if (IS_DIRECTORY_SEP (name
[0]))
2205 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2212 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2217 if (IS_DIRECTORY_SEP (name
[0]))
2224 return name
- start
;
2227 /* Get long base name for name; name is assumed to be absolute. */
2229 get_long_basename (char * name
, char * buf
, int size
)
2231 HANDLE dir_handle
= INVALID_HANDLE_VALUE
;
2232 char fname_utf8
[MAX_UTF8_PATH
];
2236 /* Must be valid filename, no wild cards or other invalid characters. */
2237 if (strpbrk (name
, "*?|<>\""))
2240 if (w32_unicode_filenames
)
2242 wchar_t fname_utf16
[MAX_PATH
];
2243 WIN32_FIND_DATAW find_data_wide
;
2245 filename_to_utf16 (name
, fname_utf16
);
2246 dir_handle
= FindFirstFileW (fname_utf16
, &find_data_wide
);
2247 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2248 cstatus
= filename_from_utf16 (find_data_wide
.cFileName
, fname_utf8
);
2252 char fname_ansi
[MAX_PATH
];
2253 WIN32_FIND_DATAA find_data_ansi
;
2255 filename_to_ansi (name
, fname_ansi
);
2256 /* If the ANSI name includes ? characters, it is not encodable
2257 in the ANSI codepage. In that case, we deliver the question
2258 marks to the caller; calling FindFirstFileA in this case
2259 could return some unrelated file name in the same
2261 if (_mbspbrk (fname_ansi
, "?"))
2263 /* Find the basename of fname_ansi. */
2264 char *p
= strrchr (fname_ansi
, '\\');
2270 cstatus
= filename_from_ansi (p
, fname_utf8
);
2274 dir_handle
= FindFirstFileA (fname_ansi
, &find_data_ansi
);
2275 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2276 cstatus
= filename_from_ansi (find_data_ansi
.cFileName
, fname_utf8
);
2280 if (cstatus
== 0 && (len
= strlen (fname_utf8
)) < size
)
2281 memcpy (buf
, fname_utf8
, len
+ 1);
2285 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2286 FindClose (dir_handle
);
2291 /* Get long name for file, if possible (assumed to be absolute). */
2293 w32_get_long_filename (char * name
, char * buf
, int size
)
2298 char full
[ MAX_UTF8_PATH
];
2301 len
= strlen (name
);
2302 if (len
>= MAX_UTF8_PATH
)
2305 /* Use local copy for destructive modification. */
2306 memcpy (full
, name
, len
+1);
2307 unixtodos_filename (full
);
2309 /* Copy root part verbatim. */
2310 len
= parse_root (full
, (const char **)&p
);
2311 memcpy (o
, full
, len
);
2316 while (p
!= NULL
&& *p
)
2319 p
= strchr (q
, '\\');
2321 len
= get_long_basename (full
, o
, size
);
2344 w32_get_short_filename (char * name
, char * buf
, int size
)
2346 if (w32_unicode_filenames
)
2348 wchar_t name_utf16
[MAX_PATH
], short_name
[MAX_PATH
];
2349 unsigned int retval
;
2351 filename_to_utf16 (name
, name_utf16
);
2352 retval
= GetShortPathNameW (name_utf16
, short_name
, size
);
2353 if (retval
&& retval
< size
)
2354 filename_from_utf16 (short_name
, buf
);
2359 char name_ansi
[MAX_PATH
];
2361 filename_to_ansi (name
, name_ansi
);
2362 return GetShortPathNameA (name_ansi
, buf
, size
);
2366 /* Re-encode FILENAME, a UTF-8 encoded unibyte string, using the
2367 MS-Windows ANSI codepage. If FILENAME includes characters not
2368 supported by the ANSI codepage, return the 8+3 alias of FILENAME,
2369 if it exists. This is needed because the w32 build wants to
2370 support file names outside of the system locale, but image
2371 libraries typically don't support wide (a.k.a. "Unicode") APIs
2372 required for that. */
2375 ansi_encode_filename (Lisp_Object filename
)
2377 Lisp_Object encoded_filename
;
2378 char fname
[MAX_PATH
];
2380 filename_to_ansi (SSDATA (filename
), fname
);
2381 if (_mbspbrk (fname
, "?"))
2383 char shortname
[MAX_PATH
];
2385 if (w32_get_short_filename (SDATA (filename
), shortname
, MAX_PATH
))
2387 dostounix_filename (shortname
);
2388 encoded_filename
= build_string (shortname
);
2392 encoded_filename
= build_unibyte_string (fname
);
2393 return encoded_filename
;
2397 is_unc_volume (const char *filename
)
2399 const char *ptr
= filename
;
2401 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
2404 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
2410 /* Emulate the Posix unsetenv. */
2412 unsetenv (const char *name
)
2417 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
2422 name_len
= strlen (name
);
2423 /* MS docs says an environment variable cannot be longer than 32K. */
2424 if (name_len
> 32767)
2429 /* It is safe to use 'alloca' with 32K size, since the stack is at
2430 least 2MB, and we set it to 8MB in the link command line. */
2431 var
= alloca (name_len
+ 2);
2432 strncpy (var
, name
, name_len
);
2433 var
[name_len
++] = '=';
2434 var
[name_len
] = '\0';
2435 return _putenv (var
);
2438 /* MS _putenv doesn't support removing a variable when the argument
2439 does not include the '=' character, so we fix that here. */
2441 sys_putenv (char *str
)
2443 const char *const name_end
= strchr (str
, '=');
2445 if (name_end
== NULL
)
2447 /* Remove the variable from the environment. */
2448 return unsetenv (str
);
2451 return _putenv (str
);
2454 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
2457 w32_get_resource (char *key
, LPDWORD lpdwtype
)
2460 HKEY hrootkey
= NULL
;
2463 /* Check both the current user and the local machine to see if
2464 we have any resources. */
2466 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2470 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2471 && (lpvalue
= xmalloc (cbData
)) != NULL
2472 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2474 RegCloseKey (hrootkey
);
2480 RegCloseKey (hrootkey
);
2483 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2487 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2488 && (lpvalue
= xmalloc (cbData
)) != NULL
2489 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2491 RegCloseKey (hrootkey
);
2497 RegCloseKey (hrootkey
);
2503 /* The argv[] array holds ANSI-encoded strings, and so this function
2504 works with ANS_encoded strings. */
2506 init_environment (char ** argv
)
2508 static const char * const tempdirs
[] = {
2509 "$TMPDIR", "$TEMP", "$TMP", "c:/"
2514 const int imax
= ARRAYELTS (tempdirs
);
2516 /* Implementation note: This function explicitly works with ANSI
2517 file names, not with UTF-8 encoded file names. This is because
2518 this function pushes variables into the Emacs's environment, and
2519 the environment variables are always assumed to be in the
2520 locale-specific encoding. Do NOT call any functions that accept
2521 UTF-8 file names from this function! */
2523 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
2524 temporary files and assume "/tmp" if $TMPDIR is unset, which
2525 will break on DOS/Windows. Refuse to work if we cannot find
2526 a directory, not even "c:/", usable for that purpose. */
2527 for (i
= 0; i
< imax
; i
++)
2529 const char *tmp
= tempdirs
[i
];
2532 tmp
= getenv (tmp
+ 1);
2533 /* Note that `access' can lie to us if the directory resides on a
2534 read-only filesystem, like CD-ROM or a write-protected floppy.
2535 The only way to be really sure is to actually create a file and
2536 see if it succeeds. But I think that's too much to ask. */
2538 /* MSVCRT's _access crashes with D_OK, so we use our replacement. */
2539 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
2541 char * var
= alloca (strlen (tmp
) + 8);
2542 sprintf (var
, "TMPDIR=%s", tmp
);
2543 _putenv (strdup (var
));
2550 Fcons (build_string ("no usable temporary directories found!!"),
2552 "While setting TMPDIR: ");
2554 /* Check for environment variables and use registry settings if they
2555 don't exist. Fallback on default values where applicable. */
2560 char locale_name
[32];
2561 char default_home
[MAX_PATH
];
2564 static const struct env_entry
2570 /* If the default value is NULL, we will use the value from the
2571 outside environment or the Registry, but will not push the
2572 variable into the Emacs environment if it is defined neither
2573 in the Registry nor in the outside environment. */
2575 {"PRELOAD_WINSOCK", NULL
},
2576 {"emacs_dir", "C:/emacs"},
2577 {"EMACSLOADPATH", NULL
},
2578 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2579 {"EMACSDATA", NULL
},
2580 {"EMACSPATH", NULL
},
2587 #define N_ENV_VARS ARRAYELTS (dflt_envvars)
2589 /* We need to copy dflt_envvars[] and work on the copy because we
2590 don't want the dumped Emacs to inherit the values of
2591 environment variables we saw during dumping (which could be on
2592 a different system). The defaults above must be left intact. */
2593 struct env_entry env_vars
[N_ENV_VARS
];
2595 for (i
= 0; i
< N_ENV_VARS
; i
++)
2596 env_vars
[i
] = dflt_envvars
[i
];
2598 /* For backwards compatibility, check if a .emacs file exists in C:/
2599 If not, then we can try to default to the appdata directory under the
2600 user's profile, which is more likely to be writable. */
2601 if (sys_access ("C:/.emacs", F_OK
) != 0)
2603 HRESULT profile_result
;
2604 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2605 of Windows 95 and NT4 that have not been updated to include
2607 ShGetFolderPath_fn get_folder_path
;
2608 get_folder_path
= (ShGetFolderPath_fn
)
2609 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2611 if (get_folder_path
!= NULL
)
2613 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2616 /* If we can't get the appdata dir, revert to old behavior. */
2617 if (profile_result
== S_OK
)
2619 env_vars
[0].def_value
= default_home
;
2625 /* Get default locale info and use it for LANG. */
2626 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2627 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2628 locale_name
, sizeof (locale_name
)))
2630 for (i
= 0; i
< N_ENV_VARS
; i
++)
2632 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2634 env_vars
[i
].def_value
= locale_name
;
2640 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2642 /* Treat emacs_dir specially: set it unconditionally based on our
2646 char modname
[MAX_PATH
];
2648 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2650 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2654 if ((p
= _mbsrchr (modname
, '\\'))
2655 /* From bin means installed Emacs, from src means uninstalled. */
2656 && (xstrcasecmp (p
, "\\bin") == 0 || xstrcasecmp (p
, "\\src") == 0))
2658 char buf
[SET_ENV_BUF_SIZE
];
2659 int within_build_tree
= xstrcasecmp (p
, "\\src") == 0;
2662 for (p
= modname
; *p
; p
= CharNext (p
))
2663 if (*p
== '\\') *p
= '/';
2665 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2666 _putenv (strdup (buf
));
2667 /* If we are running from the Posix-like build tree, define
2668 SHELL to point to our own cmdproxy. The loop below will
2669 then disregard PATH_EXEC and the default value. */
2670 if (within_build_tree
)
2672 _snprintf (buf
, sizeof (buf
) - 1,
2673 "SHELL=%s/nt/cmdproxy.exe", modname
);
2674 _putenv (strdup (buf
));
2679 for (i
= 0; i
< N_ENV_VARS
; i
++)
2681 if (!getenv (env_vars
[i
].name
))
2684 char bufc
[SET_ENV_BUF_SIZE
];
2686 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2687 /* Also ignore empty environment variables. */
2692 if (strcmp (env_vars
[i
].name
, "SHELL") == 0)
2694 /* Look for cmdproxy.exe in every directory in
2695 PATH_EXEC. FIXME: This does not find cmdproxy
2696 in nt/ when we run uninstalled. */
2697 char fname
[MAX_PATH
];
2698 const char *pstart
= PATH_EXEC
, *pend
;
2701 pend
= _mbschr (pstart
, ';');
2703 pend
= pstart
+ strlen (pstart
);
2704 /* Be defensive against series of ;;; characters. */
2707 strncpy (fname
, pstart
, pend
- pstart
);
2708 fname
[pend
- pstart
] = '/';
2709 strcpy (&fname
[pend
- pstart
+ 1], "cmdproxy.exe");
2710 ExpandEnvironmentStrings ((LPSTR
) fname
, bufc
,
2712 if (sys_access (bufc
, F_OK
) == 0)
2725 /* If not found in any directory, use the
2726 default as the last resort. */
2727 lpval
= env_vars
[i
].def_value
;
2728 dwType
= REG_EXPAND_SZ
;
2734 lpval
= env_vars
[i
].def_value
;
2735 dwType
= REG_EXPAND_SZ
;
2737 if (strcmp (env_vars
[i
].name
, "HOME") == 0 && !appdata
)
2738 Vdelayed_warnings_list
2739 = Fcons (listn (CONSTYPE_HEAP
, 2,
2740 intern ("initialization"),
2741 build_string ("Setting HOME to C:\\ by default is deprecated")),
2742 Vdelayed_warnings_list
);
2747 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2749 if (dwType
== REG_EXPAND_SZ
)
2750 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2751 else if (dwType
== REG_SZ
)
2752 strcpy (buf1
, lpval
);
2753 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2755 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2757 _putenv (strdup (buf2
));
2767 /* Rebuild system configuration to reflect invoking system. */
2768 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2770 /* Another special case: on NT, the PATH variable is actually named
2771 "Path" although cmd.exe (perhaps NT itself) arranges for
2772 environment variable lookup and setting to be case insensitive.
2773 However, Emacs assumes a fully case sensitive environment, so we
2774 need to change "Path" to "PATH" to match the expectations of
2775 various elisp packages. We do this by the sneaky method of
2776 modifying the string in the C runtime environ entry.
2778 The same applies to COMSPEC. */
2782 for (envp
= environ
; *envp
; envp
++)
2783 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2784 memcpy (*envp
, "PATH=", 5);
2785 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2786 memcpy (*envp
, "COMSPEC=", 8);
2789 /* Remember the initial working directory for getcwd. */
2790 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2791 Does it matter anywhere in Emacs? */
2792 if (w32_unicode_filenames
)
2794 wchar_t wstartup_dir
[MAX_PATH
];
2796 if (!GetCurrentDirectoryW (MAX_PATH
, wstartup_dir
))
2798 filename_from_utf16 (wstartup_dir
, startup_dir
);
2802 char astartup_dir
[MAX_PATH
];
2804 if (!GetCurrentDirectoryA (MAX_PATH
, astartup_dir
))
2806 filename_from_ansi (astartup_dir
, startup_dir
);
2810 static char modname
[MAX_PATH
];
2812 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2817 /* Determine if there is a middle mouse button, to allow parse_button
2818 to decide whether right mouse events should be mouse-2 or
2820 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2825 /* Called from expand-file-name when default-directory is not a string. */
2828 emacs_root_dir (void)
2830 static char root_dir
[MAX_UTF8_PATH
];
2833 p
= getenv ("emacs_dir");
2836 filename_from_ansi (p
, root_dir
);
2837 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2838 dostounix_filename (root_dir
);
2842 #include <sys/timeb.h>
2844 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2846 gettimeofday (struct timeval
*__restrict tv
, struct timezone
*__restrict tz
)
2851 tv
->tv_sec
= tb
.time
;
2852 tv
->tv_usec
= tb
.millitm
* 1000L;
2853 /* Implementation note: _ftime sometimes doesn't update the dstflag
2854 according to the new timezone when the system timezone is
2855 changed. We could fix that by using GetSystemTime and
2856 GetTimeZoneInformation, but that doesn't seem necessary, since
2857 Emacs always calls gettimeofday with the 2nd argument NULL (see
2858 current_emacs_time). */
2861 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2862 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2867 /* Emulate fdutimens. */
2869 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2870 TIMESPEC[0] and TIMESPEC[1], respectively.
2871 FD must be either negative -- in which case it is ignored --
2872 or a file descriptor that is open on FILE.
2873 If FD is nonnegative, then FILE can be NULL, which means
2874 use just futimes instead of utimes.
2875 If TIMESPEC is null, FAIL.
2876 Return 0 on success, -1 (setting errno) on failure. */
2879 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2886 if (fd
< 0 && !file
)
2891 /* _futime's prototype defines 2nd arg as having the type 'struct
2892 _utimbuf', while utime needs to accept 'struct utimbuf' for
2893 compatibility with Posix. So we need to use 2 different (but
2894 equivalent) types to avoid compiler warnings, sigh. */
2897 struct _utimbuf _ut
;
2899 _ut
.actime
= timespec
[0].tv_sec
;
2900 _ut
.modtime
= timespec
[1].tv_sec
;
2901 return _futime (fd
, &_ut
);
2907 ut
.actime
= timespec
[0].tv_sec
;
2908 ut
.modtime
= timespec
[1].tv_sec
;
2909 /* Call 'utime', which is implemented below, not the MS library
2910 function, which fails on directories. */
2911 return utime (file
, &ut
);
2916 /* ------------------------------------------------------------------------- */
2917 /* IO support and wrapper functions for the Windows API. */
2918 /* ------------------------------------------------------------------------- */
2920 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2921 on network directories, so we handle that case here.
2922 (Ulrich Leodolter, 1/11/95). */
2924 sys_ctime (const time_t *t
)
2926 char *str
= (char *) ctime (t
);
2927 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2930 /* Emulate sleep...we could have done this with a define, but that
2931 would necessitate including windows.h in the files that used it.
2932 This is much easier. */
2934 sys_sleep (int seconds
)
2936 Sleep (seconds
* 1000);
2939 /* Internal MSVC functions for low-level descriptor munging */
2940 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2941 extern int __cdecl
_free_osfhnd (int fd
);
2943 /* parallel array of private info on file handles */
2944 filedesc fd_info
[ MAXDESC
];
2946 typedef struct volume_info_data
{
2947 struct volume_info_data
* next
;
2949 /* time when info was obtained */
2952 /* actual volume info */
2961 /* Global referenced by various functions. */
2962 static volume_info_data volume_info
;
2964 /* Vector to indicate which drives are local and fixed (for which cached
2965 data never expires). */
2966 static BOOL fixed_drives
[26];
2968 /* Consider cached volume information to be stale if older than 10s,
2969 at least for non-local drives. Info for fixed drives is never stale. */
2970 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2971 #define VOLINFO_STILL_VALID( root_dir, info ) \
2972 ( ( isalpha (root_dir[0]) && \
2973 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2974 || GetTickCount () - info->timestamp < 10000 )
2976 /* Cache support functions. */
2978 /* Simple linked list with linear search is sufficient. */
2979 static volume_info_data
*volume_cache
= NULL
;
2981 static volume_info_data
*
2982 lookup_volume_info (char * root_dir
)
2984 volume_info_data
* info
;
2986 for (info
= volume_cache
; info
; info
= info
->next
)
2987 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2993 add_volume_info (char * root_dir
, volume_info_data
* info
)
2995 info
->root_dir
= xstrdup (root_dir
);
2996 unixtodos_filename (info
->root_dir
);
2997 info
->next
= volume_cache
;
2998 volume_cache
= info
;
3002 /* Wrapper for GetVolumeInformation, which uses caching to avoid
3003 performance penalty (~2ms on 486 for local drives, 7.5ms for local
3004 cdrom drive, ~5-10ms or more for remote drives on LAN). */
3005 static volume_info_data
*
3006 GetCachedVolumeInformation (char * root_dir
)
3008 volume_info_data
* info
;
3009 char default_root
[ MAX_UTF8_PATH
];
3010 char name
[MAX_PATH
+1];
3011 char type
[MAX_PATH
+1];
3013 /* NULL for root_dir means use root from current directory. */
3014 if (root_dir
== NULL
)
3016 if (w32_unicode_filenames
)
3018 wchar_t curdirw
[MAX_PATH
];
3020 if (GetCurrentDirectoryW (MAX_PATH
, curdirw
) == 0)
3022 filename_from_utf16 (curdirw
, default_root
);
3026 char curdira
[MAX_PATH
];
3028 if (GetCurrentDirectoryA (MAX_PATH
, curdira
) == 0)
3030 filename_from_ansi (curdira
, default_root
);
3032 parse_root (default_root
, (const char **)&root_dir
);
3034 root_dir
= default_root
;
3037 /* Local fixed drives can be cached permanently. Removable drives
3038 cannot be cached permanently, since the volume name and serial
3039 number (if nothing else) can change. Remote drives should be
3040 treated as if they are removable, since there is no sure way to
3041 tell whether they are or not. Also, the UNC association of drive
3042 letters mapped to remote volumes can be changed at any time (even
3043 by other processes) without notice.
3045 As a compromise, so we can benefit from caching info for remote
3046 volumes, we use a simple expiry mechanism to invalidate cache
3047 entries that are more than ten seconds old. */
3050 /* No point doing this, because WNetGetConnection is even slower than
3051 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
3052 GetDriveType is about the only call of this type which does not
3053 involve network access, and so is extremely quick). */
3055 /* Map drive letter to UNC if remote. */
3056 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
3058 char remote_name
[ 256 ];
3059 char drive
[3] = { root_dir
[0], ':' };
3061 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
3063 /* do something */ ;
3067 info
= lookup_volume_info (root_dir
);
3069 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
3075 /* Info is not cached, or is stale. */
3076 if (w32_unicode_filenames
)
3078 wchar_t root_w
[MAX_PATH
];
3079 wchar_t name_w
[MAX_PATH
+1];
3080 wchar_t type_w
[MAX_PATH
+1];
3082 filename_to_utf16 (root_dir
, root_w
);
3083 if (!GetVolumeInformationW (root_w
,
3084 name_w
, sizeof (name_w
),
3088 type_w
, sizeof (type_w
)))
3090 /* Hmm... not really 100% correct, as these 2 are not file
3092 filename_from_utf16 (name_w
, name
);
3093 filename_from_utf16 (type_w
, type
);
3097 char root_a
[MAX_PATH
];
3098 char name_a
[MAX_PATH
+1];
3099 char type_a
[MAX_PATH
+1];
3101 filename_to_ansi (root_dir
, root_a
);
3102 if (!GetVolumeInformationA (root_a
,
3103 name_a
, sizeof (name_a
),
3107 type_a
, sizeof (type_a
)))
3109 filename_from_ansi (name_a
, name
);
3110 filename_from_ansi (type_a
, type
);
3113 /* Cache the volume information for future use, overwriting existing
3114 entry if present. */
3117 info
= xmalloc (sizeof (volume_info_data
));
3118 add_volume_info (root_dir
, info
);
3126 info
->name
= xstrdup (name
);
3127 unixtodos_filename (info
->name
);
3128 info
->serialnum
= serialnum
;
3129 info
->maxcomp
= maxcomp
;
3130 info
->flags
= flags
;
3131 info
->type
= xstrdup (type
);
3132 info
->timestamp
= GetTickCount ();
3138 /* Get information on the volume where NAME is held; set path pointer to
3139 start of pathname in NAME (past UNC header\volume header if present),
3140 if pPath is non-NULL.
3142 Note: if NAME includes symlinks, the information is for the volume
3143 of the symlink, not of its target. That's because, even though
3144 GetVolumeInformation returns information about the symlink target
3145 of its argument, we only pass the root directory to
3146 GetVolumeInformation, not the full NAME. */
3148 get_volume_info (const char * name
, const char ** pPath
)
3150 char temp
[MAX_UTF8_PATH
];
3151 char *rootname
= NULL
; /* default to current volume */
3152 volume_info_data
* info
;
3153 int root_len
= parse_root (name
, pPath
);
3158 /* Copy the root name of the volume, if given. */
3161 strncpy (temp
, name
, root_len
);
3162 temp
[root_len
] = '\0';
3163 unixtodos_filename (temp
);
3167 info
= GetCachedVolumeInformation (rootname
);
3170 /* Set global referenced by other functions. */
3171 volume_info
= *info
;
3177 /* Determine if volume is FAT format (ie. only supports short 8.3
3178 names); also set path pointer to start of pathname in name, if
3179 pPath is non-NULL. */
3181 is_fat_volume (const char * name
, const char ** pPath
)
3183 if (get_volume_info (name
, pPath
))
3184 return (volume_info
.maxcomp
== 12);
3188 /* Convert all slashes in a filename to backslashes, and map filename
3189 to a valid 8.3 name if necessary. The result is a pointer to a
3190 static buffer, so CAVEAT EMPTOR! */
3192 map_w32_filename (const char * name
, const char ** pPath
)
3194 static char shortname
[MAX_UTF8_PATH
];
3195 char * str
= shortname
;
3198 const char * save_name
= name
;
3200 if (strlen (name
) >= sizeof (shortname
))
3202 /* Return a filename which will cause callers to fail. */
3203 strcpy (shortname
, "?");
3207 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
3209 register int left
= 8; /* maximum number of chars in part */
3210 register int extn
= 0; /* extension added? */
3211 register int dots
= 2; /* maximum number of dots allowed */
3214 *str
++ = *name
++; /* skip past UNC header */
3216 while ((c
= *name
++))
3223 *str
++ = (c
== ':' ? ':' : '\\');
3224 extn
= 0; /* reset extension flags */
3225 dots
= 2; /* max 2 dots */
3226 left
= 8; /* max length 8 for main part */
3231 /* Convert path components of the form .xxx to _xxx,
3232 but leave . and .. as they are. This allows .emacs
3233 to be read as _emacs, for example. */
3237 IS_DIRECTORY_SEP (*name
))
3252 extn
= 1; /* we've got an extension */
3253 left
= 3; /* 3 chars in extension */
3257 /* any embedded dots after the first are converted to _ */
3262 case '#': /* don't lose these, they're important */
3264 str
[-1] = c
; /* replace last character of part */
3267 if ( left
&& 'A' <= c
&& c
<= 'Z' )
3269 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
3271 dots
= 0; /* started a path component */
3280 strcpy (shortname
, name
);
3281 unixtodos_filename (shortname
);
3285 *pPath
= shortname
+ (path
- save_name
);
3291 is_exec (const char * name
)
3293 char * p
= strrchr (name
, '.');
3296 && (xstrcasecmp (p
, ".exe") == 0 ||
3297 xstrcasecmp (p
, ".com") == 0 ||
3298 xstrcasecmp (p
, ".bat") == 0 ||
3299 xstrcasecmp (p
, ".cmd") == 0));
3302 /* Emulate the Unix directory procedures opendir, closedir, and
3303 readdir. We rename them to sys_* names because some versions of
3304 MinGW startup code call opendir and readdir to glob wildcards, and
3305 the code that calls them doesn't grok UTF-8 encoded file names we
3306 produce in dirent->d_name[]. */
3308 struct dirent dir_static
; /* simulated directory contents */
3309 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
3310 static int dir_is_fat
;
3311 static char dir_pathname
[MAX_UTF8_PATH
];
3312 static WIN32_FIND_DATAW dir_find_data_w
;
3313 static WIN32_FIND_DATAA dir_find_data_a
;
3314 #define DIR_FIND_DATA_W 1
3315 #define DIR_FIND_DATA_A 2
3316 static int last_dir_find_data
= -1;
3318 /* Support shares on a network resource as subdirectories of a read-only
3320 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3321 static HANDLE
open_unc_volume (const char *);
3322 static void *read_unc_volume (HANDLE
, wchar_t *, char *, int);
3323 static void close_unc_volume (HANDLE
);
3326 sys_opendir (const char *filename
)
3330 /* Opening is done by FindFirstFile. However, a read is inherent to
3331 this operation, so we defer the open until read time. */
3333 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3335 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3338 /* Note: We don't support traversal of UNC volumes via symlinks.
3339 Doing so would mean punishing 99.99% of use cases by resolving
3340 all the possible symlinks in FILENAME, recursively. */
3341 if (is_unc_volume (filename
))
3343 wnet_enum_handle
= open_unc_volume (filename
);
3344 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
3348 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
3355 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAX_UTF8_PATH
- 1);
3356 dir_pathname
[MAX_UTF8_PATH
- 1] = '\0';
3357 /* Note: We don't support symlinks to file names on FAT volumes.
3358 Doing so would mean punishing 99.99% of use cases by resolving
3359 all the possible symlinks in FILENAME, recursively. */
3360 dir_is_fat
= is_fat_volume (filename
, NULL
);
3366 sys_closedir (DIR *dirp
)
3368 /* If we have a find-handle open, close it. */
3369 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3371 FindClose (dir_find_handle
);
3372 dir_find_handle
= INVALID_HANDLE_VALUE
;
3374 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3376 close_unc_volume (wnet_enum_handle
);
3377 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3379 xfree ((char *) dirp
);
3383 sys_readdir (DIR *dirp
)
3385 int downcase
= !NILP (Vw32_downcase_file_names
);
3387 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3389 if (!read_unc_volume (wnet_enum_handle
,
3390 dir_find_data_w
.cFileName
,
3391 dir_find_data_a
.cFileName
,
3395 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3396 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3398 char filename
[MAX_UTF8_PATH
+ 2];
3401 strcpy (filename
, dir_pathname
);
3402 ln
= strlen (filename
) - 1;
3403 if (!IS_DIRECTORY_SEP (filename
[ln
]))
3404 strcat (filename
, "\\");
3405 strcat (filename
, "*");
3407 /* Note: No need to resolve symlinks in FILENAME, because
3408 FindFirst opens the directory that is the target of a
3410 if (w32_unicode_filenames
)
3412 wchar_t fnw
[MAX_PATH
];
3414 filename_to_utf16 (filename
, fnw
);
3415 dir_find_handle
= FindFirstFileW (fnw
, &dir_find_data_w
);
3421 filename_to_ansi (filename
, fna
);
3422 /* If FILENAME is not representable by the current ANSI
3423 codepage, we don't want FindFirstFileA to interpret the
3424 '?' characters as a wildcard. */
3425 if (_mbspbrk (fna
, "?"))
3426 dir_find_handle
= INVALID_HANDLE_VALUE
;
3428 dir_find_handle
= FindFirstFileA (fna
, &dir_find_data_a
);
3431 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3434 else if (w32_unicode_filenames
)
3436 if (!FindNextFileW (dir_find_handle
, &dir_find_data_w
))
3441 if (!FindNextFileA (dir_find_handle
, &dir_find_data_a
))
3445 /* Emacs never uses this value, so don't bother making it match
3446 value returned by stat(). */
3447 dir_static
.d_ino
= 1;
3449 if (w32_unicode_filenames
)
3451 if (downcase
|| dir_is_fat
)
3453 wchar_t tem
[MAX_PATH
];
3455 wcscpy (tem
, dir_find_data_w
.cFileName
);
3457 filename_from_utf16 (tem
, dir_static
.d_name
);
3460 filename_from_utf16 (dir_find_data_w
.cFileName
, dir_static
.d_name
);
3461 last_dir_find_data
= DIR_FIND_DATA_W
;
3467 /* If the file name in cFileName[] includes `?' characters, it
3468 means the original file name used characters that cannot be
3469 represented by the current ANSI codepage. To avoid total
3470 lossage, retrieve the short 8+3 alias of the long file
3472 if (_mbspbrk (dir_find_data_a
.cFileName
, "?"))
3474 strcpy (tem
, dir_find_data_a
.cAlternateFileName
);
3475 /* 8+3 aliases are returned in all caps, which could break
3476 various alists that look at filenames' extensions. */
3479 else if (downcase
|| dir_is_fat
)
3480 strcpy (tem
, dir_find_data_a
.cFileName
);
3482 filename_from_ansi (dir_find_data_a
.cFileName
, dir_static
.d_name
);
3483 if (downcase
|| dir_is_fat
)
3486 filename_from_ansi (tem
, dir_static
.d_name
);
3488 last_dir_find_data
= DIR_FIND_DATA_A
;
3491 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3492 dir_static
.d_reclen
= sizeof (struct dirent
) - MAX_UTF8_PATH
+ 3 +
3493 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3499 open_unc_volume (const char *path
)
3501 const char *fn
= map_w32_filename (path
, NULL
);
3505 if (w32_unicode_filenames
)
3508 wchar_t fnw
[MAX_PATH
];
3510 nrw
.dwScope
= RESOURCE_GLOBALNET
;
3511 nrw
.dwType
= RESOURCETYPE_DISK
;
3512 nrw
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3513 nrw
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3514 nrw
.lpLocalName
= NULL
;
3515 filename_to_utf16 (fn
, fnw
);
3516 nrw
.lpRemoteName
= fnw
;
3517 nrw
.lpComment
= NULL
;
3518 nrw
.lpProvider
= NULL
;
3520 result
= WNetOpenEnumW (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3521 RESOURCEUSAGE_CONNECTABLE
, &nrw
, &henum
);
3528 nra
.dwScope
= RESOURCE_GLOBALNET
;
3529 nra
.dwType
= RESOURCETYPE_DISK
;
3530 nra
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3531 nra
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3532 nra
.lpLocalName
= NULL
;
3533 filename_to_ansi (fn
, fna
);
3534 nra
.lpRemoteName
= fna
;
3535 nra
.lpComment
= NULL
;
3536 nra
.lpProvider
= NULL
;
3538 result
= WNetOpenEnumA (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3539 RESOURCEUSAGE_CONNECTABLE
, &nra
, &henum
);
3541 if (result
== NO_ERROR
)
3544 return INVALID_HANDLE_VALUE
;
3548 read_unc_volume (HANDLE henum
, wchar_t *fname_w
, char *fname_a
, int size
)
3553 DWORD bufsize
= 512;
3557 if (w32_unicode_filenames
)
3562 buffer
= alloca (bufsize
);
3563 result
= WNetEnumResourceW (henum
, &count
, buffer
, &bufsize
);
3564 if (result
!= NO_ERROR
)
3566 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3567 ptrw
= ((LPNETRESOURCEW
) buffer
)->lpRemoteName
;
3569 while (*ptrw
&& *ptrw
!= L
'/' && *ptrw
!= L
'\\') ptrw
++;
3571 wcsncpy (fname_w
, ptrw
, size
);
3576 int dbcs_p
= max_filename_mbslen () > 1;
3579 buffer
= alloca (bufsize
);
3580 result
= WNetEnumResourceA (henum
, &count
, buffer
, &bufsize
);
3581 if (result
!= NO_ERROR
)
3583 ptra
= ((LPNETRESOURCEA
) buffer
)->lpRemoteName
;
3586 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
)) ptra
++;
3589 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
))
3590 ptra
= CharNextExA (file_name_codepage
, ptra
, 0);
3593 strncpy (fname_a
, ptra
, size
);
3601 close_unc_volume (HANDLE henum
)
3603 if (henum
!= INVALID_HANDLE_VALUE
)
3604 WNetCloseEnum (henum
);
3608 unc_volume_file_attributes (const char *path
)
3613 henum
= open_unc_volume (path
);
3614 if (henum
== INVALID_HANDLE_VALUE
)
3617 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3619 close_unc_volume (henum
);
3624 /* Ensure a network connection is authenticated. */
3626 logon_network_drive (const char *path
)
3628 char share
[MAX_UTF8_PATH
];
3635 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3636 drvtype
= DRIVE_REMOTE
;
3637 else if (path
[0] == '\0' || path
[1] != ':')
3638 drvtype
= GetDriveType (NULL
);
3645 drvtype
= GetDriveType (drive
);
3648 /* Only logon to networked drives. */
3649 if (drvtype
!= DRIVE_REMOTE
)
3653 strncpy (share
, path
, MAX_UTF8_PATH
);
3654 /* Truncate to just server and share name. */
3655 for (p
= share
+ 2; *p
&& p
< share
+ MAX_UTF8_PATH
; p
++)
3657 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3664 if (w32_unicode_filenames
)
3666 NETRESOURCEW resourcew
;
3667 wchar_t share_w
[MAX_PATH
];
3669 resourcew
.dwScope
= RESOURCE_GLOBALNET
;
3670 resourcew
.dwType
= RESOURCETYPE_DISK
;
3671 resourcew
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3672 resourcew
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3673 resourcew
.lpLocalName
= NULL
;
3674 filename_to_utf16 (share
, share_w
);
3675 resourcew
.lpRemoteName
= share_w
;
3676 resourcew
.lpProvider
= NULL
;
3678 val
= WNetAddConnection2W (&resourcew
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3682 NETRESOURCEA resourcea
;
3683 char share_a
[MAX_PATH
];
3685 resourcea
.dwScope
= RESOURCE_GLOBALNET
;
3686 resourcea
.dwType
= RESOURCETYPE_DISK
;
3687 resourcea
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3688 resourcea
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3689 resourcea
.lpLocalName
= NULL
;
3690 filename_to_ansi (share
, share_a
);
3691 resourcea
.lpRemoteName
= share_a
;
3692 resourcea
.lpProvider
= NULL
;
3694 val
= WNetAddConnection2A (&resourcea
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3700 case ERROR_ALREADY_ASSIGNED
:
3702 case ERROR_ACCESS_DENIED
:
3703 case ERROR_LOGON_FAILURE
:
3709 case ERROR_BAD_NET_NAME
:
3710 case ERROR_NO_NET_OR_BAD_PATH
:
3711 case ERROR_NO_NETWORK
:
3712 case ERROR_CANCELLED
:
3719 /* Emulate faccessat(2). */
3721 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3725 if (dirfd
!= AT_FDCWD
3726 && !(IS_DIRECTORY_SEP (path
[0])
3727 || IS_DEVICE_SEP (path
[1])))
3733 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3734 newer versions blow up when passed D_OK. */
3735 path
= map_w32_filename (path
, NULL
);
3736 /* If the last element of PATH is a symlink, we need to resolve it
3737 to get the attributes of its target file. Note: any symlinks in
3738 PATH elements other than the last one are transparently resolved
3739 by GetFileAttributes below. */
3740 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3741 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3742 path
= chase_symlinks (path
);
3744 if (w32_unicode_filenames
)
3746 wchar_t path_w
[MAX_PATH
];
3748 filename_to_utf16 (path
, path_w
);
3749 attributes
= GetFileAttributesW (path_w
);
3753 char path_a
[MAX_PATH
];
3755 filename_to_ansi (path
, path_a
);
3756 attributes
= GetFileAttributesA (path_a
);
3759 if (attributes
== -1)
3761 DWORD w32err
= GetLastError ();
3765 case ERROR_INVALID_NAME
:
3766 case ERROR_BAD_PATHNAME
:
3767 if (is_unc_volume (path
))
3769 attributes
= unc_volume_file_attributes (path
);
3770 if (attributes
== -1)
3778 case ERROR_FILE_NOT_FOUND
:
3779 case ERROR_BAD_NETPATH
:
3788 if ((mode
& X_OK
) != 0
3789 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3794 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3799 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3807 /* A version of 'access' to be used locally with file names in
3808 locale-specific encoding. Does not resolve symlinks and does not
3809 support file names on FAT12 and FAT16 volumes, but that's OK, since
3810 we only invoke this function for files inside the Emacs source or
3811 installation tree, on directories (so any symlinks should have the
3812 directory bit set), and on short file names such as "C:/.emacs". */
3814 sys_access (const char *fname
, int mode
)
3816 char fname_copy
[MAX_PATH
], *p
;
3819 strcpy (fname_copy
, fname
);
3820 /* Do the equivalent of unixtodos_filename. */
3821 for (p
= fname_copy
; *p
; p
= CharNext (p
))
3825 if ((attributes
= GetFileAttributesA (fname_copy
)) == -1)
3827 DWORD w32err
= GetLastError ();
3831 case ERROR_INVALID_NAME
:
3832 case ERROR_BAD_PATHNAME
:
3833 case ERROR_FILE_NOT_FOUND
:
3834 case ERROR_BAD_NETPATH
:
3843 if ((mode
& X_OK
) != 0
3844 && !(is_exec (fname_copy
)
3845 || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3850 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3855 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3863 /* Shadow some MSVC runtime functions to map requests for long filenames
3864 to reasonable short names if necessary. This was originally added to
3865 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3869 sys_chdir (const char * path
)
3871 path
= map_w32_filename (path
, NULL
);
3872 if (w32_unicode_filenames
)
3874 wchar_t newdir_w
[MAX_PATH
];
3876 if (filename_to_utf16 (path
, newdir_w
) == 0)
3877 return _wchdir (newdir_w
);
3882 char newdir_a
[MAX_PATH
];
3884 if (filename_to_ansi (path
, newdir_a
) == 0)
3885 return _chdir (newdir_a
);
3891 sys_chmod (const char * path
, int mode
)
3893 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3894 if (w32_unicode_filenames
)
3896 wchar_t path_w
[MAX_PATH
];
3898 filename_to_utf16 (path
, path_w
);
3899 return _wchmod (path_w
, mode
);
3903 char path_a
[MAX_PATH
];
3905 filename_to_ansi (path
, path_a
);
3906 return _chmod (path_a
, mode
);
3911 sys_creat (const char * path
, int mode
)
3913 path
= map_w32_filename (path
, NULL
);
3914 if (w32_unicode_filenames
)
3916 wchar_t path_w
[MAX_PATH
];
3918 filename_to_utf16 (path
, path_w
);
3919 return _wcreat (path_w
, mode
);
3923 char path_a
[MAX_PATH
];
3925 filename_to_ansi (path
, path_a
);
3926 return _creat (path_a
, mode
);
3931 sys_fopen (const char * path
, const char * mode
)
3935 const char * mode_save
= mode
;
3937 /* Force all file handles to be non-inheritable. This is necessary to
3938 ensure child processes don't unwittingly inherit handles that might
3939 prevent future file access. */
3943 else if (mode
[0] == 'w' || mode
[0] == 'a')
3944 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3948 /* Only do simplistic option parsing. */
3952 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3955 else if (mode
[0] == 'b')
3960 else if (mode
[0] == 't')
3967 path
= map_w32_filename (path
, NULL
);
3968 if (w32_unicode_filenames
)
3970 wchar_t path_w
[MAX_PATH
];
3972 filename_to_utf16 (path
, path_w
);
3973 fd
= _wopen (path_w
, oflag
| _O_NOINHERIT
, 0644);
3977 char path_a
[MAX_PATH
];
3979 filename_to_ansi (path
, path_a
);
3980 fd
= _open (path_a
, oflag
| _O_NOINHERIT
, 0644);
3985 return _fdopen (fd
, mode_save
);
3988 /* This only works on NTFS volumes, but is useful to have. */
3990 sys_link (const char * old
, const char * new)
3994 char oldname
[MAX_UTF8_PATH
], newname
[MAX_UTF8_PATH
];
3995 wchar_t oldname_w
[MAX_PATH
];
3996 char oldname_a
[MAX_PATH
];
3998 if (old
== NULL
|| new == NULL
)
4004 strcpy (oldname
, map_w32_filename (old
, NULL
));
4005 strcpy (newname
, map_w32_filename (new, NULL
));
4007 if (w32_unicode_filenames
)
4009 filename_to_utf16 (oldname
, oldname_w
);
4010 fileh
= CreateFileW (oldname_w
, 0, 0, NULL
, OPEN_EXISTING
,
4011 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4015 filename_to_ansi (oldname
, oldname_a
);
4016 fileh
= CreateFileA (oldname_a
, 0, 0, NULL
, OPEN_EXISTING
,
4017 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4019 if (fileh
!= INVALID_HANDLE_VALUE
)
4023 /* Confusingly, the "alternate" stream name field does not apply
4024 when restoring a hard link, and instead contains the actual
4025 stream data for the link (ie. the name of the link to create).
4026 The WIN32_STREAM_ID structure before the cStreamName field is
4027 the stream header, which is then immediately followed by the
4031 WIN32_STREAM_ID wid
;
4032 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
4035 /* We used to pass MB_PRECOMPOSED as the 2nd arg here, but MSDN
4036 indicates that flag is unsupported for CP_UTF8, and OTOH says
4037 it is the default anyway. */
4038 wlen
= pMultiByteToWideChar (CP_UTF8
, 0, newname
, -1,
4039 data
.wid
.cStreamName
, MAX_PATH
);
4042 LPVOID context
= NULL
;
4045 data
.wid
.dwStreamId
= BACKUP_LINK
;
4046 data
.wid
.dwStreamAttributes
= 0;
4047 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
4048 data
.wid
.Size
.HighPart
= 0;
4049 data
.wid
.dwStreamNameSize
= 0;
4051 if (BackupWrite (fileh
, (LPBYTE
)&data
,
4052 offsetof (WIN32_STREAM_ID
, cStreamName
)
4053 + data
.wid
.Size
.LowPart
,
4054 &wbytes
, FALSE
, FALSE
, &context
)
4055 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
4062 DWORD err
= GetLastError ();
4067 case ERROR_ACCESS_DENIED
:
4068 /* This is what happens when OLDNAME is a directory,
4069 since Windows doesn't support hard links to
4070 directories. Posix says to set errno to EPERM in
4072 if (w32_unicode_filenames
)
4073 attributes
= GetFileAttributesW (oldname_w
);
4075 attributes
= GetFileAttributesA (oldname_a
);
4076 if (attributes
!= -1
4077 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
4079 else if (attributes
== -1
4080 && is_unc_volume (oldname
)
4081 && unc_volume_file_attributes (oldname
) != -1)
4086 case ERROR_TOO_MANY_LINKS
:
4089 case ERROR_NOT_SAME_DEVICE
:
4099 CloseHandle (fileh
);
4108 sys_mkdir (const char * path
)
4110 path
= map_w32_filename (path
, NULL
);
4112 if (w32_unicode_filenames
)
4114 wchar_t path_w
[MAX_PATH
];
4116 filename_to_utf16 (path
, path_w
);
4117 return _wmkdir (path_w
);
4121 char path_a
[MAX_PATH
];
4123 filename_to_ansi (path
, path_a
);
4124 return _mkdir (path_a
);
4129 sys_open (const char * path
, int oflag
, int mode
)
4131 const char* mpath
= map_w32_filename (path
, NULL
);
4134 if (w32_unicode_filenames
)
4136 wchar_t mpath_w
[MAX_PATH
];
4138 filename_to_utf16 (mpath
, mpath_w
);
4139 /* If possible, try to open file without _O_CREAT, to be able to
4140 write to existing hidden and system files. Force all file
4141 handles to be non-inheritable. */
4142 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4143 res
= _wopen (mpath_w
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4145 res
= _wopen (mpath_w
, oflag
| _O_NOINHERIT
, mode
);
4149 char mpath_a
[MAX_PATH
];
4151 filename_to_ansi (mpath
, mpath_a
);
4152 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4153 res
= _open (mpath_a
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4155 res
= _open (mpath_a
, oflag
| _O_NOINHERIT
, mode
);
4161 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
4164 Standard algorithm for generating a temporary file name seems to be
4165 use pid or tid with a letter on the front (in place of the 6 X's)
4166 and cycle through the letters to find a unique name. We extend
4167 that to allow any reasonable character as the first of the 6 X's,
4168 so that the number of simultaneously used temporary files will be
4172 mkostemp (char * template, int flags
)
4176 unsigned uid
= GetCurrentThreadId ();
4177 int save_errno
= errno
;
4178 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
4181 if (template == NULL
)
4184 p
= template + strlen (template);
4186 /* replace up to the last 5 X's with uid in decimal */
4187 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
4189 p
[0] = '0' + uid
% 10;
4193 if (i
< 0 && p
[0] == 'X')
4198 p
[0] = first_char
[i
];
4199 if ((fd
= sys_open (template,
4200 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
4201 S_IRUSR
| S_IWUSR
)) >= 0
4209 while (++i
< sizeof (first_char
));
4212 /* Template is badly formed or else we can't generate a unique name. */
4217 fchmod (int fd
, mode_t mode
)
4223 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
4226 char temp
[MAX_UTF8_PATH
], temp_a
[MAX_PATH
];;
4229 bool have_temp_a
= false;
4231 /* MoveFile on Windows 95 doesn't correctly change the short file name
4232 alias in a number of circumstances (it is not easy to predict when
4233 just by looking at oldname and newname, unfortunately). In these
4234 cases, renaming through a temporary name avoids the problem.
4236 A second problem on Windows 95 is that renaming through a temp name when
4237 newname is uppercase fails (the final long name ends up in
4238 lowercase, although the short alias might be uppercase) UNLESS the
4239 long temp name is not 8.3.
4241 So, on Windows 95 we always rename through a temp name, and we make sure
4242 the temp name has a long extension to ensure correct renaming. */
4244 strcpy (temp
, map_w32_filename (oldname
, NULL
));
4246 /* volume_info is set indirectly by map_w32_filename. */
4247 oldname_dev
= volume_info
.serialnum
;
4249 if (os_subtype
== OS_9X
)
4254 char oldname_a
[MAX_PATH
];
4256 oldname
= map_w32_filename (oldname
, NULL
);
4257 filename_to_ansi (oldname
, oldname_a
);
4258 filename_to_ansi (temp
, temp_a
);
4259 if ((o
= strrchr (oldname_a
, '\\')))
4262 o
= (char *) oldname_a
;
4264 if ((p
= strrchr (temp_a
, '\\')))
4271 /* Force temp name to require a manufactured 8.3 alias - this
4272 seems to make the second rename work properly. */
4273 sprintf (p
, "_.%s.%u", o
, i
);
4275 result
= rename (oldname_a
, temp_a
);
4277 /* This loop must surely terminate! */
4278 while (result
< 0 && errno
== EEXIST
);
4284 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
4285 (at least if it is a file; don't do this for directories).
4287 Since we mustn't do this if we are just changing the case of the
4288 file name (we would end up deleting the file we are trying to
4289 rename!), we let rename detect if the destination file already
4290 exists - that way we avoid the possible pitfalls of trying to
4291 determine ourselves whether two names really refer to the same
4292 file, which is not always possible in the general case. (Consider
4293 all the permutations of shared or subst'd drives, etc.) */
4295 newname
= map_w32_filename (newname
, NULL
);
4297 /* volume_info is set indirectly by map_w32_filename. */
4298 newname_dev
= volume_info
.serialnum
;
4300 if (w32_unicode_filenames
)
4302 wchar_t temp_w
[MAX_PATH
], newname_w
[MAX_PATH
];
4304 filename_to_utf16 (temp
, temp_w
);
4305 filename_to_utf16 (newname
, newname_w
);
4306 result
= _wrename (temp_w
, newname_w
);
4307 if (result
< 0 && force
)
4309 DWORD w32err
= GetLastError ();
4312 && newname_dev
!= oldname_dev
)
4314 /* The implementation of `rename' on Windows does not return
4315 errno = EXDEV when you are moving a directory to a
4316 different storage device (ex. logical disk). It returns
4317 EACCES instead. So here we handle such situations and
4321 if ((attributes
= GetFileAttributesW (temp_w
)) != -1
4322 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4325 else if (errno
== EEXIST
)
4327 if (_wchmod (newname_w
, 0666) != 0)
4329 if (_wunlink (newname_w
) != 0)
4331 result
= _wrename (temp_w
, newname_w
);
4333 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4334 && is_symlink (temp
))
4336 /* This is Windows prohibiting the user from creating a
4337 symlink in another place, since that requires
4345 char newname_a
[MAX_PATH
];
4348 filename_to_ansi (temp
, temp_a
);
4349 filename_to_ansi (newname
, newname_a
);
4350 result
= rename (temp_a
, newname_a
);
4351 if (result
< 0 && force
)
4353 DWORD w32err
= GetLastError ();
4356 && newname_dev
!= oldname_dev
)
4360 if ((attributes
= GetFileAttributesA (temp_a
)) != -1
4361 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4364 else if (errno
== EEXIST
)
4366 if (_chmod (newname_a
, 0666) != 0)
4368 if (_unlink (newname_a
) != 0)
4370 result
= rename (temp_a
, newname_a
);
4372 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4373 && is_symlink (temp
))
4382 sys_rename (char const *old
, char const *new)
4384 return sys_rename_replace (old
, new, TRUE
);
4388 sys_rmdir (const char * path
)
4390 path
= map_w32_filename (path
, NULL
);
4392 if (w32_unicode_filenames
)
4394 wchar_t path_w
[MAX_PATH
];
4396 filename_to_utf16 (path
, path_w
);
4397 return _wrmdir (path_w
);
4401 char path_a
[MAX_PATH
];
4403 filename_to_ansi (path
, path_a
);
4404 return _rmdir (path_a
);
4409 sys_unlink (const char * path
)
4411 path
= map_w32_filename (path
, NULL
);
4413 if (w32_unicode_filenames
)
4415 wchar_t path_w
[MAX_PATH
];
4417 filename_to_utf16 (path
, path_w
);
4418 /* On Unix, unlink works without write permission. */
4419 _wchmod (path_w
, 0666);
4420 return _wunlink (path_w
);
4424 char path_a
[MAX_PATH
];
4426 filename_to_ansi (path
, path_a
);
4427 _chmod (path_a
, 0666);
4428 return _unlink (path_a
);
4432 static FILETIME utc_base_ft
;
4433 static ULONGLONG utc_base
; /* In 100ns units */
4434 static int init
= 0;
4436 #define FILETIME_TO_U64(result, ft) \
4438 ULARGE_INTEGER uiTemp; \
4439 uiTemp.LowPart = (ft).dwLowDateTime; \
4440 uiTemp.HighPart = (ft).dwHighDateTime; \
4441 result = uiTemp.QuadPart; \
4445 initialize_utc_base (void)
4447 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4456 st
.wMilliseconds
= 0;
4458 SystemTimeToFileTime (&st
, &utc_base_ft
);
4459 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
4463 convert_time (FILETIME ft
)
4469 initialize_utc_base ();
4473 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
4476 FILETIME_TO_U64 (tmp
, ft
);
4477 return (time_t) ((tmp
- utc_base
) / 10000000L);
4481 convert_from_time_t (time_t time
, FILETIME
* pft
)
4487 initialize_utc_base ();
4491 /* time in 100ns units since 1-Jan-1601 */
4492 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
4493 pft
->dwHighDateTime
= tmp
.HighPart
;
4494 pft
->dwLowDateTime
= tmp
.LowPart
;
4497 static PSECURITY_DESCRIPTOR
4498 get_file_security_desc_by_handle (HANDLE h
)
4500 PSECURITY_DESCRIPTOR psd
= NULL
;
4502 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4503 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4505 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
4506 NULL
, NULL
, NULL
, NULL
, &psd
);
4507 if (err
!= ERROR_SUCCESS
)
4513 static PSECURITY_DESCRIPTOR
4514 get_file_security_desc_by_name (const char *fname
)
4516 PSECURITY_DESCRIPTOR psd
= NULL
;
4518 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4519 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4521 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
4523 err
= GetLastError ();
4524 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
4528 psd
= xmalloc (sd_len
);
4529 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4541 unsigned n_subauthorities
;
4543 /* Use the last sub-authority value of the RID, the relative
4544 portion of the SID, as user/group ID. */
4545 n_subauthorities
= *get_sid_sub_authority_count (sid
);
4546 if (n_subauthorities
< 1)
4547 return 0; /* the "World" RID */
4548 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
4551 /* Caching SID and account values for faster lokup. */
4555 struct w32_id
*next
;
4557 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
4560 static struct w32_id
*w32_idlist
;
4563 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
4565 struct w32_id
*tail
, *found
;
4567 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
4569 if (equal_sid ((PSID
)tail
->sid
, sid
))
4578 strcpy (name
, found
->name
);
4586 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
4589 struct w32_id
*new_entry
;
4591 /* We don't want to leave behind stale cache from when Emacs was
4595 sid_len
= get_length_sid (sid
);
4596 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
4599 new_entry
->rid
= id
;
4600 strcpy (new_entry
->name
, name
);
4601 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
4602 new_entry
->next
= w32_idlist
;
4603 w32_idlist
= new_entry
;
4612 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
4616 SID_NAME_USE ignore
;
4618 DWORD name_len
= sizeof (name
);
4620 DWORD domain_len
= sizeof (domain
);
4625 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
4626 else if (what
== GID
)
4627 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
4631 if (!result
|| !is_valid_sid (sid
))
4633 else if (!w32_cached_id (sid
, id
, nm
))
4635 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
4636 domain
, &domain_len
, &ignore
)
4637 || name_len
> UNLEN
+1)
4641 *id
= get_rid (sid
);
4643 w32_add_to_cache (sid
, *id
, name
);
4650 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
4652 int dflt_usr
= 0, dflt_grp
= 0;
4661 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
4663 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
4666 /* Consider files to belong to current user/group, if we cannot get
4667 more accurate information. */
4670 st
->st_uid
= dflt_passwd
.pw_uid
;
4671 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
4675 st
->st_gid
= dflt_passwd
.pw_gid
;
4676 strcpy (st
->st_gname
, dflt_group
.gr_name
);
4680 /* Return non-zero if NAME is a potentially slow filesystem. */
4682 is_slow_fs (const char *name
)
4687 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
4688 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
4689 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
4690 devtype
= GetDriveType (NULL
); /* use root of current drive */
4693 /* GetDriveType needs the root directory of the drive. */
4694 strncpy (drive_root
, name
, 2);
4695 drive_root
[2] = '\\';
4696 drive_root
[3] = '\0';
4697 devtype
= GetDriveType (drive_root
);
4699 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
4702 /* If this is non-zero, the caller wants accurate information about
4703 file's owner and group, which could be expensive to get. dired.c
4704 uses this flag when needed for the job at hand. */
4705 int w32_stat_get_owner_group
;
4707 /* MSVC stat function can't cope with UNC names and has other bugs, so
4708 replace it with our own. This also allows us to calculate consistent
4709 inode values and owner/group without hacks in the main Emacs code,
4710 and support file names encoded in UTF-8. */
4713 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
4715 char *name
, *save_name
, *r
;
4716 WIN32_FIND_DATAW wfd_w
;
4717 WIN32_FIND_DATAA wfd_a
;
4719 unsigned __int64 fake_inode
= 0;
4722 int rootdir
= FALSE
;
4723 PSECURITY_DESCRIPTOR psd
= NULL
;
4724 int is_a_symlink
= 0;
4725 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
4726 DWORD access_rights
= 0;
4727 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
4728 FILETIME ctime
, atime
, wtime
;
4729 wchar_t name_w
[MAX_PATH
];
4730 char name_a
[MAX_PATH
];
4732 if (path
== NULL
|| buf
== NULL
)
4738 save_name
= name
= (char *) map_w32_filename (path
, &path
);
4739 /* Must be valid filename, no wild cards or other invalid
4741 if (strpbrk (name
, "*?|<>\""))
4747 len
= strlen (name
);
4748 /* Allocate 1 extra byte so that we could append a slash to a root
4749 directory, down below. */
4750 name
= strcpy (alloca (len
+ 2), name
);
4752 /* Avoid a somewhat costly call to is_symlink if the filesystem
4753 doesn't support symlinks. */
4754 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4755 is_a_symlink
= is_symlink (name
);
4757 /* Plan A: Open the file and get all the necessary information via
4758 the resulting handle. This solves several issues in one blow:
4760 . retrieves attributes for the target of a symlink, if needed
4761 . gets attributes of root directories and symlinks pointing to
4762 root directories, thus avoiding the need for special-casing
4763 these and detecting them by examining the file-name format
4764 . retrieves more accurate attributes (e.g., non-zero size for
4765 some directories, esp. directories that are junction points)
4766 . correctly resolves "c:/..", "/.." and similar file names
4767 . avoids run-time penalties for 99% of use cases
4769 Plan A is always tried first, unless the user asked not to (but
4770 if the file is a symlink and we need to follow links, we try Plan
4771 A even if the user asked not to).
4773 If Plan A fails, we go to Plan B (below), where various
4774 potentially expensive techniques must be used to handle "special"
4775 files such as UNC volumes etc. */
4776 if (!(NILP (Vw32_get_true_file_attributes
)
4777 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4778 /* Following symlinks requires getting the info by handle. */
4779 || (is_a_symlink
&& follow_symlinks
))
4781 BY_HANDLE_FILE_INFORMATION info
;
4783 if (is_a_symlink
&& !follow_symlinks
)
4784 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4785 /* READ_CONTROL access rights are required to get security info
4786 by handle. But if the OS doesn't support security in the
4787 first place, we don't need to try. */
4788 if (is_windows_9x () != TRUE
)
4789 access_rights
|= READ_CONTROL
;
4791 if (w32_unicode_filenames
)
4793 filename_to_utf16 (name
, name_w
);
4794 fh
= CreateFileW (name_w
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4796 /* If CreateFile fails with READ_CONTROL, try again with
4797 zero as access rights. */
4798 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4799 fh
= CreateFileW (name_w
, 0, 0, NULL
, OPEN_EXISTING
,
4804 filename_to_ansi (name
, name_a
);
4805 fh
= CreateFileA (name_a
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4807 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4808 fh
= CreateFileA (name_a
, 0, 0, NULL
, OPEN_EXISTING
,
4811 if (fh
== INVALID_HANDLE_VALUE
)
4812 goto no_true_file_attributes
;
4814 /* This is more accurate in terms of getting the correct number
4815 of links, but is quite slow (it is noticeable when Emacs is
4816 making a list of file name completions). */
4817 if (GetFileInformationByHandle (fh
, &info
))
4819 nlinks
= info
.nNumberOfLinks
;
4820 /* Might as well use file index to fake inode values, but this
4821 is not guaranteed to be unique unless we keep a handle open
4822 all the time (even then there are situations where it is
4823 not unique). Reputedly, there are at most 48 bits of info
4824 (on NTFS, presumably less on FAT). */
4825 fake_inode
= info
.nFileIndexHigh
;
4827 fake_inode
+= info
.nFileIndexLow
;
4828 serialnum
= info
.dwVolumeSerialNumber
;
4829 fs_high
= info
.nFileSizeHigh
;
4830 fs_low
= info
.nFileSizeLow
;
4831 ctime
= info
.ftCreationTime
;
4832 atime
= info
.ftLastAccessTime
;
4833 wtime
= info
.ftLastWriteTime
;
4834 fattrs
= info
.dwFileAttributes
;
4838 /* We don't go to Plan B here, because it's not clear that
4839 it's a good idea. The only known use case where
4840 CreateFile succeeds, but GetFileInformationByHandle fails
4841 (with ERROR_INVALID_FUNCTION) is for character devices
4842 such as NUL, PRN, etc. For these, switching to Plan B is
4843 a net loss, because we lose the character device
4844 attribute returned by GetFileType below (FindFirstFile
4845 doesn't set that bit in the attributes), and the other
4846 fields don't make sense for character devices anyway.
4847 Emacs doesn't really care for non-file entities in the
4848 context of l?stat, so neither do we. */
4850 /* w32err is assigned so one could put a breakpoint here and
4851 examine its value, when GetFileInformationByHandle
4853 DWORD w32err
= GetLastError ();
4857 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4863 /* Test for a symlink before testing for a directory, since
4864 symlinks to directories have the directory bit set, but we
4865 don't want them to appear as directories. */
4866 if (is_a_symlink
&& !follow_symlinks
)
4867 buf
->st_mode
= S_IFLNK
;
4868 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4869 buf
->st_mode
= S_IFDIR
;
4872 DWORD ftype
= GetFileType (fh
);
4876 case FILE_TYPE_DISK
:
4877 buf
->st_mode
= S_IFREG
;
4879 case FILE_TYPE_PIPE
:
4880 buf
->st_mode
= S_IFIFO
;
4882 case FILE_TYPE_CHAR
:
4883 case FILE_TYPE_UNKNOWN
:
4885 buf
->st_mode
= S_IFCHR
;
4888 /* We produce the fallback owner and group data, based on the
4889 current user that runs Emacs, in the following cases:
4891 . caller didn't request owner and group info
4892 . this is Windows 9X
4893 . getting security by handle failed, and we need to produce
4894 information for the target of a symlink (this is better
4895 than producing a potentially misleading info about the
4898 If getting security by handle fails, and we don't need to
4899 resolve symlinks, we try getting security by name. */
4900 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4901 get_file_owner_and_group (NULL
, buf
);
4904 psd
= get_file_security_desc_by_handle (fh
);
4907 get_file_owner_and_group (psd
, buf
);
4910 else if (!(is_a_symlink
&& follow_symlinks
))
4912 psd
= get_file_security_desc_by_name (name
);
4913 get_file_owner_and_group (psd
, buf
);
4917 get_file_owner_and_group (NULL
, buf
);
4923 no_true_file_attributes
:
4924 /* Plan B: Either getting a handle on the file failed, or the
4925 caller explicitly asked us to not bother making this
4926 information more accurate.
4928 Implementation note: In Plan B, we never bother to resolve
4929 symlinks, even if we got here because we tried Plan A and
4930 failed. That's because, even if the caller asked for extra
4931 precision by setting Vw32_get_true_file_attributes to t,
4932 resolving symlinks requires acquiring a file handle to the
4933 symlink, which we already know will fail. And if the user
4934 did not ask for extra precision, resolving symlinks will fly
4935 in the face of that request, since the user then wants the
4936 lightweight version of the code. */
4937 rootdir
= (path
>= save_name
+ len
- 1
4938 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4940 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4941 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4942 if (IS_DIRECTORY_SEP (r
[0])
4943 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4946 /* Note: If NAME is a symlink to the root of a UNC volume
4947 (i.e. "\\SERVER"), we will not detect that here, and we will
4948 return data about the symlink as result of FindFirst below.
4949 This is unfortunate, but that marginal use case does not
4950 justify a call to chase_symlinks which would impose a penalty
4951 on all the other use cases. (We get here for symlinks to
4952 roots of UNC volumes because CreateFile above fails for them,
4953 unlike with symlinks to root directories X:\ of drives.) */
4954 if (is_unc_volume (name
))
4956 fattrs
= unc_volume_file_attributes (name
);
4960 ctime
= atime
= wtime
= utc_base_ft
;
4964 /* Make sure root directories end in a slash. */
4965 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4966 strcat (name
, "\\");
4967 if (GetDriveType (name
) < 2)
4973 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4974 ctime
= atime
= wtime
= utc_base_ft
;
4980 /* Make sure non-root directories do NOT end in a slash,
4981 otherwise FindFirstFile might fail. */
4982 if (IS_DIRECTORY_SEP (name
[len
-1]))
4985 /* (This is hacky, but helps when doing file completions on
4986 network drives.) Optimize by using information available from
4987 active readdir if possible. */
4988 len
= strlen (dir_pathname
);
4989 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4991 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4992 && last_dir_find_data
!= -1
4993 && !(is_a_symlink
&& follow_symlinks
)
4994 /* The 2 file-name comparisons below support only ASCII
4995 characters, and will lose (compare not equal) when
4996 the file names include non-ASCII characters that are
4997 the same but for the case. However, doing this
4998 properly involves: (a) converting both file names to
4999 UTF-16, (b) lower-casing both names using CharLowerW,
5000 and (c) comparing the results; this would be quite a
5001 bit slower, whereas Plan B is for users who want
5002 lightweight albeit inaccurate version of 'stat'. */
5003 && c_strncasecmp (save_name
, dir_pathname
, len
) == 0
5004 && IS_DIRECTORY_SEP (name
[len
])
5005 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
5007 have_wfd
= last_dir_find_data
;
5008 /* This was the last entry returned by readdir. */
5009 if (last_dir_find_data
== DIR_FIND_DATA_W
)
5010 wfd_w
= dir_find_data_w
;
5012 wfd_a
= dir_find_data_a
;
5016 logon_network_drive (name
);
5018 if (w32_unicode_filenames
)
5020 filename_to_utf16 (name
, name_w
);
5021 fh
= FindFirstFileW (name_w
, &wfd_w
);
5022 have_wfd
= DIR_FIND_DATA_W
;
5026 filename_to_ansi (name
, name_a
);
5027 /* If NAME includes characters not representable by
5028 the current ANSI codepage, filename_to_ansi
5029 usually replaces them with a '?'. We don't want
5030 to let FindFirstFileA interpret those as wildcards,
5031 and "succeed", returning us data from some random
5032 file in the same directory. */
5033 if (_mbspbrk (name_a
, "?"))
5034 fh
= INVALID_HANDLE_VALUE
;
5036 fh
= FindFirstFileA (name_a
, &wfd_a
);
5037 have_wfd
= DIR_FIND_DATA_A
;
5039 if (fh
== INVALID_HANDLE_VALUE
)
5046 /* Note: if NAME is a symlink, the information we get from
5047 FindFirstFile is for the symlink, not its target. */
5048 if (have_wfd
== DIR_FIND_DATA_W
)
5050 fattrs
= wfd_w
.dwFileAttributes
;
5051 ctime
= wfd_w
.ftCreationTime
;
5052 atime
= wfd_w
.ftLastAccessTime
;
5053 wtime
= wfd_w
.ftLastWriteTime
;
5054 fs_high
= wfd_w
.nFileSizeHigh
;
5055 fs_low
= wfd_w
.nFileSizeLow
;
5059 fattrs
= wfd_a
.dwFileAttributes
;
5060 ctime
= wfd_a
.ftCreationTime
;
5061 atime
= wfd_a
.ftLastAccessTime
;
5062 wtime
= wfd_a
.ftLastWriteTime
;
5063 fs_high
= wfd_a
.nFileSizeHigh
;
5064 fs_low
= wfd_a
.nFileSizeLow
;
5068 serialnum
= volume_info
.serialnum
;
5070 if (is_a_symlink
&& !follow_symlinks
)
5071 buf
->st_mode
= S_IFLNK
;
5072 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5073 buf
->st_mode
= S_IFDIR
;
5075 buf
->st_mode
= S_IFREG
;
5077 get_file_owner_and_group (NULL
, buf
);
5080 buf
->st_ino
= fake_inode
;
5082 buf
->st_dev
= serialnum
;
5083 buf
->st_rdev
= serialnum
;
5085 buf
->st_size
= fs_high
;
5086 buf
->st_size
<<= 32;
5087 buf
->st_size
+= fs_low
;
5088 buf
->st_nlink
= nlinks
;
5090 /* Convert timestamps to Unix format. */
5091 buf
->st_mtime
= convert_time (wtime
);
5092 buf
->st_atime
= convert_time (atime
);
5093 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5094 buf
->st_ctime
= convert_time (ctime
);
5095 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5097 /* determine rwx permissions */
5098 if (is_a_symlink
&& !follow_symlinks
)
5099 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
5102 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
5103 permission
= S_IREAD
;
5105 permission
= S_IREAD
| S_IWRITE
;
5107 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5108 permission
|= S_IEXEC
;
5109 else if (is_exec (name
))
5110 permission
|= S_IEXEC
;
5113 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5119 stat (const char * path
, struct stat
* buf
)
5121 return stat_worker (path
, buf
, 1);
5125 lstat (const char * path
, struct stat
* buf
)
5127 return stat_worker (path
, buf
, 0);
5131 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
5133 /* Rely on a hack: an open directory is modeled as file descriptor 0.
5134 This is good enough for the current usage in Emacs, but is fragile.
5136 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
5137 Gnulib does this and can serve as a model. */
5138 char fullname
[MAX_UTF8_PATH
];
5142 char lastc
= dir_pathname
[strlen (dir_pathname
) - 1];
5144 if (_snprintf (fullname
, sizeof fullname
, "%s%s%s",
5145 dir_pathname
, IS_DIRECTORY_SEP (lastc
) ? "" : "/", name
)
5148 errno
= ENAMETOOLONG
;
5154 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
5157 /* Provide fstat and utime as well as stat for consistent handling of
5160 fstat (int desc
, struct stat
* buf
)
5162 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
5163 BY_HANDLE_FILE_INFORMATION info
;
5164 unsigned __int64 fake_inode
;
5167 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
5169 case FILE_TYPE_DISK
:
5170 buf
->st_mode
= S_IFREG
;
5171 if (!GetFileInformationByHandle (fh
, &info
))
5177 case FILE_TYPE_PIPE
:
5178 buf
->st_mode
= S_IFIFO
;
5180 case FILE_TYPE_CHAR
:
5181 case FILE_TYPE_UNKNOWN
:
5183 buf
->st_mode
= S_IFCHR
;
5185 memset (&info
, 0, sizeof (info
));
5186 info
.dwFileAttributes
= 0;
5187 info
.ftCreationTime
= utc_base_ft
;
5188 info
.ftLastAccessTime
= utc_base_ft
;
5189 info
.ftLastWriteTime
= utc_base_ft
;
5192 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5193 buf
->st_mode
= S_IFDIR
;
5195 buf
->st_nlink
= info
.nNumberOfLinks
;
5196 /* Might as well use file index to fake inode values, but this
5197 is not guaranteed to be unique unless we keep a handle open
5198 all the time (even then there are situations where it is
5199 not unique). Reputedly, there are at most 48 bits of info
5200 (on NTFS, presumably less on FAT). */
5201 fake_inode
= info
.nFileIndexHigh
;
5203 fake_inode
+= info
.nFileIndexLow
;
5205 /* MSVC defines _ino_t to be short; other libc's might not. */
5206 if (sizeof (buf
->st_ino
) == 2)
5207 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
5209 buf
->st_ino
= fake_inode
;
5211 /* If the caller so requested, get the true file owner and group.
5212 Otherwise, consider the file to belong to the current user. */
5213 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
5214 get_file_owner_and_group (NULL
, buf
);
5217 PSECURITY_DESCRIPTOR psd
= NULL
;
5219 psd
= get_file_security_desc_by_handle (fh
);
5222 get_file_owner_and_group (psd
, buf
);
5226 get_file_owner_and_group (NULL
, buf
);
5229 buf
->st_dev
= info
.dwVolumeSerialNumber
;
5230 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
5232 buf
->st_size
= info
.nFileSizeHigh
;
5233 buf
->st_size
<<= 32;
5234 buf
->st_size
+= info
.nFileSizeLow
;
5236 /* Convert timestamps to Unix format. */
5237 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
5238 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
5239 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5240 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
5241 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5243 /* determine rwx permissions */
5244 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
5245 permission
= S_IREAD
;
5247 permission
= S_IREAD
| S_IWRITE
;
5249 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5250 permission
|= S_IEXEC
;
5253 #if 0 /* no way of knowing the filename */
5254 char * p
= strrchr (name
, '.');
5256 (xstrcasecmp (p
, ".exe") == 0 ||
5257 xstrcasecmp (p
, ".com") == 0 ||
5258 xstrcasecmp (p
, ".bat") == 0 ||
5259 xstrcasecmp (p
, ".cmd") == 0))
5260 permission
|= S_IEXEC
;
5264 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5269 /* A version of 'utime' which handles directories as well as
5273 utime (const char *name
, struct utimbuf
*times
)
5275 struct utimbuf deftime
;
5282 deftime
.modtime
= deftime
.actime
= time (NULL
);
5286 if (w32_unicode_filenames
)
5288 wchar_t name_utf16
[MAX_PATH
];
5290 if (filename_to_utf16 (name
, name_utf16
) != 0)
5291 return -1; /* errno set by filename_to_utf16 */
5293 /* Need write access to set times. */
5294 fh
= CreateFileW (name_utf16
, FILE_WRITE_ATTRIBUTES
,
5295 /* If NAME specifies a directory, FILE_SHARE_DELETE
5296 allows other processes to delete files inside it,
5297 while we have the directory open. */
5298 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5299 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5303 char name_ansi
[MAX_PATH
];
5305 if (filename_to_ansi (name
, name_ansi
) != 0)
5306 return -1; /* errno set by filename_to_ansi */
5308 fh
= CreateFileA (name_ansi
, FILE_WRITE_ATTRIBUTES
,
5309 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5310 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5312 if (fh
!= INVALID_HANDLE_VALUE
)
5314 convert_from_time_t (times
->actime
, &atime
);
5315 convert_from_time_t (times
->modtime
, &mtime
);
5316 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
5326 DWORD err
= GetLastError ();
5330 case ERROR_FILE_NOT_FOUND
:
5331 case ERROR_PATH_NOT_FOUND
:
5332 case ERROR_INVALID_DRIVE
:
5333 case ERROR_BAD_NETPATH
:
5334 case ERROR_DEV_NOT_EXIST
:
5335 /* ERROR_INVALID_NAME is the error CreateFile sets when the
5336 file name includes ?s, i.e. translation to ANSI failed. */
5337 case ERROR_INVALID_NAME
:
5340 case ERROR_TOO_MANY_OPEN_FILES
:
5343 case ERROR_ACCESS_DENIED
:
5344 case ERROR_SHARING_VIOLATION
:
5356 /* Emacs expects us to support the traditional octal form of the mode
5357 bits, which is not what msvcrt.dll wants. */
5359 #define WRITE_USER 00200
5362 sys_umask (int mode
)
5364 static int current_mask
;
5365 int retval
, arg
= 0;
5367 /* The only bit we really support is the write bit. Files are
5368 always readable on MS-Windows, and the execute bit does not exist
5370 /* FIXME: if the GROUP and OTHER bits are reset, we should use ACLs
5371 to prevent access by other users on NTFS. */
5372 if ((mode
& WRITE_USER
) != 0)
5375 retval
= _umask (arg
);
5376 /* Merge into the return value the bits they've set the last time,
5377 which msvcrt.dll ignores and never returns. Emacs insists on its
5378 notion of mask being identical to what we return. */
5379 retval
|= (current_mask
& ~WRITE_USER
);
5380 current_mask
= mode
;
5386 /* Symlink-related functions. */
5387 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
5388 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
5392 symlink (char const *filename
, char const *linkname
)
5394 char linkfn
[MAX_UTF8_PATH
], *tgtfn
;
5396 int dir_access
, filename_ends_in_slash
;
5398 /* Diagnostics follows Posix as much as possible. */
5399 if (filename
== NULL
|| linkname
== NULL
)
5409 if (strlen (filename
) > MAX_UTF8_PATH
|| strlen (linkname
) > MAX_UTF8_PATH
)
5411 errno
= ENAMETOOLONG
;
5415 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
5416 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
5422 /* Note: since empty FILENAME was already rejected, we can safely
5423 refer to FILENAME[1]. */
5424 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
5426 /* Non-absolute FILENAME is understood as being relative to
5427 LINKNAME's directory. We need to prepend that directory to
5428 FILENAME to get correct results from faccessat below, since
5429 otherwise it will interpret FILENAME relative to the
5430 directory where the Emacs process runs. Note that
5431 make-symbolic-link always makes sure LINKNAME is a fully
5432 expanded file name. */
5433 char tem
[MAX_UTF8_PATH
];
5434 char *p
= linkfn
+ strlen (linkfn
);
5436 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
5439 strncpy (tem
, linkfn
, p
- linkfn
);
5440 tem
[p
- linkfn
] = '\0';
5441 strcat (tem
, filename
);
5442 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
5445 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
5447 /* Since Windows distinguishes between symlinks to directories and
5448 to files, we provide a kludgy feature: if FILENAME doesn't
5449 exist, but ends in a slash, we create a symlink to directory. If
5450 FILENAME exists and is a directory, we always create a symlink to
5452 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
5453 if (dir_access
== 0 || filename_ends_in_slash
)
5454 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
5456 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
5457 if (filename_ends_in_slash
)
5458 tgtfn
[strlen (tgtfn
) - 1] = '\0';
5461 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
5463 /* ENOSYS is set by create_symbolic_link, when it detects that
5464 the OS doesn't support the CreateSymbolicLink API. */
5465 if (errno
!= ENOSYS
)
5467 DWORD w32err
= GetLastError ();
5471 /* ERROR_SUCCESS is sometimes returned when LINKFN and
5472 TGTFN point to the same file name, go figure. */
5474 case ERROR_FILE_EXISTS
:
5477 case ERROR_ACCESS_DENIED
:
5480 case ERROR_FILE_NOT_FOUND
:
5481 case ERROR_PATH_NOT_FOUND
:
5482 case ERROR_BAD_NETPATH
:
5483 case ERROR_INVALID_REPARSE_DATA
:
5486 case ERROR_DIRECTORY
:
5489 case ERROR_PRIVILEGE_NOT_HELD
:
5490 case ERROR_NOT_ALL_ASSIGNED
:
5493 case ERROR_DISK_FULL
:
5506 /* A quick inexpensive test of whether FILENAME identifies a file that
5507 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
5508 must already be in the normalized form returned by
5511 Note: for repeated operations on many files, it is best to test
5512 whether the underlying volume actually supports symlinks, by
5513 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
5514 avoid the call to this function if it doesn't. That's because the
5515 call to GetFileAttributes takes a non-negligible time, especially
5516 on non-local or removable filesystems. See stat_worker for an
5517 example of how to do that. */
5519 is_symlink (const char *filename
)
5522 wchar_t filename_w
[MAX_PATH
];
5523 char filename_a
[MAX_PATH
];
5524 WIN32_FIND_DATAW wfdw
;
5525 WIN32_FIND_DATAA wfda
;
5527 int attrs_mean_symlink
;
5529 if (w32_unicode_filenames
)
5531 filename_to_utf16 (filename
, filename_w
);
5532 attrs
= GetFileAttributesW (filename_w
);
5536 filename_to_ansi (filename
, filename_a
);
5537 attrs
= GetFileAttributesA (filename_a
);
5541 DWORD w32err
= GetLastError ();
5545 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
5547 case ERROR_ACCESS_DENIED
:
5550 case ERROR_FILE_NOT_FOUND
:
5551 case ERROR_PATH_NOT_FOUND
:
5558 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
5560 logon_network_drive (filename
);
5561 if (w32_unicode_filenames
)
5563 fh
= FindFirstFileW (filename_w
, &wfdw
);
5564 attrs_mean_symlink
=
5565 (wfdw
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5566 && (wfdw
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5568 else if (_mbspbrk (filename_a
, "?"))
5570 /* filename_to_ansi failed to convert the file name. */
5576 fh
= FindFirstFileA (filename_a
, &wfda
);
5577 attrs_mean_symlink
=
5578 (wfda
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5579 && (wfda
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5581 if (fh
== INVALID_HANDLE_VALUE
)
5584 return attrs_mean_symlink
;
5587 /* If NAME identifies a symbolic link, copy into BUF the file name of
5588 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
5589 null-terminate the target name, even if it fits. Return the number
5590 of bytes copied, or -1 if NAME is not a symlink or any error was
5591 encountered while resolving it. The file name copied into BUF is
5592 encoded in the current ANSI codepage. */
5594 readlink (const char *name
, char *buf
, size_t buf_size
)
5597 TOKEN_PRIVILEGES privs
;
5598 int restore_privs
= 0;
5601 char resolved
[MAX_UTF8_PATH
];
5614 path
= map_w32_filename (name
, NULL
);
5616 if (strlen (path
) > MAX_UTF8_PATH
)
5618 errno
= ENAMETOOLONG
;
5623 if (is_windows_9x () == TRUE
5624 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
5625 || !is_symlink (path
))
5628 errno
= EINVAL
; /* not a symlink */
5632 /* Done with simple tests, now we're in for some _real_ work. */
5633 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
5635 /* Implementation note: From here and onward, don't return early,
5636 since that will fail to restore the original set of privileges of
5637 the calling thread. */
5639 retval
= -1; /* not too optimistic, are we? */
5641 /* Note: In the next call to CreateFile, we use zero as the 2nd
5642 argument because, when the symlink is a hidden/system file,
5643 e.g. 'C:\Users\All Users', GENERIC_READ fails with
5644 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
5645 and directory symlinks. */
5646 if (w32_unicode_filenames
)
5648 wchar_t path_w
[MAX_PATH
];
5650 filename_to_utf16 (path
, path_w
);
5651 sh
= CreateFileW (path_w
, 0, 0, NULL
, OPEN_EXISTING
,
5652 FILE_FLAG_OPEN_REPARSE_POINT
5653 | FILE_FLAG_BACKUP_SEMANTICS
,
5658 char path_a
[MAX_PATH
];
5660 filename_to_ansi (path
, path_a
);
5661 sh
= CreateFileA (path_a
, 0, 0, NULL
, OPEN_EXISTING
,
5662 FILE_FLAG_OPEN_REPARSE_POINT
5663 | FILE_FLAG_BACKUP_SEMANTICS
,
5666 if (sh
!= INVALID_HANDLE_VALUE
)
5668 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
5669 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
5672 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
5673 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
5676 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
5680 /* Copy the link target name, in wide characters, from
5681 reparse_data, then convert it to multibyte encoding in
5682 the current locale's codepage. */
5686 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
5688 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
5689 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
5690 size_t size_to_copy
= buf_size
;
5692 /* According to MSDN, PrintNameLength does not include the
5693 terminating null character. */
5694 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
5695 memcpy (lwname
, lwname_src
, lwname_len
);
5696 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
5697 filename_from_utf16 (lwname
, resolved
);
5698 dostounix_filename (resolved
);
5699 lname_size
= strlen (resolved
) + 1;
5700 if (lname_size
<= buf_size
)
5701 size_to_copy
= lname_size
;
5702 strncpy (buf
, resolved
, size_to_copy
);
5704 retval
= size_to_copy
;
5710 /* CreateFile failed. */
5711 DWORD w32err2
= GetLastError ();
5715 case ERROR_FILE_NOT_FOUND
:
5716 case ERROR_PATH_NOT_FOUND
:
5719 case ERROR_ACCESS_DENIED
:
5720 case ERROR_TOO_MANY_OPEN_FILES
:
5730 restore_privilege (&privs
);
5738 readlinkat (int fd
, char const *name
, char *buffer
,
5741 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5742 as in fstatat. FIXME: Add proper support for readlinkat. */
5743 char fullname
[MAX_UTF8_PATH
];
5747 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
5750 errno
= ENAMETOOLONG
;
5756 return readlink (name
, buffer
, buffer_size
);
5759 /* If FILE is a symlink, return its target (stored in a static
5760 buffer); otherwise return FILE.
5762 This function repeatedly resolves symlinks in the last component of
5763 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5764 until it arrives at a file whose last component is not a symlink,
5765 or some error occurs. It returns the target of the last
5766 successfully resolved symlink in the chain. If it succeeds to
5767 resolve even a single symlink, the value returned is an absolute
5768 file name with backslashes (result of GetFullPathName). By
5769 contrast, if the original FILE is returned, it is unaltered.
5771 Note: This function can set errno even if it succeeds.
5773 Implementation note: we only resolve the last portion ("basename")
5774 of the argument FILE and of each following file in the chain,
5775 disregarding any possible symlinks in its leading directories.
5776 This is because Windows system calls and library functions
5777 transparently resolve symlinks in leading directories and return
5778 correct information, as long as the basename is not a symlink. */
5780 chase_symlinks (const char *file
)
5782 static char target
[MAX_UTF8_PATH
];
5783 char link
[MAX_UTF8_PATH
];
5784 wchar_t target_w
[MAX_PATH
], link_w
[MAX_PATH
];
5785 char target_a
[MAX_PATH
], link_a
[MAX_PATH
];
5786 ssize_t res
, link_len
;
5789 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
5790 return (char *)file
;
5792 if (w32_unicode_filenames
)
5794 wchar_t file_w
[MAX_PATH
];
5796 filename_to_utf16 (file
, file_w
);
5797 if (GetFullPathNameW (file_w
, MAX_PATH
, link_w
, NULL
) == 0)
5798 return (char *)file
;
5799 filename_from_utf16 (link_w
, link
);
5803 char file_a
[MAX_PATH
];
5805 filename_to_ansi (file
, file_a
);
5806 if (GetFullPathNameA (file_a
, MAX_PATH
, link_a
, NULL
) == 0)
5807 return (char *)file
;
5808 filename_from_ansi (link_a
, link
);
5810 link_len
= strlen (link
);
5815 /* Remove trailing slashes, as we want to resolve the last
5816 non-trivial part of the link name. */
5817 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
5818 link
[link_len
--] = '\0';
5820 res
= readlink (link
, target
, MAX_UTF8_PATH
);
5824 if (!(IS_DEVICE_SEP (target
[1])
5825 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5827 /* Target is relative. Append it to the directory part of
5828 the symlink, then copy the result back to target. */
5829 char *p
= link
+ link_len
;
5831 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5834 strcpy (target
, link
);
5836 /* Resolve any "." and ".." to get a fully-qualified file name
5838 if (w32_unicode_filenames
)
5840 filename_to_utf16 (target
, target_w
);
5841 link_len
= GetFullPathNameW (target_w
, MAX_PATH
, link_w
, NULL
);
5843 filename_from_utf16 (link_w
, link
);
5847 filename_to_ansi (target
, target_a
);
5848 link_len
= GetFullPathNameA (target_a
, MAX_PATH
, link_a
, NULL
);
5850 filename_from_ansi (link_a
, link
);
5852 link_len
= strlen (link
);
5854 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5856 if (loop_count
> 100)
5859 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5860 return (char *)file
;
5865 /* Posix ACL emulation. */
5868 acl_valid (acl_t acl
)
5870 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5874 acl_to_text (acl_t acl
, ssize_t
*size
)
5877 SECURITY_INFORMATION flags
=
5878 OWNER_SECURITY_INFORMATION
|
5879 GROUP_SECURITY_INFORMATION
|
5880 DACL_SECURITY_INFORMATION
;
5881 char *retval
= NULL
;
5887 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5890 /* We don't want to mix heaps, so we duplicate the string in our
5891 heap and free the one allocated by the API. */
5892 retval
= xstrdup (str_acl
);
5895 LocalFree (str_acl
);
5897 else if (errno
!= ENOTSUP
)
5904 acl_from_text (const char *acl_str
)
5906 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5912 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5915 retval
= xmalloc (sd_size
);
5916 memcpy (retval
, psd
, sd_size
);
5919 else if (errno
!= ENOTSUP
)
5926 acl_free (void *ptr
)
5933 acl_get_file (const char *fname
, acl_type_t type
)
5935 PSECURITY_DESCRIPTOR psd
= NULL
;
5936 const char *filename
;
5938 if (type
== ACL_TYPE_ACCESS
)
5941 SECURITY_INFORMATION si
=
5942 OWNER_SECURITY_INFORMATION
|
5943 GROUP_SECURITY_INFORMATION
|
5944 DACL_SECURITY_INFORMATION
;
5947 filename
= map_w32_filename (fname
, NULL
);
5948 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5949 fname
= chase_symlinks (filename
);
5954 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5955 && errno
!= ENOTSUP
)
5957 err
= GetLastError ();
5958 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5960 psd
= xmalloc (sd_len
);
5961 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5968 else if (err
== ERROR_FILE_NOT_FOUND
5969 || err
== ERROR_PATH_NOT_FOUND
5970 /* ERROR_INVALID_NAME is what we get if
5971 w32-unicode-filenames is nil and the file cannot
5972 be encoded in the current ANSI codepage. */
5973 || err
== ERROR_INVALID_NAME
)
5981 else if (type
!= ACL_TYPE_DEFAULT
)
5988 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
5990 TOKEN_PRIVILEGES old1
, old2
;
5992 int st
= 0, retval
= -1;
5993 SECURITY_INFORMATION flags
= 0;
5994 PSID psidOwner
, psidGroup
;
5999 const char *filename
;
6001 if (acl_valid (acl
) != 0
6002 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
6008 if (type
== ACL_TYPE_DEFAULT
)
6014 filename
= map_w32_filename (fname
, NULL
);
6015 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
6016 fname
= chase_symlinks (filename
);
6020 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psidOwner
,
6023 flags
|= OWNER_SECURITY_INFORMATION
;
6024 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psidGroup
,
6027 flags
|= GROUP_SECURITY_INFORMATION
;
6028 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
6031 flags
|= DACL_SECURITY_INFORMATION
;
6035 /* According to KB-245153, setting the owner will succeed if either:
6036 (1) the caller is the user who will be the new owner, and has the
6037 SE_TAKE_OWNERSHIP privilege, or
6038 (2) the caller has the SE_RESTORE privilege, in which case she can
6039 set any valid user or group as the owner
6041 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
6042 privileges, and disregard any failures in obtaining them. If
6043 these privileges cannot be obtained, and do not already exist in
6044 the calling thread's security token, this function could fail
6046 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
6048 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
6053 /* SetFileSecurity is deprecated by MS, and sometimes fails when
6054 DACL inheritance is involved, but it seems to preserve ownership
6055 better than SetNamedSecurityInfo, which is important e.g., in
6057 if (!set_file_security (fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
6059 err
= GetLastError ();
6061 if (errno
!= ENOTSUP
)
6062 err
= set_named_security_info (fname
, SE_FILE_OBJECT
, flags
,
6063 psidOwner
, psidGroup
, pacl
, NULL
);
6066 err
= ERROR_SUCCESS
;
6067 if (err
!= ERROR_SUCCESS
)
6069 if (errno
== ENOTSUP
)
6071 else if (err
== ERROR_INVALID_OWNER
6072 || err
== ERROR_NOT_ALL_ASSIGNED
6073 || err
== ERROR_ACCESS_DENIED
)
6075 /* Maybe the requested ACL and the one the file already has
6076 are identical, in which case we can silently ignore the
6077 failure. (And no, Windows doesn't.) */
6078 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
6083 char *acl_from
= acl_to_text (current_acl
, NULL
);
6084 char *acl_to
= acl_to_text (acl
, NULL
);
6086 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
6092 acl_free (acl_from
);
6095 acl_free (current_acl
);
6098 else if (err
== ERROR_FILE_NOT_FOUND
6099 || err
== ERROR_PATH_NOT_FOUND
6100 /* ERROR_INVALID_NAME is what we get if
6101 w32-unicode-filenames is nil and the file cannot be
6102 encoded in the current ANSI codepage. */
6103 || err
== ERROR_INVALID_NAME
)
6117 restore_privilege (&old2
);
6118 restore_privilege (&old1
);
6126 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
6127 have a fixed max size for file names, so we don't need the kind of
6128 alloc/malloc/realloc dance the gnulib version does. We also don't
6129 support FD-relative symlinks. */
6131 careadlinkat (int fd
, char const *filename
,
6132 char *buffer
, size_t buffer_size
,
6133 struct allocator
const *alloc
,
6134 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
6136 char linkname
[MAX_UTF8_PATH
];
6139 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
6143 char *retval
= buffer
;
6145 linkname
[link_size
++] = '\0';
6146 if (link_size
> buffer_size
)
6147 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
6149 memcpy (retval
, linkname
, link_size
);
6157 w32_copy_file (const char *from
, const char *to
,
6158 int keep_time
, int preserve_ownership
, int copy_acls
)
6162 wchar_t from_w
[MAX_PATH
], to_w
[MAX_PATH
];
6163 char from_a
[MAX_PATH
], to_a
[MAX_PATH
];
6165 /* We ignore preserve_ownership for now. */
6166 preserve_ownership
= preserve_ownership
;
6170 acl
= acl_get_file (from
, ACL_TYPE_ACCESS
);
6171 if (acl
== NULL
&& acl_errno_valid (errno
))
6174 if (w32_unicode_filenames
)
6176 filename_to_utf16 (from
, from_w
);
6177 filename_to_utf16 (to
, to_w
);
6178 copy_result
= CopyFileW (from_w
, to_w
, FALSE
);
6182 filename_to_ansi (from
, from_a
);
6183 filename_to_ansi (to
, to_a
);
6184 copy_result
= CopyFileA (from_a
, to_a
, FALSE
);
6188 /* CopyFile doesn't set errno when it fails. By far the most
6189 "popular" reason is that the target is read-only. */
6190 DWORD err
= GetLastError ();
6194 case ERROR_FILE_NOT_FOUND
:
6197 case ERROR_ACCESS_DENIED
:
6200 case ERROR_ENCRYPTION_FAILED
:
6212 /* CopyFile retains the timestamp by default. However, see
6213 "Community Additions" for CopyFile: it sounds like that is not
6214 entirely true. Testing on Windows XP confirms that modified time
6215 is copied, but creation and last-access times are not.
6217 else if (!keep_time
)
6219 struct timespec now
;
6222 if (w32_unicode_filenames
)
6224 /* Ensure file is writable while its times are set. */
6225 attributes
= GetFileAttributesW (to_w
);
6226 SetFileAttributesW (to_w
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6227 now
= current_timespec ();
6228 if (set_file_times (-1, to
, now
, now
))
6230 /* Restore original attributes. */
6231 SetFileAttributesW (to_w
, attributes
);
6236 /* Restore original attributes. */
6237 SetFileAttributesW (to_w
, attributes
);
6241 attributes
= GetFileAttributesA (to_a
);
6242 SetFileAttributesA (to_a
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6243 now
= current_timespec ();
6244 if (set_file_times (-1, to
, now
, now
))
6246 SetFileAttributesA (to_a
, attributes
);
6251 SetFileAttributesA (to_a
, attributes
);
6257 acl_set_file (to
, ACL_TYPE_ACCESS
, acl
) != 0;
6259 if (fail
&& acl_errno_valid (errno
))
6267 /* Support for browsing other processes and their attributes. See
6268 process.c for the Lisp bindings. */
6270 /* Helper wrapper functions. */
6272 static HANDLE WINAPI
6273 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
6275 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
6277 if (g_b_init_create_toolhelp32_snapshot
== 0)
6279 g_b_init_create_toolhelp32_snapshot
= 1;
6280 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
6281 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6282 "CreateToolhelp32Snapshot");
6284 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
6286 return INVALID_HANDLE_VALUE
;
6288 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
6292 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6294 static Process32First_Proc s_pfn_Process32_First
= NULL
;
6296 if (g_b_init_process32_first
== 0)
6298 g_b_init_process32_first
= 1;
6299 s_pfn_Process32_First
= (Process32First_Proc
)
6300 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6303 if (s_pfn_Process32_First
== NULL
)
6307 return (s_pfn_Process32_First (hSnapshot
, lppe
));
6311 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6313 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
6315 if (g_b_init_process32_next
== 0)
6317 g_b_init_process32_next
= 1;
6318 s_pfn_Process32_Next
= (Process32Next_Proc
)
6319 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6322 if (s_pfn_Process32_Next
== NULL
)
6326 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
6330 open_thread_token (HANDLE ThreadHandle
,
6331 DWORD DesiredAccess
,
6333 PHANDLE TokenHandle
)
6335 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
6336 HMODULE hm_advapi32
= NULL
;
6337 if (is_windows_9x () == TRUE
)
6339 SetLastError (ERROR_NOT_SUPPORTED
);
6342 if (g_b_init_open_thread_token
== 0)
6344 g_b_init_open_thread_token
= 1;
6345 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6346 s_pfn_Open_Thread_Token
=
6347 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
6349 if (s_pfn_Open_Thread_Token
== NULL
)
6351 SetLastError (ERROR_NOT_SUPPORTED
);
6355 s_pfn_Open_Thread_Token (
6364 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
6366 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
6367 HMODULE hm_advapi32
= NULL
;
6368 if (is_windows_9x () == TRUE
)
6372 if (g_b_init_impersonate_self
== 0)
6374 g_b_init_impersonate_self
= 1;
6375 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6376 s_pfn_Impersonate_Self
=
6377 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
6379 if (s_pfn_Impersonate_Self
== NULL
)
6383 return s_pfn_Impersonate_Self (ImpersonationLevel
);
6387 revert_to_self (void)
6389 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
6390 HMODULE hm_advapi32
= NULL
;
6391 if (is_windows_9x () == TRUE
)
6395 if (g_b_init_revert_to_self
== 0)
6397 g_b_init_revert_to_self
= 1;
6398 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6399 s_pfn_Revert_To_Self
=
6400 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
6402 if (s_pfn_Revert_To_Self
== NULL
)
6406 return s_pfn_Revert_To_Self ();
6410 get_process_memory_info (HANDLE h_proc
,
6411 PPROCESS_MEMORY_COUNTERS mem_counters
,
6414 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
6415 HMODULE hm_psapi
= NULL
;
6416 if (is_windows_9x () == TRUE
)
6420 if (g_b_init_get_process_memory_info
== 0)
6422 g_b_init_get_process_memory_info
= 1;
6423 hm_psapi
= LoadLibrary ("Psapi.dll");
6425 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
6426 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
6428 if (s_pfn_Get_Process_Memory_Info
== NULL
)
6432 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
6436 get_process_working_set_size (HANDLE h_proc
,
6440 static GetProcessWorkingSetSize_Proc
6441 s_pfn_Get_Process_Working_Set_Size
= NULL
;
6443 if (is_windows_9x () == TRUE
)
6447 if (g_b_init_get_process_working_set_size
== 0)
6449 g_b_init_get_process_working_set_size
= 1;
6450 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
6451 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6452 "GetProcessWorkingSetSize");
6454 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
6458 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
6462 global_memory_status (MEMORYSTATUS
*buf
)
6464 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
6466 if (is_windows_9x () == TRUE
)
6470 if (g_b_init_global_memory_status
== 0)
6472 g_b_init_global_memory_status
= 1;
6473 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
6474 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6475 "GlobalMemoryStatus");
6477 if (s_pfn_Global_Memory_Status
== NULL
)
6481 return s_pfn_Global_Memory_Status (buf
);
6485 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
6487 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
6489 if (is_windows_9x () == TRUE
)
6493 if (g_b_init_global_memory_status_ex
== 0)
6495 g_b_init_global_memory_status_ex
= 1;
6496 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
6497 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6498 "GlobalMemoryStatusEx");
6500 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
6504 return s_pfn_Global_Memory_Status_Ex (buf
);
6508 list_system_processes (void)
6510 struct gcpro gcpro1
;
6511 Lisp_Object proclist
= Qnil
;
6514 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6516 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6518 PROCESSENTRY32 proc_entry
;
6524 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
6525 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
6526 res
= process32_next (h_snapshot
, &proc_entry
))
6528 proc_id
= proc_entry
.th32ProcessID
;
6529 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
6532 CloseHandle (h_snapshot
);
6534 proclist
= Fnreverse (proclist
);
6541 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
6543 TOKEN_PRIVILEGES priv
;
6544 DWORD priv_size
= sizeof (priv
);
6545 DWORD opriv_size
= sizeof (*old_priv
);
6546 HANDLE h_token
= NULL
;
6547 HANDLE h_thread
= GetCurrentThread ();
6551 res
= open_thread_token (h_thread
,
6552 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6554 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
6556 if (impersonate_self (SecurityImpersonation
))
6557 res
= open_thread_token (h_thread
,
6558 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6563 priv
.PrivilegeCount
= 1;
6564 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
6565 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
6566 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
6567 old_priv
, &opriv_size
)
6568 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6572 CloseHandle (h_token
);
6578 restore_privilege (TOKEN_PRIVILEGES
*priv
)
6580 DWORD priv_size
= sizeof (*priv
);
6581 HANDLE h_token
= NULL
;
6584 if (open_thread_token (GetCurrentThread (),
6585 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6588 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
6589 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6593 CloseHandle (h_token
);
6599 ltime (ULONGLONG time_100ns
)
6601 ULONGLONG time_sec
= time_100ns
/ 10000000;
6602 int subsec
= time_100ns
% 10000000;
6603 return list4i (time_sec
>> 16, time_sec
& 0xffff,
6604 subsec
/ 10, subsec
% 10 * 100000);
6607 #define U64_TO_LISP_TIME(time) ltime (time)
6610 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
6611 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
6614 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
6615 ULONGLONG tem1
, tem2
, tem3
, tem
;
6618 || !get_process_times_fn
6619 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
6620 &ft_kernel
, &ft_user
))
6623 GetSystemTimeAsFileTime (&ft_current
);
6625 FILETIME_TO_U64 (tem1
, ft_kernel
);
6626 *stime
= U64_TO_LISP_TIME (tem1
);
6628 FILETIME_TO_U64 (tem2
, ft_user
);
6629 *utime
= U64_TO_LISP_TIME (tem2
);
6632 *ttime
= U64_TO_LISP_TIME (tem3
);
6634 FILETIME_TO_U64 (tem
, ft_creation
);
6635 /* Process no 4 (System) returns zero creation time. */
6638 *ctime
= U64_TO_LISP_TIME (tem
);
6642 FILETIME_TO_U64 (tem3
, ft_current
);
6643 tem
= (tem3
- utc_base
) - tem
;
6645 *etime
= U64_TO_LISP_TIME (tem
);
6649 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
6660 system_process_attributes (Lisp_Object pid
)
6662 struct gcpro gcpro1
, gcpro2
, gcpro3
;
6663 Lisp_Object attrs
= Qnil
;
6664 Lisp_Object cmd_str
, decoded_cmd
, tem
;
6665 HANDLE h_snapshot
, h_proc
;
6668 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
6669 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
6670 DWORD glength
= sizeof (gname
);
6671 HANDLE token
= NULL
;
6672 SID_NAME_USE user_type
;
6673 unsigned char *buf
= NULL
;
6675 TOKEN_USER user_token
;
6676 TOKEN_PRIMARY_GROUP group_token
;
6679 PROCESS_MEMORY_COUNTERS mem
;
6680 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
6681 SIZE_T minrss
, maxrss
;
6683 MEMORY_STATUS_EX memstex
;
6684 double totphys
= 0.0;
6685 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
6687 BOOL result
= FALSE
;
6689 CHECK_NUMBER_OR_FLOAT (pid
);
6690 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
6692 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6694 GCPRO3 (attrs
, decoded_cmd
, tem
);
6696 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6701 pe
.dwSize
= sizeof (PROCESSENTRY32
);
6702 for (res
= process32_first (h_snapshot
, &pe
); res
;
6703 res
= process32_next (h_snapshot
, &pe
))
6705 if (proc_id
== pe
.th32ProcessID
)
6708 decoded_cmd
= build_string ("Idle");
6711 /* Decode the command name from locale-specific
6713 cmd_str
= build_unibyte_string (pe
.szExeFile
);
6716 code_convert_string_norecord (cmd_str
,
6717 Vlocale_coding_system
, 0);
6719 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
6720 attrs
= Fcons (Fcons (Qppid
,
6721 make_fixnum_or_float (pe
.th32ParentProcessID
)),
6723 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
6725 attrs
= Fcons (Fcons (Qthcount
,
6726 make_fixnum_or_float (pe
.cntThreads
)),
6733 CloseHandle (h_snapshot
);
6742 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6744 /* If we were denied a handle to the process, try again after
6745 enabling the SeDebugPrivilege in our process. */
6748 TOKEN_PRIVILEGES priv_current
;
6750 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
6752 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6754 restore_privilege (&priv_current
);
6760 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
6763 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
6764 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6766 buf
= xmalloc (blen
);
6767 result
= get_token_information (token
, TokenUser
,
6768 (LPVOID
)buf
, blen
, &needed
);
6771 memcpy (&user_token
, buf
, sizeof (user_token
));
6772 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
6774 euid
= get_rid (user_token
.User
.Sid
);
6775 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
6780 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
6783 strcpy (uname
, "unknown");
6787 ulength
= strlen (uname
);
6793 /* Determine a reasonable euid and gid values. */
6794 if (xstrcasecmp ("administrator", uname
) == 0)
6796 euid
= 500; /* well-known Administrator uid */
6797 egid
= 513; /* well-known None gid */
6801 /* Get group id and name. */
6802 result
= get_token_information (token
, TokenPrimaryGroup
,
6803 (LPVOID
)buf
, blen
, &needed
);
6804 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6806 buf
= xrealloc (buf
, blen
= needed
);
6807 result
= get_token_information (token
, TokenPrimaryGroup
,
6808 (LPVOID
)buf
, blen
, &needed
);
6812 memcpy (&group_token
, buf
, sizeof (group_token
));
6813 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
6815 egid
= get_rid (group_token
.PrimaryGroup
);
6816 dlength
= sizeof (domain
);
6818 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
6819 gname
, &glength
, NULL
, &dlength
,
6822 w32_add_to_cache (group_token
.PrimaryGroup
,
6826 strcpy (gname
, "None");
6830 glength
= strlen (gname
);
6838 if (!is_windows_9x ())
6840 /* We couldn't open the process token, presumably because of
6841 insufficient access rights. Assume this process is run
6843 strcpy (uname
, "SYSTEM");
6844 strcpy (gname
, "None");
6845 euid
= 18; /* SYSTEM */
6846 egid
= 513; /* None */
6847 glength
= strlen (gname
);
6848 ulength
= strlen (uname
);
6850 /* If we are running under Windows 9X, where security calls are
6851 not supported, we assume all processes are run by the current
6853 else if (GetUserName (uname
, &ulength
))
6855 if (xstrcasecmp ("administrator", uname
) == 0)
6860 strcpy (gname
, "None");
6861 glength
= strlen (gname
);
6862 ulength
= strlen (uname
);
6868 strcpy (uname
, "administrator");
6869 ulength
= strlen (uname
);
6870 strcpy (gname
, "None");
6871 glength
= strlen (gname
);
6874 CloseHandle (token
);
6877 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
6878 tem
= make_unibyte_string (uname
, ulength
);
6879 attrs
= Fcons (Fcons (Quser
,
6880 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6882 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
6883 tem
= make_unibyte_string (gname
, glength
);
6884 attrs
= Fcons (Fcons (Qgroup
,
6885 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6888 if (global_memory_status_ex (&memstex
))
6889 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
6890 totphys
= memstex
.ullTotalPhys
/ 1024.0;
6892 /* Visual Studio 6 cannot convert an unsigned __int64 type to
6893 double, so we need to do this for it... */
6895 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
6896 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
6897 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
6899 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
6901 #endif /* __GNUC__ || _MSC_VER >= 1300 */
6902 else if (global_memory_status (&memst
))
6903 totphys
= memst
.dwTotalPhys
/ 1024.0;
6906 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
6909 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6911 attrs
= Fcons (Fcons (Qmajflt
,
6912 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
6914 attrs
= Fcons (Fcons (Qvsize
,
6915 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
6917 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6919 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6922 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
6924 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6926 attrs
= Fcons (Fcons (Qmajflt
,
6927 make_fixnum_or_float (mem
.PageFaultCount
)),
6929 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6931 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6934 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
6936 DWORD rss
= maxrss
/ 1024;
6938 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
6940 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6943 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
6945 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
6946 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
6947 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
6948 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
6949 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
6950 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
6953 /* FIXME: Retrieve command line by walking the PEB of the process. */
6956 CloseHandle (h_proc
);
6962 /* Wrappers for winsock functions to map between our file descriptors
6963 and winsock's handles; also set h_errno for convenience.
6965 To allow Emacs to run on systems which don't have winsock support
6966 installed, we dynamically link to winsock on startup if present, and
6967 otherwise provide the minimum necessary functionality
6968 (eg. gethostname). */
6970 /* function pointers for relevant socket functions */
6971 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
6972 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
6973 int (PASCAL
*pfn_WSAGetLastError
) (void);
6974 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
6975 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
6976 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
6977 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
6978 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6979 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6980 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
6981 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
6982 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
6983 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
6984 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
6985 int (PASCAL
*pfn_WSACleanup
) (void);
6987 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
6988 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
6989 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
6990 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
6991 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
6992 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
6993 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
6994 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
6995 const char * optval
, int optlen
);
6996 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
6997 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
6999 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
7000 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
7001 struct sockaddr
* from
, int * fromlen
);
7002 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
7003 const struct sockaddr
* to
, int tolen
);
7005 /* SetHandleInformation is only needed to make sockets non-inheritable. */
7006 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
7007 #ifndef HANDLE_FLAG_INHERIT
7008 #define HANDLE_FLAG_INHERIT 1
7012 static int winsock_inuse
;
7017 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
7019 release_listen_threads ();
7020 /* Not sure what would cause WSAENETDOWN, or even if it can happen
7021 after WSAStartup returns successfully, but it seems reasonable
7022 to allow unloading winsock anyway in that case. */
7023 if (pfn_WSACleanup () == 0 ||
7024 pfn_WSAGetLastError () == WSAENETDOWN
)
7026 if (FreeLibrary (winsock_lib
))
7035 init_winsock (int load_now
)
7037 WSADATA winsockData
;
7039 if (winsock_lib
!= NULL
)
7042 pfn_SetHandleInformation
7043 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
7044 "SetHandleInformation");
7046 winsock_lib
= LoadLibrary ("Ws2_32.dll");
7048 if (winsock_lib
!= NULL
)
7050 /* dynamically link to socket functions */
7052 #define LOAD_PROC(fn) \
7053 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
7056 LOAD_PROC (WSAStartup
);
7057 LOAD_PROC (WSASetLastError
);
7058 LOAD_PROC (WSAGetLastError
);
7059 LOAD_PROC (WSAEventSelect
);
7060 LOAD_PROC (WSACreateEvent
);
7061 LOAD_PROC (WSACloseEvent
);
7064 LOAD_PROC (connect
);
7065 LOAD_PROC (ioctlsocket
);
7068 LOAD_PROC (closesocket
);
7069 LOAD_PROC (shutdown
);
7072 LOAD_PROC (inet_addr
);
7073 LOAD_PROC (gethostname
);
7074 LOAD_PROC (gethostbyname
);
7075 LOAD_PROC (getservbyname
);
7076 LOAD_PROC (getpeername
);
7077 LOAD_PROC (WSACleanup
);
7078 LOAD_PROC (setsockopt
);
7080 LOAD_PROC (getsockname
);
7082 LOAD_PROC (recvfrom
);
7086 /* specify version 1.1 of winsock */
7087 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
7089 if (winsockData
.wVersion
!= 0x101)
7094 /* Report that winsock exists and is usable, but leave
7095 socket functions disabled. I am assuming that calling
7096 WSAStartup does not require any network interaction,
7097 and in particular does not cause or require a dial-up
7098 connection to be established. */
7101 FreeLibrary (winsock_lib
);
7109 FreeLibrary (winsock_lib
);
7119 /* Function to map winsock error codes to errno codes for those errno
7120 code defined in errno.h (errno values not defined by errno.h are
7121 already in nt/inc/sys/socket.h). */
7128 if (winsock_lib
== NULL
)
7131 wsa_err
= pfn_WSAGetLastError ();
7135 case WSAEACCES
: errno
= EACCES
; break;
7136 case WSAEBADF
: errno
= EBADF
; break;
7137 case WSAEFAULT
: errno
= EFAULT
; break;
7138 case WSAEINTR
: errno
= EINTR
; break;
7139 case WSAEINVAL
: errno
= EINVAL
; break;
7140 case WSAEMFILE
: errno
= EMFILE
; break;
7141 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
7142 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
7143 default: errno
= wsa_err
; break;
7151 if (winsock_lib
!= NULL
)
7152 pfn_WSASetLastError (0);
7155 /* Extend strerror to handle the winsock-specific error codes. */
7159 } _wsa_errlist
[] = {
7160 {WSAEINTR
, "Interrupted function call"},
7161 {WSAEBADF
, "Bad file descriptor"},
7162 {WSAEACCES
, "Permission denied"},
7163 {WSAEFAULT
, "Bad address"},
7164 {WSAEINVAL
, "Invalid argument"},
7165 {WSAEMFILE
, "Too many open files"},
7167 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
7168 {WSAEINPROGRESS
, "Operation now in progress"},
7169 {WSAEALREADY
, "Operation already in progress"},
7170 {WSAENOTSOCK
, "Socket operation on non-socket"},
7171 {WSAEDESTADDRREQ
, "Destination address required"},
7172 {WSAEMSGSIZE
, "Message too long"},
7173 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
7174 {WSAENOPROTOOPT
, "Bad protocol option"},
7175 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
7176 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
7177 {WSAEOPNOTSUPP
, "Operation not supported"},
7178 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
7179 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
7180 {WSAEADDRINUSE
, "Address already in use"},
7181 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
7182 {WSAENETDOWN
, "Network is down"},
7183 {WSAENETUNREACH
, "Network is unreachable"},
7184 {WSAENETRESET
, "Network dropped connection on reset"},
7185 {WSAECONNABORTED
, "Software caused connection abort"},
7186 {WSAECONNRESET
, "Connection reset by peer"},
7187 {WSAENOBUFS
, "No buffer space available"},
7188 {WSAEISCONN
, "Socket is already connected"},
7189 {WSAENOTCONN
, "Socket is not connected"},
7190 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
7191 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
7192 {WSAETIMEDOUT
, "Connection timed out"},
7193 {WSAECONNREFUSED
, "Connection refused"},
7194 {WSAELOOP
, "Network loop"}, /* not sure */
7195 {WSAENAMETOOLONG
, "Name is too long"},
7196 {WSAEHOSTDOWN
, "Host is down"},
7197 {WSAEHOSTUNREACH
, "No route to host"},
7198 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
7199 {WSAEPROCLIM
, "Too many processes"},
7200 {WSAEUSERS
, "Too many users"}, /* not sure */
7201 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
7202 {WSAESTALE
, "Data is stale"}, /* not sure */
7203 {WSAEREMOTE
, "Remote error"}, /* not sure */
7205 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
7206 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
7207 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
7208 {WSAEDISCON
, "Graceful shutdown in progress"},
7210 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
7211 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
7212 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
7213 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
7214 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
7215 {WSASYSCALLFAILURE
, "System call failure"},
7216 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
7217 {WSATYPE_NOT_FOUND
, "Class type not found"},
7218 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
7219 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
7220 {WSAEREFUSED
, "Operation refused"}, /* not sure */
7223 {WSAHOST_NOT_FOUND
, "Host not found"},
7224 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
7225 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
7226 {WSANO_DATA
, "Valid name, no data record of requested type"},
7232 sys_strerror (int error_no
)
7235 static char unknown_msg
[40];
7237 if (error_no
>= 0 && error_no
< sys_nerr
)
7238 return sys_errlist
[error_no
];
7240 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
7241 if (_wsa_errlist
[i
].errnum
== error_no
)
7242 return _wsa_errlist
[i
].msg
;
7244 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
7248 /* [andrewi 3-May-96] I've had conflicting results using both methods,
7249 but I believe the method of keeping the socket handle separate (and
7250 insuring it is not inheritable) is the correct one. */
7252 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
7254 static int socket_to_fd (SOCKET s
);
7257 sys_socket (int af
, int type
, int protocol
)
7261 if (winsock_lib
== NULL
)
7264 return INVALID_SOCKET
;
7269 /* call the real socket function */
7270 s
= pfn_socket (af
, type
, protocol
);
7272 if (s
!= INVALID_SOCKET
)
7273 return socket_to_fd (s
);
7279 /* Convert a SOCKET to a file descriptor. */
7281 socket_to_fd (SOCKET s
)
7286 /* Although under NT 3.5 _open_osfhandle will accept a socket
7287 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
7288 that does not work under NT 3.1. However, we can get the same
7289 effect by using a backdoor function to replace an existing
7290 descriptor handle with the one we want. */
7292 /* allocate a file descriptor (with appropriate flags) */
7293 fd
= _open ("NUL:", _O_RDWR
);
7296 /* Make a non-inheritable copy of the socket handle. Note
7297 that it is possible that sockets aren't actually kernel
7298 handles, which appears to be the case on Windows 9x when
7299 the MS Proxy winsock client is installed. */
7301 /* Apparently there is a bug in NT 3.51 with some service
7302 packs, which prevents using DuplicateHandle to make a
7303 socket handle non-inheritable (causes WSACleanup to
7304 hang). The work-around is to use SetHandleInformation
7305 instead if it is available and implemented. */
7306 if (pfn_SetHandleInformation
)
7308 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
7312 HANDLE parent
= GetCurrentProcess ();
7313 HANDLE new_s
= INVALID_HANDLE_VALUE
;
7315 if (DuplicateHandle (parent
,
7321 DUPLICATE_SAME_ACCESS
))
7323 /* It is possible that DuplicateHandle succeeds even
7324 though the socket wasn't really a kernel handle,
7325 because a real handle has the same value. So
7326 test whether the new handle really is a socket. */
7327 long nonblocking
= 0;
7328 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
7330 pfn_closesocket (s
);
7335 CloseHandle (new_s
);
7340 eassert (fd
< MAXDESC
);
7341 fd_info
[fd
].hnd
= (HANDLE
) s
;
7343 /* set our own internal flags */
7344 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
7350 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7352 /* attach child_process to fd_info */
7353 if (fd_info
[ fd
].cp
!= NULL
)
7355 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
7359 fd_info
[ fd
].cp
= cp
;
7362 winsock_inuse
++; /* count open sockets */
7370 pfn_closesocket (s
);
7376 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
7378 if (winsock_lib
== NULL
)
7381 return SOCKET_ERROR
;
7385 if (fd_info
[s
].flags
& FILE_SOCKET
)
7387 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
7388 if (rc
== SOCKET_ERROR
)
7393 return SOCKET_ERROR
;
7397 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
7399 if (winsock_lib
== NULL
)
7402 return SOCKET_ERROR
;
7406 if (fd_info
[s
].flags
& FILE_SOCKET
)
7408 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
7409 if (rc
== SOCKET_ERROR
)
7414 return SOCKET_ERROR
;
7418 sys_htons (u_short hostshort
)
7420 return (winsock_lib
!= NULL
) ?
7421 pfn_htons (hostshort
) : hostshort
;
7425 sys_ntohs (u_short netshort
)
7427 return (winsock_lib
!= NULL
) ?
7428 pfn_ntohs (netshort
) : netshort
;
7432 sys_inet_addr (const char * cp
)
7434 return (winsock_lib
!= NULL
) ?
7435 pfn_inet_addr (cp
) : INADDR_NONE
;
7439 sys_gethostname (char * name
, int namelen
)
7441 if (winsock_lib
!= NULL
)
7446 retval
= pfn_gethostname (name
, namelen
);
7447 if (retval
== SOCKET_ERROR
)
7452 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
7453 return !GetComputerName (name
, (DWORD
*)&namelen
);
7456 return SOCKET_ERROR
;
7460 sys_gethostbyname (const char * name
)
7462 struct hostent
* host
;
7463 int h_err
= h_errno
;
7465 if (winsock_lib
== NULL
)
7467 h_errno
= NO_RECOVERY
;
7473 host
= pfn_gethostbyname (name
);
7485 sys_getservbyname (const char * name
, const char * proto
)
7487 struct servent
* serv
;
7489 if (winsock_lib
== NULL
)
7496 serv
= pfn_getservbyname (name
, proto
);
7503 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
7505 if (winsock_lib
== NULL
)
7508 return SOCKET_ERROR
;
7512 if (fd_info
[s
].flags
& FILE_SOCKET
)
7514 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
7515 if (rc
== SOCKET_ERROR
)
7520 return SOCKET_ERROR
;
7524 sys_shutdown (int s
, int how
)
7526 if (winsock_lib
== NULL
)
7529 return SOCKET_ERROR
;
7533 if (fd_info
[s
].flags
& FILE_SOCKET
)
7535 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
7536 if (rc
== SOCKET_ERROR
)
7541 return SOCKET_ERROR
;
7545 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
7547 if (winsock_lib
== NULL
)
7550 return SOCKET_ERROR
;
7554 if (fd_info
[s
].flags
& FILE_SOCKET
)
7556 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
7557 (const char *)optval
, optlen
);
7558 if (rc
== SOCKET_ERROR
)
7563 return SOCKET_ERROR
;
7567 sys_listen (int s
, int backlog
)
7569 if (winsock_lib
== NULL
)
7572 return SOCKET_ERROR
;
7576 if (fd_info
[s
].flags
& FILE_SOCKET
)
7578 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
7579 if (rc
== SOCKET_ERROR
)
7582 fd_info
[s
].flags
|= FILE_LISTEN
;
7586 return SOCKET_ERROR
;
7590 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
7592 if (winsock_lib
== NULL
)
7595 return SOCKET_ERROR
;
7599 if (fd_info
[s
].flags
& FILE_SOCKET
)
7601 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
7602 if (rc
== SOCKET_ERROR
)
7607 return SOCKET_ERROR
;
7611 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
7613 if (winsock_lib
== NULL
)
7620 if (fd_info
[s
].flags
& FILE_LISTEN
)
7622 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
7624 if (t
== INVALID_SOCKET
)
7627 fd
= socket_to_fd (t
);
7631 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7632 ResetEvent (fd_info
[s
].cp
->char_avail
);
7641 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
7642 struct sockaddr
* from
, int * fromlen
)
7644 if (winsock_lib
== NULL
)
7647 return SOCKET_ERROR
;
7651 if (fd_info
[s
].flags
& FILE_SOCKET
)
7653 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
7654 if (rc
== SOCKET_ERROR
)
7659 return SOCKET_ERROR
;
7663 sys_sendto (int s
, const char * buf
, int len
, int flags
,
7664 const struct sockaddr
* to
, int tolen
)
7666 if (winsock_lib
== NULL
)
7669 return SOCKET_ERROR
;
7673 if (fd_info
[s
].flags
& FILE_SOCKET
)
7675 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
7676 if (rc
== SOCKET_ERROR
)
7681 return SOCKET_ERROR
;
7684 /* Windows does not have an fcntl function. Provide an implementation
7685 good enough for Emacs. */
7687 fcntl (int s
, int cmd
, int options
)
7689 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
7690 invoked in a context where fd1 is closed and all descriptors less
7691 than fd1 are open, so sys_dup is an adequate implementation. */
7692 if (cmd
== F_DUPFD_CLOEXEC
)
7695 if (winsock_lib
== NULL
)
7702 if (fd_info
[s
].flags
& FILE_SOCKET
)
7704 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7706 unsigned long nblock
= 1;
7707 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
7708 if (rc
== SOCKET_ERROR
)
7710 /* Keep track of the fact that we set this to non-blocking. */
7711 fd_info
[s
].flags
|= FILE_NDELAY
;
7717 return SOCKET_ERROR
;
7721 return SOCKET_ERROR
;
7725 /* Shadow main io functions: we need to handle pipes and sockets more
7726 intelligently, and implement non-blocking mode as well. */
7739 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
7741 child_process
* cp
= fd_info
[fd
].cp
;
7743 fd_info
[fd
].cp
= NULL
;
7745 if (CHILD_ACTIVE (cp
))
7747 /* if last descriptor to active child_process then cleanup */
7749 for (i
= 0; i
< MAXDESC
; i
++)
7753 if (fd_info
[i
].cp
== cp
)
7758 if (fd_info
[fd
].flags
& FILE_SOCKET
)
7760 if (winsock_lib
== NULL
) emacs_abort ();
7762 pfn_shutdown (SOCK_HANDLE (fd
), 2);
7763 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
7765 winsock_inuse
--; /* count open sockets */
7767 /* If the process handle is NULL, it's either a socket
7768 or serial connection, or a subprocess that was
7769 already reaped by reap_subprocess, but whose
7770 resources were not yet freed, because its output was
7771 not fully read yet by the time it was reaped. (This
7772 usually happens with async subprocesses whose output
7773 is being read by Emacs.) Otherwise, this process was
7774 not reaped yet, so we set its FD to a negative value
7775 to make sure sys_select will eventually get to
7776 calling the SIGCHLD handler for it, which will then
7777 invoke waitpid and reap_subprocess. */
7778 if (cp
->procinfo
.hProcess
== NULL
)
7786 if (fd
>= 0 && fd
< MAXDESC
)
7787 fd_info
[fd
].flags
= 0;
7789 /* Note that sockets do not need special treatment here (at least on
7790 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
7791 closesocket is equivalent to CloseHandle, which is to be expected
7792 because socket handles are fully fledged kernel handles. */
7804 if (new_fd
>= 0 && new_fd
< MAXDESC
)
7806 /* duplicate our internal info as well */
7807 fd_info
[new_fd
] = fd_info
[fd
];
7813 sys_dup2 (int src
, int dst
)
7817 if (dst
< 0 || dst
>= MAXDESC
)
7823 /* make sure we close the destination first if it's a pipe or socket */
7824 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
7827 rc
= _dup2 (src
, dst
);
7830 /* duplicate our internal info as well */
7831 fd_info
[dst
] = fd_info
[src
];
7837 pipe2 (int * phandles
, int pipe2_flags
)
7842 eassert (pipe2_flags
== O_CLOEXEC
);
7844 /* make pipe handles non-inheritable; when we spawn a child, we
7845 replace the relevant handle with an inheritable one. Also put
7846 pipes into binary mode; we will do text mode translation ourselves
7848 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
7852 /* Protect against overflow, since Windows can open more handles than
7853 our fd_info array has room for. */
7854 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
7856 _close (phandles
[0]);
7857 _close (phandles
[1]);
7863 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
7864 fd_info
[phandles
[0]].flags
= flags
;
7866 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
7867 fd_info
[phandles
[1]].flags
= flags
;
7874 /* Function to do blocking read of one byte, needed to implement
7875 select. It is only allowed on communication ports, sockets, or
7878 _sys_read_ahead (int fd
)
7883 if (fd
< 0 || fd
>= MAXDESC
)
7884 return STATUS_READ_ERROR
;
7886 cp
= fd_info
[fd
].cp
;
7888 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7889 return STATUS_READ_ERROR
;
7891 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
7892 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
7894 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
7898 cp
->status
= STATUS_READ_IN_PROGRESS
;
7900 if (fd_info
[fd
].flags
& FILE_PIPE
)
7902 rc
= _read (fd
, &cp
->chr
, sizeof (char));
7904 /* Give subprocess time to buffer some more output for us before
7905 reporting that input is available; we need this because Windows 95
7906 connects DOS programs to pipes by making the pipe appear to be
7907 the normal console stdout - as a result most DOS programs will
7908 write to stdout without buffering, ie. one character at a
7909 time. Even some W32 programs do this - "dir" in a command
7910 shell on NT is very slow if we don't do this. */
7913 int wait
= w32_pipe_read_delay
;
7919 /* Yield remainder of our time slice, effectively giving a
7920 temporary priority boost to the child process. */
7924 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7926 HANDLE hnd
= fd_info
[fd
].hnd
;
7927 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7930 /* Configure timeouts for blocking read. */
7931 if (!GetCommTimeouts (hnd
, &ct
))
7933 cp
->status
= STATUS_READ_ERROR
;
7934 return STATUS_READ_ERROR
;
7936 ct
.ReadIntervalTimeout
= 0;
7937 ct
.ReadTotalTimeoutMultiplier
= 0;
7938 ct
.ReadTotalTimeoutConstant
= 0;
7939 if (!SetCommTimeouts (hnd
, &ct
))
7941 cp
->status
= STATUS_READ_ERROR
;
7942 return STATUS_READ_ERROR
;
7945 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
7947 if (GetLastError () != ERROR_IO_PENDING
)
7949 cp
->status
= STATUS_READ_ERROR
;
7950 return STATUS_READ_ERROR
;
7952 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7954 cp
->status
= STATUS_READ_ERROR
;
7955 return STATUS_READ_ERROR
;
7959 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
7961 unsigned long nblock
= 0;
7962 /* We always want this to block, so temporarily disable NDELAY. */
7963 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7964 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7966 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
7968 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7971 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7975 if (rc
== sizeof (char))
7976 cp
->status
= STATUS_READ_SUCCEEDED
;
7978 cp
->status
= STATUS_READ_FAILED
;
7984 _sys_wait_accept (int fd
)
7990 if (fd
< 0 || fd
>= MAXDESC
)
7991 return STATUS_READ_ERROR
;
7993 cp
= fd_info
[fd
].cp
;
7995 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7996 return STATUS_READ_ERROR
;
7998 cp
->status
= STATUS_READ_FAILED
;
8000 hEv
= pfn_WSACreateEvent ();
8001 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
8002 if (rc
!= SOCKET_ERROR
)
8005 rc
= WaitForSingleObject (hEv
, 500);
8007 } while (rc
== WAIT_TIMEOUT
8008 && cp
->status
!= STATUS_READ_ERROR
8010 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
8011 if (rc
== WAIT_OBJECT_0
)
8012 cp
->status
= STATUS_READ_SUCCEEDED
;
8014 pfn_WSACloseEvent (hEv
);
8020 sys_read (int fd
, char * buffer
, unsigned int count
)
8025 char * orig_buffer
= buffer
;
8033 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8035 child_process
*cp
= fd_info
[fd
].cp
;
8037 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
8045 /* re-read CR carried over from last read */
8046 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
8048 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
8052 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
8055 /* presence of a child_process structure means we are operating in
8056 non-blocking mode - otherwise we just call _read directly.
8057 Note that the child_process structure might be missing because
8058 reap_subprocess has been called; in this case the pipe is
8059 already broken, so calling _read on it is okay. */
8062 int current_status
= cp
->status
;
8064 switch (current_status
)
8066 case STATUS_READ_FAILED
:
8067 case STATUS_READ_ERROR
:
8068 /* report normal EOF if nothing in buffer */
8070 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8073 case STATUS_READ_READY
:
8074 case STATUS_READ_IN_PROGRESS
:
8075 DebPrint (("sys_read called when read is in progress\n"));
8076 errno
= EWOULDBLOCK
;
8079 case STATUS_READ_SUCCEEDED
:
8080 /* consume read-ahead char */
8081 *buffer
++ = cp
->chr
;
8084 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
8085 ResetEvent (cp
->char_avail
);
8087 case STATUS_READ_ACKNOWLEDGED
:
8091 DebPrint (("sys_read: bad status %d\n", current_status
));
8096 if (fd_info
[fd
].flags
& FILE_PIPE
)
8098 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
8099 to_read
= min (waiting
, (DWORD
) count
);
8102 nchars
+= _read (fd
, buffer
, to_read
);
8104 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
8106 HANDLE hnd
= fd_info
[fd
].hnd
;
8107 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
8113 /* Configure timeouts for non-blocking read. */
8114 if (!GetCommTimeouts (hnd
, &ct
))
8119 ct
.ReadIntervalTimeout
= MAXDWORD
;
8120 ct
.ReadTotalTimeoutMultiplier
= 0;
8121 ct
.ReadTotalTimeoutConstant
= 0;
8122 if (!SetCommTimeouts (hnd
, &ct
))
8128 if (!ResetEvent (ovl
->hEvent
))
8133 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
8135 if (GetLastError () != ERROR_IO_PENDING
)
8140 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
8149 else /* FILE_SOCKET */
8151 if (winsock_lib
== NULL
) emacs_abort ();
8153 /* do the equivalent of a non-blocking read */
8154 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
8155 if (waiting
== 0 && nchars
== 0)
8157 errno
= EWOULDBLOCK
;
8163 /* always use binary mode for sockets */
8164 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
8165 if (res
== SOCKET_ERROR
)
8167 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
8168 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8178 int nread
= _read (fd
, buffer
, count
);
8181 else if (nchars
== 0)
8186 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8187 /* Perform text mode translation if required. */
8188 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8190 nchars
= crlf_to_lf (nchars
, orig_buffer
);
8191 /* If buffer contains only CR, return that. To be absolutely
8192 sure we should attempt to read the next char, but in
8193 practice a CR to be followed by LF would not appear by
8194 itself in the buffer. */
8195 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
8197 fd_info
[fd
].flags
|= FILE_LAST_CR
;
8203 nchars
= _read (fd
, buffer
, count
);
8208 /* From w32xfns.c */
8209 extern HANDLE interrupt_handle
;
8211 /* For now, don't bother with a non-blocking mode */
8213 sys_write (int fd
, const void * buffer
, unsigned int count
)
8223 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8225 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
8231 /* Perform text mode translation if required. */
8232 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8234 char * tmpbuf
= alloca (count
* 2);
8235 unsigned char * src
= (void *)buffer
;
8236 unsigned char * dst
= tmpbuf
;
8241 unsigned char *next
;
8242 /* copy next line or remaining bytes */
8243 next
= _memccpy (dst
, src
, '\n', nbytes
);
8246 /* copied one line ending with '\n' */
8247 int copied
= next
- dst
;
8250 /* insert '\r' before '\n' */
8257 /* copied remaining partial line -> now finished */
8264 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
8266 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
8267 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
8268 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
8271 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
8273 if (GetLastError () != ERROR_IO_PENDING
)
8278 if (detect_input_pending ())
8279 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
8282 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
8283 if (active
== WAIT_OBJECT_0
)
8284 { /* User pressed C-g, cancel write, then leave. Don't bother
8285 cleaning up as we may only get stuck in buggy drivers. */
8286 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
8291 if (active
== WAIT_OBJECT_0
+ 1
8292 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
8299 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
8301 unsigned long nblock
= 0;
8302 if (winsock_lib
== NULL
) emacs_abort ();
8304 /* TODO: implement select() properly so non-blocking I/O works. */
8305 /* For now, make sure the write blocks. */
8306 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8307 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8309 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
8311 /* Set the socket back to non-blocking if it was before,
8312 for other operations that support it. */
8313 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8316 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8319 if (nchars
== SOCKET_ERROR
)
8321 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
8322 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8328 /* Some networked filesystems don't like too large writes, so
8329 break them into smaller chunks. See the Comments section of
8330 the MSDN documentation of WriteFile for details behind the
8331 choice of the value of CHUNK below. See also the thread
8332 http://thread.gmane.org/gmane.comp.version-control.git/145294
8333 in the git mailing list. */
8334 const unsigned char *p
= buffer
;
8335 const unsigned chunk
= 30 * 1024 * 1024;
8340 unsigned this_chunk
= count
< chunk
? count
: chunk
;
8341 int n
= _write (fd
, p
, this_chunk
);
8349 else if (n
< this_chunk
)
8360 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
8362 extern Lisp_Object
conv_sockaddr_to_lisp (struct sockaddr
*, int);
8364 /* Return information about network interface IFNAME, or about all
8365 interfaces (if IFNAME is nil). */
8367 network_interface_get_info (Lisp_Object ifname
)
8369 ULONG ainfo_len
= sizeof (IP_ADAPTER_INFO
);
8370 IP_ADAPTER_INFO
*adapter
, *ainfo
= xmalloc (ainfo_len
);
8371 DWORD retval
= get_adapters_info (ainfo
, &ainfo_len
);
8372 Lisp_Object res
= Qnil
;
8374 if (retval
== ERROR_BUFFER_OVERFLOW
)
8376 ainfo
= xrealloc (ainfo
, ainfo_len
);
8377 retval
= get_adapters_info (ainfo
, &ainfo_len
);
8380 if (retval
== ERROR_SUCCESS
)
8382 int eth_count
= 0, tr_count
= 0, fddi_count
= 0, ppp_count
= 0;
8383 int sl_count
= 0, wlan_count
= 0, lo_count
= 0, ifx_count
= 0;
8385 struct sockaddr_in sa
;
8387 /* For the below, we need some winsock functions, so make sure
8388 the winsock DLL is loaded. If we cannot successfully load
8389 it, they will have no use of the information we provide,
8391 if (!winsock_lib
&& !init_winsock (1))
8394 for (adapter
= ainfo
; adapter
; adapter
= adapter
->Next
)
8396 char namebuf
[MAX_ADAPTER_NAME_LENGTH
+ 4];
8398 /* Present Unix-compatible interface names, instead of the
8399 Windows names, which are really GUIDs not readable by
8401 static const char *ifmt
[] = {
8402 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
8417 switch (adapter
->Type
)
8419 case MIB_IF_TYPE_ETHERNET
:
8420 /* Windows before Vista reports wireless adapters as
8421 Ethernet. Work around by looking at the Description
8423 if (strstr (adapter
->Description
, "Wireless "))
8426 if_num
= wlan_count
++;
8430 ifmt_idx
= ETHERNET
;
8431 if_num
= eth_count
++;
8434 case MIB_IF_TYPE_TOKENRING
:
8435 ifmt_idx
= TOKENRING
;
8436 if_num
= tr_count
++;
8438 case MIB_IF_TYPE_FDDI
:
8440 if_num
= fddi_count
++;
8442 case MIB_IF_TYPE_PPP
:
8444 if_num
= ppp_count
++;
8446 case MIB_IF_TYPE_SLIP
:
8448 if_num
= sl_count
++;
8450 case IF_TYPE_IEEE80211
:
8452 if_num
= wlan_count
++;
8454 case MIB_IF_TYPE_LOOPBACK
:
8457 ifmt_idx
= LOOPBACK
;
8458 if_num
= lo_count
++;
8464 ifmt_idx
= OTHER_IF
;
8465 if_num
= ifx_count
++;
8468 if (ifmt_idx
== NONE
)
8470 sprintf (namebuf
, ifmt
[ifmt_idx
], if_num
);
8472 sa
.sin_family
= AF_INET
;
8473 ip_addr
= sys_inet_addr (adapter
->IpAddressList
.IpAddress
.String
);
8474 if (ip_addr
== INADDR_NONE
)
8476 /* Bogus address, skip this interface. */
8479 sa
.sin_addr
.s_addr
= ip_addr
;
8482 res
= Fcons (Fcons (build_string (namebuf
),
8483 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8484 sizeof (struct sockaddr
))),
8486 else if (strcmp (namebuf
, SSDATA (ifname
)) == 0)
8488 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
8489 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
8490 Lisp_Object flags
= Qnil
;
8494 /* Flags. We guess most of them by type, since the
8495 Windows flags are different and hard to get by. */
8496 flags
= Fcons (intern ("up"), flags
);
8497 if (ifmt_idx
== ETHERNET
|| ifmt_idx
== WLAN
)
8499 flags
= Fcons (intern ("broadcast"), flags
);
8500 flags
= Fcons (intern ("multicast"), flags
);
8502 flags
= Fcons (intern ("running"), flags
);
8503 if (ifmt_idx
== PPP
)
8505 flags
= Fcons (intern ("pointopoint"), flags
);
8506 flags
= Fcons (intern ("noarp"), flags
);
8508 if (adapter
->HaveWins
)
8509 flags
= Fcons (intern ("WINS"), flags
);
8510 if (adapter
->DhcpEnabled
)
8511 flags
= Fcons (intern ("dynamic"), flags
);
8513 res
= Fcons (flags
, res
);
8515 /* Hardware address and its family. */
8516 for (n
= 0; n
< adapter
->AddressLength
; n
++)
8517 p
->contents
[n
] = make_number ((int) adapter
->Address
[n
]);
8518 /* Windows does not support AF_LINK or AF_PACKET family
8519 of addresses. Use an arbitrary family number that is
8520 identical to what GNU/Linux returns. */
8521 res
= Fcons (Fcons (make_number (1), hwaddr
), res
);
8524 sa
.sin_family
= AF_INET
;
8525 net_mask
= sys_inet_addr (adapter
->IpAddressList
.IpMask
.String
);
8526 if (net_mask
!= INADDR_NONE
)
8528 sa
.sin_addr
.s_addr
= net_mask
;
8530 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8531 sizeof (struct sockaddr
)),
8535 res
= Fcons (Qnil
, res
);
8537 sa
.sin_family
= AF_INET
;
8538 if (ip_addr
!= INADDR_NONE
)
8540 /* Broadcast address is only reported by
8541 GetAdaptersAddresses, which is of limited
8542 availability. Generate it on our own. */
8543 u_long bcast_addr
= (ip_addr
& net_mask
) | ~net_mask
;
8545 sa
.sin_addr
.s_addr
= bcast_addr
;
8547 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8548 sizeof (struct sockaddr
)),
8552 sa
.sin_addr
.s_addr
= ip_addr
;
8554 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8555 sizeof (struct sockaddr
)),
8559 res
= Fcons (Qnil
, Fcons (Qnil
, res
));
8562 /* GetAdaptersInfo is documented to not report loopback
8563 interfaces, so we generate one out of thin air. */
8566 sa
.sin_family
= AF_INET
;
8570 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8571 res
= Fcons (Fcons (build_string ("lo"),
8572 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8573 sizeof (struct sockaddr
))),
8576 else if (strcmp (SSDATA (ifname
), "lo") == 0)
8578 res
= Fcons (Fcons (intern ("running"),
8579 Fcons (intern ("loopback"),
8580 Fcons (intern ("up"), Qnil
))), Qnil
);
8581 /* 772 is what 3 different GNU/Linux systems report for
8582 the loopback interface. */
8583 res
= Fcons (Fcons (make_number (772),
8584 Fmake_vector (make_number (6),
8587 sa
.sin_addr
.s_addr
= sys_inet_addr ("255.0.0.0");
8588 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8589 sizeof (struct sockaddr
)),
8591 sa
.sin_addr
.s_addr
= sys_inet_addr ("0.0.0.0");
8592 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8593 sizeof (struct sockaddr
)),
8595 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8596 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8597 sizeof (struct sockaddr
)),
8610 network_interface_list (void)
8612 return network_interface_get_info (Qnil
);
8616 network_interface_info (Lisp_Object ifname
)
8618 return network_interface_get_info (ifname
);
8622 /* The Windows CRT functions are "optimized for speed", so they don't
8623 check for timezone and DST changes if they were last called less
8624 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
8625 all Emacs features that repeatedly call time functions (e.g.,
8626 display-time) are in real danger of missing timezone and DST
8627 changes. Calling tzset before each localtime call fixes that. */
8629 sys_localtime (const time_t *t
)
8632 return localtime (t
);
8637 /* Try loading LIBRARY_ID from the file(s) specified in
8638 Vdynamic_library_alist. If the library is loaded successfully,
8639 return the handle of the DLL, and record the filename in the
8640 property :loaded-from of LIBRARY_ID. If the library could not be
8641 found, or when it was already loaded (because the handle is not
8642 recorded anywhere, and so is lost after use), return NULL.
8644 We could also save the handle in :loaded-from, but currently
8645 there's no use case for it. */
8647 w32_delayed_load (Lisp_Object library_id
)
8649 HMODULE dll_handle
= NULL
;
8651 CHECK_SYMBOL (library_id
);
8653 if (CONSP (Vdynamic_library_alist
)
8654 && NILP (Fassq (library_id
, Vlibrary_cache
)))
8656 Lisp_Object found
= Qnil
;
8657 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
8660 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
8662 Lisp_Object dll
= XCAR (dlls
);
8663 char name
[MAX_UTF8_PATH
];
8667 dll
= ENCODE_FILE (dll
);
8668 if (w32_unicode_filenames
)
8670 wchar_t name_w
[MAX_PATH
];
8672 filename_to_utf16 (SSDATA (dll
), name_w
);
8673 dll_handle
= LoadLibraryW (name_w
);
8676 res
= GetModuleFileNameW (dll_handle
, name_w
,
8679 filename_from_utf16 (name_w
, name
);
8684 char name_a
[MAX_PATH
];
8686 filename_to_ansi (SSDATA (dll
), name_a
);
8687 dll_handle
= LoadLibraryA (name_a
);
8690 res
= GetModuleFileNameA (dll_handle
, name_a
,
8693 filename_from_ansi (name_a
, name
);
8698 ptrdiff_t len
= strlen (name
);
8701 /* Possibly truncated */
8702 ? make_specified_string (name
, -1, len
, 1)
8704 /* This prevents thread start and end notifications
8705 from being sent to the DLL, for every thread we
8706 start. We don't need those notifications because
8707 threads we create never use any of these DLLs, only
8708 the main thread uses them. This is supposed to
8709 speed up thread creation. */
8710 DisableThreadLibraryCalls (dll_handle
);
8715 Fput (library_id
, QCloaded_from
, found
);
8723 check_windows_init_file (void)
8725 /* A common indication that Emacs is not installed properly is when
8726 it cannot find the Windows installation file. If this file does
8727 not exist in the expected place, tell the user. */
8729 if (!noninteractive
&& !inhibit_window_system
8730 /* Vload_path is not yet initialized when we are loading
8732 && NILP (Vpurify_flag
))
8734 Lisp_Object init_file
;
8737 /* Implementation note: this function runs early during Emacs
8738 startup, before startup.el is run. So Vload_path is still in
8739 its initial unibyte form, but it holds UTF-8 encoded file
8740 names, since init_callproc was already called. So we do not
8741 need to ENCODE_FILE here, but we do need to convert the file
8742 names from UTF-8 to ANSI. */
8743 init_file
= build_string ("term/w32-win");
8744 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
, 0);
8747 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
8748 char *init_file_name
= SDATA (init_file
);
8749 char *load_path
= SDATA (load_path_print
);
8750 char *buffer
= alloca (1024
8751 + strlen (init_file_name
)
8752 + strlen (load_path
));
8757 "The Emacs Windows initialization file \"%s.el\" "
8758 "could not be found in your Emacs installation. "
8759 "Emacs checked the following directories for this file:\n"
8761 "When Emacs cannot find this file, it usually means that it "
8762 "was not installed properly, or its distribution file was "
8763 "not unpacked properly.\nSee the README.W32 file in the "
8764 "top-level Emacs directory for more information.",
8765 init_file_name
, load_path
);
8766 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
,
8770 wchar_t *msg_w
= alloca ((needed
+ 1) * sizeof (wchar_t));
8772 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
, -1,
8774 needed
= pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1,
8775 NULL
, 0, NULL
, NULL
);
8778 char *msg_a
= alloca (needed
+ 1);
8780 pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1, msg_a
, needed
,
8787 "Emacs Abort Dialog",
8788 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
8789 /* Use the low-level system abort. */
8800 term_ntproc (int ignored
)
8806 /* shutdown the socket interface if necessary */
8813 init_ntproc (int dumping
)
8815 sigset_t initial_mask
= 0;
8817 /* Initialize the socket interface now if available and requested by
8818 the user by defining PRELOAD_WINSOCK; otherwise loading will be
8819 delayed until open-network-stream is called (w32-has-winsock can
8820 also be used to dynamically load or reload winsock).
8822 Conveniently, init_environment is called before us, so
8823 PRELOAD_WINSOCK can be set in the registry. */
8825 /* Always initialize this correctly. */
8828 if (getenv ("PRELOAD_WINSOCK") != NULL
)
8829 init_winsock (TRUE
);
8831 /* Initial preparation for subprocess support: replace our standard
8832 handles with non-inheritable versions. */
8835 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
8836 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
8837 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
8839 parent
= GetCurrentProcess ();
8841 /* ignore errors when duplicating and closing; typically the
8842 handles will be invalid when running as a gui program. */
8843 DuplicateHandle (parent
,
8844 GetStdHandle (STD_INPUT_HANDLE
),
8849 DUPLICATE_SAME_ACCESS
);
8851 DuplicateHandle (parent
,
8852 GetStdHandle (STD_OUTPUT_HANDLE
),
8857 DUPLICATE_SAME_ACCESS
);
8859 DuplicateHandle (parent
,
8860 GetStdHandle (STD_ERROR_HANDLE
),
8865 DUPLICATE_SAME_ACCESS
);
8871 if (stdin_save
!= INVALID_HANDLE_VALUE
)
8872 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
8874 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
8877 if (stdout_save
!= INVALID_HANDLE_VALUE
)
8878 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
8880 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8883 if (stderr_save
!= INVALID_HANDLE_VALUE
)
8884 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
8886 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8890 /* unfortunately, atexit depends on implementation of malloc */
8891 /* atexit (term_ntproc); */
8894 /* Make sure we start with all signals unblocked. */
8895 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
8896 signal (SIGABRT
, term_ntproc
);
8900 /* determine which drives are fixed, for GetCachedVolumeInformation */
8902 /* GetDriveType must have trailing backslash. */
8903 char drive
[] = "A:\\";
8905 /* Loop over all possible drive letters */
8906 while (*drive
<= 'Z')
8908 /* Record if this drive letter refers to a fixed drive. */
8909 fixed_drives
[DRIVE_INDEX (*drive
)] =
8910 (GetDriveType (drive
) == DRIVE_FIXED
);
8915 /* Reset the volume info cache. */
8916 volume_cache
= NULL
;
8921 shutdown_handler ensures that buffers' autosave files are
8922 up to date when the user logs off, or the system shuts down.
8925 shutdown_handler (DWORD type
)
8927 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
8928 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
8929 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
8930 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
8932 /* Shut down cleanly, making sure autosave files are up to date. */
8933 shut_down_emacs (0, Qnil
);
8936 /* Allow other handlers to handle this signal. */
8940 /* On Windows 9X, load UNICOWS.DLL and return its handle, or die. On
8941 NT, return a handle to GDI32.DLL. */
8943 maybe_load_unicows_dll (void)
8945 if (os_subtype
== OS_9X
)
8947 HANDLE ret
= LoadLibrary ("Unicows.dll");
8950 /* These two functions are present on Windows 9X as stubs
8951 that always fail. We need the real implementations from
8952 UNICOWS.DLL, so we must call these functions through
8953 pointers, and assign the correct addresses to these
8954 pointers at program startup (see emacs.c, which calls
8955 this function early on). */
8956 pMultiByteToWideChar
= GetProcAddress (ret
, "MultiByteToWideChar");
8957 pWideCharToMultiByte
= GetProcAddress (ret
, "WideCharToMultiByte");
8964 button
= MessageBox (NULL
,
8965 "Emacs cannot load the UNICOWS.DLL library.\n"
8966 "This library is essential for using Emacs\n"
8967 "on this system. You need to install it.\n\n"
8968 "Emacs will exit when you click OK.",
8969 "Emacs cannot load UNICOWS.DLL",
8970 MB_ICONERROR
| MB_TASKMODAL
8971 | MB_SETFOREGROUND
| MB_OK
);
8982 /* On NT family of Windows, these two functions are always
8983 linked in, so we just assign their addresses to the 2
8984 pointers; no need for the LoadLibrary dance. */
8985 pMultiByteToWideChar
= MultiByteToWideChar
;
8986 pWideCharToMultiByte
= WideCharToMultiByte
;
8987 return LoadLibrary ("Gdi32.dll");
8992 globals_of_w32 is used to initialize those global variables that
8993 must always be initialized on startup even when the global variable
8994 initialized is non zero (see the function main in emacs.c).
8997 globals_of_w32 (void)
8999 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
9001 get_process_times_fn
= (GetProcessTimes_Proc
)
9002 GetProcAddress (kernel32
, "GetProcessTimes");
9004 DEFSYM (QCloaded_from
, ":loaded-from");
9006 g_b_init_is_windows_9x
= 0;
9007 g_b_init_open_process_token
= 0;
9008 g_b_init_get_token_information
= 0;
9009 g_b_init_lookup_account_sid
= 0;
9010 g_b_init_get_sid_sub_authority
= 0;
9011 g_b_init_get_sid_sub_authority_count
= 0;
9012 g_b_init_get_security_info
= 0;
9013 g_b_init_get_file_security_w
= 0;
9014 g_b_init_get_file_security_a
= 0;
9015 g_b_init_get_security_descriptor_owner
= 0;
9016 g_b_init_get_security_descriptor_group
= 0;
9017 g_b_init_is_valid_sid
= 0;
9018 g_b_init_create_toolhelp32_snapshot
= 0;
9019 g_b_init_process32_first
= 0;
9020 g_b_init_process32_next
= 0;
9021 g_b_init_open_thread_token
= 0;
9022 g_b_init_impersonate_self
= 0;
9023 g_b_init_revert_to_self
= 0;
9024 g_b_init_get_process_memory_info
= 0;
9025 g_b_init_get_process_working_set_size
= 0;
9026 g_b_init_global_memory_status
= 0;
9027 g_b_init_global_memory_status_ex
= 0;
9028 g_b_init_equal_sid
= 0;
9029 g_b_init_copy_sid
= 0;
9030 g_b_init_get_length_sid
= 0;
9031 g_b_init_get_native_system_info
= 0;
9032 g_b_init_get_system_times
= 0;
9033 g_b_init_create_symbolic_link_w
= 0;
9034 g_b_init_create_symbolic_link_a
= 0;
9035 g_b_init_get_security_descriptor_dacl
= 0;
9036 g_b_init_convert_sd_to_sddl
= 0;
9037 g_b_init_convert_sddl_to_sd
= 0;
9038 g_b_init_is_valid_security_descriptor
= 0;
9039 g_b_init_set_file_security_w
= 0;
9040 g_b_init_set_file_security_a
= 0;
9041 g_b_init_set_named_security_info_w
= 0;
9042 g_b_init_set_named_security_info_a
= 0;
9043 g_b_init_get_adapters_info
= 0;
9044 num_of_processors
= 0;
9045 /* The following sets a handler for shutdown notifications for
9046 console apps. This actually applies to Emacs in both console and
9047 GUI modes, since we had to fool windows into thinking emacs is a
9048 console application to get console mode to work. */
9049 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
9051 /* "None" is the default group name on standalone workstations. */
9052 strcpy (dflt_group_name
, "None");
9054 /* Reset, in case it has some value inherited from dump time. */
9055 w32_stat_get_owner_group
= 0;
9057 /* If w32_unicode_filenames is non-zero, we will be using Unicode
9058 (a.k.a. "wide") APIs to invoke functions that accept file
9060 if (is_windows_9x ())
9061 w32_unicode_filenames
= 0;
9063 w32_unicode_filenames
= 1;
9066 /* For make-serial-process */
9068 serial_open (Lisp_Object port_obj
)
9070 char *port
= SSDATA (port_obj
);
9075 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
9076 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
9077 if (hnd
== INVALID_HANDLE_VALUE
)
9078 error ("Could not open %s", port
);
9079 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
9081 error ("Could not open %s", port
);
9085 error ("Could not create child process");
9087 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
9088 fd_info
[ fd
].hnd
= hnd
;
9089 fd_info
[ fd
].flags
|=
9090 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
9091 if (fd_info
[ fd
].cp
!= NULL
)
9093 error ("fd_info[fd = %d] is already in use", fd
);
9095 fd_info
[ fd
].cp
= cp
;
9096 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9097 if (cp
->ovl_read
.hEvent
== NULL
)
9098 error ("Could not create read event");
9099 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9100 if (cp
->ovl_write
.hEvent
== NULL
)
9101 error ("Could not create write event");
9106 /* For serial-process-configure */
9108 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
9110 Lisp_Object childp2
= Qnil
;
9111 Lisp_Object tem
= Qnil
;
9115 char summary
[4] = "???"; /* This usually becomes "8N1". */
9117 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
9118 error ("Not a serial process");
9119 hnd
= fd_info
[ p
->outfd
].hnd
;
9121 childp2
= Fcopy_sequence (p
->childp
);
9123 /* Initialize timeouts for blocking read and blocking write. */
9124 if (!GetCommTimeouts (hnd
, &ct
))
9125 error ("GetCommTimeouts() failed");
9126 ct
.ReadIntervalTimeout
= 0;
9127 ct
.ReadTotalTimeoutMultiplier
= 0;
9128 ct
.ReadTotalTimeoutConstant
= 0;
9129 ct
.WriteTotalTimeoutMultiplier
= 0;
9130 ct
.WriteTotalTimeoutConstant
= 0;
9131 if (!SetCommTimeouts (hnd
, &ct
))
9132 error ("SetCommTimeouts() failed");
9133 /* Read port attributes and prepare default configuration. */
9134 memset (&dcb
, 0, sizeof (dcb
));
9135 dcb
.DCBlength
= sizeof (DCB
);
9136 if (!GetCommState (hnd
, &dcb
))
9137 error ("GetCommState() failed");
9140 dcb
.fAbortOnError
= FALSE
;
9141 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
9146 /* Configure speed. */
9147 if (!NILP (Fplist_member (contact
, QCspeed
)))
9148 tem
= Fplist_get (contact
, QCspeed
);
9150 tem
= Fplist_get (p
->childp
, QCspeed
);
9152 dcb
.BaudRate
= XINT (tem
);
9153 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
9155 /* Configure bytesize. */
9156 if (!NILP (Fplist_member (contact
, QCbytesize
)))
9157 tem
= Fplist_get (contact
, QCbytesize
);
9159 tem
= Fplist_get (p
->childp
, QCbytesize
);
9161 tem
= make_number (8);
9163 if (XINT (tem
) != 7 && XINT (tem
) != 8)
9164 error (":bytesize must be nil (8), 7, or 8");
9165 dcb
.ByteSize
= XINT (tem
);
9166 summary
[0] = XINT (tem
) + '0';
9167 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
9169 /* Configure parity. */
9170 if (!NILP (Fplist_member (contact
, QCparity
)))
9171 tem
= Fplist_get (contact
, QCparity
);
9173 tem
= Fplist_get (p
->childp
, QCparity
);
9174 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
9175 error (":parity must be nil (no parity), `even', or `odd'");
9176 dcb
.fParity
= FALSE
;
9177 dcb
.Parity
= NOPARITY
;
9178 dcb
.fErrorChar
= FALSE
;
9183 else if (EQ (tem
, Qeven
))
9187 dcb
.Parity
= EVENPARITY
;
9188 dcb
.fErrorChar
= TRUE
;
9190 else if (EQ (tem
, Qodd
))
9194 dcb
.Parity
= ODDPARITY
;
9195 dcb
.fErrorChar
= TRUE
;
9197 childp2
= Fplist_put (childp2
, QCparity
, tem
);
9199 /* Configure stopbits. */
9200 if (!NILP (Fplist_member (contact
, QCstopbits
)))
9201 tem
= Fplist_get (contact
, QCstopbits
);
9203 tem
= Fplist_get (p
->childp
, QCstopbits
);
9205 tem
= make_number (1);
9207 if (XINT (tem
) != 1 && XINT (tem
) != 2)
9208 error (":stopbits must be nil (1 stopbit), 1, or 2");
9209 summary
[2] = XINT (tem
) + '0';
9210 if (XINT (tem
) == 1)
9211 dcb
.StopBits
= ONESTOPBIT
;
9212 else if (XINT (tem
) == 2)
9213 dcb
.StopBits
= TWOSTOPBITS
;
9214 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
9216 /* Configure flowcontrol. */
9217 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
9218 tem
= Fplist_get (contact
, QCflowcontrol
);
9220 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
9221 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
9222 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
9223 dcb
.fOutxCtsFlow
= FALSE
;
9224 dcb
.fOutxDsrFlow
= FALSE
;
9225 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
9226 dcb
.fDsrSensitivity
= FALSE
;
9227 dcb
.fTXContinueOnXoff
= FALSE
;
9230 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
9231 dcb
.XonChar
= 17; /* Control-Q */
9232 dcb
.XoffChar
= 19; /* Control-S */
9235 /* Already configured. */
9237 else if (EQ (tem
, Qhw
))
9239 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
9240 dcb
.fOutxCtsFlow
= TRUE
;
9242 else if (EQ (tem
, Qsw
))
9247 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
9249 /* Activate configuration. */
9250 if (!SetCommState (hnd
, &dcb
))
9251 error ("SetCommState() failed");
9253 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
9254 pset_childp (p
, childp2
);
9260 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
9263 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9264 int fd
= process
->infd
;
9266 n
= sys_read (fd
, (char*)buf
, sz
);
9273 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9274 if (err
== EWOULDBLOCK
)
9277 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
9283 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
9285 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9286 int fd
= process
->outfd
;
9287 ssize_t n
= sys_write (fd
, buf
, sz
);
9289 /* 0 or more bytes written means everything went fine. */
9293 /* Negative bytes written means we got an error in errno.
9294 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9295 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
9296 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
9300 #endif /* HAVE_GNUTLS */