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