1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1994-1995, 2000-2015 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 defines these in its _mingw.h. */
76 #if defined(__GNUC__) && !defined(MINGW_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(MINGW_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
= sizeof (samples
) / sizeof (samples
[0]);
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
);
2391 encoded_filename
= build_unibyte_string (fname
);
2394 encoded_filename
= build_unibyte_string (fname
);
2395 return encoded_filename
;
2399 is_unc_volume (const char *filename
)
2401 const char *ptr
= filename
;
2403 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
2406 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
2412 /* Emulate the Posix unsetenv. */
2414 unsetenv (const char *name
)
2420 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
2425 name_len
= strlen (name
);
2426 /* MS docs says an environment variable cannot be longer than 32K. */
2427 if (name_len
> 32767)
2432 /* It is safe to use 'alloca' with 32K size, since the stack is at
2433 least 2MB, and we set it to 8MB in the link command line. */
2434 var
= alloca (name_len
+ 2);
2435 strncpy (var
, name
, name_len
);
2436 var
[name_len
++] = '=';
2437 var
[name_len
] = '\0';
2438 return _putenv (var
);
2441 /* MS _putenv doesn't support removing a variable when the argument
2442 does not include the '=' character, so we fix that here. */
2444 sys_putenv (char *str
)
2446 const char *const name_end
= strchr (str
, '=');
2448 if (name_end
== NULL
)
2450 /* Remove the variable from the environment. */
2451 return unsetenv (str
);
2454 return _putenv (str
);
2457 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
2460 w32_get_resource (char *key
, LPDWORD lpdwtype
)
2463 HKEY hrootkey
= NULL
;
2466 /* Check both the current user and the local machine to see if
2467 we have any resources. */
2469 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2473 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2474 && (lpvalue
= xmalloc (cbData
)) != NULL
2475 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2477 RegCloseKey (hrootkey
);
2483 RegCloseKey (hrootkey
);
2486 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2490 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2491 && (lpvalue
= xmalloc (cbData
)) != NULL
2492 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2494 RegCloseKey (hrootkey
);
2500 RegCloseKey (hrootkey
);
2506 /* The argv[] array holds ANSI-encoded strings, and so this function
2507 works with ANS_encoded strings. */
2509 init_environment (char ** argv
)
2511 static const char * const tempdirs
[] = {
2512 "$TMPDIR", "$TEMP", "$TMP", "c:/"
2517 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
2519 /* Implementation note: This function explicitly works with ANSI
2520 file names, not with UTF-8 encoded file names. This is because
2521 this function pushes variables into the Emacs's environment, and
2522 the environment variables are always assumed to be in the
2523 locale-specific encoding. Do NOT call any functions that accept
2524 UTF-8 file names from this function! */
2526 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
2527 temporary files and assume "/tmp" if $TMPDIR is unset, which
2528 will break on DOS/Windows. Refuse to work if we cannot find
2529 a directory, not even "c:/", usable for that purpose. */
2530 for (i
= 0; i
< imax
; i
++)
2532 const char *tmp
= tempdirs
[i
];
2535 tmp
= getenv (tmp
+ 1);
2536 /* Note that `access' can lie to us if the directory resides on a
2537 read-only filesystem, like CD-ROM or a write-protected floppy.
2538 The only way to be really sure is to actually create a file and
2539 see if it succeeds. But I think that's too much to ask. */
2541 /* MSVCRT's _access crashes with D_OK, so we use our replacement. */
2542 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
2544 char * var
= alloca (strlen (tmp
) + 8);
2545 sprintf (var
, "TMPDIR=%s", tmp
);
2546 _putenv (strdup (var
));
2553 Fcons (build_string ("no usable temporary directories found!!"),
2555 "While setting TMPDIR: ");
2557 /* Check for environment variables and use registry settings if they
2558 don't exist. Fallback on default values where applicable. */
2563 char locale_name
[32];
2564 char default_home
[MAX_PATH
];
2567 static const struct env_entry
2573 /* If the default value is NULL, we will use the value from the
2574 outside environment or the Registry, but will not push the
2575 variable into the Emacs environment if it is defined neither
2576 in the Registry nor in the outside environment. */
2578 {"PRELOAD_WINSOCK", NULL
},
2579 {"emacs_dir", "C:/emacs"},
2580 {"EMACSLOADPATH", NULL
},
2581 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2582 {"EMACSDATA", NULL
},
2583 {"EMACSPATH", NULL
},
2590 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2592 /* We need to copy dflt_envvars[] and work on the copy because we
2593 don't want the dumped Emacs to inherit the values of
2594 environment variables we saw during dumping (which could be on
2595 a different system). The defaults above must be left intact. */
2596 struct env_entry env_vars
[N_ENV_VARS
];
2598 for (i
= 0; i
< N_ENV_VARS
; i
++)
2599 env_vars
[i
] = dflt_envvars
[i
];
2601 /* For backwards compatibility, check if a .emacs file exists in C:/
2602 If not, then we can try to default to the appdata directory under the
2603 user's profile, which is more likely to be writable. */
2604 if (sys_access ("C:/.emacs", F_OK
) != 0)
2606 HRESULT profile_result
;
2607 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2608 of Windows 95 and NT4 that have not been updated to include
2610 ShGetFolderPath_fn get_folder_path
;
2611 get_folder_path
= (ShGetFolderPath_fn
)
2612 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2614 if (get_folder_path
!= NULL
)
2616 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2619 /* If we can't get the appdata dir, revert to old behavior. */
2620 if (profile_result
== S_OK
)
2622 env_vars
[0].def_value
= default_home
;
2628 /* Get default locale info and use it for LANG. */
2629 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2630 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2631 locale_name
, sizeof (locale_name
)))
2633 for (i
= 0; i
< N_ENV_VARS
; i
++)
2635 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2637 env_vars
[i
].def_value
= locale_name
;
2643 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2645 /* Treat emacs_dir specially: set it unconditionally based on our
2649 char modname
[MAX_PATH
];
2651 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2653 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2657 if ((p
= _mbsrchr (modname
, '\\'))
2658 /* From bin means installed Emacs, from src means uninstalled. */
2659 && (xstrcasecmp (p
, "\\bin") == 0 || xstrcasecmp (p
, "\\src") == 0))
2661 char buf
[SET_ENV_BUF_SIZE
];
2662 int within_build_tree
= xstrcasecmp (p
, "\\src") == 0;
2665 for (p
= modname
; *p
; p
= CharNext (p
))
2666 if (*p
== '\\') *p
= '/';
2668 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2669 _putenv (strdup (buf
));
2670 /* If we are running from the Posix-like build tree, define
2671 SHELL to point to our own cmdproxy. The loop below will
2672 then disregard PATH_EXEC and the default value. */
2673 if (within_build_tree
)
2675 _snprintf (buf
, sizeof (buf
) - 1,
2676 "SHELL=%s/nt/cmdproxy.exe", modname
);
2677 _putenv (strdup (buf
));
2682 for (i
= 0; i
< N_ENV_VARS
; i
++)
2684 if (!getenv (env_vars
[i
].name
))
2687 char bufc
[SET_ENV_BUF_SIZE
];
2689 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2690 /* Also ignore empty environment variables. */
2695 if (strcmp (env_vars
[i
].name
, "SHELL") == 0)
2697 /* Look for cmdproxy.exe in every directory in
2698 PATH_EXEC. FIXME: This does not find cmdproxy
2699 in nt/ when we run uninstalled. */
2700 char fname
[MAX_PATH
];
2701 const char *pstart
= PATH_EXEC
, *pend
;
2704 pend
= _mbschr (pstart
, ';');
2706 pend
= pstart
+ strlen (pstart
);
2707 /* Be defensive against series of ;;; characters. */
2710 strncpy (fname
, pstart
, pend
- pstart
);
2711 fname
[pend
- pstart
] = '/';
2712 strcpy (&fname
[pend
- pstart
+ 1], "cmdproxy.exe");
2713 ExpandEnvironmentStrings ((LPSTR
) fname
, bufc
,
2715 if (sys_access (bufc
, F_OK
) == 0)
2728 /* If not found in any directory, use the
2729 default as the last resort. */
2730 lpval
= env_vars
[i
].def_value
;
2731 dwType
= REG_EXPAND_SZ
;
2737 lpval
= env_vars
[i
].def_value
;
2738 dwType
= REG_EXPAND_SZ
;
2740 if (strcmp (env_vars
[i
].name
, "HOME") == 0 && !appdata
)
2741 Vdelayed_warnings_list
2742 = Fcons (listn (CONSTYPE_HEAP
, 2,
2743 intern ("initialization"),
2744 build_string ("Setting HOME to C:\\ by default is deprecated")),
2745 Vdelayed_warnings_list
);
2750 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2752 if (dwType
== REG_EXPAND_SZ
)
2753 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2754 else if (dwType
== REG_SZ
)
2755 strcpy (buf1
, lpval
);
2756 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2758 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2760 _putenv (strdup (buf2
));
2770 /* Rebuild system configuration to reflect invoking system. */
2771 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2773 /* Another special case: on NT, the PATH variable is actually named
2774 "Path" although cmd.exe (perhaps NT itself) arranges for
2775 environment variable lookup and setting to be case insensitive.
2776 However, Emacs assumes a fully case sensitive environment, so we
2777 need to change "Path" to "PATH" to match the expectations of
2778 various elisp packages. We do this by the sneaky method of
2779 modifying the string in the C runtime environ entry.
2781 The same applies to COMSPEC. */
2785 for (envp
= environ
; *envp
; envp
++)
2786 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2787 memcpy (*envp
, "PATH=", 5);
2788 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2789 memcpy (*envp
, "COMSPEC=", 8);
2792 /* Remember the initial working directory for getcwd. */
2793 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2794 Does it matter anywhere in Emacs? */
2795 if (w32_unicode_filenames
)
2797 wchar_t wstartup_dir
[MAX_PATH
];
2799 if (!GetCurrentDirectoryW (MAX_PATH
, wstartup_dir
))
2801 filename_from_utf16 (wstartup_dir
, startup_dir
);
2805 char astartup_dir
[MAX_PATH
];
2807 if (!GetCurrentDirectoryA (MAX_PATH
, astartup_dir
))
2809 filename_from_ansi (astartup_dir
, startup_dir
);
2813 static char modname
[MAX_PATH
];
2815 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2820 /* Determine if there is a middle mouse button, to allow parse_button
2821 to decide whether right mouse events should be mouse-2 or
2823 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2828 /* Called from expand-file-name when default-directory is not a string. */
2831 emacs_root_dir (void)
2833 static char root_dir
[MAX_UTF8_PATH
];
2836 p
= getenv ("emacs_dir");
2839 filename_from_ansi (p
, root_dir
);
2840 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2841 dostounix_filename (root_dir
);
2845 #include <sys/timeb.h>
2847 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2849 gettimeofday (struct timeval
*__restrict tv
, struct timezone
*__restrict tz
)
2854 tv
->tv_sec
= tb
.time
;
2855 tv
->tv_usec
= tb
.millitm
* 1000L;
2856 /* Implementation note: _ftime sometimes doesn't update the dstflag
2857 according to the new timezone when the system timezone is
2858 changed. We could fix that by using GetSystemTime and
2859 GetTimeZoneInformation, but that doesn't seem necessary, since
2860 Emacs always calls gettimeofday with the 2nd argument NULL (see
2861 current_emacs_time). */
2864 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2865 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2870 /* Emulate fdutimens. */
2872 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2873 TIMESPEC[0] and TIMESPEC[1], respectively.
2874 FD must be either negative -- in which case it is ignored --
2875 or a file descriptor that is open on FILE.
2876 If FD is nonnegative, then FILE can be NULL, which means
2877 use just futimes instead of utimes.
2878 If TIMESPEC is null, FAIL.
2879 Return 0 on success, -1 (setting errno) on failure. */
2882 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2889 if (fd
< 0 && !file
)
2894 /* _futime's prototype defines 2nd arg as having the type 'struct
2895 _utimbuf', while utime needs to accept 'struct utimbuf' for
2896 compatibility with Posix. So we need to use 2 different (but
2897 equivalent) types to avoid compiler warnings, sigh. */
2900 struct _utimbuf _ut
;
2902 _ut
.actime
= timespec
[0].tv_sec
;
2903 _ut
.modtime
= timespec
[1].tv_sec
;
2904 return _futime (fd
, &_ut
);
2910 ut
.actime
= timespec
[0].tv_sec
;
2911 ut
.modtime
= timespec
[1].tv_sec
;
2912 /* Call 'utime', which is implemented below, not the MS library
2913 function, which fails on directories. */
2914 return utime (file
, &ut
);
2919 /* ------------------------------------------------------------------------- */
2920 /* IO support and wrapper functions for the Windows API. */
2921 /* ------------------------------------------------------------------------- */
2923 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2924 on network directories, so we handle that case here.
2925 (Ulrich Leodolter, 1/11/95). */
2927 sys_ctime (const time_t *t
)
2929 char *str
= (char *) ctime (t
);
2930 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2933 /* Emulate sleep...we could have done this with a define, but that
2934 would necessitate including windows.h in the files that used it.
2935 This is much easier. */
2937 sys_sleep (int seconds
)
2939 Sleep (seconds
* 1000);
2942 /* Internal MSVC functions for low-level descriptor munging */
2943 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2944 extern int __cdecl
_free_osfhnd (int fd
);
2946 /* parallel array of private info on file handles */
2947 filedesc fd_info
[ MAXDESC
];
2949 typedef struct volume_info_data
{
2950 struct volume_info_data
* next
;
2952 /* time when info was obtained */
2955 /* actual volume info */
2964 /* Global referenced by various functions. */
2965 static volume_info_data volume_info
;
2967 /* Vector to indicate which drives are local and fixed (for which cached
2968 data never expires). */
2969 static BOOL fixed_drives
[26];
2971 /* Consider cached volume information to be stale if older than 10s,
2972 at least for non-local drives. Info for fixed drives is never stale. */
2973 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2974 #define VOLINFO_STILL_VALID( root_dir, info ) \
2975 ( ( isalpha (root_dir[0]) && \
2976 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2977 || GetTickCount () - info->timestamp < 10000 )
2979 /* Cache support functions. */
2981 /* Simple linked list with linear search is sufficient. */
2982 static volume_info_data
*volume_cache
= NULL
;
2984 static volume_info_data
*
2985 lookup_volume_info (char * root_dir
)
2987 volume_info_data
* info
;
2989 for (info
= volume_cache
; info
; info
= info
->next
)
2990 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2996 add_volume_info (char * root_dir
, volume_info_data
* info
)
2998 info
->root_dir
= xstrdup (root_dir
);
2999 unixtodos_filename (info
->root_dir
);
3000 info
->next
= volume_cache
;
3001 volume_cache
= info
;
3005 /* Wrapper for GetVolumeInformation, which uses caching to avoid
3006 performance penalty (~2ms on 486 for local drives, 7.5ms for local
3007 cdrom drive, ~5-10ms or more for remote drives on LAN). */
3008 static volume_info_data
*
3009 GetCachedVolumeInformation (char * root_dir
)
3011 volume_info_data
* info
;
3012 char default_root
[ MAX_UTF8_PATH
];
3013 char name
[MAX_PATH
+1];
3014 char type
[MAX_PATH
+1];
3016 /* NULL for root_dir means use root from current directory. */
3017 if (root_dir
== NULL
)
3019 if (w32_unicode_filenames
)
3021 wchar_t curdirw
[MAX_PATH
];
3023 if (GetCurrentDirectoryW (MAX_PATH
, curdirw
) == 0)
3025 filename_from_utf16 (curdirw
, default_root
);
3029 char curdira
[MAX_PATH
];
3031 if (GetCurrentDirectoryA (MAX_PATH
, curdira
) == 0)
3033 filename_from_ansi (curdira
, default_root
);
3035 parse_root (default_root
, (const char **)&root_dir
);
3037 root_dir
= default_root
;
3040 /* Local fixed drives can be cached permanently. Removable drives
3041 cannot be cached permanently, since the volume name and serial
3042 number (if nothing else) can change. Remote drives should be
3043 treated as if they are removable, since there is no sure way to
3044 tell whether they are or not. Also, the UNC association of drive
3045 letters mapped to remote volumes can be changed at any time (even
3046 by other processes) without notice.
3048 As a compromise, so we can benefit from caching info for remote
3049 volumes, we use a simple expiry mechanism to invalidate cache
3050 entries that are more than ten seconds old. */
3053 /* No point doing this, because WNetGetConnection is even slower than
3054 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
3055 GetDriveType is about the only call of this type which does not
3056 involve network access, and so is extremely quick). */
3058 /* Map drive letter to UNC if remote. */
3059 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
3061 char remote_name
[ 256 ];
3062 char drive
[3] = { root_dir
[0], ':' };
3064 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
3066 /* do something */ ;
3070 info
= lookup_volume_info (root_dir
);
3072 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
3078 /* Info is not cached, or is stale. */
3079 if (w32_unicode_filenames
)
3081 wchar_t root_w
[MAX_PATH
];
3082 wchar_t name_w
[MAX_PATH
+1];
3083 wchar_t type_w
[MAX_PATH
+1];
3085 filename_to_utf16 (root_dir
, root_w
);
3086 if (!GetVolumeInformationW (root_w
,
3087 name_w
, sizeof (name_w
),
3091 type_w
, sizeof (type_w
)))
3093 /* Hmm... not really 100% correct, as these 2 are not file
3095 filename_from_utf16 (name_w
, name
);
3096 filename_from_utf16 (type_w
, type
);
3100 char root_a
[MAX_PATH
];
3101 char name_a
[MAX_PATH
+1];
3102 char type_a
[MAX_PATH
+1];
3104 filename_to_ansi (root_dir
, root_a
);
3105 if (!GetVolumeInformationA (root_a
,
3106 name_a
, sizeof (name_a
),
3110 type_a
, sizeof (type_a
)))
3112 filename_from_ansi (name_a
, name
);
3113 filename_from_ansi (type_a
, type
);
3116 /* Cache the volume information for future use, overwriting existing
3117 entry if present. */
3120 info
= xmalloc (sizeof (volume_info_data
));
3121 add_volume_info (root_dir
, info
);
3129 info
->name
= xstrdup (name
);
3130 unixtodos_filename (info
->name
);
3131 info
->serialnum
= serialnum
;
3132 info
->maxcomp
= maxcomp
;
3133 info
->flags
= flags
;
3134 info
->type
= xstrdup (type
);
3135 info
->timestamp
= GetTickCount ();
3141 /* Get information on the volume where NAME is held; set path pointer to
3142 start of pathname in NAME (past UNC header\volume header if present),
3143 if pPath is non-NULL.
3145 Note: if NAME includes symlinks, the information is for the volume
3146 of the symlink, not of its target. That's because, even though
3147 GetVolumeInformation returns information about the symlink target
3148 of its argument, we only pass the root directory to
3149 GetVolumeInformation, not the full NAME. */
3151 get_volume_info (const char * name
, const char ** pPath
)
3153 char temp
[MAX_UTF8_PATH
];
3154 char *rootname
= NULL
; /* default to current volume */
3155 volume_info_data
* info
;
3156 int root_len
= parse_root (name
, pPath
);
3161 /* Copy the root name of the volume, if given. */
3164 strncpy (temp
, name
, root_len
);
3165 temp
[root_len
] = '\0';
3166 unixtodos_filename (temp
);
3170 info
= GetCachedVolumeInformation (rootname
);
3173 /* Set global referenced by other functions. */
3174 volume_info
= *info
;
3180 /* Determine if volume is FAT format (ie. only supports short 8.3
3181 names); also set path pointer to start of pathname in name, if
3182 pPath is non-NULL. */
3184 is_fat_volume (const char * name
, const char ** pPath
)
3186 if (get_volume_info (name
, pPath
))
3187 return (volume_info
.maxcomp
== 12);
3191 /* Convert all slashes in a filename to backslashes, and map filename
3192 to a valid 8.3 name if necessary. The result is a pointer to a
3193 static buffer, so CAVEAT EMPTOR! */
3195 map_w32_filename (const char * name
, const char ** pPath
)
3197 static char shortname
[MAX_UTF8_PATH
];
3198 char * str
= shortname
;
3201 const char * save_name
= name
;
3203 if (strlen (name
) >= sizeof (shortname
))
3205 /* Return a filename which will cause callers to fail. */
3206 strcpy (shortname
, "?");
3210 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
3212 register int left
= 8; /* maximum number of chars in part */
3213 register int extn
= 0; /* extension added? */
3214 register int dots
= 2; /* maximum number of dots allowed */
3217 *str
++ = *name
++; /* skip past UNC header */
3219 while ((c
= *name
++))
3226 *str
++ = (c
== ':' ? ':' : '\\');
3227 extn
= 0; /* reset extension flags */
3228 dots
= 2; /* max 2 dots */
3229 left
= 8; /* max length 8 for main part */
3234 /* Convert path components of the form .xxx to _xxx,
3235 but leave . and .. as they are. This allows .emacs
3236 to be read as _emacs, for example. */
3240 IS_DIRECTORY_SEP (*name
))
3255 extn
= 1; /* we've got an extension */
3256 left
= 3; /* 3 chars in extension */
3260 /* any embedded dots after the first are converted to _ */
3265 case '#': /* don't lose these, they're important */
3267 str
[-1] = c
; /* replace last character of part */
3270 if ( left
&& 'A' <= c
&& c
<= 'Z' )
3272 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
3274 dots
= 0; /* started a path component */
3283 strcpy (shortname
, name
);
3284 unixtodos_filename (shortname
);
3288 *pPath
= shortname
+ (path
- save_name
);
3294 is_exec (const char * name
)
3296 char * p
= strrchr (name
, '.');
3299 && (xstrcasecmp (p
, ".exe") == 0 ||
3300 xstrcasecmp (p
, ".com") == 0 ||
3301 xstrcasecmp (p
, ".bat") == 0 ||
3302 xstrcasecmp (p
, ".cmd") == 0));
3305 /* Emulate the Unix directory procedures opendir, closedir, and
3306 readdir. We rename them to sys_* names because some versions of
3307 MinGW startup code call opendir and readdir to glob wildcards, and
3308 the code that calls them doesn't grok UTF-8 encoded file names we
3309 produce in dirent->d_name[]. */
3311 struct dirent dir_static
; /* simulated directory contents */
3312 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
3313 static int dir_is_fat
;
3314 static char dir_pathname
[MAX_UTF8_PATH
];
3315 static WIN32_FIND_DATAW dir_find_data_w
;
3316 static WIN32_FIND_DATAA dir_find_data_a
;
3317 #define DIR_FIND_DATA_W 1
3318 #define DIR_FIND_DATA_A 2
3319 static int last_dir_find_data
= -1;
3321 /* Support shares on a network resource as subdirectories of a read-only
3323 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3324 static HANDLE
open_unc_volume (const char *);
3325 static void *read_unc_volume (HANDLE
, wchar_t *, char *, int);
3326 static void close_unc_volume (HANDLE
);
3329 sys_opendir (const char *filename
)
3333 /* Opening is done by FindFirstFile. However, a read is inherent to
3334 this operation, so we defer the open until read time. */
3336 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3338 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3341 /* Note: We don't support traversal of UNC volumes via symlinks.
3342 Doing so would mean punishing 99.99% of use cases by resolving
3343 all the possible symlinks in FILENAME, recursively. */
3344 if (is_unc_volume (filename
))
3346 wnet_enum_handle
= open_unc_volume (filename
);
3347 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
3351 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
3358 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAX_UTF8_PATH
- 1);
3359 dir_pathname
[MAX_UTF8_PATH
- 1] = '\0';
3360 /* Note: We don't support symlinks to file names on FAT volumes.
3361 Doing so would mean punishing 99.99% of use cases by resolving
3362 all the possible symlinks in FILENAME, recursively. */
3363 dir_is_fat
= is_fat_volume (filename
, NULL
);
3369 sys_closedir (DIR *dirp
)
3371 /* If we have a find-handle open, close it. */
3372 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3374 FindClose (dir_find_handle
);
3375 dir_find_handle
= INVALID_HANDLE_VALUE
;
3377 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3379 close_unc_volume (wnet_enum_handle
);
3380 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3382 xfree ((char *) dirp
);
3386 sys_readdir (DIR *dirp
)
3388 int downcase
= !NILP (Vw32_downcase_file_names
);
3390 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3392 if (!read_unc_volume (wnet_enum_handle
,
3393 dir_find_data_w
.cFileName
,
3394 dir_find_data_a
.cFileName
,
3398 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3399 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3401 char filename
[MAX_UTF8_PATH
+ 2];
3404 strcpy (filename
, dir_pathname
);
3405 ln
= strlen (filename
) - 1;
3406 if (!IS_DIRECTORY_SEP (filename
[ln
]))
3407 strcat (filename
, "\\");
3408 strcat (filename
, "*");
3410 /* Note: No need to resolve symlinks in FILENAME, because
3411 FindFirst opens the directory that is the target of a
3413 if (w32_unicode_filenames
)
3415 wchar_t fnw
[MAX_PATH
];
3417 filename_to_utf16 (filename
, fnw
);
3418 dir_find_handle
= FindFirstFileW (fnw
, &dir_find_data_w
);
3424 filename_to_ansi (filename
, fna
);
3425 /* If FILENAME is not representable by the current ANSI
3426 codepage, we don't want FindFirstFileA to interpret the
3427 '?' characters as a wildcard. */
3428 if (_mbspbrk (fna
, "?"))
3429 dir_find_handle
= INVALID_HANDLE_VALUE
;
3431 dir_find_handle
= FindFirstFileA (fna
, &dir_find_data_a
);
3434 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3436 switch (GetLastError ())
3438 case ERROR_PATH_NOT_FOUND
:
3439 case ERROR_ACCESS_DENIED
:
3440 case ERROR_INVALID_DRIVE
:
3441 case ERROR_BAD_NETPATH
:
3442 /* This special value will be noticed by
3443 directory_files_internal, which see. */
3452 else if (w32_unicode_filenames
)
3454 if (!FindNextFileW (dir_find_handle
, &dir_find_data_w
))
3459 if (!FindNextFileA (dir_find_handle
, &dir_find_data_a
))
3463 /* Emacs never uses this value, so don't bother making it match
3464 value returned by stat(). */
3465 dir_static
.d_ino
= 1;
3467 if (w32_unicode_filenames
)
3469 if (downcase
|| dir_is_fat
)
3471 wchar_t tem
[MAX_PATH
];
3473 wcscpy (tem
, dir_find_data_w
.cFileName
);
3475 filename_from_utf16 (tem
, dir_static
.d_name
);
3478 filename_from_utf16 (dir_find_data_w
.cFileName
, dir_static
.d_name
);
3479 last_dir_find_data
= DIR_FIND_DATA_W
;
3485 /* If the file name in cFileName[] includes `?' characters, it
3486 means the original file name used characters that cannot be
3487 represented by the current ANSI codepage. To avoid total
3488 lossage, retrieve the short 8+3 alias of the long file
3490 if (_mbspbrk (dir_find_data_a
.cFileName
, "?"))
3492 strcpy (tem
, dir_find_data_a
.cAlternateFileName
);
3493 /* 8+3 aliases are returned in all caps, which could break
3494 various alists that look at filenames' extensions. */
3497 else if (downcase
|| dir_is_fat
)
3498 strcpy (tem
, dir_find_data_a
.cFileName
);
3500 filename_from_ansi (dir_find_data_a
.cFileName
, dir_static
.d_name
);
3501 if (downcase
|| dir_is_fat
)
3504 filename_from_ansi (tem
, dir_static
.d_name
);
3506 last_dir_find_data
= DIR_FIND_DATA_A
;
3509 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3510 dir_static
.d_reclen
= sizeof (struct dirent
) - MAX_UTF8_PATH
+ 3 +
3511 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3517 open_unc_volume (const char *path
)
3519 const char *fn
= map_w32_filename (path
, NULL
);
3523 if (w32_unicode_filenames
)
3526 wchar_t fnw
[MAX_PATH
];
3528 nrw
.dwScope
= RESOURCE_GLOBALNET
;
3529 nrw
.dwType
= RESOURCETYPE_DISK
;
3530 nrw
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3531 nrw
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3532 nrw
.lpLocalName
= NULL
;
3533 filename_to_utf16 (fn
, fnw
);
3534 nrw
.lpRemoteName
= fnw
;
3535 nrw
.lpComment
= NULL
;
3536 nrw
.lpProvider
= NULL
;
3538 result
= WNetOpenEnumW (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3539 RESOURCEUSAGE_CONNECTABLE
, &nrw
, &henum
);
3546 nra
.dwScope
= RESOURCE_GLOBALNET
;
3547 nra
.dwType
= RESOURCETYPE_DISK
;
3548 nra
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3549 nra
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3550 nra
.lpLocalName
= NULL
;
3551 filename_to_ansi (fn
, fna
);
3552 nra
.lpRemoteName
= fna
;
3553 nra
.lpComment
= NULL
;
3554 nra
.lpProvider
= NULL
;
3556 result
= WNetOpenEnumA (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3557 RESOURCEUSAGE_CONNECTABLE
, &nra
, &henum
);
3559 if (result
== NO_ERROR
)
3562 return INVALID_HANDLE_VALUE
;
3566 read_unc_volume (HANDLE henum
, wchar_t *fname_w
, char *fname_a
, int size
)
3571 DWORD bufsize
= 512;
3575 if (w32_unicode_filenames
)
3580 buffer
= alloca (bufsize
);
3581 result
= WNetEnumResourceW (henum
, &count
, buffer
, &bufsize
);
3582 if (result
!= NO_ERROR
)
3584 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3585 ptrw
= ((LPNETRESOURCEW
) buffer
)->lpRemoteName
;
3587 while (*ptrw
&& *ptrw
!= L
'/' && *ptrw
!= L
'\\') ptrw
++;
3589 wcsncpy (fname_w
, ptrw
, size
);
3594 int dbcs_p
= max_filename_mbslen () > 1;
3597 buffer
= alloca (bufsize
);
3598 result
= WNetEnumResourceA (henum
, &count
, buffer
, &bufsize
);
3599 if (result
!= NO_ERROR
)
3601 ptra
= ((LPNETRESOURCEA
) buffer
)->lpRemoteName
;
3604 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
)) ptra
++;
3607 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
))
3608 ptra
= CharNextExA (file_name_codepage
, ptra
, 0);
3611 strncpy (fname_a
, ptra
, size
);
3619 close_unc_volume (HANDLE henum
)
3621 if (henum
!= INVALID_HANDLE_VALUE
)
3622 WNetCloseEnum (henum
);
3626 unc_volume_file_attributes (const char *path
)
3631 henum
= open_unc_volume (path
);
3632 if (henum
== INVALID_HANDLE_VALUE
)
3635 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3637 close_unc_volume (henum
);
3642 /* Ensure a network connection is authenticated. */
3644 logon_network_drive (const char *path
)
3646 char share
[MAX_UTF8_PATH
];
3653 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3654 drvtype
= DRIVE_REMOTE
;
3655 else if (path
[0] == '\0' || path
[1] != ':')
3656 drvtype
= GetDriveType (NULL
);
3663 drvtype
= GetDriveType (drive
);
3666 /* Only logon to networked drives. */
3667 if (drvtype
!= DRIVE_REMOTE
)
3671 strncpy (share
, path
, MAX_UTF8_PATH
);
3672 /* Truncate to just server and share name. */
3673 for (p
= share
+ 2; *p
&& p
< share
+ MAX_UTF8_PATH
; p
++)
3675 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3682 if (w32_unicode_filenames
)
3684 NETRESOURCEW resourcew
;
3685 wchar_t share_w
[MAX_PATH
];
3687 resourcew
.dwScope
= RESOURCE_GLOBALNET
;
3688 resourcew
.dwType
= RESOURCETYPE_DISK
;
3689 resourcew
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3690 resourcew
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3691 resourcew
.lpLocalName
= NULL
;
3692 filename_to_utf16 (share
, share_w
);
3693 resourcew
.lpRemoteName
= share_w
;
3694 resourcew
.lpProvider
= NULL
;
3696 val
= WNetAddConnection2W (&resourcew
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3700 NETRESOURCEA resourcea
;
3701 char share_a
[MAX_PATH
];
3703 resourcea
.dwScope
= RESOURCE_GLOBALNET
;
3704 resourcea
.dwType
= RESOURCETYPE_DISK
;
3705 resourcea
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3706 resourcea
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3707 resourcea
.lpLocalName
= NULL
;
3708 filename_to_ansi (share
, share_a
);
3709 resourcea
.lpRemoteName
= share_a
;
3710 resourcea
.lpProvider
= NULL
;
3712 val
= WNetAddConnection2A (&resourcea
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3718 case ERROR_ALREADY_ASSIGNED
:
3720 case ERROR_ACCESS_DENIED
:
3721 case ERROR_LOGON_FAILURE
:
3727 case ERROR_BAD_NET_NAME
:
3728 case ERROR_NO_NET_OR_BAD_PATH
:
3729 case ERROR_NO_NETWORK
:
3730 case ERROR_CANCELLED
:
3737 /* Emulate faccessat(2). */
3739 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3743 if (dirfd
!= AT_FDCWD
3744 && !(IS_DIRECTORY_SEP (path
[0])
3745 || IS_DEVICE_SEP (path
[1])))
3751 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3752 newer versions blow up when passed D_OK. */
3753 path
= map_w32_filename (path
, NULL
);
3754 /* If the last element of PATH is a symlink, we need to resolve it
3755 to get the attributes of its target file. Note: any symlinks in
3756 PATH elements other than the last one are transparently resolved
3757 by GetFileAttributes below. */
3758 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3759 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3760 path
= chase_symlinks (path
);
3762 if (w32_unicode_filenames
)
3764 wchar_t path_w
[MAX_PATH
];
3766 filename_to_utf16 (path
, path_w
);
3767 attributes
= GetFileAttributesW (path_w
);
3771 char path_a
[MAX_PATH
];
3773 filename_to_ansi (path
, path_a
);
3774 attributes
= GetFileAttributesA (path_a
);
3777 if (attributes
== -1)
3779 DWORD w32err
= GetLastError ();
3783 case ERROR_INVALID_NAME
:
3784 case ERROR_BAD_PATHNAME
:
3785 if (is_unc_volume (path
))
3787 attributes
= unc_volume_file_attributes (path
);
3788 if (attributes
== -1)
3796 case ERROR_FILE_NOT_FOUND
:
3797 case ERROR_BAD_NETPATH
:
3806 if ((mode
& X_OK
) != 0
3807 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3812 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3817 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3825 /* A version of 'access' to be used locally with file names in
3826 locale-specific encoding. Does not resolve symlinks and does not
3827 support file names on FAT12 and FAT16 volumes, but that's OK, since
3828 we only invoke this function for files inside the Emacs source or
3829 installation tree, on directories (so any symlinks should have the
3830 directory bit set), and on short file names such as "C:/.emacs". */
3832 sys_access (const char *fname
, int mode
)
3834 char fname_copy
[MAX_PATH
], *p
;
3837 strcpy (fname_copy
, fname
);
3838 /* Do the equivalent of unixtodos_filename. */
3839 for (p
= fname_copy
; *p
; p
= CharNext (p
))
3843 if ((attributes
= GetFileAttributesA (fname_copy
)) == -1)
3845 DWORD w32err
= GetLastError ();
3849 case ERROR_INVALID_NAME
:
3850 case ERROR_BAD_PATHNAME
:
3851 case ERROR_FILE_NOT_FOUND
:
3852 case ERROR_BAD_NETPATH
:
3861 if ((mode
& X_OK
) != 0
3862 && !(is_exec (fname_copy
)
3863 || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3868 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3873 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3881 /* Shadow some MSVC runtime functions to map requests for long filenames
3882 to reasonable short names if necessary. This was originally added to
3883 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3887 sys_chdir (const char * path
)
3889 path
= map_w32_filename (path
, NULL
);
3890 if (w32_unicode_filenames
)
3892 wchar_t newdir_w
[MAX_PATH
];
3894 if (filename_to_utf16 (path
, newdir_w
) == 0)
3895 return _wchdir (newdir_w
);
3900 char newdir_a
[MAX_PATH
];
3902 if (filename_to_ansi (path
, newdir_a
) == 0)
3903 return _chdir (newdir_a
);
3909 sys_chmod (const char * path
, int mode
)
3911 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3912 if (w32_unicode_filenames
)
3914 wchar_t path_w
[MAX_PATH
];
3916 filename_to_utf16 (path
, path_w
);
3917 return _wchmod (path_w
, mode
);
3921 char path_a
[MAX_PATH
];
3923 filename_to_ansi (path
, path_a
);
3924 return _chmod (path_a
, mode
);
3929 sys_creat (const char * path
, int mode
)
3931 path
= map_w32_filename (path
, NULL
);
3932 if (w32_unicode_filenames
)
3934 wchar_t path_w
[MAX_PATH
];
3936 filename_to_utf16 (path
, path_w
);
3937 return _wcreat (path_w
, mode
);
3941 char path_a
[MAX_PATH
];
3943 filename_to_ansi (path
, path_a
);
3944 return _creat (path_a
, mode
);
3949 sys_fopen (const char * path
, const char * mode
)
3953 const char * mode_save
= mode
;
3955 /* Force all file handles to be non-inheritable. This is necessary to
3956 ensure child processes don't unwittingly inherit handles that might
3957 prevent future file access. */
3961 else if (mode
[0] == 'w' || mode
[0] == 'a')
3962 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3966 /* Only do simplistic option parsing. */
3970 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3973 else if (mode
[0] == 'b')
3978 else if (mode
[0] == 't')
3985 path
= map_w32_filename (path
, NULL
);
3986 if (w32_unicode_filenames
)
3988 wchar_t path_w
[MAX_PATH
];
3990 filename_to_utf16 (path
, path_w
);
3991 fd
= _wopen (path_w
, oflag
| _O_NOINHERIT
, 0644);
3995 char path_a
[MAX_PATH
];
3997 filename_to_ansi (path
, path_a
);
3998 fd
= _open (path_a
, oflag
| _O_NOINHERIT
, 0644);
4003 return _fdopen (fd
, mode_save
);
4006 /* This only works on NTFS volumes, but is useful to have. */
4008 sys_link (const char * old
, const char * new)
4012 char oldname
[MAX_UTF8_PATH
], newname
[MAX_UTF8_PATH
];
4013 wchar_t oldname_w
[MAX_PATH
];
4014 char oldname_a
[MAX_PATH
];
4016 if (old
== NULL
|| new == NULL
)
4022 strcpy (oldname
, map_w32_filename (old
, NULL
));
4023 strcpy (newname
, map_w32_filename (new, NULL
));
4025 if (w32_unicode_filenames
)
4027 filename_to_utf16 (oldname
, oldname_w
);
4028 fileh
= CreateFileW (oldname_w
, 0, 0, NULL
, OPEN_EXISTING
,
4029 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4033 filename_to_ansi (oldname
, oldname_a
);
4034 fileh
= CreateFileA (oldname_a
, 0, 0, NULL
, OPEN_EXISTING
,
4035 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4037 if (fileh
!= INVALID_HANDLE_VALUE
)
4041 /* Confusingly, the "alternate" stream name field does not apply
4042 when restoring a hard link, and instead contains the actual
4043 stream data for the link (ie. the name of the link to create).
4044 The WIN32_STREAM_ID structure before the cStreamName field is
4045 the stream header, which is then immediately followed by the
4049 WIN32_STREAM_ID wid
;
4050 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
4053 /* We used to pass MB_PRECOMPOSED as the 2nd arg here, but MSDN
4054 indicates that flag is unsupported for CP_UTF8, and OTOH says
4055 it is the default anyway. */
4056 wlen
= pMultiByteToWideChar (CP_UTF8
, 0, newname
, -1,
4057 data
.wid
.cStreamName
, MAX_PATH
);
4060 LPVOID context
= NULL
;
4063 data
.wid
.dwStreamId
= BACKUP_LINK
;
4064 data
.wid
.dwStreamAttributes
= 0;
4065 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
4066 data
.wid
.Size
.HighPart
= 0;
4067 data
.wid
.dwStreamNameSize
= 0;
4069 if (BackupWrite (fileh
, (LPBYTE
)&data
,
4070 offsetof (WIN32_STREAM_ID
, cStreamName
)
4071 + data
.wid
.Size
.LowPart
,
4072 &wbytes
, FALSE
, FALSE
, &context
)
4073 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
4080 DWORD err
= GetLastError ();
4085 case ERROR_ACCESS_DENIED
:
4086 /* This is what happens when OLDNAME is a directory,
4087 since Windows doesn't support hard links to
4088 directories. Posix says to set errno to EPERM in
4090 if (w32_unicode_filenames
)
4091 attributes
= GetFileAttributesW (oldname_w
);
4093 attributes
= GetFileAttributesA (oldname_a
);
4094 if (attributes
!= -1
4095 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
4097 else if (attributes
== -1
4098 && is_unc_volume (oldname
)
4099 && unc_volume_file_attributes (oldname
) != -1)
4104 case ERROR_TOO_MANY_LINKS
:
4107 case ERROR_NOT_SAME_DEVICE
:
4117 CloseHandle (fileh
);
4126 sys_mkdir (const char * path
)
4128 path
= map_w32_filename (path
, NULL
);
4130 if (w32_unicode_filenames
)
4132 wchar_t path_w
[MAX_PATH
];
4134 filename_to_utf16 (path
, path_w
);
4135 return _wmkdir (path_w
);
4139 char path_a
[MAX_PATH
];
4141 filename_to_ansi (path
, path_a
);
4142 return _mkdir (path_a
);
4147 sys_open (const char * path
, int oflag
, int mode
)
4149 const char* mpath
= map_w32_filename (path
, NULL
);
4152 if (w32_unicode_filenames
)
4154 wchar_t mpath_w
[MAX_PATH
];
4156 filename_to_utf16 (mpath
, mpath_w
);
4157 /* If possible, try to open file without _O_CREAT, to be able to
4158 write to existing hidden and system files. Force all file
4159 handles to be non-inheritable. */
4160 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4161 res
= _wopen (mpath_w
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4163 res
= _wopen (mpath_w
, oflag
| _O_NOINHERIT
, mode
);
4167 char mpath_a
[MAX_PATH
];
4169 filename_to_ansi (mpath
, mpath_a
);
4170 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4171 res
= _open (mpath_a
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4173 res
= _open (mpath_a
, oflag
| _O_NOINHERIT
, mode
);
4179 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
4182 Standard algorithm for generating a temporary file name seems to be
4183 use pid or tid with a letter on the front (in place of the 6 X's)
4184 and cycle through the letters to find a unique name. We extend
4185 that to allow any reasonable character as the first of the 6 X's,
4186 so that the number of simultaneously used temporary files will be
4190 mkostemp (char * template, int flags
)
4194 unsigned uid
= GetCurrentThreadId ();
4195 int save_errno
= errno
;
4196 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
4199 if (template == NULL
)
4202 p
= template + strlen (template);
4204 /* replace up to the last 5 X's with uid in decimal */
4205 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
4207 p
[0] = '0' + uid
% 10;
4211 if (i
< 0 && p
[0] == 'X')
4216 p
[0] = first_char
[i
];
4217 if ((fd
= sys_open (template,
4218 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
4219 S_IRUSR
| S_IWUSR
)) >= 0
4227 while (++i
< sizeof (first_char
));
4230 /* Template is badly formed or else we can't generate a unique name. */
4235 fchmod (int fd
, mode_t mode
)
4241 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
4244 char temp
[MAX_UTF8_PATH
], temp_a
[MAX_PATH
];;
4247 bool have_temp_a
= false;
4249 /* MoveFile on Windows 95 doesn't correctly change the short file name
4250 alias in a number of circumstances (it is not easy to predict when
4251 just by looking at oldname and newname, unfortunately). In these
4252 cases, renaming through a temporary name avoids the problem.
4254 A second problem on Windows 95 is that renaming through a temp name when
4255 newname is uppercase fails (the final long name ends up in
4256 lowercase, although the short alias might be uppercase) UNLESS the
4257 long temp name is not 8.3.
4259 So, on Windows 95 we always rename through a temp name, and we make sure
4260 the temp name has a long extension to ensure correct renaming. */
4262 strcpy (temp
, map_w32_filename (oldname
, NULL
));
4264 /* volume_info is set indirectly by map_w32_filename. */
4265 oldname_dev
= volume_info
.serialnum
;
4267 if (os_subtype
== OS_9X
)
4272 char oldname_a
[MAX_PATH
];
4274 oldname
= map_w32_filename (oldname
, NULL
);
4275 filename_to_ansi (oldname
, oldname_a
);
4276 filename_to_ansi (temp
, temp_a
);
4277 if ((o
= strrchr (oldname_a
, '\\')))
4280 o
= (char *) oldname_a
;
4282 if ((p
= strrchr (temp_a
, '\\')))
4289 /* Force temp name to require a manufactured 8.3 alias - this
4290 seems to make the second rename work properly. */
4291 sprintf (p
, "_.%s.%u", o
, i
);
4293 result
= rename (oldname_a
, temp_a
);
4295 /* This loop must surely terminate! */
4296 while (result
< 0 && errno
== EEXIST
);
4302 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
4303 (at least if it is a file; don't do this for directories).
4305 Since we mustn't do this if we are just changing the case of the
4306 file name (we would end up deleting the file we are trying to
4307 rename!), we let rename detect if the destination file already
4308 exists - that way we avoid the possible pitfalls of trying to
4309 determine ourselves whether two names really refer to the same
4310 file, which is not always possible in the general case. (Consider
4311 all the permutations of shared or subst'd drives, etc.) */
4313 newname
= map_w32_filename (newname
, NULL
);
4315 /* volume_info is set indirectly by map_w32_filename. */
4316 newname_dev
= volume_info
.serialnum
;
4318 if (w32_unicode_filenames
)
4320 wchar_t temp_w
[MAX_PATH
], newname_w
[MAX_PATH
];
4322 filename_to_utf16 (temp
, temp_w
);
4323 filename_to_utf16 (newname
, newname_w
);
4324 result
= _wrename (temp_w
, newname_w
);
4325 if (result
< 0 && force
)
4327 DWORD w32err
= GetLastError ();
4330 && newname_dev
!= oldname_dev
)
4332 /* The implementation of `rename' on Windows does not return
4333 errno = EXDEV when you are moving a directory to a
4334 different storage device (ex. logical disk). It returns
4335 EACCES instead. So here we handle such situations and
4339 if ((attributes
= GetFileAttributesW (temp_w
)) != -1
4340 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4343 else if (errno
== EEXIST
)
4345 if (_wchmod (newname_w
, 0666) != 0)
4347 if (_wunlink (newname_w
) != 0)
4349 result
= _wrename (temp_w
, newname_w
);
4351 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4352 && is_symlink (temp
))
4354 /* This is Windows prohibiting the user from creating a
4355 symlink in another place, since that requires
4363 char newname_a
[MAX_PATH
];
4366 filename_to_ansi (temp
, temp_a
);
4367 filename_to_ansi (newname
, newname_a
);
4368 result
= rename (temp_a
, newname_a
);
4369 if (result
< 0 && force
)
4371 DWORD w32err
= GetLastError ();
4374 && newname_dev
!= oldname_dev
)
4378 if ((attributes
= GetFileAttributesA (temp_a
)) != -1
4379 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4382 else if (errno
== EEXIST
)
4384 if (_chmod (newname_a
, 0666) != 0)
4386 if (_unlink (newname_a
) != 0)
4388 result
= rename (temp_a
, newname_a
);
4390 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4391 && is_symlink (temp
))
4400 sys_rename (char const *old
, char const *new)
4402 return sys_rename_replace (old
, new, TRUE
);
4406 sys_rmdir (const char * path
)
4408 path
= map_w32_filename (path
, NULL
);
4410 if (w32_unicode_filenames
)
4412 wchar_t path_w
[MAX_PATH
];
4414 filename_to_utf16 (path
, path_w
);
4415 return _wrmdir (path_w
);
4419 char path_a
[MAX_PATH
];
4421 filename_to_ansi (path
, path_a
);
4422 return _rmdir (path_a
);
4427 sys_unlink (const char * path
)
4429 path
= map_w32_filename (path
, NULL
);
4431 if (w32_unicode_filenames
)
4433 wchar_t path_w
[MAX_PATH
];
4435 filename_to_utf16 (path
, path_w
);
4436 /* On Unix, unlink works without write permission. */
4437 _wchmod (path_w
, 0666);
4438 return _wunlink (path_w
);
4442 char path_a
[MAX_PATH
];
4444 filename_to_ansi (path
, path_a
);
4445 _chmod (path_a
, 0666);
4446 return _unlink (path_a
);
4450 static FILETIME utc_base_ft
;
4451 static ULONGLONG utc_base
; /* In 100ns units */
4452 static int init
= 0;
4454 #define FILETIME_TO_U64(result, ft) \
4456 ULARGE_INTEGER uiTemp; \
4457 uiTemp.LowPart = (ft).dwLowDateTime; \
4458 uiTemp.HighPart = (ft).dwHighDateTime; \
4459 result = uiTemp.QuadPart; \
4463 initialize_utc_base (void)
4465 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4474 st
.wMilliseconds
= 0;
4476 SystemTimeToFileTime (&st
, &utc_base_ft
);
4477 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
4481 convert_time (FILETIME ft
)
4487 initialize_utc_base ();
4491 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
4494 FILETIME_TO_U64 (tmp
, ft
);
4495 return (time_t) ((tmp
- utc_base
) / 10000000L);
4499 convert_from_time_t (time_t time
, FILETIME
* pft
)
4505 initialize_utc_base ();
4509 /* time in 100ns units since 1-Jan-1601 */
4510 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
4511 pft
->dwHighDateTime
= tmp
.HighPart
;
4512 pft
->dwLowDateTime
= tmp
.LowPart
;
4515 static PSECURITY_DESCRIPTOR
4516 get_file_security_desc_by_handle (HANDLE h
)
4518 PSECURITY_DESCRIPTOR psd
= NULL
;
4520 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4521 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4523 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
4524 NULL
, NULL
, NULL
, NULL
, &psd
);
4525 if (err
!= ERROR_SUCCESS
)
4531 static PSECURITY_DESCRIPTOR
4532 get_file_security_desc_by_name (const char *fname
)
4534 PSECURITY_DESCRIPTOR psd
= NULL
;
4536 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4537 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4539 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
4541 err
= GetLastError ();
4542 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
4546 psd
= xmalloc (sd_len
);
4547 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4559 unsigned n_subauthorities
;
4561 /* Use the last sub-authority value of the RID, the relative
4562 portion of the SID, as user/group ID. */
4563 n_subauthorities
= *get_sid_sub_authority_count (sid
);
4564 if (n_subauthorities
< 1)
4565 return 0; /* the "World" RID */
4566 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
4569 /* Caching SID and account values for faster lokup. */
4573 struct w32_id
*next
;
4575 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
4578 static struct w32_id
*w32_idlist
;
4581 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
4583 struct w32_id
*tail
, *found
;
4585 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
4587 if (equal_sid ((PSID
)tail
->sid
, sid
))
4596 strcpy (name
, found
->name
);
4604 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
4607 struct w32_id
*new_entry
;
4609 /* We don't want to leave behind stale cache from when Emacs was
4613 sid_len
= get_length_sid (sid
);
4614 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
4617 new_entry
->rid
= id
;
4618 strcpy (new_entry
->name
, name
);
4619 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
4620 new_entry
->next
= w32_idlist
;
4621 w32_idlist
= new_entry
;
4630 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
4634 SID_NAME_USE ignore
;
4636 DWORD name_len
= sizeof (name
);
4638 DWORD domain_len
= sizeof (domain
);
4643 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
4644 else if (what
== GID
)
4645 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
4649 if (!result
|| !is_valid_sid (sid
))
4651 else if (!w32_cached_id (sid
, id
, nm
))
4653 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
4654 domain
, &domain_len
, &ignore
)
4655 || name_len
> UNLEN
+1)
4659 *id
= get_rid (sid
);
4661 w32_add_to_cache (sid
, *id
, name
);
4668 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
4670 int dflt_usr
= 0, dflt_grp
= 0;
4679 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
4681 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
4684 /* Consider files to belong to current user/group, if we cannot get
4685 more accurate information. */
4688 st
->st_uid
= dflt_passwd
.pw_uid
;
4689 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
4693 st
->st_gid
= dflt_passwd
.pw_gid
;
4694 strcpy (st
->st_gname
, dflt_group
.gr_name
);
4698 /* Return non-zero if NAME is a potentially slow filesystem. */
4700 is_slow_fs (const char *name
)
4705 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
4706 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
4707 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
4708 devtype
= GetDriveType (NULL
); /* use root of current drive */
4711 /* GetDriveType needs the root directory of the drive. */
4712 strncpy (drive_root
, name
, 2);
4713 drive_root
[2] = '\\';
4714 drive_root
[3] = '\0';
4715 devtype
= GetDriveType (drive_root
);
4717 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
4720 /* If this is non-zero, the caller wants accurate information about
4721 file's owner and group, which could be expensive to get. dired.c
4722 uses this flag when needed for the job at hand. */
4723 int w32_stat_get_owner_group
;
4725 /* MSVC stat function can't cope with UNC names and has other bugs, so
4726 replace it with our own. This also allows us to calculate consistent
4727 inode values and owner/group without hacks in the main Emacs code,
4728 and support file names encoded in UTF-8. */
4731 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
4733 char *name
, *save_name
, *r
;
4734 WIN32_FIND_DATAW wfd_w
;
4735 WIN32_FIND_DATAA wfd_a
;
4737 unsigned __int64 fake_inode
= 0;
4740 int rootdir
= FALSE
;
4741 PSECURITY_DESCRIPTOR psd
= NULL
;
4742 int is_a_symlink
= 0;
4743 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
4744 DWORD access_rights
= 0;
4745 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
4746 FILETIME ctime
, atime
, wtime
;
4747 wchar_t name_w
[MAX_PATH
];
4748 char name_a
[MAX_PATH
];
4750 if (path
== NULL
|| buf
== NULL
)
4756 save_name
= name
= (char *) map_w32_filename (path
, &path
);
4757 /* Must be valid filename, no wild cards or other invalid
4759 if (strpbrk (name
, "*?|<>\""))
4765 len
= strlen (name
);
4766 /* Allocate 1 extra byte so that we could append a slash to a root
4767 directory, down below. */
4768 name
= strcpy (alloca (len
+ 2), name
);
4770 /* Avoid a somewhat costly call to is_symlink if the filesystem
4771 doesn't support symlinks. */
4772 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4773 is_a_symlink
= is_symlink (name
);
4775 /* Plan A: Open the file and get all the necessary information via
4776 the resulting handle. This solves several issues in one blow:
4778 . retrieves attributes for the target of a symlink, if needed
4779 . gets attributes of root directories and symlinks pointing to
4780 root directories, thus avoiding the need for special-casing
4781 these and detecting them by examining the file-name format
4782 . retrieves more accurate attributes (e.g., non-zero size for
4783 some directories, esp. directories that are junction points)
4784 . correctly resolves "c:/..", "/.." and similar file names
4785 . avoids run-time penalties for 99% of use cases
4787 Plan A is always tried first, unless the user asked not to (but
4788 if the file is a symlink and we need to follow links, we try Plan
4789 A even if the user asked not to).
4791 If Plan A fails, we go to Plan B (below), where various
4792 potentially expensive techniques must be used to handle "special"
4793 files such as UNC volumes etc. */
4794 if (!(NILP (Vw32_get_true_file_attributes
)
4795 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4796 /* Following symlinks requires getting the info by handle. */
4797 || (is_a_symlink
&& follow_symlinks
))
4799 BY_HANDLE_FILE_INFORMATION info
;
4801 if (is_a_symlink
&& !follow_symlinks
)
4802 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4803 /* READ_CONTROL access rights are required to get security info
4804 by handle. But if the OS doesn't support security in the
4805 first place, we don't need to try. */
4806 if (is_windows_9x () != TRUE
)
4807 access_rights
|= READ_CONTROL
;
4809 if (w32_unicode_filenames
)
4811 filename_to_utf16 (name
, name_w
);
4812 fh
= CreateFileW (name_w
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4814 /* If CreateFile fails with READ_CONTROL, try again with
4815 zero as access rights. */
4816 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4817 fh
= CreateFileW (name_w
, 0, 0, NULL
, OPEN_EXISTING
,
4822 filename_to_ansi (name
, name_a
);
4823 fh
= CreateFileA (name_a
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4825 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4826 fh
= CreateFileA (name_a
, 0, 0, NULL
, OPEN_EXISTING
,
4829 if (fh
== INVALID_HANDLE_VALUE
)
4830 goto no_true_file_attributes
;
4832 /* This is more accurate in terms of getting the correct number
4833 of links, but is quite slow (it is noticeable when Emacs is
4834 making a list of file name completions). */
4835 if (GetFileInformationByHandle (fh
, &info
))
4837 nlinks
= info
.nNumberOfLinks
;
4838 /* Might as well use file index to fake inode values, but this
4839 is not guaranteed to be unique unless we keep a handle open
4840 all the time (even then there are situations where it is
4841 not unique). Reputedly, there are at most 48 bits of info
4842 (on NTFS, presumably less on FAT). */
4843 fake_inode
= info
.nFileIndexHigh
;
4845 fake_inode
+= info
.nFileIndexLow
;
4846 serialnum
= info
.dwVolumeSerialNumber
;
4847 fs_high
= info
.nFileSizeHigh
;
4848 fs_low
= info
.nFileSizeLow
;
4849 ctime
= info
.ftCreationTime
;
4850 atime
= info
.ftLastAccessTime
;
4851 wtime
= info
.ftLastWriteTime
;
4852 fattrs
= info
.dwFileAttributes
;
4856 /* We don't go to Plan B here, because it's not clear that
4857 it's a good idea. The only known use case where
4858 CreateFile succeeds, but GetFileInformationByHandle fails
4859 (with ERROR_INVALID_FUNCTION) is for character devices
4860 such as NUL, PRN, etc. For these, switching to Plan B is
4861 a net loss, because we lose the character device
4862 attribute returned by GetFileType below (FindFirstFile
4863 doesn't set that bit in the attributes), and the other
4864 fields don't make sense for character devices anyway.
4865 Emacs doesn't really care for non-file entities in the
4866 context of l?stat, so neither do we. */
4868 /* w32err is assigned so one could put a breakpoint here and
4869 examine its value, when GetFileInformationByHandle
4871 DWORD w32err
= GetLastError ();
4875 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4881 /* Test for a symlink before testing for a directory, since
4882 symlinks to directories have the directory bit set, but we
4883 don't want them to appear as directories. */
4884 if (is_a_symlink
&& !follow_symlinks
)
4885 buf
->st_mode
= S_IFLNK
;
4886 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4887 buf
->st_mode
= S_IFDIR
;
4890 DWORD ftype
= GetFileType (fh
);
4894 case FILE_TYPE_DISK
:
4895 buf
->st_mode
= S_IFREG
;
4897 case FILE_TYPE_PIPE
:
4898 buf
->st_mode
= S_IFIFO
;
4900 case FILE_TYPE_CHAR
:
4901 case FILE_TYPE_UNKNOWN
:
4903 buf
->st_mode
= S_IFCHR
;
4906 /* We produce the fallback owner and group data, based on the
4907 current user that runs Emacs, in the following cases:
4909 . caller didn't request owner and group info
4910 . this is Windows 9X
4911 . getting security by handle failed, and we need to produce
4912 information for the target of a symlink (this is better
4913 than producing a potentially misleading info about the
4916 If getting security by handle fails, and we don't need to
4917 resolve symlinks, we try getting security by name. */
4918 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4919 get_file_owner_and_group (NULL
, buf
);
4922 psd
= get_file_security_desc_by_handle (fh
);
4925 get_file_owner_and_group (psd
, buf
);
4928 else if (!(is_a_symlink
&& follow_symlinks
))
4930 psd
= get_file_security_desc_by_name (name
);
4931 get_file_owner_and_group (psd
, buf
);
4935 get_file_owner_and_group (NULL
, buf
);
4941 no_true_file_attributes
:
4942 /* Plan B: Either getting a handle on the file failed, or the
4943 caller explicitly asked us to not bother making this
4944 information more accurate.
4946 Implementation note: In Plan B, we never bother to resolve
4947 symlinks, even if we got here because we tried Plan A and
4948 failed. That's because, even if the caller asked for extra
4949 precision by setting Vw32_get_true_file_attributes to t,
4950 resolving symlinks requires acquiring a file handle to the
4951 symlink, which we already know will fail. And if the user
4952 did not ask for extra precision, resolving symlinks will fly
4953 in the face of that request, since the user then wants the
4954 lightweight version of the code. */
4955 rootdir
= (path
>= save_name
+ len
- 1
4956 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4958 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4959 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4960 if (IS_DIRECTORY_SEP (r
[0])
4961 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4964 /* Note: If NAME is a symlink to the root of a UNC volume
4965 (i.e. "\\SERVER"), we will not detect that here, and we will
4966 return data about the symlink as result of FindFirst below.
4967 This is unfortunate, but that marginal use case does not
4968 justify a call to chase_symlinks which would impose a penalty
4969 on all the other use cases. (We get here for symlinks to
4970 roots of UNC volumes because CreateFile above fails for them,
4971 unlike with symlinks to root directories X:\ of drives.) */
4972 if (is_unc_volume (name
))
4974 fattrs
= unc_volume_file_attributes (name
);
4978 ctime
= atime
= wtime
= utc_base_ft
;
4982 /* Make sure root directories end in a slash. */
4983 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4984 strcat (name
, "\\");
4985 if (GetDriveType (name
) < 2)
4991 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4992 ctime
= atime
= wtime
= utc_base_ft
;
4998 /* Make sure non-root directories do NOT end in a slash,
4999 otherwise FindFirstFile might fail. */
5000 if (IS_DIRECTORY_SEP (name
[len
-1]))
5003 /* (This is hacky, but helps when doing file completions on
5004 network drives.) Optimize by using information available from
5005 active readdir if possible. */
5006 len
= strlen (dir_pathname
);
5007 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
5009 if (dir_find_handle
!= INVALID_HANDLE_VALUE
5010 && last_dir_find_data
!= -1
5011 && !(is_a_symlink
&& follow_symlinks
)
5012 /* The 2 file-name comparisons below support only ASCII
5013 characters, and will lose (compare not equal) when
5014 the file names include non-ASCII characters that are
5015 the same but for the case. However, doing this
5016 properly involves: (a) converting both file names to
5017 UTF-16, (b) lower-casing both names using CharLowerW,
5018 and (c) comparing the results; this would be quite a
5019 bit slower, whereas Plan B is for users who want
5020 lightweight albeit inaccurate version of 'stat'. */
5021 && c_strncasecmp (save_name
, dir_pathname
, len
) == 0
5022 && IS_DIRECTORY_SEP (name
[len
])
5023 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
5025 have_wfd
= last_dir_find_data
;
5026 /* This was the last entry returned by readdir. */
5027 if (last_dir_find_data
== DIR_FIND_DATA_W
)
5028 wfd_w
= dir_find_data_w
;
5030 wfd_a
= dir_find_data_a
;
5034 logon_network_drive (name
);
5036 if (w32_unicode_filenames
)
5038 filename_to_utf16 (name
, name_w
);
5039 fh
= FindFirstFileW (name_w
, &wfd_w
);
5040 have_wfd
= DIR_FIND_DATA_W
;
5044 filename_to_ansi (name
, name_a
);
5045 /* If NAME includes characters not representable by
5046 the current ANSI codepage, filename_to_ansi
5047 usually replaces them with a '?'. We don't want
5048 to let FindFirstFileA interpret those as wildcards,
5049 and "succeed", returning us data from some random
5050 file in the same directory. */
5051 if (_mbspbrk (name_a
, "?"))
5052 fh
= INVALID_HANDLE_VALUE
;
5054 fh
= FindFirstFileA (name_a
, &wfd_a
);
5055 have_wfd
= DIR_FIND_DATA_A
;
5057 if (fh
== INVALID_HANDLE_VALUE
)
5064 /* Note: if NAME is a symlink, the information we get from
5065 FindFirstFile is for the symlink, not its target. */
5066 if (have_wfd
== DIR_FIND_DATA_W
)
5068 fattrs
= wfd_w
.dwFileAttributes
;
5069 ctime
= wfd_w
.ftCreationTime
;
5070 atime
= wfd_w
.ftLastAccessTime
;
5071 wtime
= wfd_w
.ftLastWriteTime
;
5072 fs_high
= wfd_w
.nFileSizeHigh
;
5073 fs_low
= wfd_w
.nFileSizeLow
;
5077 fattrs
= wfd_a
.dwFileAttributes
;
5078 ctime
= wfd_a
.ftCreationTime
;
5079 atime
= wfd_a
.ftLastAccessTime
;
5080 wtime
= wfd_a
.ftLastWriteTime
;
5081 fs_high
= wfd_a
.nFileSizeHigh
;
5082 fs_low
= wfd_a
.nFileSizeLow
;
5086 serialnum
= volume_info
.serialnum
;
5088 if (is_a_symlink
&& !follow_symlinks
)
5089 buf
->st_mode
= S_IFLNK
;
5090 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5091 buf
->st_mode
= S_IFDIR
;
5093 buf
->st_mode
= S_IFREG
;
5095 get_file_owner_and_group (NULL
, buf
);
5098 buf
->st_ino
= fake_inode
;
5100 buf
->st_dev
= serialnum
;
5101 buf
->st_rdev
= serialnum
;
5103 buf
->st_size
= fs_high
;
5104 buf
->st_size
<<= 32;
5105 buf
->st_size
+= fs_low
;
5106 buf
->st_nlink
= nlinks
;
5108 /* Convert timestamps to Unix format. */
5109 buf
->st_mtime
= convert_time (wtime
);
5110 buf
->st_atime
= convert_time (atime
);
5111 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5112 buf
->st_ctime
= convert_time (ctime
);
5113 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5115 /* determine rwx permissions */
5116 if (is_a_symlink
&& !follow_symlinks
)
5117 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
5120 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
5121 permission
= S_IREAD
;
5123 permission
= S_IREAD
| S_IWRITE
;
5125 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5126 permission
|= S_IEXEC
;
5127 else if (is_exec (name
))
5128 permission
|= S_IEXEC
;
5131 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5137 stat (const char * path
, struct stat
* buf
)
5139 return stat_worker (path
, buf
, 1);
5143 lstat (const char * path
, struct stat
* buf
)
5145 return stat_worker (path
, buf
, 0);
5149 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
5151 /* Rely on a hack: an open directory is modeled as file descriptor 0.
5152 This is good enough for the current usage in Emacs, but is fragile.
5154 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
5155 Gnulib does this and can serve as a model. */
5156 char fullname
[MAX_UTF8_PATH
];
5160 char lastc
= dir_pathname
[strlen (dir_pathname
) - 1];
5162 if (_snprintf (fullname
, sizeof fullname
, "%s%s%s",
5163 dir_pathname
, IS_DIRECTORY_SEP (lastc
) ? "" : "/", name
)
5166 errno
= ENAMETOOLONG
;
5172 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
5175 /* Provide fstat and utime as well as stat for consistent handling of
5178 fstat (int desc
, struct stat
* buf
)
5180 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
5181 BY_HANDLE_FILE_INFORMATION info
;
5182 unsigned __int64 fake_inode
;
5185 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
5187 case FILE_TYPE_DISK
:
5188 buf
->st_mode
= S_IFREG
;
5189 if (!GetFileInformationByHandle (fh
, &info
))
5195 case FILE_TYPE_PIPE
:
5196 buf
->st_mode
= S_IFIFO
;
5198 case FILE_TYPE_CHAR
:
5199 case FILE_TYPE_UNKNOWN
:
5201 buf
->st_mode
= S_IFCHR
;
5203 memset (&info
, 0, sizeof (info
));
5204 info
.dwFileAttributes
= 0;
5205 info
.ftCreationTime
= utc_base_ft
;
5206 info
.ftLastAccessTime
= utc_base_ft
;
5207 info
.ftLastWriteTime
= utc_base_ft
;
5210 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5211 buf
->st_mode
= S_IFDIR
;
5213 buf
->st_nlink
= info
.nNumberOfLinks
;
5214 /* Might as well use file index to fake inode values, but this
5215 is not guaranteed to be unique unless we keep a handle open
5216 all the time (even then there are situations where it is
5217 not unique). Reputedly, there are at most 48 bits of info
5218 (on NTFS, presumably less on FAT). */
5219 fake_inode
= info
.nFileIndexHigh
;
5221 fake_inode
+= info
.nFileIndexLow
;
5223 /* MSVC defines _ino_t to be short; other libc's might not. */
5224 if (sizeof (buf
->st_ino
) == 2)
5225 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
5227 buf
->st_ino
= fake_inode
;
5229 /* If the caller so requested, get the true file owner and group.
5230 Otherwise, consider the file to belong to the current user. */
5231 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
5232 get_file_owner_and_group (NULL
, buf
);
5235 PSECURITY_DESCRIPTOR psd
= NULL
;
5237 psd
= get_file_security_desc_by_handle (fh
);
5240 get_file_owner_and_group (psd
, buf
);
5244 get_file_owner_and_group (NULL
, buf
);
5247 buf
->st_dev
= info
.dwVolumeSerialNumber
;
5248 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
5250 buf
->st_size
= info
.nFileSizeHigh
;
5251 buf
->st_size
<<= 32;
5252 buf
->st_size
+= info
.nFileSizeLow
;
5254 /* Convert timestamps to Unix format. */
5255 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
5256 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
5257 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5258 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
5259 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5261 /* determine rwx permissions */
5262 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
5263 permission
= S_IREAD
;
5265 permission
= S_IREAD
| S_IWRITE
;
5267 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5268 permission
|= S_IEXEC
;
5271 #if 0 /* no way of knowing the filename */
5272 char * p
= strrchr (name
, '.');
5274 (xstrcasecmp (p
, ".exe") == 0 ||
5275 xstrcasecmp (p
, ".com") == 0 ||
5276 xstrcasecmp (p
, ".bat") == 0 ||
5277 xstrcasecmp (p
, ".cmd") == 0))
5278 permission
|= S_IEXEC
;
5282 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5287 /* A version of 'utime' which handles directories as well as
5291 utime (const char *name
, struct utimbuf
*times
)
5293 struct utimbuf deftime
;
5300 deftime
.modtime
= deftime
.actime
= time (NULL
);
5304 if (w32_unicode_filenames
)
5306 wchar_t name_utf16
[MAX_PATH
];
5308 if (filename_to_utf16 (name
, name_utf16
) != 0)
5309 return -1; /* errno set by filename_to_utf16 */
5311 /* Need write access to set times. */
5312 fh
= CreateFileW (name_utf16
, FILE_WRITE_ATTRIBUTES
,
5313 /* If NAME specifies a directory, FILE_SHARE_DELETE
5314 allows other processes to delete files inside it,
5315 while we have the directory open. */
5316 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5317 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5321 char name_ansi
[MAX_PATH
];
5323 if (filename_to_ansi (name
, name_ansi
) != 0)
5324 return -1; /* errno set by filename_to_ansi */
5326 fh
= CreateFileA (name_ansi
, FILE_WRITE_ATTRIBUTES
,
5327 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5328 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5330 if (fh
!= INVALID_HANDLE_VALUE
)
5332 convert_from_time_t (times
->actime
, &atime
);
5333 convert_from_time_t (times
->modtime
, &mtime
);
5334 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
5344 DWORD err
= GetLastError ();
5348 case ERROR_FILE_NOT_FOUND
:
5349 case ERROR_PATH_NOT_FOUND
:
5350 case ERROR_INVALID_DRIVE
:
5351 case ERROR_BAD_NETPATH
:
5352 case ERROR_DEV_NOT_EXIST
:
5353 /* ERROR_INVALID_NAME is the error CreateFile sets when the
5354 file name includes ?s, i.e. translation to ANSI failed. */
5355 case ERROR_INVALID_NAME
:
5358 case ERROR_TOO_MANY_OPEN_FILES
:
5361 case ERROR_ACCESS_DENIED
:
5362 case ERROR_SHARING_VIOLATION
:
5375 sys_umask (int mode
)
5377 static int current_mask
;
5378 int retval
, arg
= 0;
5380 /* The only bit we really support is the write bit. Files are
5381 always readable on MS-Windows, and the execute bit does not exist
5383 /* FIXME: if the GROUP and OTHER bits are reset, we should use ACLs
5384 to prevent access by other users on NTFS. */
5385 if ((mode
& S_IWRITE
) != 0)
5388 retval
= _umask (arg
);
5389 /* Merge into the return value the bits they've set the last time,
5390 which msvcrt.dll ignores and never returns. Emacs insists on its
5391 notion of mask being identical to what we return. */
5392 retval
|= (current_mask
& ~S_IWRITE
);
5393 current_mask
= mode
;
5399 /* Symlink-related functions. */
5400 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
5401 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
5405 symlink (char const *filename
, char const *linkname
)
5407 char linkfn
[MAX_UTF8_PATH
], *tgtfn
;
5409 int dir_access
, filename_ends_in_slash
;
5411 /* Diagnostics follows Posix as much as possible. */
5412 if (filename
== NULL
|| linkname
== NULL
)
5422 if (strlen (filename
) > MAX_UTF8_PATH
|| strlen (linkname
) > MAX_UTF8_PATH
)
5424 errno
= ENAMETOOLONG
;
5428 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
5429 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
5435 /* Note: since empty FILENAME was already rejected, we can safely
5436 refer to FILENAME[1]. */
5437 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
5439 /* Non-absolute FILENAME is understood as being relative to
5440 LINKNAME's directory. We need to prepend that directory to
5441 FILENAME to get correct results from faccessat below, since
5442 otherwise it will interpret FILENAME relative to the
5443 directory where the Emacs process runs. Note that
5444 make-symbolic-link always makes sure LINKNAME is a fully
5445 expanded file name. */
5446 char tem
[MAX_UTF8_PATH
];
5447 char *p
= linkfn
+ strlen (linkfn
);
5449 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
5452 strncpy (tem
, linkfn
, p
- linkfn
);
5453 tem
[p
- linkfn
] = '\0';
5454 strcat (tem
, filename
);
5455 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
5458 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
5460 /* Since Windows distinguishes between symlinks to directories and
5461 to files, we provide a kludgy feature: if FILENAME doesn't
5462 exist, but ends in a slash, we create a symlink to directory. If
5463 FILENAME exists and is a directory, we always create a symlink to
5465 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
5466 if (dir_access
== 0 || filename_ends_in_slash
)
5467 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
5469 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
5470 if (filename_ends_in_slash
)
5471 tgtfn
[strlen (tgtfn
) - 1] = '\0';
5474 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
5476 /* ENOSYS is set by create_symbolic_link, when it detects that
5477 the OS doesn't support the CreateSymbolicLink API. */
5478 if (errno
!= ENOSYS
)
5480 DWORD w32err
= GetLastError ();
5484 /* ERROR_SUCCESS is sometimes returned when LINKFN and
5485 TGTFN point to the same file name, go figure. */
5487 case ERROR_FILE_EXISTS
:
5490 case ERROR_ACCESS_DENIED
:
5493 case ERROR_FILE_NOT_FOUND
:
5494 case ERROR_PATH_NOT_FOUND
:
5495 case ERROR_BAD_NETPATH
:
5496 case ERROR_INVALID_REPARSE_DATA
:
5499 case ERROR_DIRECTORY
:
5502 case ERROR_PRIVILEGE_NOT_HELD
:
5503 case ERROR_NOT_ALL_ASSIGNED
:
5506 case ERROR_DISK_FULL
:
5519 /* A quick inexpensive test of whether FILENAME identifies a file that
5520 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
5521 must already be in the normalized form returned by
5524 Note: for repeated operations on many files, it is best to test
5525 whether the underlying volume actually supports symlinks, by
5526 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
5527 avoid the call to this function if it doesn't. That's because the
5528 call to GetFileAttributes takes a non-negligible time, especially
5529 on non-local or removable filesystems. See stat_worker for an
5530 example of how to do that. */
5532 is_symlink (const char *filename
)
5535 wchar_t filename_w
[MAX_PATH
];
5536 char filename_a
[MAX_PATH
];
5537 WIN32_FIND_DATAW wfdw
;
5538 WIN32_FIND_DATAA wfda
;
5540 int attrs_mean_symlink
;
5542 if (w32_unicode_filenames
)
5544 filename_to_utf16 (filename
, filename_w
);
5545 attrs
= GetFileAttributesW (filename_w
);
5549 filename_to_ansi (filename
, filename_a
);
5550 attrs
= GetFileAttributesA (filename_a
);
5554 DWORD w32err
= GetLastError ();
5558 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
5560 case ERROR_ACCESS_DENIED
:
5563 case ERROR_FILE_NOT_FOUND
:
5564 case ERROR_PATH_NOT_FOUND
:
5571 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
5573 logon_network_drive (filename
);
5574 if (w32_unicode_filenames
)
5576 fh
= FindFirstFileW (filename_w
, &wfdw
);
5577 attrs_mean_symlink
=
5578 (wfdw
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5579 && (wfdw
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5581 else if (_mbspbrk (filename_a
, "?"))
5583 /* filename_to_ansi failed to convert the file name. */
5589 fh
= FindFirstFileA (filename_a
, &wfda
);
5590 attrs_mean_symlink
=
5591 (wfda
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5592 && (wfda
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5594 if (fh
== INVALID_HANDLE_VALUE
)
5597 return attrs_mean_symlink
;
5600 /* If NAME identifies a symbolic link, copy into BUF the file name of
5601 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
5602 null-terminate the target name, even if it fits. Return the number
5603 of bytes copied, or -1 if NAME is not a symlink or any error was
5604 encountered while resolving it. The file name copied into BUF is
5605 encoded in the current ANSI codepage. */
5607 readlink (const char *name
, char *buf
, size_t buf_size
)
5610 TOKEN_PRIVILEGES privs
;
5611 int restore_privs
= 0;
5614 char resolved
[MAX_UTF8_PATH
];
5627 path
= map_w32_filename (name
, NULL
);
5629 if (strlen (path
) > MAX_UTF8_PATH
)
5631 errno
= ENAMETOOLONG
;
5636 if (is_windows_9x () == TRUE
5637 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
5638 || !is_symlink (path
))
5641 errno
= EINVAL
; /* not a symlink */
5645 /* Done with simple tests, now we're in for some _real_ work. */
5646 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
5648 /* Implementation note: From here and onward, don't return early,
5649 since that will fail to restore the original set of privileges of
5650 the calling thread. */
5652 retval
= -1; /* not too optimistic, are we? */
5654 /* Note: In the next call to CreateFile, we use zero as the 2nd
5655 argument because, when the symlink is a hidden/system file,
5656 e.g. 'C:\Users\All Users', GENERIC_READ fails with
5657 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
5658 and directory symlinks. */
5659 if (w32_unicode_filenames
)
5661 wchar_t path_w
[MAX_PATH
];
5663 filename_to_utf16 (path
, path_w
);
5664 sh
= CreateFileW (path_w
, 0, 0, NULL
, OPEN_EXISTING
,
5665 FILE_FLAG_OPEN_REPARSE_POINT
5666 | FILE_FLAG_BACKUP_SEMANTICS
,
5671 char path_a
[MAX_PATH
];
5673 filename_to_ansi (path
, path_a
);
5674 sh
= CreateFileA (path_a
, 0, 0, NULL
, OPEN_EXISTING
,
5675 FILE_FLAG_OPEN_REPARSE_POINT
5676 | FILE_FLAG_BACKUP_SEMANTICS
,
5679 if (sh
!= INVALID_HANDLE_VALUE
)
5681 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
5682 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
5685 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
5686 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
5689 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
5693 /* Copy the link target name, in wide characters, from
5694 reparse_data, then convert it to multibyte encoding in
5695 the current locale's codepage. */
5699 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
5701 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
5702 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
5703 size_t size_to_copy
= buf_size
;
5705 /* According to MSDN, PrintNameLength does not include the
5706 terminating null character. */
5707 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
5708 memcpy (lwname
, lwname_src
, lwname_len
);
5709 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
5710 filename_from_utf16 (lwname
, resolved
);
5711 dostounix_filename (resolved
);
5712 lname_size
= strlen (resolved
) + 1;
5713 if (lname_size
<= buf_size
)
5714 size_to_copy
= lname_size
;
5715 strncpy (buf
, resolved
, size_to_copy
);
5717 retval
= size_to_copy
;
5723 /* CreateFile failed. */
5724 DWORD w32err2
= GetLastError ();
5728 case ERROR_FILE_NOT_FOUND
:
5729 case ERROR_PATH_NOT_FOUND
:
5732 case ERROR_ACCESS_DENIED
:
5733 case ERROR_TOO_MANY_OPEN_FILES
:
5743 restore_privilege (&privs
);
5751 readlinkat (int fd
, char const *name
, char *buffer
,
5754 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5755 as in fstatat. FIXME: Add proper support for readlinkat. */
5756 char fullname
[MAX_UTF8_PATH
];
5760 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
5763 errno
= ENAMETOOLONG
;
5769 return readlink (name
, buffer
, buffer_size
);
5772 /* If FILE is a symlink, return its target (stored in a static
5773 buffer); otherwise return FILE.
5775 This function repeatedly resolves symlinks in the last component of
5776 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5777 until it arrives at a file whose last component is not a symlink,
5778 or some error occurs. It returns the target of the last
5779 successfully resolved symlink in the chain. If it succeeds to
5780 resolve even a single symlink, the value returned is an absolute
5781 file name with backslashes (result of GetFullPathName). By
5782 contrast, if the original FILE is returned, it is unaltered.
5784 Note: This function can set errno even if it succeeds.
5786 Implementation note: we only resolve the last portion ("basename")
5787 of the argument FILE and of each following file in the chain,
5788 disregarding any possible symlinks in its leading directories.
5789 This is because Windows system calls and library functions
5790 transparently resolve symlinks in leading directories and return
5791 correct information, as long as the basename is not a symlink. */
5793 chase_symlinks (const char *file
)
5795 static char target
[MAX_UTF8_PATH
];
5796 char link
[MAX_UTF8_PATH
];
5797 wchar_t target_w
[MAX_PATH
], link_w
[MAX_PATH
];
5798 char target_a
[MAX_PATH
], link_a
[MAX_PATH
];
5799 ssize_t res
, link_len
;
5802 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
5803 return (char *)file
;
5805 if (w32_unicode_filenames
)
5807 wchar_t file_w
[MAX_PATH
];
5809 filename_to_utf16 (file
, file_w
);
5810 if (GetFullPathNameW (file_w
, MAX_PATH
, link_w
, NULL
) == 0)
5811 return (char *)file
;
5812 filename_from_utf16 (link_w
, link
);
5816 char file_a
[MAX_PATH
];
5818 filename_to_ansi (file
, file_a
);
5819 if (GetFullPathNameA (file_a
, MAX_PATH
, link_a
, NULL
) == 0)
5820 return (char *)file
;
5821 filename_from_ansi (link_a
, link
);
5823 link_len
= strlen (link
);
5828 /* Remove trailing slashes, as we want to resolve the last
5829 non-trivial part of the link name. */
5830 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
5831 link
[link_len
--] = '\0';
5833 res
= readlink (link
, target
, MAX_UTF8_PATH
);
5837 if (!(IS_DEVICE_SEP (target
[1])
5838 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5840 /* Target is relative. Append it to the directory part of
5841 the symlink, then copy the result back to target. */
5842 char *p
= link
+ link_len
;
5844 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5847 strcpy (target
, link
);
5849 /* Resolve any "." and ".." to get a fully-qualified file name
5851 if (w32_unicode_filenames
)
5853 filename_to_utf16 (target
, target_w
);
5854 link_len
= GetFullPathNameW (target_w
, MAX_PATH
, link_w
, NULL
);
5856 filename_from_utf16 (link_w
, link
);
5860 filename_to_ansi (target
, target_a
);
5861 link_len
= GetFullPathNameA (target_a
, MAX_PATH
, link_a
, NULL
);
5863 filename_from_ansi (link_a
, link
);
5865 link_len
= strlen (link
);
5867 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5869 if (loop_count
> 100)
5872 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5873 return (char *)file
;
5878 /* Posix ACL emulation. */
5881 acl_valid (acl_t acl
)
5883 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5887 acl_to_text (acl_t acl
, ssize_t
*size
)
5890 SECURITY_INFORMATION flags
=
5891 OWNER_SECURITY_INFORMATION
|
5892 GROUP_SECURITY_INFORMATION
|
5893 DACL_SECURITY_INFORMATION
;
5894 char *retval
= NULL
;
5900 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5903 /* We don't want to mix heaps, so we duplicate the string in our
5904 heap and free the one allocated by the API. */
5905 retval
= xstrdup (str_acl
);
5908 LocalFree (str_acl
);
5910 else if (errno
!= ENOTSUP
)
5917 acl_from_text (const char *acl_str
)
5919 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5925 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5928 retval
= xmalloc (sd_size
);
5929 memcpy (retval
, psd
, sd_size
);
5932 else if (errno
!= ENOTSUP
)
5939 acl_free (void *ptr
)
5946 acl_get_file (const char *fname
, acl_type_t type
)
5948 PSECURITY_DESCRIPTOR psd
= NULL
;
5949 const char *filename
;
5951 if (type
== ACL_TYPE_ACCESS
)
5954 SECURITY_INFORMATION si
=
5955 OWNER_SECURITY_INFORMATION
|
5956 GROUP_SECURITY_INFORMATION
|
5957 DACL_SECURITY_INFORMATION
;
5960 filename
= map_w32_filename (fname
, NULL
);
5961 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5962 fname
= chase_symlinks (filename
);
5967 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5968 && errno
!= ENOTSUP
)
5970 err
= GetLastError ();
5971 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5973 psd
= xmalloc (sd_len
);
5974 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5981 else if (err
== ERROR_FILE_NOT_FOUND
5982 || err
== ERROR_PATH_NOT_FOUND
5983 /* ERROR_INVALID_NAME is what we get if
5984 w32-unicode-filenames is nil and the file cannot
5985 be encoded in the current ANSI codepage. */
5986 || err
== ERROR_INVALID_NAME
)
5994 else if (type
!= ACL_TYPE_DEFAULT
)
6001 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
6003 TOKEN_PRIVILEGES old1
, old2
;
6005 int st
= 0, retval
= -1;
6006 SECURITY_INFORMATION flags
= 0;
6007 PSID psidOwner
, psidGroup
;
6012 const char *filename
;
6014 if (acl_valid (acl
) != 0
6015 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
6021 if (type
== ACL_TYPE_DEFAULT
)
6027 filename
= map_w32_filename (fname
, NULL
);
6028 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
6029 fname
= chase_symlinks (filename
);
6033 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psidOwner
,
6036 flags
|= OWNER_SECURITY_INFORMATION
;
6037 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psidGroup
,
6040 flags
|= GROUP_SECURITY_INFORMATION
;
6041 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
6044 flags
|= DACL_SECURITY_INFORMATION
;
6048 /* According to KB-245153, setting the owner will succeed if either:
6049 (1) the caller is the user who will be the new owner, and has the
6050 SE_TAKE_OWNERSHIP privilege, or
6051 (2) the caller has the SE_RESTORE privilege, in which case she can
6052 set any valid user or group as the owner
6054 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
6055 privileges, and disregard any failures in obtaining them. If
6056 these privileges cannot be obtained, and do not already exist in
6057 the calling thread's security token, this function could fail
6059 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
6061 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
6066 /* SetFileSecurity is deprecated by MS, and sometimes fails when
6067 DACL inheritance is involved, but it seems to preserve ownership
6068 better than SetNamedSecurityInfo, which is important e.g., in
6070 if (!set_file_security (fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
6072 err
= GetLastError ();
6074 if (errno
!= ENOTSUP
)
6075 err
= set_named_security_info (fname
, SE_FILE_OBJECT
, flags
,
6076 psidOwner
, psidGroup
, pacl
, NULL
);
6079 err
= ERROR_SUCCESS
;
6080 if (err
!= ERROR_SUCCESS
)
6082 if (errno
== ENOTSUP
)
6084 else if (err
== ERROR_INVALID_OWNER
6085 || err
== ERROR_NOT_ALL_ASSIGNED
6086 || err
== ERROR_ACCESS_DENIED
)
6088 /* Maybe the requested ACL and the one the file already has
6089 are identical, in which case we can silently ignore the
6090 failure. (And no, Windows doesn't.) */
6091 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
6096 char *acl_from
= acl_to_text (current_acl
, NULL
);
6097 char *acl_to
= acl_to_text (acl
, NULL
);
6099 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
6105 acl_free (acl_from
);
6108 acl_free (current_acl
);
6111 else if (err
== ERROR_FILE_NOT_FOUND
6112 || err
== ERROR_PATH_NOT_FOUND
6113 /* ERROR_INVALID_NAME is what we get if
6114 w32-unicode-filenames is nil and the file cannot be
6115 encoded in the current ANSI codepage. */
6116 || err
== ERROR_INVALID_NAME
)
6130 restore_privilege (&old2
);
6131 restore_privilege (&old1
);
6139 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
6140 have a fixed max size for file names, so we don't need the kind of
6141 alloc/malloc/realloc dance the gnulib version does. We also don't
6142 support FD-relative symlinks. */
6144 careadlinkat (int fd
, char const *filename
,
6145 char *buffer
, size_t buffer_size
,
6146 struct allocator
const *alloc
,
6147 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
6149 char linkname
[MAX_UTF8_PATH
];
6152 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
6156 char *retval
= buffer
;
6158 linkname
[link_size
++] = '\0';
6159 if (link_size
> buffer_size
)
6160 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
6162 memcpy (retval
, linkname
, link_size
);
6170 w32_copy_file (const char *from
, const char *to
,
6171 int keep_time
, int preserve_ownership
, int copy_acls
)
6175 wchar_t from_w
[MAX_PATH
], to_w
[MAX_PATH
];
6176 char from_a
[MAX_PATH
], to_a
[MAX_PATH
];
6178 /* We ignore preserve_ownership for now. */
6179 preserve_ownership
= preserve_ownership
;
6183 acl
= acl_get_file (from
, ACL_TYPE_ACCESS
);
6184 if (acl
== NULL
&& acl_errno_valid (errno
))
6187 if (w32_unicode_filenames
)
6189 filename_to_utf16 (from
, from_w
);
6190 filename_to_utf16 (to
, to_w
);
6191 copy_result
= CopyFileW (from_w
, to_w
, FALSE
);
6195 filename_to_ansi (from
, from_a
);
6196 filename_to_ansi (to
, to_a
);
6197 copy_result
= CopyFileA (from_a
, to_a
, FALSE
);
6201 /* CopyFile doesn't set errno when it fails. By far the most
6202 "popular" reason is that the target is read-only. */
6203 DWORD err
= GetLastError ();
6207 case ERROR_FILE_NOT_FOUND
:
6210 case ERROR_ACCESS_DENIED
:
6213 case ERROR_ENCRYPTION_FAILED
:
6225 /* CopyFile retains the timestamp by default. However, see
6226 "Community Additions" for CopyFile: it sounds like that is not
6227 entirely true. Testing on Windows XP confirms that modified time
6228 is copied, but creation and last-access times are not.
6230 else if (!keep_time
)
6232 struct timespec now
;
6235 if (w32_unicode_filenames
)
6237 /* Ensure file is writable while its times are set. */
6238 attributes
= GetFileAttributesW (to_w
);
6239 SetFileAttributesW (to_w
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6240 now
= current_timespec ();
6241 if (set_file_times (-1, to
, now
, now
))
6243 /* Restore original attributes. */
6244 SetFileAttributesW (to_w
, attributes
);
6249 /* Restore original attributes. */
6250 SetFileAttributesW (to_w
, attributes
);
6254 attributes
= GetFileAttributesA (to_a
);
6255 SetFileAttributesA (to_a
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6256 now
= current_timespec ();
6257 if (set_file_times (-1, to
, now
, now
))
6259 SetFileAttributesA (to_a
, attributes
);
6264 SetFileAttributesA (to_a
, attributes
);
6270 acl_set_file (to
, ACL_TYPE_ACCESS
, acl
) != 0;
6272 if (fail
&& acl_errno_valid (errno
))
6280 /* Support for browsing other processes and their attributes. See
6281 process.c for the Lisp bindings. */
6283 /* Helper wrapper functions. */
6285 static HANDLE WINAPI
6286 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
6288 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
6290 if (g_b_init_create_toolhelp32_snapshot
== 0)
6292 g_b_init_create_toolhelp32_snapshot
= 1;
6293 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
6294 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6295 "CreateToolhelp32Snapshot");
6297 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
6299 return INVALID_HANDLE_VALUE
;
6301 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
6305 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6307 static Process32First_Proc s_pfn_Process32_First
= NULL
;
6309 if (g_b_init_process32_first
== 0)
6311 g_b_init_process32_first
= 1;
6312 s_pfn_Process32_First
= (Process32First_Proc
)
6313 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6316 if (s_pfn_Process32_First
== NULL
)
6320 return (s_pfn_Process32_First (hSnapshot
, lppe
));
6324 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6326 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
6328 if (g_b_init_process32_next
== 0)
6330 g_b_init_process32_next
= 1;
6331 s_pfn_Process32_Next
= (Process32Next_Proc
)
6332 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6335 if (s_pfn_Process32_Next
== NULL
)
6339 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
6343 open_thread_token (HANDLE ThreadHandle
,
6344 DWORD DesiredAccess
,
6346 PHANDLE TokenHandle
)
6348 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
6349 HMODULE hm_advapi32
= NULL
;
6350 if (is_windows_9x () == TRUE
)
6352 SetLastError (ERROR_NOT_SUPPORTED
);
6355 if (g_b_init_open_thread_token
== 0)
6357 g_b_init_open_thread_token
= 1;
6358 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6359 s_pfn_Open_Thread_Token
=
6360 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
6362 if (s_pfn_Open_Thread_Token
== NULL
)
6364 SetLastError (ERROR_NOT_SUPPORTED
);
6368 s_pfn_Open_Thread_Token (
6377 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
6379 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
6380 HMODULE hm_advapi32
= NULL
;
6381 if (is_windows_9x () == TRUE
)
6385 if (g_b_init_impersonate_self
== 0)
6387 g_b_init_impersonate_self
= 1;
6388 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6389 s_pfn_Impersonate_Self
=
6390 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
6392 if (s_pfn_Impersonate_Self
== NULL
)
6396 return s_pfn_Impersonate_Self (ImpersonationLevel
);
6400 revert_to_self (void)
6402 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
6403 HMODULE hm_advapi32
= NULL
;
6404 if (is_windows_9x () == TRUE
)
6408 if (g_b_init_revert_to_self
== 0)
6410 g_b_init_revert_to_self
= 1;
6411 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6412 s_pfn_Revert_To_Self
=
6413 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
6415 if (s_pfn_Revert_To_Self
== NULL
)
6419 return s_pfn_Revert_To_Self ();
6423 get_process_memory_info (HANDLE h_proc
,
6424 PPROCESS_MEMORY_COUNTERS mem_counters
,
6427 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
6428 HMODULE hm_psapi
= NULL
;
6429 if (is_windows_9x () == TRUE
)
6433 if (g_b_init_get_process_memory_info
== 0)
6435 g_b_init_get_process_memory_info
= 1;
6436 hm_psapi
= LoadLibrary ("Psapi.dll");
6438 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
6439 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
6441 if (s_pfn_Get_Process_Memory_Info
== NULL
)
6445 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
6449 get_process_working_set_size (HANDLE h_proc
,
6453 static GetProcessWorkingSetSize_Proc
6454 s_pfn_Get_Process_Working_Set_Size
= NULL
;
6456 if (is_windows_9x () == TRUE
)
6460 if (g_b_init_get_process_working_set_size
== 0)
6462 g_b_init_get_process_working_set_size
= 1;
6463 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
6464 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6465 "GetProcessWorkingSetSize");
6467 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
6471 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
6475 global_memory_status (MEMORYSTATUS
*buf
)
6477 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
6479 if (is_windows_9x () == TRUE
)
6483 if (g_b_init_global_memory_status
== 0)
6485 g_b_init_global_memory_status
= 1;
6486 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
6487 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6488 "GlobalMemoryStatus");
6490 if (s_pfn_Global_Memory_Status
== NULL
)
6494 return s_pfn_Global_Memory_Status (buf
);
6498 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
6500 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
6502 if (is_windows_9x () == TRUE
)
6506 if (g_b_init_global_memory_status_ex
== 0)
6508 g_b_init_global_memory_status_ex
= 1;
6509 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
6510 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6511 "GlobalMemoryStatusEx");
6513 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
6517 return s_pfn_Global_Memory_Status_Ex (buf
);
6521 list_system_processes (void)
6523 struct gcpro gcpro1
;
6524 Lisp_Object proclist
= Qnil
;
6527 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6529 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6531 PROCESSENTRY32 proc_entry
;
6537 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
6538 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
6539 res
= process32_next (h_snapshot
, &proc_entry
))
6541 proc_id
= proc_entry
.th32ProcessID
;
6542 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
6545 CloseHandle (h_snapshot
);
6547 proclist
= Fnreverse (proclist
);
6554 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
6556 TOKEN_PRIVILEGES priv
;
6557 DWORD priv_size
= sizeof (priv
);
6558 DWORD opriv_size
= sizeof (*old_priv
);
6559 HANDLE h_token
= NULL
;
6560 HANDLE h_thread
= GetCurrentThread ();
6564 res
= open_thread_token (h_thread
,
6565 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6567 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
6569 if (impersonate_self (SecurityImpersonation
))
6570 res
= open_thread_token (h_thread
,
6571 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6576 priv
.PrivilegeCount
= 1;
6577 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
6578 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
6579 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
6580 old_priv
, &opriv_size
)
6581 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6585 CloseHandle (h_token
);
6591 restore_privilege (TOKEN_PRIVILEGES
*priv
)
6593 DWORD priv_size
= sizeof (*priv
);
6594 HANDLE h_token
= NULL
;
6597 if (open_thread_token (GetCurrentThread (),
6598 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6601 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
6602 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6606 CloseHandle (h_token
);
6612 ltime (ULONGLONG time_100ns
)
6614 ULONGLONG time_sec
= time_100ns
/ 10000000;
6615 int subsec
= time_100ns
% 10000000;
6616 return list4i (time_sec
>> 16, time_sec
& 0xffff,
6617 subsec
/ 10, subsec
% 10 * 100000);
6620 #define U64_TO_LISP_TIME(time) ltime (time)
6623 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
6624 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
6627 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
6628 ULONGLONG tem1
, tem2
, tem3
, tem
;
6631 || !get_process_times_fn
6632 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
6633 &ft_kernel
, &ft_user
))
6636 GetSystemTimeAsFileTime (&ft_current
);
6638 FILETIME_TO_U64 (tem1
, ft_kernel
);
6639 *stime
= U64_TO_LISP_TIME (tem1
);
6641 FILETIME_TO_U64 (tem2
, ft_user
);
6642 *utime
= U64_TO_LISP_TIME (tem2
);
6645 *ttime
= U64_TO_LISP_TIME (tem3
);
6647 FILETIME_TO_U64 (tem
, ft_creation
);
6648 /* Process no 4 (System) returns zero creation time. */
6651 *ctime
= U64_TO_LISP_TIME (tem
);
6655 FILETIME_TO_U64 (tem3
, ft_current
);
6656 tem
= (tem3
- utc_base
) - tem
;
6658 *etime
= U64_TO_LISP_TIME (tem
);
6662 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
6673 system_process_attributes (Lisp_Object pid
)
6675 struct gcpro gcpro1
, gcpro2
, gcpro3
;
6676 Lisp_Object attrs
= Qnil
;
6677 Lisp_Object cmd_str
, decoded_cmd
, tem
;
6678 HANDLE h_snapshot
, h_proc
;
6681 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
6682 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
6683 DWORD glength
= sizeof (gname
);
6684 HANDLE token
= NULL
;
6685 SID_NAME_USE user_type
;
6686 unsigned char *buf
= NULL
;
6688 TOKEN_USER user_token
;
6689 TOKEN_PRIMARY_GROUP group_token
;
6692 PROCESS_MEMORY_COUNTERS mem
;
6693 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
6694 SIZE_T minrss
, maxrss
;
6696 MEMORY_STATUS_EX memstex
;
6697 double totphys
= 0.0;
6698 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
6700 BOOL result
= FALSE
;
6702 CHECK_NUMBER_OR_FLOAT (pid
);
6703 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
6705 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6707 GCPRO3 (attrs
, decoded_cmd
, tem
);
6709 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6714 pe
.dwSize
= sizeof (PROCESSENTRY32
);
6715 for (res
= process32_first (h_snapshot
, &pe
); res
;
6716 res
= process32_next (h_snapshot
, &pe
))
6718 if (proc_id
== pe
.th32ProcessID
)
6721 decoded_cmd
= build_string ("Idle");
6724 /* Decode the command name from locale-specific
6726 cmd_str
= build_unibyte_string (pe
.szExeFile
);
6729 code_convert_string_norecord (cmd_str
,
6730 Vlocale_coding_system
, 0);
6732 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
6733 attrs
= Fcons (Fcons (Qppid
,
6734 make_fixnum_or_float (pe
.th32ParentProcessID
)),
6736 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
6738 attrs
= Fcons (Fcons (Qthcount
,
6739 make_fixnum_or_float (pe
.cntThreads
)),
6746 CloseHandle (h_snapshot
);
6755 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6757 /* If we were denied a handle to the process, try again after
6758 enabling the SeDebugPrivilege in our process. */
6761 TOKEN_PRIVILEGES priv_current
;
6763 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
6765 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6767 restore_privilege (&priv_current
);
6773 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
6776 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
6777 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6779 buf
= xmalloc (blen
);
6780 result
= get_token_information (token
, TokenUser
,
6781 (LPVOID
)buf
, blen
, &needed
);
6784 memcpy (&user_token
, buf
, sizeof (user_token
));
6785 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
6787 euid
= get_rid (user_token
.User
.Sid
);
6788 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
6793 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
6796 strcpy (uname
, "unknown");
6800 ulength
= strlen (uname
);
6806 /* Determine a reasonable euid and gid values. */
6807 if (xstrcasecmp ("administrator", uname
) == 0)
6809 euid
= 500; /* well-known Administrator uid */
6810 egid
= 513; /* well-known None gid */
6814 /* Get group id and name. */
6815 result
= get_token_information (token
, TokenPrimaryGroup
,
6816 (LPVOID
)buf
, blen
, &needed
);
6817 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6819 buf
= xrealloc (buf
, blen
= needed
);
6820 result
= get_token_information (token
, TokenPrimaryGroup
,
6821 (LPVOID
)buf
, blen
, &needed
);
6825 memcpy (&group_token
, buf
, sizeof (group_token
));
6826 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
6828 egid
= get_rid (group_token
.PrimaryGroup
);
6829 dlength
= sizeof (domain
);
6831 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
6832 gname
, &glength
, NULL
, &dlength
,
6835 w32_add_to_cache (group_token
.PrimaryGroup
,
6839 strcpy (gname
, "None");
6843 glength
= strlen (gname
);
6851 if (!is_windows_9x ())
6853 /* We couldn't open the process token, presumably because of
6854 insufficient access rights. Assume this process is run
6856 strcpy (uname
, "SYSTEM");
6857 strcpy (gname
, "None");
6858 euid
= 18; /* SYSTEM */
6859 egid
= 513; /* None */
6860 glength
= strlen (gname
);
6861 ulength
= strlen (uname
);
6863 /* If we are running under Windows 9X, where security calls are
6864 not supported, we assume all processes are run by the current
6866 else if (GetUserName (uname
, &ulength
))
6868 if (xstrcasecmp ("administrator", uname
) == 0)
6873 strcpy (gname
, "None");
6874 glength
= strlen (gname
);
6875 ulength
= strlen (uname
);
6881 strcpy (uname
, "administrator");
6882 ulength
= strlen (uname
);
6883 strcpy (gname
, "None");
6884 glength
= strlen (gname
);
6887 CloseHandle (token
);
6890 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
6891 tem
= make_unibyte_string (uname
, ulength
);
6892 attrs
= Fcons (Fcons (Quser
,
6893 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6895 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
6896 tem
= make_unibyte_string (gname
, glength
);
6897 attrs
= Fcons (Fcons (Qgroup
,
6898 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6901 if (global_memory_status_ex (&memstex
))
6902 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
6903 totphys
= memstex
.ullTotalPhys
/ 1024.0;
6905 /* Visual Studio 6 cannot convert an unsigned __int64 type to
6906 double, so we need to do this for it... */
6908 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
6909 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
6910 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
6912 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
6914 #endif /* __GNUC__ || _MSC_VER >= 1300 */
6915 else if (global_memory_status (&memst
))
6916 totphys
= memst
.dwTotalPhys
/ 1024.0;
6919 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
6922 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6924 attrs
= Fcons (Fcons (Qmajflt
,
6925 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
6927 attrs
= Fcons (Fcons (Qvsize
,
6928 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
6930 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6932 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6935 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
6937 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
6939 attrs
= Fcons (Fcons (Qmajflt
,
6940 make_fixnum_or_float (mem
.PageFaultCount
)),
6942 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
6944 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6947 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
6949 DWORD rss
= maxrss
/ 1024;
6951 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
6953 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
6956 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
6958 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
6959 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
6960 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
6961 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
6962 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
6963 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
6966 /* FIXME: Retrieve command line by walking the PEB of the process. */
6969 CloseHandle (h_proc
);
6975 /* Wrappers for winsock functions to map between our file descriptors
6976 and winsock's handles; also set h_errno for convenience.
6978 To allow Emacs to run on systems which don't have winsock support
6979 installed, we dynamically link to winsock on startup if present, and
6980 otherwise provide the minimum necessary functionality
6981 (eg. gethostname). */
6983 /* function pointers for relevant socket functions */
6984 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
6985 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
6986 int (PASCAL
*pfn_WSAGetLastError
) (void);
6987 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
6988 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
6989 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
6990 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
6991 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6992 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6993 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
6994 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
6995 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
6996 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
6997 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
6998 int (PASCAL
*pfn_WSACleanup
) (void);
7000 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
7001 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
7002 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
7003 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
7004 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
7005 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
7006 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
7007 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
7008 const char * optval
, int optlen
);
7009 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
7010 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
7012 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
7013 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
7014 struct sockaddr
* from
, int * fromlen
);
7015 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
7016 const struct sockaddr
* to
, int tolen
);
7018 /* SetHandleInformation is only needed to make sockets non-inheritable. */
7019 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
7020 #ifndef HANDLE_FLAG_INHERIT
7021 #define HANDLE_FLAG_INHERIT 1
7025 static int winsock_inuse
;
7030 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
7032 release_listen_threads ();
7033 /* Not sure what would cause WSAENETDOWN, or even if it can happen
7034 after WSAStartup returns successfully, but it seems reasonable
7035 to allow unloading winsock anyway in that case. */
7036 if (pfn_WSACleanup () == 0 ||
7037 pfn_WSAGetLastError () == WSAENETDOWN
)
7039 if (FreeLibrary (winsock_lib
))
7048 init_winsock (int load_now
)
7050 WSADATA winsockData
;
7052 if (winsock_lib
!= NULL
)
7055 pfn_SetHandleInformation
7056 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
7057 "SetHandleInformation");
7059 winsock_lib
= LoadLibrary ("Ws2_32.dll");
7061 if (winsock_lib
!= NULL
)
7063 /* dynamically link to socket functions */
7065 #define LOAD_PROC(fn) \
7066 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
7069 LOAD_PROC (WSAStartup
);
7070 LOAD_PROC (WSASetLastError
);
7071 LOAD_PROC (WSAGetLastError
);
7072 LOAD_PROC (WSAEventSelect
);
7073 LOAD_PROC (WSACreateEvent
);
7074 LOAD_PROC (WSACloseEvent
);
7077 LOAD_PROC (connect
);
7078 LOAD_PROC (ioctlsocket
);
7081 LOAD_PROC (closesocket
);
7082 LOAD_PROC (shutdown
);
7085 LOAD_PROC (inet_addr
);
7086 LOAD_PROC (gethostname
);
7087 LOAD_PROC (gethostbyname
);
7088 LOAD_PROC (getservbyname
);
7089 LOAD_PROC (getpeername
);
7090 LOAD_PROC (WSACleanup
);
7091 LOAD_PROC (setsockopt
);
7093 LOAD_PROC (getsockname
);
7095 LOAD_PROC (recvfrom
);
7099 /* specify version 1.1 of winsock */
7100 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
7102 if (winsockData
.wVersion
!= 0x101)
7107 /* Report that winsock exists and is usable, but leave
7108 socket functions disabled. I am assuming that calling
7109 WSAStartup does not require any network interaction,
7110 and in particular does not cause or require a dial-up
7111 connection to be established. */
7114 FreeLibrary (winsock_lib
);
7122 FreeLibrary (winsock_lib
);
7132 /* Function to map winsock error codes to errno codes for those errno
7133 code defined in errno.h (errno values not defined by errno.h are
7134 already in nt/inc/sys/socket.h). */
7141 if (winsock_lib
== NULL
)
7144 wsa_err
= pfn_WSAGetLastError ();
7148 case WSAEACCES
: errno
= EACCES
; break;
7149 case WSAEBADF
: errno
= EBADF
; break;
7150 case WSAEFAULT
: errno
= EFAULT
; break;
7151 case WSAEINTR
: errno
= EINTR
; break;
7152 case WSAEINVAL
: errno
= EINVAL
; break;
7153 case WSAEMFILE
: errno
= EMFILE
; break;
7154 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
7155 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
7156 default: errno
= wsa_err
; break;
7164 if (winsock_lib
!= NULL
)
7165 pfn_WSASetLastError (0);
7168 /* Extend strerror to handle the winsock-specific error codes. */
7172 } _wsa_errlist
[] = {
7173 {WSAEINTR
, "Interrupted function call"},
7174 {WSAEBADF
, "Bad file descriptor"},
7175 {WSAEACCES
, "Permission denied"},
7176 {WSAEFAULT
, "Bad address"},
7177 {WSAEINVAL
, "Invalid argument"},
7178 {WSAEMFILE
, "Too many open files"},
7180 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
7181 {WSAEINPROGRESS
, "Operation now in progress"},
7182 {WSAEALREADY
, "Operation already in progress"},
7183 {WSAENOTSOCK
, "Socket operation on non-socket"},
7184 {WSAEDESTADDRREQ
, "Destination address required"},
7185 {WSAEMSGSIZE
, "Message too long"},
7186 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
7187 {WSAENOPROTOOPT
, "Bad protocol option"},
7188 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
7189 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
7190 {WSAEOPNOTSUPP
, "Operation not supported"},
7191 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
7192 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
7193 {WSAEADDRINUSE
, "Address already in use"},
7194 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
7195 {WSAENETDOWN
, "Network is down"},
7196 {WSAENETUNREACH
, "Network is unreachable"},
7197 {WSAENETRESET
, "Network dropped connection on reset"},
7198 {WSAECONNABORTED
, "Software caused connection abort"},
7199 {WSAECONNRESET
, "Connection reset by peer"},
7200 {WSAENOBUFS
, "No buffer space available"},
7201 {WSAEISCONN
, "Socket is already connected"},
7202 {WSAENOTCONN
, "Socket is not connected"},
7203 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
7204 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
7205 {WSAETIMEDOUT
, "Connection timed out"},
7206 {WSAECONNREFUSED
, "Connection refused"},
7207 {WSAELOOP
, "Network loop"}, /* not sure */
7208 {WSAENAMETOOLONG
, "Name is too long"},
7209 {WSAEHOSTDOWN
, "Host is down"},
7210 {WSAEHOSTUNREACH
, "No route to host"},
7211 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
7212 {WSAEPROCLIM
, "Too many processes"},
7213 {WSAEUSERS
, "Too many users"}, /* not sure */
7214 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
7215 {WSAESTALE
, "Data is stale"}, /* not sure */
7216 {WSAEREMOTE
, "Remote error"}, /* not sure */
7218 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
7219 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
7220 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
7221 {WSAEDISCON
, "Graceful shutdown in progress"},
7223 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
7224 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
7225 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
7226 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
7227 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
7228 {WSASYSCALLFAILURE
, "System call failure"},
7229 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
7230 {WSATYPE_NOT_FOUND
, "Class type not found"},
7231 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
7232 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
7233 {WSAEREFUSED
, "Operation refused"}, /* not sure */
7236 {WSAHOST_NOT_FOUND
, "Host not found"},
7237 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
7238 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
7239 {WSANO_DATA
, "Valid name, no data record of requested type"},
7245 sys_strerror (int error_no
)
7248 static char unknown_msg
[40];
7250 if (error_no
>= 0 && error_no
< sys_nerr
)
7251 return sys_errlist
[error_no
];
7253 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
7254 if (_wsa_errlist
[i
].errnum
== error_no
)
7255 return _wsa_errlist
[i
].msg
;
7257 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
7261 /* [andrewi 3-May-96] I've had conflicting results using both methods,
7262 but I believe the method of keeping the socket handle separate (and
7263 insuring it is not inheritable) is the correct one. */
7265 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
7267 static int socket_to_fd (SOCKET s
);
7270 sys_socket (int af
, int type
, int protocol
)
7274 if (winsock_lib
== NULL
)
7277 return INVALID_SOCKET
;
7282 /* call the real socket function */
7283 s
= pfn_socket (af
, type
, protocol
);
7285 if (s
!= INVALID_SOCKET
)
7286 return socket_to_fd (s
);
7292 /* Convert a SOCKET to a file descriptor. */
7294 socket_to_fd (SOCKET s
)
7299 /* Although under NT 3.5 _open_osfhandle will accept a socket
7300 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
7301 that does not work under NT 3.1. However, we can get the same
7302 effect by using a backdoor function to replace an existing
7303 descriptor handle with the one we want. */
7305 /* allocate a file descriptor (with appropriate flags) */
7306 fd
= _open ("NUL:", _O_RDWR
);
7309 /* Make a non-inheritable copy of the socket handle. Note
7310 that it is possible that sockets aren't actually kernel
7311 handles, which appears to be the case on Windows 9x when
7312 the MS Proxy winsock client is installed. */
7314 /* Apparently there is a bug in NT 3.51 with some service
7315 packs, which prevents using DuplicateHandle to make a
7316 socket handle non-inheritable (causes WSACleanup to
7317 hang). The work-around is to use SetHandleInformation
7318 instead if it is available and implemented. */
7319 if (pfn_SetHandleInformation
)
7321 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
7325 HANDLE parent
= GetCurrentProcess ();
7326 HANDLE new_s
= INVALID_HANDLE_VALUE
;
7328 if (DuplicateHandle (parent
,
7334 DUPLICATE_SAME_ACCESS
))
7336 /* It is possible that DuplicateHandle succeeds even
7337 though the socket wasn't really a kernel handle,
7338 because a real handle has the same value. So
7339 test whether the new handle really is a socket. */
7340 long nonblocking
= 0;
7341 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
7343 pfn_closesocket (s
);
7348 CloseHandle (new_s
);
7353 eassert (fd
< MAXDESC
);
7354 fd_info
[fd
].hnd
= (HANDLE
) s
;
7356 /* set our own internal flags */
7357 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
7363 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7365 /* attach child_process to fd_info */
7366 if (fd_info
[ fd
].cp
!= NULL
)
7368 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
7372 fd_info
[ fd
].cp
= cp
;
7375 winsock_inuse
++; /* count open sockets */
7383 pfn_closesocket (s
);
7389 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
7391 if (winsock_lib
== NULL
)
7394 return SOCKET_ERROR
;
7398 if (fd_info
[s
].flags
& FILE_SOCKET
)
7400 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
7401 if (rc
== SOCKET_ERROR
)
7406 return SOCKET_ERROR
;
7410 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
7412 if (winsock_lib
== NULL
)
7415 return SOCKET_ERROR
;
7419 if (fd_info
[s
].flags
& FILE_SOCKET
)
7421 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
7422 if (rc
== SOCKET_ERROR
)
7427 return SOCKET_ERROR
;
7431 sys_htons (u_short hostshort
)
7433 return (winsock_lib
!= NULL
) ?
7434 pfn_htons (hostshort
) : hostshort
;
7438 sys_ntohs (u_short netshort
)
7440 return (winsock_lib
!= NULL
) ?
7441 pfn_ntohs (netshort
) : netshort
;
7445 sys_inet_addr (const char * cp
)
7447 return (winsock_lib
!= NULL
) ?
7448 pfn_inet_addr (cp
) : INADDR_NONE
;
7452 sys_gethostname (char * name
, int namelen
)
7454 if (winsock_lib
!= NULL
)
7459 retval
= pfn_gethostname (name
, namelen
);
7460 if (retval
== SOCKET_ERROR
)
7465 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
7466 return !GetComputerName (name
, (DWORD
*)&namelen
);
7469 return SOCKET_ERROR
;
7473 sys_gethostbyname (const char * name
)
7475 struct hostent
* host
;
7476 int h_err
= h_errno
;
7478 if (winsock_lib
== NULL
)
7480 h_errno
= NO_RECOVERY
;
7486 host
= pfn_gethostbyname (name
);
7498 sys_getservbyname (const char * name
, const char * proto
)
7500 struct servent
* serv
;
7502 if (winsock_lib
== NULL
)
7509 serv
= pfn_getservbyname (name
, proto
);
7516 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
7518 if (winsock_lib
== NULL
)
7521 return SOCKET_ERROR
;
7525 if (fd_info
[s
].flags
& FILE_SOCKET
)
7527 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
7528 if (rc
== SOCKET_ERROR
)
7533 return SOCKET_ERROR
;
7537 sys_shutdown (int s
, int how
)
7539 if (winsock_lib
== NULL
)
7542 return SOCKET_ERROR
;
7546 if (fd_info
[s
].flags
& FILE_SOCKET
)
7548 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
7549 if (rc
== SOCKET_ERROR
)
7554 return SOCKET_ERROR
;
7558 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
7560 if (winsock_lib
== NULL
)
7563 return SOCKET_ERROR
;
7567 if (fd_info
[s
].flags
& FILE_SOCKET
)
7569 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
7570 (const char *)optval
, optlen
);
7571 if (rc
== SOCKET_ERROR
)
7576 return SOCKET_ERROR
;
7580 sys_listen (int s
, int backlog
)
7582 if (winsock_lib
== NULL
)
7585 return SOCKET_ERROR
;
7589 if (fd_info
[s
].flags
& FILE_SOCKET
)
7591 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
7592 if (rc
== SOCKET_ERROR
)
7595 fd_info
[s
].flags
|= FILE_LISTEN
;
7599 return SOCKET_ERROR
;
7603 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
7605 if (winsock_lib
== NULL
)
7608 return SOCKET_ERROR
;
7612 if (fd_info
[s
].flags
& FILE_SOCKET
)
7614 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
7615 if (rc
== SOCKET_ERROR
)
7620 return SOCKET_ERROR
;
7624 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
7626 if (winsock_lib
== NULL
)
7633 if (fd_info
[s
].flags
& FILE_LISTEN
)
7635 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
7637 if (t
== INVALID_SOCKET
)
7640 fd
= socket_to_fd (t
);
7644 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7645 ResetEvent (fd_info
[s
].cp
->char_avail
);
7654 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
7655 struct sockaddr
* from
, int * fromlen
)
7657 if (winsock_lib
== NULL
)
7660 return SOCKET_ERROR
;
7664 if (fd_info
[s
].flags
& FILE_SOCKET
)
7666 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
7667 if (rc
== SOCKET_ERROR
)
7672 return SOCKET_ERROR
;
7676 sys_sendto (int s
, const char * buf
, int len
, int flags
,
7677 const struct sockaddr
* to
, int tolen
)
7679 if (winsock_lib
== NULL
)
7682 return SOCKET_ERROR
;
7686 if (fd_info
[s
].flags
& FILE_SOCKET
)
7688 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
7689 if (rc
== SOCKET_ERROR
)
7694 return SOCKET_ERROR
;
7697 /* Windows does not have an fcntl function. Provide an implementation
7698 good enough for Emacs. */
7700 fcntl (int s
, int cmd
, int options
)
7702 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
7703 invoked in a context where fd1 is closed and all descriptors less
7704 than fd1 are open, so sys_dup is an adequate implementation. */
7705 if (cmd
== F_DUPFD_CLOEXEC
)
7709 if (fd_info
[s
].flags
& FILE_SOCKET
)
7711 if (winsock_lib
== NULL
)
7717 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7719 unsigned long nblock
= 1;
7720 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
7721 if (rc
== SOCKET_ERROR
)
7723 /* Keep track of the fact that we set this to non-blocking. */
7724 fd_info
[s
].flags
|= FILE_NDELAY
;
7730 return SOCKET_ERROR
;
7733 else if ((fd_info
[s
].flags
& (FILE_PIPE
| FILE_WRITE
))
7734 == (FILE_PIPE
| FILE_WRITE
))
7736 /* Force our writes to pipes be non-blocking. */
7737 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7739 HANDLE h
= (HANDLE
)_get_osfhandle (s
);
7740 DWORD pipe_mode
= PIPE_NOWAIT
;
7742 if (!SetNamedPipeHandleState (h
, &pipe_mode
, NULL
, NULL
))
7744 DebPrint (("SetNamedPipeHandleState: %lu\n", GetLastError ()));
7745 return SOCKET_ERROR
;
7747 fd_info
[s
].flags
|= FILE_NDELAY
;
7753 return SOCKET_ERROR
;
7757 return SOCKET_ERROR
;
7761 /* Shadow main io functions: we need to handle pipes and sockets more
7775 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
7777 child_process
* cp
= fd_info
[fd
].cp
;
7779 fd_info
[fd
].cp
= NULL
;
7781 if (CHILD_ACTIVE (cp
))
7783 /* if last descriptor to active child_process then cleanup */
7785 for (i
= 0; i
< MAXDESC
; i
++)
7789 if (fd_info
[i
].cp
== cp
)
7794 if (fd_info
[fd
].flags
& FILE_SOCKET
)
7796 if (winsock_lib
== NULL
) emacs_abort ();
7798 pfn_shutdown (SOCK_HANDLE (fd
), 2);
7799 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
7801 winsock_inuse
--; /* count open sockets */
7803 /* If the process handle is NULL, it's either a socket
7804 or serial connection, or a subprocess that was
7805 already reaped by reap_subprocess, but whose
7806 resources were not yet freed, because its output was
7807 not fully read yet by the time it was reaped. (This
7808 usually happens with async subprocesses whose output
7809 is being read by Emacs.) Otherwise, this process was
7810 not reaped yet, so we set its FD to a negative value
7811 to make sure sys_select will eventually get to
7812 calling the SIGCHLD handler for it, which will then
7813 invoke waitpid and reap_subprocess. */
7814 if (cp
->procinfo
.hProcess
== NULL
)
7822 if (fd
>= 0 && fd
< MAXDESC
)
7823 fd_info
[fd
].flags
= 0;
7825 /* Note that sockets do not need special treatment here (at least on
7826 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
7827 closesocket is equivalent to CloseHandle, which is to be expected
7828 because socket handles are fully fledged kernel handles. */
7840 if (new_fd
>= 0 && new_fd
< MAXDESC
)
7842 /* duplicate our internal info as well */
7843 fd_info
[new_fd
] = fd_info
[fd
];
7849 sys_dup2 (int src
, int dst
)
7853 if (dst
< 0 || dst
>= MAXDESC
)
7859 /* make sure we close the destination first if it's a pipe or socket */
7860 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
7863 rc
= _dup2 (src
, dst
);
7866 /* duplicate our internal info as well */
7867 fd_info
[dst
] = fd_info
[src
];
7873 pipe2 (int * phandles
, int pipe2_flags
)
7878 eassert (pipe2_flags
== O_CLOEXEC
);
7880 /* make pipe handles non-inheritable; when we spawn a child, we
7881 replace the relevant handle with an inheritable one. Also put
7882 pipes into binary mode; we will do text mode translation ourselves
7884 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
7888 /* Protect against overflow, since Windows can open more handles than
7889 our fd_info array has room for. */
7890 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
7892 _close (phandles
[0]);
7893 _close (phandles
[1]);
7899 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
7900 fd_info
[phandles
[0]].flags
= flags
;
7902 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
7903 fd_info
[phandles
[1]].flags
= flags
;
7910 /* Function to do blocking read of one byte, needed to implement
7911 select. It is only allowed on communication ports, sockets, or
7914 _sys_read_ahead (int fd
)
7919 if (fd
< 0 || fd
>= MAXDESC
)
7920 return STATUS_READ_ERROR
;
7922 cp
= fd_info
[fd
].cp
;
7924 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7925 return STATUS_READ_ERROR
;
7927 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
7928 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
7930 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
7934 cp
->status
= STATUS_READ_IN_PROGRESS
;
7936 if (fd_info
[fd
].flags
& FILE_PIPE
)
7938 rc
= _read (fd
, &cp
->chr
, sizeof (char));
7940 /* Give subprocess time to buffer some more output for us before
7941 reporting that input is available; we need this because Windows 95
7942 connects DOS programs to pipes by making the pipe appear to be
7943 the normal console stdout - as a result most DOS programs will
7944 write to stdout without buffering, ie. one character at a
7945 time. Even some W32 programs do this - "dir" in a command
7946 shell on NT is very slow if we don't do this. */
7949 int wait
= w32_pipe_read_delay
;
7955 /* Yield remainder of our time slice, effectively giving a
7956 temporary priority boost to the child process. */
7960 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7962 HANDLE hnd
= fd_info
[fd
].hnd
;
7963 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7966 /* Configure timeouts for blocking read. */
7967 if (!GetCommTimeouts (hnd
, &ct
))
7969 cp
->status
= STATUS_READ_ERROR
;
7970 return STATUS_READ_ERROR
;
7972 ct
.ReadIntervalTimeout
= 0;
7973 ct
.ReadTotalTimeoutMultiplier
= 0;
7974 ct
.ReadTotalTimeoutConstant
= 0;
7975 if (!SetCommTimeouts (hnd
, &ct
))
7977 cp
->status
= STATUS_READ_ERROR
;
7978 return STATUS_READ_ERROR
;
7981 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
7983 if (GetLastError () != ERROR_IO_PENDING
)
7985 cp
->status
= STATUS_READ_ERROR
;
7986 return STATUS_READ_ERROR
;
7988 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7990 cp
->status
= STATUS_READ_ERROR
;
7991 return STATUS_READ_ERROR
;
7995 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
7997 unsigned long nblock
= 0;
7998 /* We always want this to block, so temporarily disable NDELAY. */
7999 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8000 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8002 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
8004 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8007 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8011 if (rc
== sizeof (char))
8012 cp
->status
= STATUS_READ_SUCCEEDED
;
8014 cp
->status
= STATUS_READ_FAILED
;
8020 _sys_wait_accept (int fd
)
8026 if (fd
< 0 || fd
>= MAXDESC
)
8027 return STATUS_READ_ERROR
;
8029 cp
= fd_info
[fd
].cp
;
8031 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
8032 return STATUS_READ_ERROR
;
8034 cp
->status
= STATUS_READ_FAILED
;
8036 hEv
= pfn_WSACreateEvent ();
8037 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
8038 if (rc
!= SOCKET_ERROR
)
8041 rc
= WaitForSingleObject (hEv
, 500);
8043 } while (rc
== WAIT_TIMEOUT
8044 && cp
->status
!= STATUS_READ_ERROR
8046 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
8047 if (rc
== WAIT_OBJECT_0
)
8048 cp
->status
= STATUS_READ_SUCCEEDED
;
8050 pfn_WSACloseEvent (hEv
);
8056 sys_read (int fd
, char * buffer
, unsigned int count
)
8061 char * orig_buffer
= buffer
;
8069 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8071 child_process
*cp
= fd_info
[fd
].cp
;
8073 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
8081 /* re-read CR carried over from last read */
8082 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
8084 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
8088 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
8091 /* presence of a child_process structure means we are operating in
8092 non-blocking mode - otherwise we just call _read directly.
8093 Note that the child_process structure might be missing because
8094 reap_subprocess has been called; in this case the pipe is
8095 already broken, so calling _read on it is okay. */
8098 int current_status
= cp
->status
;
8100 switch (current_status
)
8102 case STATUS_READ_FAILED
:
8103 case STATUS_READ_ERROR
:
8104 /* report normal EOF if nothing in buffer */
8106 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8109 case STATUS_READ_READY
:
8110 case STATUS_READ_IN_PROGRESS
:
8111 DebPrint (("sys_read called when read is in progress\n"));
8112 errno
= EWOULDBLOCK
;
8115 case STATUS_READ_SUCCEEDED
:
8116 /* consume read-ahead char */
8117 *buffer
++ = cp
->chr
;
8120 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
8121 ResetEvent (cp
->char_avail
);
8123 case STATUS_READ_ACKNOWLEDGED
:
8127 DebPrint (("sys_read: bad status %d\n", current_status
));
8132 if (fd_info
[fd
].flags
& FILE_PIPE
)
8134 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
8135 to_read
= min (waiting
, (DWORD
) count
);
8138 nchars
+= _read (fd
, buffer
, to_read
);
8140 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
8142 HANDLE hnd
= fd_info
[fd
].hnd
;
8143 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
8149 /* Configure timeouts for non-blocking read. */
8150 if (!GetCommTimeouts (hnd
, &ct
))
8155 ct
.ReadIntervalTimeout
= MAXDWORD
;
8156 ct
.ReadTotalTimeoutMultiplier
= 0;
8157 ct
.ReadTotalTimeoutConstant
= 0;
8158 if (!SetCommTimeouts (hnd
, &ct
))
8164 if (!ResetEvent (ovl
->hEvent
))
8169 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
8171 if (GetLastError () != ERROR_IO_PENDING
)
8176 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
8185 else /* FILE_SOCKET */
8187 if (winsock_lib
== NULL
) emacs_abort ();
8189 /* do the equivalent of a non-blocking read */
8190 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
8191 if (waiting
== 0 && nchars
== 0)
8193 errno
= EWOULDBLOCK
;
8199 /* always use binary mode for sockets */
8200 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
8201 if (res
== SOCKET_ERROR
)
8203 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
8204 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8214 int nread
= _read (fd
, buffer
, count
);
8217 else if (nchars
== 0)
8222 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8223 /* Perform text mode translation if required. */
8224 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8226 nchars
= crlf_to_lf (nchars
, orig_buffer
);
8227 /* If buffer contains only CR, return that. To be absolutely
8228 sure we should attempt to read the next char, but in
8229 practice a CR to be followed by LF would not appear by
8230 itself in the buffer. */
8231 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
8233 fd_info
[fd
].flags
|= FILE_LAST_CR
;
8239 nchars
= _read (fd
, buffer
, count
);
8244 /* From w32xfns.c */
8245 extern HANDLE interrupt_handle
;
8248 sys_write (int fd
, const void * buffer
, unsigned int count
)
8258 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8260 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
8266 /* Perform text mode translation if required. */
8267 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8269 char * tmpbuf
= alloca (count
* 2);
8270 unsigned char * src
= (void *)buffer
;
8271 unsigned char * dst
= tmpbuf
;
8276 unsigned char *next
;
8277 /* copy next line or remaining bytes */
8278 next
= _memccpy (dst
, src
, '\n', nbytes
);
8281 /* copied one line ending with '\n' */
8282 int copied
= next
- dst
;
8285 /* insert '\r' before '\n' */
8292 /* copied remaining partial line -> now finished */
8299 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
8301 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
8302 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
8303 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
8306 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
8308 if (GetLastError () != ERROR_IO_PENDING
)
8313 if (detect_input_pending ())
8314 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
8317 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
8318 if (active
== WAIT_OBJECT_0
)
8319 { /* User pressed C-g, cancel write, then leave. Don't bother
8320 cleaning up as we may only get stuck in buggy drivers. */
8321 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
8326 if (active
== WAIT_OBJECT_0
+ 1
8327 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
8334 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
8336 unsigned long nblock
= 0;
8337 if (winsock_lib
== NULL
) emacs_abort ();
8339 /* TODO: implement select() properly so non-blocking I/O works. */
8340 /* For now, make sure the write blocks. */
8341 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8342 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8344 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
8346 /* Set the socket back to non-blocking if it was before,
8347 for other operations that support it. */
8348 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8351 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8354 if (nchars
== SOCKET_ERROR
)
8356 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
8357 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8363 /* Some networked filesystems don't like too large writes, so
8364 break them into smaller chunks. See the Comments section of
8365 the MSDN documentation of WriteFile for details behind the
8366 choice of the value of CHUNK below. See also the thread
8367 http://thread.gmane.org/gmane.comp.version-control.git/145294
8368 in the git mailing list. */
8369 const unsigned char *p
= buffer
;
8370 const unsigned chunk
= 30 * 1024 * 1024;
8375 unsigned this_chunk
= count
< chunk
? count
: chunk
;
8376 int n
= _write (fd
, p
, this_chunk
);
8381 /* When there's no buffer space in a pipe that is in the
8382 non-blocking mode, _write returns ENOSPC. We return
8383 EAGAIN instead, which should trigger the logic in
8384 send_process that enters waiting loop and calls
8385 wait_reading_process_output to allow process input to
8386 be accepted during the wait. Those calls to
8387 wait_reading_process_output allow sys_select to
8388 notice when process input becomes available, thus
8389 avoiding deadlock whereby each side of the pipe is
8390 blocked on write, waiting for the other party to read
8391 its end of the pipe. */
8394 && ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_NDELAY
))
8395 == (FILE_PIPE
| FILE_NDELAY
)))
8400 else if (n
< this_chunk
)
8411 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
8413 extern Lisp_Object
conv_sockaddr_to_lisp (struct sockaddr
*, int);
8415 /* Return information about network interface IFNAME, or about all
8416 interfaces (if IFNAME is nil). */
8418 network_interface_get_info (Lisp_Object ifname
)
8420 ULONG ainfo_len
= sizeof (IP_ADAPTER_INFO
);
8421 IP_ADAPTER_INFO
*adapter
, *ainfo
= xmalloc (ainfo_len
);
8422 DWORD retval
= get_adapters_info (ainfo
, &ainfo_len
);
8423 Lisp_Object res
= Qnil
;
8425 if (retval
== ERROR_BUFFER_OVERFLOW
)
8427 ainfo
= xrealloc (ainfo
, ainfo_len
);
8428 retval
= get_adapters_info (ainfo
, &ainfo_len
);
8431 if (retval
== ERROR_SUCCESS
)
8433 int eth_count
= 0, tr_count
= 0, fddi_count
= 0, ppp_count
= 0;
8434 int sl_count
= 0, wlan_count
= 0, lo_count
= 0, ifx_count
= 0;
8436 struct sockaddr_in sa
;
8438 /* For the below, we need some winsock functions, so make sure
8439 the winsock DLL is loaded. If we cannot successfully load
8440 it, they will have no use of the information we provide,
8442 if (!winsock_lib
&& !init_winsock (1))
8445 for (adapter
= ainfo
; adapter
; adapter
= adapter
->Next
)
8447 char namebuf
[MAX_ADAPTER_NAME_LENGTH
+ 4];
8449 /* Present Unix-compatible interface names, instead of the
8450 Windows names, which are really GUIDs not readable by
8452 static const char *ifmt
[] = {
8453 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
8468 switch (adapter
->Type
)
8470 case MIB_IF_TYPE_ETHERNET
:
8471 /* Windows before Vista reports wireless adapters as
8472 Ethernet. Work around by looking at the Description
8474 if (strstr (adapter
->Description
, "Wireless "))
8477 if_num
= wlan_count
++;
8481 ifmt_idx
= ETHERNET
;
8482 if_num
= eth_count
++;
8485 case MIB_IF_TYPE_TOKENRING
:
8486 ifmt_idx
= TOKENRING
;
8487 if_num
= tr_count
++;
8489 case MIB_IF_TYPE_FDDI
:
8491 if_num
= fddi_count
++;
8493 case MIB_IF_TYPE_PPP
:
8495 if_num
= ppp_count
++;
8497 case MIB_IF_TYPE_SLIP
:
8499 if_num
= sl_count
++;
8501 case IF_TYPE_IEEE80211
:
8503 if_num
= wlan_count
++;
8505 case MIB_IF_TYPE_LOOPBACK
:
8508 ifmt_idx
= LOOPBACK
;
8509 if_num
= lo_count
++;
8515 ifmt_idx
= OTHER_IF
;
8516 if_num
= ifx_count
++;
8519 if (ifmt_idx
== NONE
)
8521 sprintf (namebuf
, ifmt
[ifmt_idx
], if_num
);
8523 sa
.sin_family
= AF_INET
;
8524 ip_addr
= sys_inet_addr (adapter
->IpAddressList
.IpAddress
.String
);
8525 if (ip_addr
== INADDR_NONE
)
8527 /* Bogus address, skip this interface. */
8530 sa
.sin_addr
.s_addr
= ip_addr
;
8533 res
= Fcons (Fcons (build_string (namebuf
),
8534 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8535 sizeof (struct sockaddr
))),
8537 else if (strcmp (namebuf
, SSDATA (ifname
)) == 0)
8539 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
8540 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
8541 Lisp_Object flags
= Qnil
;
8545 /* Flags. We guess most of them by type, since the
8546 Windows flags are different and hard to get by. */
8547 flags
= Fcons (intern ("up"), flags
);
8548 if (ifmt_idx
== ETHERNET
|| ifmt_idx
== WLAN
)
8550 flags
= Fcons (intern ("broadcast"), flags
);
8551 flags
= Fcons (intern ("multicast"), flags
);
8553 flags
= Fcons (intern ("running"), flags
);
8554 if (ifmt_idx
== PPP
)
8556 flags
= Fcons (intern ("pointopoint"), flags
);
8557 flags
= Fcons (intern ("noarp"), flags
);
8559 if (adapter
->HaveWins
)
8560 flags
= Fcons (intern ("WINS"), flags
);
8561 if (adapter
->DhcpEnabled
)
8562 flags
= Fcons (intern ("dynamic"), flags
);
8564 res
= Fcons (flags
, res
);
8566 /* Hardware address and its family. */
8567 for (n
= 0; n
< adapter
->AddressLength
; n
++)
8568 p
->contents
[n
] = make_number ((int) adapter
->Address
[n
]);
8569 /* Windows does not support AF_LINK or AF_PACKET family
8570 of addresses. Use an arbitrary family number that is
8571 identical to what GNU/Linux returns. */
8572 res
= Fcons (Fcons (make_number (1), hwaddr
), res
);
8575 sa
.sin_family
= AF_INET
;
8576 net_mask
= sys_inet_addr (adapter
->IpAddressList
.IpMask
.String
);
8577 if (net_mask
!= INADDR_NONE
)
8579 sa
.sin_addr
.s_addr
= net_mask
;
8581 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8582 sizeof (struct sockaddr
)),
8586 res
= Fcons (Qnil
, res
);
8588 sa
.sin_family
= AF_INET
;
8589 if (ip_addr
!= INADDR_NONE
)
8591 /* Broadcast address is only reported by
8592 GetAdaptersAddresses, which is of limited
8593 availability. Generate it on our own. */
8594 u_long bcast_addr
= (ip_addr
& net_mask
) | ~net_mask
;
8596 sa
.sin_addr
.s_addr
= bcast_addr
;
8598 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8599 sizeof (struct sockaddr
)),
8603 sa
.sin_addr
.s_addr
= ip_addr
;
8605 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8606 sizeof (struct sockaddr
)),
8610 res
= Fcons (Qnil
, Fcons (Qnil
, res
));
8613 /* GetAdaptersInfo is documented to not report loopback
8614 interfaces, so we generate one out of thin air. */
8617 sa
.sin_family
= AF_INET
;
8621 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8622 res
= Fcons (Fcons (build_string ("lo"),
8623 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8624 sizeof (struct sockaddr
))),
8627 else if (strcmp (SSDATA (ifname
), "lo") == 0)
8629 res
= Fcons (Fcons (intern ("running"),
8630 Fcons (intern ("loopback"),
8631 Fcons (intern ("up"), Qnil
))), Qnil
);
8632 /* 772 is what 3 different GNU/Linux systems report for
8633 the loopback interface. */
8634 res
= Fcons (Fcons (make_number (772),
8635 Fmake_vector (make_number (6),
8638 sa
.sin_addr
.s_addr
= sys_inet_addr ("255.0.0.0");
8639 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8640 sizeof (struct sockaddr
)),
8642 sa
.sin_addr
.s_addr
= sys_inet_addr ("0.0.0.0");
8643 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8644 sizeof (struct sockaddr
)),
8646 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8647 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8648 sizeof (struct sockaddr
)),
8661 network_interface_list (void)
8663 return network_interface_get_info (Qnil
);
8667 network_interface_info (Lisp_Object ifname
)
8669 CHECK_STRING (ifname
);
8670 return network_interface_get_info (ifname
);
8674 /* The Windows CRT functions are "optimized for speed", so they don't
8675 check for timezone and DST changes if they were last called less
8676 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
8677 all Emacs features that repeatedly call time functions (e.g.,
8678 display-time) are in real danger of missing timezone and DST
8679 changes. Calling tzset before each localtime call fixes that. */
8681 sys_localtime (const time_t *t
)
8684 return localtime (t
);
8689 /* Try loading LIBRARY_ID from the file(s) specified in
8690 Vdynamic_library_alist. If the library is loaded successfully,
8691 return the handle of the DLL, and record the filename in the
8692 property :loaded-from of LIBRARY_ID. If the library could not be
8693 found, or when it was already loaded (because the handle is not
8694 recorded anywhere, and so is lost after use), return NULL.
8696 We could also save the handle in :loaded-from, but currently
8697 there's no use case for it. */
8699 w32_delayed_load (Lisp_Object library_id
)
8701 HMODULE dll_handle
= NULL
;
8703 CHECK_SYMBOL (library_id
);
8705 if (CONSP (Vdynamic_library_alist
)
8706 && NILP (Fassq (library_id
, Vlibrary_cache
)))
8708 Lisp_Object found
= Qnil
;
8709 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
8712 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
8714 Lisp_Object dll
= XCAR (dlls
);
8715 char name
[MAX_UTF8_PATH
];
8719 dll
= ENCODE_FILE (dll
);
8720 if (w32_unicode_filenames
)
8722 wchar_t name_w
[MAX_PATH
];
8724 filename_to_utf16 (SSDATA (dll
), name_w
);
8725 dll_handle
= LoadLibraryW (name_w
);
8728 res
= GetModuleFileNameW (dll_handle
, name_w
,
8731 filename_from_utf16 (name_w
, name
);
8736 char name_a
[MAX_PATH
];
8738 filename_to_ansi (SSDATA (dll
), name_a
);
8739 dll_handle
= LoadLibraryA (name_a
);
8742 res
= GetModuleFileNameA (dll_handle
, name_a
,
8745 filename_from_ansi (name_a
, name
);
8750 ptrdiff_t len
= strlen (name
);
8753 /* Possibly truncated */
8754 ? make_specified_string (name
, -1, len
, 1)
8760 Fput (library_id
, QCloaded_from
, found
);
8768 check_windows_init_file (void)
8770 /* A common indication that Emacs is not installed properly is when
8771 it cannot find the Windows installation file. If this file does
8772 not exist in the expected place, tell the user. */
8774 if (!noninteractive
&& !inhibit_window_system
8775 /* Vload_path is not yet initialized when we are loading
8777 && NILP (Vpurify_flag
))
8779 Lisp_Object init_file
;
8782 /* Implementation note: this function runs early during Emacs
8783 startup, before startup.el is run. So Vload_path is still in
8784 its initial unibyte form, but it holds UTF-8 encoded file
8785 names, since init_callproc was already called. So we do not
8786 need to ENCODE_FILE here, but we do need to convert the file
8787 names from UTF-8 to ANSI. */
8788 init_file
= build_string ("term/w32-win");
8789 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
, 0);
8792 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
8793 char *init_file_name
= SDATA (init_file
);
8794 char *load_path
= SDATA (load_path_print
);
8795 char *buffer
= alloca (1024
8796 + strlen (init_file_name
)
8797 + strlen (load_path
));
8802 "The Emacs Windows initialization file \"%s.el\" "
8803 "could not be found in your Emacs installation. "
8804 "Emacs checked the following directories for this file:\n"
8806 "When Emacs cannot find this file, it usually means that it "
8807 "was not installed properly, or its distribution file was "
8808 "not unpacked properly.\nSee the README.W32 file in the "
8809 "top-level Emacs directory for more information.",
8810 init_file_name
, load_path
);
8811 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
,
8815 wchar_t *msg_w
= alloca ((needed
+ 1) * sizeof (wchar_t));
8817 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
, -1,
8819 needed
= pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1,
8820 NULL
, 0, NULL
, NULL
);
8823 char *msg_a
= alloca (needed
+ 1);
8825 pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1, msg_a
, needed
,
8832 "Emacs Abort Dialog",
8833 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
8834 /* Use the low-level system abort. */
8845 term_ntproc (int ignored
)
8851 /* shutdown the socket interface if necessary */
8858 init_ntproc (int dumping
)
8860 sigset_t initial_mask
= 0;
8862 /* Initialize the socket interface now if available and requested by
8863 the user by defining PRELOAD_WINSOCK; otherwise loading will be
8864 delayed until open-network-stream is called (w32-has-winsock can
8865 also be used to dynamically load or reload winsock).
8867 Conveniently, init_environment is called before us, so
8868 PRELOAD_WINSOCK can be set in the registry. */
8870 /* Always initialize this correctly. */
8873 if (getenv ("PRELOAD_WINSOCK") != NULL
)
8874 init_winsock (TRUE
);
8876 /* Initial preparation for subprocess support: replace our standard
8877 handles with non-inheritable versions. */
8880 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
8881 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
8882 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
8884 parent
= GetCurrentProcess ();
8886 /* ignore errors when duplicating and closing; typically the
8887 handles will be invalid when running as a gui program. */
8888 DuplicateHandle (parent
,
8889 GetStdHandle (STD_INPUT_HANDLE
),
8894 DUPLICATE_SAME_ACCESS
);
8896 DuplicateHandle (parent
,
8897 GetStdHandle (STD_OUTPUT_HANDLE
),
8902 DUPLICATE_SAME_ACCESS
);
8904 DuplicateHandle (parent
,
8905 GetStdHandle (STD_ERROR_HANDLE
),
8910 DUPLICATE_SAME_ACCESS
);
8916 if (stdin_save
!= INVALID_HANDLE_VALUE
)
8917 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
8919 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
8922 if (stdout_save
!= INVALID_HANDLE_VALUE
)
8923 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
8925 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8928 if (stderr_save
!= INVALID_HANDLE_VALUE
)
8929 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
8931 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
8935 /* unfortunately, atexit depends on implementation of malloc */
8936 /* atexit (term_ntproc); */
8939 /* Make sure we start with all signals unblocked. */
8940 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
8941 signal (SIGABRT
, term_ntproc
);
8945 /* determine which drives are fixed, for GetCachedVolumeInformation */
8947 /* GetDriveType must have trailing backslash. */
8948 char drive
[] = "A:\\";
8950 /* Loop over all possible drive letters */
8951 while (*drive
<= 'Z')
8953 /* Record if this drive letter refers to a fixed drive. */
8954 fixed_drives
[DRIVE_INDEX (*drive
)] =
8955 (GetDriveType (drive
) == DRIVE_FIXED
);
8960 /* Reset the volume info cache. */
8961 volume_cache
= NULL
;
8966 shutdown_handler ensures that buffers' autosave files are
8967 up to date when the user logs off, or the system shuts down.
8970 shutdown_handler (DWORD type
)
8972 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
8973 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
8974 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
8975 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
8977 /* Shut down cleanly, making sure autosave files are up to date. */
8978 shut_down_emacs (0, Qnil
);
8981 /* Allow other handlers to handle this signal. */
8985 /* On Windows 9X, load UNICOWS.DLL and return its handle, or die. On
8986 NT, return a handle to GDI32.DLL. */
8988 maybe_load_unicows_dll (void)
8990 if (os_subtype
== OS_9X
)
8992 HANDLE ret
= LoadLibrary ("Unicows.dll");
8995 /* These two functions are present on Windows 9X as stubs
8996 that always fail. We need the real implementations from
8997 UNICOWS.DLL, so we must call these functions through
8998 pointers, and assign the correct addresses to these
8999 pointers at program startup (see emacs.c, which calls
9000 this function early on). */
9001 pMultiByteToWideChar
= GetProcAddress (ret
, "MultiByteToWideChar");
9002 pWideCharToMultiByte
= GetProcAddress (ret
, "WideCharToMultiByte");
9009 button
= MessageBox (NULL
,
9010 "Emacs cannot load the UNICOWS.DLL library.\n"
9011 "This library is essential for using Emacs\n"
9012 "on this system. You need to install it.\n\n"
9013 "Emacs will exit when you click OK.",
9014 "Emacs cannot load UNICOWS.DLL",
9015 MB_ICONERROR
| MB_TASKMODAL
9016 | MB_SETFOREGROUND
| MB_OK
);
9027 /* On NT family of Windows, these two functions are always
9028 linked in, so we just assign their addresses to the 2
9029 pointers; no need for the LoadLibrary dance. */
9030 pMultiByteToWideChar
= MultiByteToWideChar
;
9031 pWideCharToMultiByte
= WideCharToMultiByte
;
9032 return LoadLibrary ("Gdi32.dll");
9037 globals_of_w32 is used to initialize those global variables that
9038 must always be initialized on startup even when the global variable
9039 initialized is non zero (see the function main in emacs.c).
9042 globals_of_w32 (void)
9044 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
9046 get_process_times_fn
= (GetProcessTimes_Proc
)
9047 GetProcAddress (kernel32
, "GetProcessTimes");
9049 DEFSYM (QCloaded_from
, ":loaded-from");
9051 g_b_init_is_windows_9x
= 0;
9052 g_b_init_open_process_token
= 0;
9053 g_b_init_get_token_information
= 0;
9054 g_b_init_lookup_account_sid
= 0;
9055 g_b_init_get_sid_sub_authority
= 0;
9056 g_b_init_get_sid_sub_authority_count
= 0;
9057 g_b_init_get_security_info
= 0;
9058 g_b_init_get_file_security_w
= 0;
9059 g_b_init_get_file_security_a
= 0;
9060 g_b_init_get_security_descriptor_owner
= 0;
9061 g_b_init_get_security_descriptor_group
= 0;
9062 g_b_init_is_valid_sid
= 0;
9063 g_b_init_create_toolhelp32_snapshot
= 0;
9064 g_b_init_process32_first
= 0;
9065 g_b_init_process32_next
= 0;
9066 g_b_init_open_thread_token
= 0;
9067 g_b_init_impersonate_self
= 0;
9068 g_b_init_revert_to_self
= 0;
9069 g_b_init_get_process_memory_info
= 0;
9070 g_b_init_get_process_working_set_size
= 0;
9071 g_b_init_global_memory_status
= 0;
9072 g_b_init_global_memory_status_ex
= 0;
9073 g_b_init_equal_sid
= 0;
9074 g_b_init_copy_sid
= 0;
9075 g_b_init_get_length_sid
= 0;
9076 g_b_init_get_native_system_info
= 0;
9077 g_b_init_get_system_times
= 0;
9078 g_b_init_create_symbolic_link_w
= 0;
9079 g_b_init_create_symbolic_link_a
= 0;
9080 g_b_init_get_security_descriptor_dacl
= 0;
9081 g_b_init_convert_sd_to_sddl
= 0;
9082 g_b_init_convert_sddl_to_sd
= 0;
9083 g_b_init_is_valid_security_descriptor
= 0;
9084 g_b_init_set_file_security_w
= 0;
9085 g_b_init_set_file_security_a
= 0;
9086 g_b_init_set_named_security_info_w
= 0;
9087 g_b_init_set_named_security_info_a
= 0;
9088 g_b_init_get_adapters_info
= 0;
9089 num_of_processors
= 0;
9090 /* The following sets a handler for shutdown notifications for
9091 console apps. This actually applies to Emacs in both console and
9092 GUI modes, since we had to fool windows into thinking emacs is a
9093 console application to get console mode to work. */
9094 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
9096 /* "None" is the default group name on standalone workstations. */
9097 strcpy (dflt_group_name
, "None");
9099 /* Reset, in case it has some value inherited from dump time. */
9100 w32_stat_get_owner_group
= 0;
9102 /* If w32_unicode_filenames is non-zero, we will be using Unicode
9103 (a.k.a. "wide") APIs to invoke functions that accept file
9105 if (is_windows_9x ())
9106 w32_unicode_filenames
= 0;
9108 w32_unicode_filenames
= 1;
9111 /* For make-serial-process */
9113 serial_open (Lisp_Object port_obj
)
9115 char *port
= SSDATA (port_obj
);
9120 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
9121 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
9122 if (hnd
== INVALID_HANDLE_VALUE
)
9123 error ("Could not open %s", port
);
9124 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
9126 error ("Could not open %s", port
);
9130 error ("Could not create child process");
9132 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
9133 fd_info
[ fd
].hnd
= hnd
;
9134 fd_info
[ fd
].flags
|=
9135 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
9136 if (fd_info
[ fd
].cp
!= NULL
)
9138 error ("fd_info[fd = %d] is already in use", fd
);
9140 fd_info
[ fd
].cp
= cp
;
9141 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9142 if (cp
->ovl_read
.hEvent
== NULL
)
9143 error ("Could not create read event");
9144 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9145 if (cp
->ovl_write
.hEvent
== NULL
)
9146 error ("Could not create write event");
9151 /* For serial-process-configure */
9153 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
9155 Lisp_Object childp2
= Qnil
;
9156 Lisp_Object tem
= Qnil
;
9160 char summary
[4] = "???"; /* This usually becomes "8N1". */
9162 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
9163 error ("Not a serial process");
9164 hnd
= fd_info
[ p
->outfd
].hnd
;
9166 childp2
= Fcopy_sequence (p
->childp
);
9168 /* Initialize timeouts for blocking read and blocking write. */
9169 if (!GetCommTimeouts (hnd
, &ct
))
9170 error ("GetCommTimeouts() failed");
9171 ct
.ReadIntervalTimeout
= 0;
9172 ct
.ReadTotalTimeoutMultiplier
= 0;
9173 ct
.ReadTotalTimeoutConstant
= 0;
9174 ct
.WriteTotalTimeoutMultiplier
= 0;
9175 ct
.WriteTotalTimeoutConstant
= 0;
9176 if (!SetCommTimeouts (hnd
, &ct
))
9177 error ("SetCommTimeouts() failed");
9178 /* Read port attributes and prepare default configuration. */
9179 memset (&dcb
, 0, sizeof (dcb
));
9180 dcb
.DCBlength
= sizeof (DCB
);
9181 if (!GetCommState (hnd
, &dcb
))
9182 error ("GetCommState() failed");
9185 dcb
.fAbortOnError
= FALSE
;
9186 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
9191 /* Configure speed. */
9192 if (!NILP (Fplist_member (contact
, QCspeed
)))
9193 tem
= Fplist_get (contact
, QCspeed
);
9195 tem
= Fplist_get (p
->childp
, QCspeed
);
9197 dcb
.BaudRate
= XINT (tem
);
9198 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
9200 /* Configure bytesize. */
9201 if (!NILP (Fplist_member (contact
, QCbytesize
)))
9202 tem
= Fplist_get (contact
, QCbytesize
);
9204 tem
= Fplist_get (p
->childp
, QCbytesize
);
9206 tem
= make_number (8);
9208 if (XINT (tem
) != 7 && XINT (tem
) != 8)
9209 error (":bytesize must be nil (8), 7, or 8");
9210 dcb
.ByteSize
= XINT (tem
);
9211 summary
[0] = XINT (tem
) + '0';
9212 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
9214 /* Configure parity. */
9215 if (!NILP (Fplist_member (contact
, QCparity
)))
9216 tem
= Fplist_get (contact
, QCparity
);
9218 tem
= Fplist_get (p
->childp
, QCparity
);
9219 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
9220 error (":parity must be nil (no parity), `even', or `odd'");
9221 dcb
.fParity
= FALSE
;
9222 dcb
.Parity
= NOPARITY
;
9223 dcb
.fErrorChar
= FALSE
;
9228 else if (EQ (tem
, Qeven
))
9232 dcb
.Parity
= EVENPARITY
;
9233 dcb
.fErrorChar
= TRUE
;
9235 else if (EQ (tem
, Qodd
))
9239 dcb
.Parity
= ODDPARITY
;
9240 dcb
.fErrorChar
= TRUE
;
9242 childp2
= Fplist_put (childp2
, QCparity
, tem
);
9244 /* Configure stopbits. */
9245 if (!NILP (Fplist_member (contact
, QCstopbits
)))
9246 tem
= Fplist_get (contact
, QCstopbits
);
9248 tem
= Fplist_get (p
->childp
, QCstopbits
);
9250 tem
= make_number (1);
9252 if (XINT (tem
) != 1 && XINT (tem
) != 2)
9253 error (":stopbits must be nil (1 stopbit), 1, or 2");
9254 summary
[2] = XINT (tem
) + '0';
9255 if (XINT (tem
) == 1)
9256 dcb
.StopBits
= ONESTOPBIT
;
9257 else if (XINT (tem
) == 2)
9258 dcb
.StopBits
= TWOSTOPBITS
;
9259 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
9261 /* Configure flowcontrol. */
9262 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
9263 tem
= Fplist_get (contact
, QCflowcontrol
);
9265 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
9266 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
9267 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
9268 dcb
.fOutxCtsFlow
= FALSE
;
9269 dcb
.fOutxDsrFlow
= FALSE
;
9270 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
9271 dcb
.fDsrSensitivity
= FALSE
;
9272 dcb
.fTXContinueOnXoff
= FALSE
;
9275 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
9276 dcb
.XonChar
= 17; /* Control-Q */
9277 dcb
.XoffChar
= 19; /* Control-S */
9280 /* Already configured. */
9282 else if (EQ (tem
, Qhw
))
9284 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
9285 dcb
.fOutxCtsFlow
= TRUE
;
9287 else if (EQ (tem
, Qsw
))
9292 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
9294 /* Activate configuration. */
9295 if (!SetCommState (hnd
, &dcb
))
9296 error ("SetCommState() failed");
9298 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
9299 pset_childp (p
, childp2
);
9305 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
9309 struct timespec timeout
;
9310 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9311 int fd
= process
->infd
;
9313 n
= sys_read (fd
, (char*)buf
, sz
);
9320 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9321 if (err
== EWOULDBLOCK
)
9324 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
9330 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
9332 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9333 int fd
= process
->outfd
;
9334 ssize_t n
= sys_write (fd
, buf
, sz
);
9336 /* 0 or more bytes written means everything went fine. */
9340 /* Negative bytes written means we got an error in errno.
9341 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9342 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
9343 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
9347 #endif /* HAVE_GNUTLS */