* lisp/url/url-http.el (status): Remove, unused.
[emacs.git] / src / w32.c
blobfb2d7c75972326f24038e5033f4128c3b230b5aa
1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2013 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 #include <stddef.h> /* for offsetof */
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <float.h> /* for DBL_EPSILON */
26 #include <io.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <ctype.h>
30 #include <signal.h>
31 #include <sys/file.h>
32 #include <time.h> /* must be before nt/inc/sys/time.h, for MinGW64 */
33 #include <sys/time.h>
34 #include <sys/utime.h>
35 #include <math.h>
37 /* must include CRT headers *before* config.h */
39 #include <config.h>
40 #include <mbstring.h> /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
42 #undef access
43 #undef chdir
44 #undef chmod
45 #undef creat
46 #undef ctime
47 #undef fopen
48 #undef link
49 #undef mkdir
50 #undef mktemp
51 #undef open
52 #undef rename
53 #undef rmdir
54 #undef unlink
56 #undef close
57 #undef dup
58 #undef dup2
59 #undef pipe
60 #undef read
61 #undef write
63 #undef strerror
65 #undef localtime
67 #include "lisp.h"
68 #include "epaths.h" /* for SHELL */
70 #include <pwd.h>
71 #include <grp.h>
73 /* MinGW64 (_W64) defines these in its _mingw.h. */
74 #if defined(__GNUC__) && !defined(_W64)
75 #define _ANONYMOUS_UNION
76 #define _ANONYMOUS_STRUCT
77 #endif
78 #include <windows.h>
79 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
80 use a different name to avoid compilation problems. */
81 typedef struct _MEMORY_STATUS_EX {
82 DWORD dwLength;
83 DWORD dwMemoryLoad;
84 DWORDLONG ullTotalPhys;
85 DWORDLONG ullAvailPhys;
86 DWORDLONG ullTotalPageFile;
87 DWORDLONG ullAvailPageFile;
88 DWORDLONG ullTotalVirtual;
89 DWORDLONG ullAvailVirtual;
90 DWORDLONG ullAvailExtendedVirtual;
91 } MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
93 #include <lmcons.h>
94 #include <shlobj.h>
96 #include <tlhelp32.h>
97 #include <psapi.h>
98 #ifndef _MSC_VER
99 #include <w32api.h>
100 #endif
101 #if _WIN32_WINNT < 0x0500
102 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
103 /* This either is not in psapi.h or guarded by higher value of
104 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
105 defines it in psapi.h */
106 typedef struct _PROCESS_MEMORY_COUNTERS_EX {
107 DWORD cb;
108 DWORD PageFaultCount;
109 SIZE_T PeakWorkingSetSize;
110 SIZE_T WorkingSetSize;
111 SIZE_T QuotaPeakPagedPoolUsage;
112 SIZE_T QuotaPagedPoolUsage;
113 SIZE_T QuotaPeakNonPagedPoolUsage;
114 SIZE_T QuotaNonPagedPoolUsage;
115 SIZE_T PagefileUsage;
116 SIZE_T PeakPagefileUsage;
117 SIZE_T PrivateUsage;
118 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
119 #endif
120 #endif
122 #include <winioctl.h>
123 #include <aclapi.h>
124 #include <sddl.h>
126 #include <sys/acl.h>
128 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
129 define them by hand if not already defined. */
130 #ifndef SDDL_REVISION_1
131 #define SDDL_REVISION_1 1
132 #endif /* SDDL_REVISION_1 */
134 #if defined(_MSC_VER) || defined(_W64)
135 /* MSVC and MinGW64 don't provide the definition of
136 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
137 which cannot be included because it triggers conflicts with other
138 Windows API headers. So we define it here by hand. */
140 typedef struct _REPARSE_DATA_BUFFER {
141 ULONG ReparseTag;
142 USHORT ReparseDataLength;
143 USHORT Reserved;
144 union {
145 struct {
146 USHORT SubstituteNameOffset;
147 USHORT SubstituteNameLength;
148 USHORT PrintNameOffset;
149 USHORT PrintNameLength;
150 ULONG Flags;
151 WCHAR PathBuffer[1];
152 } SymbolicLinkReparseBuffer;
153 struct {
154 USHORT SubstituteNameOffset;
155 USHORT SubstituteNameLength;
156 USHORT PrintNameOffset;
157 USHORT PrintNameLength;
158 WCHAR PathBuffer[1];
159 } MountPointReparseBuffer;
160 struct {
161 UCHAR DataBuffer[1];
162 } GenericReparseBuffer;
163 } DUMMYUNIONNAME;
164 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
166 #ifndef FILE_DEVICE_FILE_SYSTEM
167 #define FILE_DEVICE_FILE_SYSTEM 9
168 #endif
169 #ifndef METHOD_BUFFERED
170 #define METHOD_BUFFERED 0
171 #endif
172 #ifndef FILE_ANY_ACCESS
173 #define FILE_ANY_ACCESS 0x00000000
174 #endif
175 #ifndef CTL_CODE
176 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
177 #endif
178 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
179 #ifndef FSCTL_GET_REPARSE_POINT
180 #define FSCTL_GET_REPARSE_POINT \
181 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
182 #endif
183 #endif
185 /* TCP connection support. */
186 #include <sys/socket.h>
187 #undef socket
188 #undef bind
189 #undef connect
190 #undef htons
191 #undef ntohs
192 #undef inet_addr
193 #undef gethostname
194 #undef gethostbyname
195 #undef getservbyname
196 #undef getpeername
197 #undef shutdown
198 #undef setsockopt
199 #undef listen
200 #undef getsockname
201 #undef accept
202 #undef recvfrom
203 #undef sendto
205 #include "w32.h"
206 #include <dirent.h>
207 #include "w32common.h"
208 #include "w32heap.h"
209 #include "w32select.h"
210 #include "systime.h"
211 #include "dispextern.h" /* for xstrcasecmp */
212 #include "coding.h" /* for Vlocale_coding_system */
214 #include "careadlinkat.h"
215 #include "allocator.h"
217 /* For serial_configure and serial_open. */
218 #include "process.h"
220 typedef HRESULT (WINAPI * ShGetFolderPath_fn)
221 (IN HWND, IN int, IN HANDLE, IN DWORD, OUT char *);
223 Lisp_Object QCloaded_from;
225 void globals_of_w32 (void);
226 static DWORD get_rid (PSID);
227 static int is_symlink (const char *);
228 static char * chase_symlinks (const char *);
229 static int enable_privilege (LPCTSTR, BOOL, TOKEN_PRIVILEGES *);
230 static int restore_privilege (TOKEN_PRIVILEGES *);
231 static BOOL WINAPI revert_to_self (void);
233 extern int sys_access (const char *, int);
234 extern void *e_malloc (size_t);
235 extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
236 EMACS_TIME *, void *);
237 extern int sys_dup (int);
242 /* Initialization states.
244 WARNING: If you add any more such variables for additional APIs,
245 you MUST add initialization for them to globals_of_w32
246 below. This is because these variables might get set
247 to non-NULL values during dumping, but the dumped Emacs
248 cannot reuse those values, because it could be run on a
249 different version of the OS, where API addresses are
250 different. */
251 static BOOL g_b_init_is_windows_9x;
252 static BOOL g_b_init_open_process_token;
253 static BOOL g_b_init_get_token_information;
254 static BOOL g_b_init_lookup_account_sid;
255 static BOOL g_b_init_get_sid_sub_authority;
256 static BOOL g_b_init_get_sid_sub_authority_count;
257 static BOOL g_b_init_get_security_info;
258 static BOOL g_b_init_get_file_security;
259 static BOOL g_b_init_get_security_descriptor_owner;
260 static BOOL g_b_init_get_security_descriptor_group;
261 static BOOL g_b_init_is_valid_sid;
262 static BOOL g_b_init_create_toolhelp32_snapshot;
263 static BOOL g_b_init_process32_first;
264 static BOOL g_b_init_process32_next;
265 static BOOL g_b_init_open_thread_token;
266 static BOOL g_b_init_impersonate_self;
267 static BOOL g_b_init_revert_to_self;
268 static BOOL g_b_init_get_process_memory_info;
269 static BOOL g_b_init_get_process_working_set_size;
270 static BOOL g_b_init_global_memory_status;
271 static BOOL g_b_init_global_memory_status_ex;
272 static BOOL g_b_init_get_length_sid;
273 static BOOL g_b_init_equal_sid;
274 static BOOL g_b_init_copy_sid;
275 static BOOL g_b_init_get_native_system_info;
276 static BOOL g_b_init_get_system_times;
277 static BOOL g_b_init_create_symbolic_link;
278 static BOOL g_b_init_get_security_descriptor_dacl;
279 static BOOL g_b_init_convert_sd_to_sddl;
280 static BOOL g_b_init_convert_sddl_to_sd;
281 static BOOL g_b_init_is_valid_security_descriptor;
282 static BOOL g_b_init_set_file_security;
285 BEGIN: Wrapper functions around OpenProcessToken
286 and other functions in advapi32.dll that are only
287 supported in Windows NT / 2k / XP
289 /* ** Function pointer typedefs ** */
290 typedef BOOL (WINAPI * OpenProcessToken_Proc) (
291 HANDLE ProcessHandle,
292 DWORD DesiredAccess,
293 PHANDLE TokenHandle);
294 typedef BOOL (WINAPI * GetTokenInformation_Proc) (
295 HANDLE TokenHandle,
296 TOKEN_INFORMATION_CLASS TokenInformationClass,
297 LPVOID TokenInformation,
298 DWORD TokenInformationLength,
299 PDWORD ReturnLength);
300 typedef BOOL (WINAPI * GetProcessTimes_Proc) (
301 HANDLE process_handle,
302 LPFILETIME creation_time,
303 LPFILETIME exit_time,
304 LPFILETIME kernel_time,
305 LPFILETIME user_time);
307 GetProcessTimes_Proc get_process_times_fn = NULL;
309 #ifdef _UNICODE
310 const char * const LookupAccountSid_Name = "LookupAccountSidW";
311 const char * const GetFileSecurity_Name = "GetFileSecurityW";
312 const char * const SetFileSecurity_Name = "SetFileSecurityW";
313 #else
314 const char * const LookupAccountSid_Name = "LookupAccountSidA";
315 const char * const GetFileSecurity_Name = "GetFileSecurityA";
316 const char * const SetFileSecurity_Name = "SetFileSecurityA";
317 #endif
318 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
319 LPCTSTR lpSystemName,
320 PSID Sid,
321 LPTSTR Name,
322 LPDWORD cbName,
323 LPTSTR DomainName,
324 LPDWORD cbDomainName,
325 PSID_NAME_USE peUse);
326 typedef PDWORD (WINAPI * GetSidSubAuthority_Proc) (
327 PSID pSid,
328 DWORD n);
329 typedef PUCHAR (WINAPI * GetSidSubAuthorityCount_Proc) (
330 PSID pSid);
331 typedef DWORD (WINAPI * GetSecurityInfo_Proc) (
332 HANDLE handle,
333 SE_OBJECT_TYPE ObjectType,
334 SECURITY_INFORMATION SecurityInfo,
335 PSID *ppsidOwner,
336 PSID *ppsidGroup,
337 PACL *ppDacl,
338 PACL *ppSacl,
339 PSECURITY_DESCRIPTOR *ppSecurityDescriptor);
340 typedef BOOL (WINAPI * GetFileSecurity_Proc) (
341 LPCTSTR lpFileName,
342 SECURITY_INFORMATION RequestedInformation,
343 PSECURITY_DESCRIPTOR pSecurityDescriptor,
344 DWORD nLength,
345 LPDWORD lpnLengthNeeded);
346 typedef BOOL (WINAPI *SetFileSecurity_Proc) (
347 LPCTSTR lpFileName,
348 SECURITY_INFORMATION SecurityInformation,
349 PSECURITY_DESCRIPTOR pSecurityDescriptor);
350 typedef BOOL (WINAPI * GetSecurityDescriptorOwner_Proc) (
351 PSECURITY_DESCRIPTOR pSecurityDescriptor,
352 PSID *pOwner,
353 LPBOOL lpbOwnerDefaulted);
354 typedef BOOL (WINAPI * GetSecurityDescriptorGroup_Proc) (
355 PSECURITY_DESCRIPTOR pSecurityDescriptor,
356 PSID *pGroup,
357 LPBOOL lpbGroupDefaulted);
358 typedef BOOL (WINAPI *GetSecurityDescriptorDacl_Proc) (
359 PSECURITY_DESCRIPTOR pSecurityDescriptor,
360 LPBOOL lpbDaclPresent,
361 PACL *pDacl,
362 LPBOOL lpbDaclDefaulted);
363 typedef BOOL (WINAPI * IsValidSid_Proc) (
364 PSID sid);
365 typedef HANDLE (WINAPI * CreateToolhelp32Snapshot_Proc) (
366 DWORD dwFlags,
367 DWORD th32ProcessID);
368 typedef BOOL (WINAPI * Process32First_Proc) (
369 HANDLE hSnapshot,
370 LPPROCESSENTRY32 lppe);
371 typedef BOOL (WINAPI * Process32Next_Proc) (
372 HANDLE hSnapshot,
373 LPPROCESSENTRY32 lppe);
374 typedef BOOL (WINAPI * OpenThreadToken_Proc) (
375 HANDLE ThreadHandle,
376 DWORD DesiredAccess,
377 BOOL OpenAsSelf,
378 PHANDLE TokenHandle);
379 typedef BOOL (WINAPI * ImpersonateSelf_Proc) (
380 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
381 typedef BOOL (WINAPI * RevertToSelf_Proc) (void);
382 typedef BOOL (WINAPI * GetProcessMemoryInfo_Proc) (
383 HANDLE Process,
384 PPROCESS_MEMORY_COUNTERS ppsmemCounters,
385 DWORD cb);
386 typedef BOOL (WINAPI * GetProcessWorkingSetSize_Proc) (
387 HANDLE hProcess,
388 PSIZE_T lpMinimumWorkingSetSize,
389 PSIZE_T lpMaximumWorkingSetSize);
390 typedef BOOL (WINAPI * GlobalMemoryStatus_Proc) (
391 LPMEMORYSTATUS lpBuffer);
392 typedef BOOL (WINAPI * GlobalMemoryStatusEx_Proc) (
393 LPMEMORY_STATUS_EX lpBuffer);
394 typedef BOOL (WINAPI * CopySid_Proc) (
395 DWORD nDestinationSidLength,
396 PSID pDestinationSid,
397 PSID pSourceSid);
398 typedef BOOL (WINAPI * EqualSid_Proc) (
399 PSID pSid1,
400 PSID pSid2);
401 typedef DWORD (WINAPI * GetLengthSid_Proc) (
402 PSID pSid);
403 typedef void (WINAPI * GetNativeSystemInfo_Proc) (
404 LPSYSTEM_INFO lpSystemInfo);
405 typedef BOOL (WINAPI * GetSystemTimes_Proc) (
406 LPFILETIME lpIdleTime,
407 LPFILETIME lpKernelTime,
408 LPFILETIME lpUserTime);
409 typedef BOOLEAN (WINAPI *CreateSymbolicLink_Proc) (
410 LPTSTR lpSymlinkFileName,
411 LPTSTR lpTargetFileName,
412 DWORD dwFlags);
413 typedef BOOL (WINAPI *ConvertStringSecurityDescriptorToSecurityDescriptor_Proc) (
414 LPCTSTR StringSecurityDescriptor,
415 DWORD StringSDRevision,
416 PSECURITY_DESCRIPTOR *SecurityDescriptor,
417 PULONG SecurityDescriptorSize);
418 typedef BOOL (WINAPI *ConvertSecurityDescriptorToStringSecurityDescriptor_Proc) (
419 PSECURITY_DESCRIPTOR SecurityDescriptor,
420 DWORD RequestedStringSDRevision,
421 SECURITY_INFORMATION SecurityInformation,
422 LPTSTR *StringSecurityDescriptor,
423 PULONG StringSecurityDescriptorLen);
424 typedef BOOL (WINAPI *IsValidSecurityDescriptor_Proc) (PSECURITY_DESCRIPTOR);
426 /* ** A utility function ** */
427 static BOOL
428 is_windows_9x (void)
430 static BOOL s_b_ret = 0;
431 OSVERSIONINFO os_ver;
432 if (g_b_init_is_windows_9x == 0)
434 g_b_init_is_windows_9x = 1;
435 ZeroMemory (&os_ver, sizeof (OSVERSIONINFO));
436 os_ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
437 if (GetVersionEx (&os_ver))
439 s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
442 return s_b_ret;
445 static Lisp_Object ltime (ULONGLONG);
447 /* Get total user and system times for get-internal-run-time.
448 Returns a list of integers if the times are provided by the OS
449 (NT derivatives), otherwise it returns the result of current-time. */
450 Lisp_Object
451 w32_get_internal_run_time (void)
453 if (get_process_times_fn)
455 FILETIME create, exit, kernel, user;
456 HANDLE proc = GetCurrentProcess ();
457 if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
459 LARGE_INTEGER user_int, kernel_int, total;
460 user_int.LowPart = user.dwLowDateTime;
461 user_int.HighPart = user.dwHighDateTime;
462 kernel_int.LowPart = kernel.dwLowDateTime;
463 kernel_int.HighPart = kernel.dwHighDateTime;
464 total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
465 return ltime (total.QuadPart);
469 return Fcurrent_time ();
472 /* ** The wrapper functions ** */
474 static BOOL WINAPI
475 open_process_token (HANDLE ProcessHandle,
476 DWORD DesiredAccess,
477 PHANDLE TokenHandle)
479 static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
480 HMODULE hm_advapi32 = NULL;
481 if (is_windows_9x () == TRUE)
483 return FALSE;
485 if (g_b_init_open_process_token == 0)
487 g_b_init_open_process_token = 1;
488 hm_advapi32 = LoadLibrary ("Advapi32.dll");
489 s_pfn_Open_Process_Token =
490 (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
492 if (s_pfn_Open_Process_Token == NULL)
494 return FALSE;
496 return (
497 s_pfn_Open_Process_Token (
498 ProcessHandle,
499 DesiredAccess,
500 TokenHandle)
504 static BOOL WINAPI
505 get_token_information (HANDLE TokenHandle,
506 TOKEN_INFORMATION_CLASS TokenInformationClass,
507 LPVOID TokenInformation,
508 DWORD TokenInformationLength,
509 PDWORD ReturnLength)
511 static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
512 HMODULE hm_advapi32 = NULL;
513 if (is_windows_9x () == TRUE)
515 return FALSE;
517 if (g_b_init_get_token_information == 0)
519 g_b_init_get_token_information = 1;
520 hm_advapi32 = LoadLibrary ("Advapi32.dll");
521 s_pfn_Get_Token_Information =
522 (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
524 if (s_pfn_Get_Token_Information == NULL)
526 return FALSE;
528 return (
529 s_pfn_Get_Token_Information (
530 TokenHandle,
531 TokenInformationClass,
532 TokenInformation,
533 TokenInformationLength,
534 ReturnLength)
538 static BOOL WINAPI
539 lookup_account_sid (LPCTSTR lpSystemName,
540 PSID Sid,
541 LPTSTR Name,
542 LPDWORD cbName,
543 LPTSTR DomainName,
544 LPDWORD cbDomainName,
545 PSID_NAME_USE peUse)
547 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
548 HMODULE hm_advapi32 = NULL;
549 if (is_windows_9x () == TRUE)
551 return FALSE;
553 if (g_b_init_lookup_account_sid == 0)
555 g_b_init_lookup_account_sid = 1;
556 hm_advapi32 = LoadLibrary ("Advapi32.dll");
557 s_pfn_Lookup_Account_Sid =
558 (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
560 if (s_pfn_Lookup_Account_Sid == NULL)
562 return FALSE;
564 return (
565 s_pfn_Lookup_Account_Sid (
566 lpSystemName,
567 Sid,
568 Name,
569 cbName,
570 DomainName,
571 cbDomainName,
572 peUse)
576 static PDWORD WINAPI
577 get_sid_sub_authority (PSID pSid, DWORD n)
579 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority = NULL;
580 static DWORD zero = 0U;
581 HMODULE hm_advapi32 = NULL;
582 if (is_windows_9x () == TRUE)
584 return &zero;
586 if (g_b_init_get_sid_sub_authority == 0)
588 g_b_init_get_sid_sub_authority = 1;
589 hm_advapi32 = LoadLibrary ("Advapi32.dll");
590 s_pfn_Get_Sid_Sub_Authority =
591 (GetSidSubAuthority_Proc) GetProcAddress (
592 hm_advapi32, "GetSidSubAuthority");
594 if (s_pfn_Get_Sid_Sub_Authority == NULL)
596 return &zero;
598 return (s_pfn_Get_Sid_Sub_Authority (pSid, n));
601 static PUCHAR WINAPI
602 get_sid_sub_authority_count (PSID pSid)
604 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count = NULL;
605 static UCHAR zero = 0U;
606 HMODULE hm_advapi32 = NULL;
607 if (is_windows_9x () == TRUE)
609 return &zero;
611 if (g_b_init_get_sid_sub_authority_count == 0)
613 g_b_init_get_sid_sub_authority_count = 1;
614 hm_advapi32 = LoadLibrary ("Advapi32.dll");
615 s_pfn_Get_Sid_Sub_Authority_Count =
616 (GetSidSubAuthorityCount_Proc) GetProcAddress (
617 hm_advapi32, "GetSidSubAuthorityCount");
619 if (s_pfn_Get_Sid_Sub_Authority_Count == NULL)
621 return &zero;
623 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid));
626 static DWORD WINAPI
627 get_security_info (HANDLE handle,
628 SE_OBJECT_TYPE ObjectType,
629 SECURITY_INFORMATION SecurityInfo,
630 PSID *ppsidOwner,
631 PSID *ppsidGroup,
632 PACL *ppDacl,
633 PACL *ppSacl,
634 PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
636 static GetSecurityInfo_Proc s_pfn_Get_Security_Info = NULL;
637 HMODULE hm_advapi32 = NULL;
638 if (is_windows_9x () == TRUE)
640 return FALSE;
642 if (g_b_init_get_security_info == 0)
644 g_b_init_get_security_info = 1;
645 hm_advapi32 = LoadLibrary ("Advapi32.dll");
646 s_pfn_Get_Security_Info =
647 (GetSecurityInfo_Proc) GetProcAddress (
648 hm_advapi32, "GetSecurityInfo");
650 if (s_pfn_Get_Security_Info == NULL)
652 return FALSE;
654 return (s_pfn_Get_Security_Info (handle, ObjectType, SecurityInfo,
655 ppsidOwner, ppsidGroup, ppDacl, ppSacl,
656 ppSecurityDescriptor));
659 static BOOL WINAPI
660 get_file_security (LPCTSTR lpFileName,
661 SECURITY_INFORMATION RequestedInformation,
662 PSECURITY_DESCRIPTOR pSecurityDescriptor,
663 DWORD nLength,
664 LPDWORD lpnLengthNeeded)
666 static GetFileSecurity_Proc s_pfn_Get_File_Security = NULL;
667 HMODULE hm_advapi32 = NULL;
668 if (is_windows_9x () == TRUE)
670 errno = ENOTSUP;
671 return FALSE;
673 if (g_b_init_get_file_security == 0)
675 g_b_init_get_file_security = 1;
676 hm_advapi32 = LoadLibrary ("Advapi32.dll");
677 s_pfn_Get_File_Security =
678 (GetFileSecurity_Proc) GetProcAddress (
679 hm_advapi32, GetFileSecurity_Name);
681 if (s_pfn_Get_File_Security == NULL)
683 errno = ENOTSUP;
684 return FALSE;
686 return (s_pfn_Get_File_Security (lpFileName, RequestedInformation,
687 pSecurityDescriptor, nLength,
688 lpnLengthNeeded));
691 static BOOL WINAPI
692 set_file_security (LPCTSTR lpFileName,
693 SECURITY_INFORMATION SecurityInformation,
694 PSECURITY_DESCRIPTOR pSecurityDescriptor)
696 static SetFileSecurity_Proc s_pfn_Set_File_Security = NULL;
697 HMODULE hm_advapi32 = NULL;
698 if (is_windows_9x () == TRUE)
700 errno = ENOTSUP;
701 return FALSE;
703 if (g_b_init_set_file_security == 0)
705 g_b_init_set_file_security = 1;
706 hm_advapi32 = LoadLibrary ("Advapi32.dll");
707 s_pfn_Set_File_Security =
708 (SetFileSecurity_Proc) GetProcAddress (
709 hm_advapi32, SetFileSecurity_Name);
711 if (s_pfn_Set_File_Security == NULL)
713 errno = ENOTSUP;
714 return FALSE;
716 return (s_pfn_Set_File_Security (lpFileName, SecurityInformation,
717 pSecurityDescriptor));
720 static BOOL WINAPI
721 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
722 PSID *pOwner,
723 LPBOOL lpbOwnerDefaulted)
725 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner = NULL;
726 HMODULE hm_advapi32 = NULL;
727 if (is_windows_9x () == TRUE)
729 errno = ENOTSUP;
730 return FALSE;
732 if (g_b_init_get_security_descriptor_owner == 0)
734 g_b_init_get_security_descriptor_owner = 1;
735 hm_advapi32 = LoadLibrary ("Advapi32.dll");
736 s_pfn_Get_Security_Descriptor_Owner =
737 (GetSecurityDescriptorOwner_Proc) GetProcAddress (
738 hm_advapi32, "GetSecurityDescriptorOwner");
740 if (s_pfn_Get_Security_Descriptor_Owner == NULL)
742 errno = ENOTSUP;
743 return FALSE;
745 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor, pOwner,
746 lpbOwnerDefaulted));
749 static BOOL WINAPI
750 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
751 PSID *pGroup,
752 LPBOOL lpbGroupDefaulted)
754 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group = NULL;
755 HMODULE hm_advapi32 = NULL;
756 if (is_windows_9x () == TRUE)
758 errno = ENOTSUP;
759 return FALSE;
761 if (g_b_init_get_security_descriptor_group == 0)
763 g_b_init_get_security_descriptor_group = 1;
764 hm_advapi32 = LoadLibrary ("Advapi32.dll");
765 s_pfn_Get_Security_Descriptor_Group =
766 (GetSecurityDescriptorGroup_Proc) GetProcAddress (
767 hm_advapi32, "GetSecurityDescriptorGroup");
769 if (s_pfn_Get_Security_Descriptor_Group == NULL)
771 errno = ENOTSUP;
772 return FALSE;
774 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor, pGroup,
775 lpbGroupDefaulted));
778 static BOOL WINAPI
779 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor,
780 LPBOOL lpbDaclPresent,
781 PACL *pDacl,
782 LPBOOL lpbDaclDefaulted)
784 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl = NULL;
785 HMODULE hm_advapi32 = NULL;
786 if (is_windows_9x () == TRUE)
788 errno = ENOTSUP;
789 return FALSE;
791 if (g_b_init_get_security_descriptor_dacl == 0)
793 g_b_init_get_security_descriptor_dacl = 1;
794 hm_advapi32 = LoadLibrary ("Advapi32.dll");
795 s_pfn_Get_Security_Descriptor_Dacl =
796 (GetSecurityDescriptorDacl_Proc) GetProcAddress (
797 hm_advapi32, "GetSecurityDescriptorDacl");
799 if (s_pfn_Get_Security_Descriptor_Dacl == NULL)
801 errno = ENOTSUP;
802 return FALSE;
804 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor,
805 lpbDaclPresent, pDacl,
806 lpbDaclDefaulted));
809 static BOOL WINAPI
810 is_valid_sid (PSID sid)
812 static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
813 HMODULE hm_advapi32 = NULL;
814 if (is_windows_9x () == TRUE)
816 return FALSE;
818 if (g_b_init_is_valid_sid == 0)
820 g_b_init_is_valid_sid = 1;
821 hm_advapi32 = LoadLibrary ("Advapi32.dll");
822 s_pfn_Is_Valid_Sid =
823 (IsValidSid_Proc) GetProcAddress (
824 hm_advapi32, "IsValidSid");
826 if (s_pfn_Is_Valid_Sid == NULL)
828 return FALSE;
830 return (s_pfn_Is_Valid_Sid (sid));
833 static BOOL WINAPI
834 equal_sid (PSID sid1, PSID sid2)
836 static EqualSid_Proc s_pfn_Equal_Sid = NULL;
837 HMODULE hm_advapi32 = NULL;
838 if (is_windows_9x () == TRUE)
840 return FALSE;
842 if (g_b_init_equal_sid == 0)
844 g_b_init_equal_sid = 1;
845 hm_advapi32 = LoadLibrary ("Advapi32.dll");
846 s_pfn_Equal_Sid =
847 (EqualSid_Proc) GetProcAddress (
848 hm_advapi32, "EqualSid");
850 if (s_pfn_Equal_Sid == NULL)
852 return FALSE;
854 return (s_pfn_Equal_Sid (sid1, sid2));
857 static DWORD WINAPI
858 get_length_sid (PSID sid)
860 static GetLengthSid_Proc s_pfn_Get_Length_Sid = NULL;
861 HMODULE hm_advapi32 = NULL;
862 if (is_windows_9x () == TRUE)
864 return 0;
866 if (g_b_init_get_length_sid == 0)
868 g_b_init_get_length_sid = 1;
869 hm_advapi32 = LoadLibrary ("Advapi32.dll");
870 s_pfn_Get_Length_Sid =
871 (GetLengthSid_Proc) GetProcAddress (
872 hm_advapi32, "GetLengthSid");
874 if (s_pfn_Get_Length_Sid == NULL)
876 return 0;
878 return (s_pfn_Get_Length_Sid (sid));
881 static BOOL WINAPI
882 copy_sid (DWORD destlen, PSID dest, PSID src)
884 static CopySid_Proc s_pfn_Copy_Sid = NULL;
885 HMODULE hm_advapi32 = NULL;
886 if (is_windows_9x () == TRUE)
888 return FALSE;
890 if (g_b_init_copy_sid == 0)
892 g_b_init_copy_sid = 1;
893 hm_advapi32 = LoadLibrary ("Advapi32.dll");
894 s_pfn_Copy_Sid =
895 (CopySid_Proc) GetProcAddress (
896 hm_advapi32, "CopySid");
898 if (s_pfn_Copy_Sid == NULL)
900 return FALSE;
902 return (s_pfn_Copy_Sid (destlen, dest, src));
906 END: Wrapper functions around OpenProcessToken
907 and other functions in advapi32.dll that are only
908 supported in Windows NT / 2k / XP
911 static void WINAPI
912 get_native_system_info (LPSYSTEM_INFO lpSystemInfo)
914 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info = NULL;
915 if (is_windows_9x () != TRUE)
917 if (g_b_init_get_native_system_info == 0)
919 g_b_init_get_native_system_info = 1;
920 s_pfn_Get_Native_System_Info =
921 (GetNativeSystemInfo_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
922 "GetNativeSystemInfo");
924 if (s_pfn_Get_Native_System_Info != NULL)
925 s_pfn_Get_Native_System_Info (lpSystemInfo);
927 else
928 lpSystemInfo->dwNumberOfProcessors = -1;
931 static BOOL WINAPI
932 get_system_times (LPFILETIME lpIdleTime,
933 LPFILETIME lpKernelTime,
934 LPFILETIME lpUserTime)
936 static GetSystemTimes_Proc s_pfn_Get_System_times = NULL;
937 if (is_windows_9x () == TRUE)
939 return FALSE;
941 if (g_b_init_get_system_times == 0)
943 g_b_init_get_system_times = 1;
944 s_pfn_Get_System_times =
945 (GetSystemTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
946 "GetSystemTimes");
948 if (s_pfn_Get_System_times == NULL)
949 return FALSE;
950 return (s_pfn_Get_System_times (lpIdleTime, lpKernelTime, lpUserTime));
953 static BOOLEAN WINAPI
954 create_symbolic_link (LPTSTR lpSymlinkFilename,
955 LPTSTR lpTargetFileName,
956 DWORD dwFlags)
958 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link = NULL;
959 BOOLEAN retval;
961 if (is_windows_9x () == TRUE)
963 errno = ENOSYS;
964 return 0;
966 if (g_b_init_create_symbolic_link == 0)
968 g_b_init_create_symbolic_link = 1;
969 #ifdef _UNICODE
970 s_pfn_Create_Symbolic_Link =
971 (CreateSymbolicLink_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
972 "CreateSymbolicLinkW");
973 #else
974 s_pfn_Create_Symbolic_Link =
975 (CreateSymbolicLink_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
976 "CreateSymbolicLinkA");
977 #endif
979 if (s_pfn_Create_Symbolic_Link == NULL)
981 errno = ENOSYS;
982 return 0;
985 retval = s_pfn_Create_Symbolic_Link (lpSymlinkFilename, lpTargetFileName,
986 dwFlags);
987 /* If we were denied creation of the symlink, try again after
988 enabling the SeCreateSymbolicLinkPrivilege for our process. */
989 if (!retval)
991 TOKEN_PRIVILEGES priv_current;
993 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME, TRUE, &priv_current))
995 retval = s_pfn_Create_Symbolic_Link (lpSymlinkFilename, lpTargetFileName,
996 dwFlags);
997 restore_privilege (&priv_current);
998 revert_to_self ();
1001 return retval;
1004 static BOOL WINAPI
1005 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor)
1007 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc = NULL;
1009 if (is_windows_9x () == TRUE)
1011 errno = ENOTSUP;
1012 return FALSE;
1015 if (g_b_init_is_valid_security_descriptor == 0)
1017 g_b_init_is_valid_security_descriptor = 1;
1018 s_pfn_Is_Valid_Security_Descriptor_Proc =
1019 (IsValidSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1020 "IsValidSecurityDescriptor");
1022 if (s_pfn_Is_Valid_Security_Descriptor_Proc == NULL)
1024 errno = ENOTSUP;
1025 return FALSE;
1028 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor);
1031 static BOOL WINAPI
1032 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor,
1033 DWORD RequestedStringSDRevision,
1034 SECURITY_INFORMATION SecurityInformation,
1035 LPTSTR *StringSecurityDescriptor,
1036 PULONG StringSecurityDescriptorLen)
1038 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL = NULL;
1039 BOOL retval;
1041 if (is_windows_9x () == TRUE)
1043 errno = ENOTSUP;
1044 return FALSE;
1047 if (g_b_init_convert_sd_to_sddl == 0)
1049 g_b_init_convert_sd_to_sddl = 1;
1050 #ifdef _UNICODE
1051 s_pfn_Convert_SD_To_SDDL =
1052 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1053 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1054 #else
1055 s_pfn_Convert_SD_To_SDDL =
1056 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1057 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1058 #endif
1060 if (s_pfn_Convert_SD_To_SDDL == NULL)
1062 errno = ENOTSUP;
1063 return FALSE;
1066 retval = s_pfn_Convert_SD_To_SDDL (SecurityDescriptor,
1067 RequestedStringSDRevision,
1068 SecurityInformation,
1069 StringSecurityDescriptor,
1070 StringSecurityDescriptorLen);
1072 return retval;
1075 static BOOL WINAPI
1076 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor,
1077 DWORD StringSDRevision,
1078 PSECURITY_DESCRIPTOR *SecurityDescriptor,
1079 PULONG SecurityDescriptorSize)
1081 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD = NULL;
1082 BOOL retval;
1084 if (is_windows_9x () == TRUE)
1086 errno = ENOTSUP;
1087 return FALSE;
1090 if (g_b_init_convert_sddl_to_sd == 0)
1092 g_b_init_convert_sddl_to_sd = 1;
1093 #ifdef _UNICODE
1094 s_pfn_Convert_SDDL_To_SD =
1095 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1096 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1097 #else
1098 s_pfn_Convert_SDDL_To_SD =
1099 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1100 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1101 #endif
1103 if (s_pfn_Convert_SDDL_To_SD == NULL)
1105 errno = ENOTSUP;
1106 return FALSE;
1109 retval = s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor,
1110 StringSDRevision,
1111 SecurityDescriptor,
1112 SecurityDescriptorSize);
1114 return retval;
1119 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1120 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1122 This is called from alloc.c:valid_pointer_p. */
1124 w32_valid_pointer_p (void *p, int size)
1126 SIZE_T done;
1127 HANDLE h = OpenProcess (PROCESS_VM_READ, FALSE, GetCurrentProcessId ());
1129 if (h)
1131 unsigned char *buf = alloca (size);
1132 int retval = ReadProcessMemory (h, p, buf, size, &done);
1134 CloseHandle (h);
1135 return retval;
1137 else
1138 return -1;
1141 static char startup_dir[MAXPATHLEN];
1143 /* Get the current working directory. */
1144 char *
1145 getcwd (char *dir, int dirsize)
1147 if (!dirsize)
1149 errno = EINVAL;
1150 return NULL;
1152 if (dirsize <= strlen (startup_dir))
1154 errno = ERANGE;
1155 return NULL;
1157 #if 0
1158 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
1159 return dir;
1160 return NULL;
1161 #else
1162 /* Emacs doesn't actually change directory itself, it stays in the
1163 same directory where it was started. */
1164 strcpy (dir, startup_dir);
1165 return dir;
1166 #endif
1169 /* Emulate getloadavg. */
1171 struct load_sample {
1172 time_t sample_time;
1173 ULONGLONG idle;
1174 ULONGLONG kernel;
1175 ULONGLONG user;
1178 /* Number of processors on this machine. */
1179 static unsigned num_of_processors;
1181 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1182 static struct load_sample samples[16*60];
1183 static int first_idx = -1, last_idx = -1;
1184 static int max_idx = sizeof (samples) / sizeof (samples[0]);
1186 static int
1187 buf_next (int from)
1189 int next_idx = from + 1;
1191 if (next_idx >= max_idx)
1192 next_idx = 0;
1194 return next_idx;
1197 static int
1198 buf_prev (int from)
1200 int prev_idx = from - 1;
1202 if (prev_idx < 0)
1203 prev_idx = max_idx - 1;
1205 return prev_idx;
1208 static void
1209 sample_system_load (ULONGLONG *idle, ULONGLONG *kernel, ULONGLONG *user)
1211 SYSTEM_INFO sysinfo;
1212 FILETIME ft_idle, ft_user, ft_kernel;
1214 /* Initialize the number of processors on this machine. */
1215 if (num_of_processors <= 0)
1217 get_native_system_info (&sysinfo);
1218 num_of_processors = sysinfo.dwNumberOfProcessors;
1219 if (num_of_processors <= 0)
1221 GetSystemInfo (&sysinfo);
1222 num_of_processors = sysinfo.dwNumberOfProcessors;
1224 if (num_of_processors <= 0)
1225 num_of_processors = 1;
1228 /* TODO: Take into account threads that are ready to run, by
1229 sampling the "\System\Processor Queue Length" performance
1230 counter. The code below accounts only for threads that are
1231 actually running. */
1233 if (get_system_times (&ft_idle, &ft_kernel, &ft_user))
1235 ULARGE_INTEGER uidle, ukernel, uuser;
1237 memcpy (&uidle, &ft_idle, sizeof (ft_idle));
1238 memcpy (&ukernel, &ft_kernel, sizeof (ft_kernel));
1239 memcpy (&uuser, &ft_user, sizeof (ft_user));
1240 *idle = uidle.QuadPart;
1241 *kernel = ukernel.QuadPart;
1242 *user = uuser.QuadPart;
1244 else
1246 *idle = 0;
1247 *kernel = 0;
1248 *user = 0;
1252 /* Produce the load average for a given time interval, using the
1253 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1254 1-minute, 5-minute, or 15-minute average, respectively. */
1255 static double
1256 getavg (int which)
1258 double retval = -1.0;
1259 double tdiff;
1260 int idx;
1261 double span = (which == 0 ? 1.0 : (which == 1 ? 5.0 : 15.0)) * 60;
1262 time_t now = samples[last_idx].sample_time;
1264 if (first_idx != last_idx)
1266 for (idx = buf_prev (last_idx); ; idx = buf_prev (idx))
1268 tdiff = difftime (now, samples[idx].sample_time);
1269 if (tdiff >= span - 2*DBL_EPSILON*now)
1271 long double sys =
1272 samples[last_idx].kernel + samples[last_idx].user
1273 - (samples[idx].kernel + samples[idx].user);
1274 long double idl = samples[last_idx].idle - samples[idx].idle;
1276 retval = (1.0 - idl / sys) * num_of_processors;
1277 break;
1279 if (idx == first_idx)
1280 break;
1284 return retval;
1288 getloadavg (double loadavg[], int nelem)
1290 int elem;
1291 ULONGLONG idle, kernel, user;
1292 time_t now = time (NULL);
1294 /* Store another sample. We ignore samples that are less than 1 sec
1295 apart. */
1296 if (difftime (now, samples[last_idx].sample_time) >= 1.0 - 2*DBL_EPSILON*now)
1298 sample_system_load (&idle, &kernel, &user);
1299 last_idx = buf_next (last_idx);
1300 samples[last_idx].sample_time = now;
1301 samples[last_idx].idle = idle;
1302 samples[last_idx].kernel = kernel;
1303 samples[last_idx].user = user;
1304 /* If the buffer has more that 15 min worth of samples, discard
1305 the old ones. */
1306 if (first_idx == -1)
1307 first_idx = last_idx;
1308 while (first_idx != last_idx
1309 && (difftime (now, samples[first_idx].sample_time)
1310 >= 15.0*60 + 2*DBL_EPSILON*now))
1311 first_idx = buf_next (first_idx);
1314 for (elem = 0; elem < nelem; elem++)
1316 double avg = getavg (elem);
1318 if (avg < 0)
1319 break;
1320 loadavg[elem] = avg;
1323 return elem;
1326 /* Emulate getpwuid, getpwnam and others. */
1328 #define PASSWD_FIELD_SIZE 256
1330 static char dflt_passwd_name[PASSWD_FIELD_SIZE];
1331 static char dflt_passwd_passwd[PASSWD_FIELD_SIZE];
1332 static char dflt_passwd_gecos[PASSWD_FIELD_SIZE];
1333 static char dflt_passwd_dir[PASSWD_FIELD_SIZE];
1334 static char dflt_passwd_shell[PASSWD_FIELD_SIZE];
1336 static struct passwd dflt_passwd =
1338 dflt_passwd_name,
1339 dflt_passwd_passwd,
1343 dflt_passwd_gecos,
1344 dflt_passwd_dir,
1345 dflt_passwd_shell,
1348 static char dflt_group_name[GNLEN+1];
1350 static struct group dflt_group =
1352 /* When group information is not available, we return this as the
1353 group for all files. */
1354 dflt_group_name,
1358 unsigned
1359 getuid (void)
1361 return dflt_passwd.pw_uid;
1364 unsigned
1365 geteuid (void)
1367 /* I could imagine arguing for checking to see whether the user is
1368 in the Administrators group and returning a UID of 0 for that
1369 case, but I don't know how wise that would be in the long run. */
1370 return getuid ();
1373 unsigned
1374 getgid (void)
1376 return dflt_passwd.pw_gid;
1379 unsigned
1380 getegid (void)
1382 return getgid ();
1385 struct passwd *
1386 getpwuid (unsigned uid)
1388 if (uid == dflt_passwd.pw_uid)
1389 return &dflt_passwd;
1390 return NULL;
1393 struct group *
1394 getgrgid (gid_t gid)
1396 return &dflt_group;
1399 struct passwd *
1400 getpwnam (char *name)
1402 struct passwd *pw;
1404 pw = getpwuid (getuid ());
1405 if (!pw)
1406 return pw;
1408 if (xstrcasecmp (name, pw->pw_name))
1409 return NULL;
1411 return pw;
1414 static void
1415 init_user_info (void)
1417 /* Find the user's real name by opening the process token and
1418 looking up the name associated with the user-sid in that token.
1420 Use the relative portion of the identifier authority value from
1421 the user-sid as the user id value (same for group id using the
1422 primary group sid from the process token). */
1424 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
1425 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
1426 DWORD glength = sizeof (gname);
1427 HANDLE token = NULL;
1428 SID_NAME_USE user_type;
1429 unsigned char *buf = NULL;
1430 DWORD blen = 0;
1431 TOKEN_USER user_token;
1432 TOKEN_PRIMARY_GROUP group_token;
1433 BOOL result;
1435 result = open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token);
1436 if (result)
1438 result = get_token_information (token, TokenUser, NULL, 0, &blen);
1439 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1441 buf = xmalloc (blen);
1442 result = get_token_information (token, TokenUser,
1443 (LPVOID)buf, blen, &needed);
1444 if (result)
1446 memcpy (&user_token, buf, sizeof (user_token));
1447 result = lookup_account_sid (NULL, user_token.User.Sid,
1448 uname, &ulength,
1449 domain, &dlength, &user_type);
1452 else
1453 result = FALSE;
1455 if (result)
1457 strcpy (dflt_passwd.pw_name, uname);
1458 /* Determine a reasonable uid value. */
1459 if (xstrcasecmp ("administrator", uname) == 0)
1461 dflt_passwd.pw_uid = 500; /* well-known Administrator uid */
1462 dflt_passwd.pw_gid = 513; /* well-known None gid */
1464 else
1466 /* Use the last sub-authority value of the RID, the relative
1467 portion of the SID, as user/group ID. */
1468 dflt_passwd.pw_uid = get_rid (user_token.User.Sid);
1470 /* Get group id and name. */
1471 result = get_token_information (token, TokenPrimaryGroup,
1472 (LPVOID)buf, blen, &needed);
1473 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1475 buf = xrealloc (buf, blen = needed);
1476 result = get_token_information (token, TokenPrimaryGroup,
1477 (LPVOID)buf, blen, &needed);
1479 if (result)
1481 memcpy (&group_token, buf, sizeof (group_token));
1482 dflt_passwd.pw_gid = get_rid (group_token.PrimaryGroup);
1483 dlength = sizeof (domain);
1484 /* If we can get at the real Primary Group name, use that.
1485 Otherwise, the default group name was already set to
1486 "None" in globals_of_w32. */
1487 if (lookup_account_sid (NULL, group_token.PrimaryGroup,
1488 gname, &glength, NULL, &dlength,
1489 &user_type))
1490 strcpy (dflt_group_name, gname);
1492 else
1493 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
1496 /* If security calls are not supported (presumably because we
1497 are running under Windows 9X), fallback to this: */
1498 else if (GetUserName (uname, &ulength))
1500 strcpy (dflt_passwd.pw_name, uname);
1501 if (xstrcasecmp ("administrator", uname) == 0)
1502 dflt_passwd.pw_uid = 0;
1503 else
1504 dflt_passwd.pw_uid = 123;
1505 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
1507 else
1509 strcpy (dflt_passwd.pw_name, "unknown");
1510 dflt_passwd.pw_uid = 123;
1511 dflt_passwd.pw_gid = 123;
1513 dflt_group.gr_gid = dflt_passwd.pw_gid;
1515 /* Ensure HOME and SHELL are defined. */
1516 if (getenv ("HOME") == NULL)
1517 emacs_abort ();
1518 if (getenv ("SHELL") == NULL)
1519 emacs_abort ();
1521 /* Set dir and shell from environment variables. */
1522 strcpy (dflt_passwd.pw_dir, getenv ("HOME"));
1523 strcpy (dflt_passwd.pw_shell, getenv ("SHELL"));
1525 xfree (buf);
1526 if (token)
1527 CloseHandle (token);
1531 random (void)
1533 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1534 return ((rand () << 15) | rand ());
1537 void
1538 srandom (int seed)
1540 srand (seed);
1543 /* Current codepage for encoding file names. */
1544 static int file_name_codepage;
1546 /* Return the maximum length in bytes of a multibyte character
1547 sequence encoded in the current ANSI codepage. This is required to
1548 correctly walk the encoded file names one character at a time. */
1549 static int
1550 max_filename_mbslen (void)
1552 /* A simple cache to avoid calling GetCPInfo every time we need to
1553 normalize a file name. The file-name encoding is not supposed to
1554 be changed too frequently, if ever. */
1555 static Lisp_Object last_file_name_encoding;
1556 static int last_max_mbslen;
1557 Lisp_Object current_encoding;
1559 current_encoding = Vfile_name_coding_system;
1560 if (NILP (current_encoding))
1561 current_encoding = Vdefault_file_name_coding_system;
1563 if (!EQ (last_file_name_encoding, current_encoding))
1565 CPINFO cp_info;
1567 last_file_name_encoding = current_encoding;
1568 /* Default to the current ANSI codepage. */
1569 file_name_codepage = w32_ansi_code_page;
1570 if (!NILP (current_encoding))
1572 char *cpname = SDATA (SYMBOL_NAME (current_encoding));
1573 char *cp = NULL, *end;
1574 int cpnum;
1576 if (strncmp (cpname, "cp", 2) == 0)
1577 cp = cpname + 2;
1578 else if (strncmp (cpname, "windows-", 8) == 0)
1579 cp = cpname + 8;
1581 if (cp)
1583 end = cp;
1584 cpnum = strtol (cp, &end, 10);
1585 if (cpnum && *end == '\0' && end - cp >= 2)
1586 file_name_codepage = cpnum;
1590 if (!file_name_codepage)
1591 file_name_codepage = CP_ACP; /* CP_ACP = 0, but let's not assume that */
1593 if (!GetCPInfo (file_name_codepage, &cp_info))
1595 file_name_codepage = CP_ACP;
1596 if (!GetCPInfo (file_name_codepage, &cp_info))
1597 emacs_abort ();
1599 last_max_mbslen = cp_info.MaxCharSize;
1602 return last_max_mbslen;
1605 /* Normalize filename by converting all path separators to
1606 the specified separator. Also conditionally convert upper
1607 case path name components to lower case. */
1609 static void
1610 normalize_filename (register char *fp, char path_sep, int multibyte)
1612 char sep;
1613 char *elem, *p2;
1614 int dbcs_p = max_filename_mbslen () > 1;
1616 /* Multibyte file names are in the Emacs internal representation, so
1617 we can traverse them by bytes with no problems. */
1618 if (multibyte)
1619 dbcs_p = 0;
1621 /* Always lower-case drive letters a-z, even if the filesystem
1622 preserves case in filenames.
1623 This is so filenames can be compared by string comparison
1624 functions that are case-sensitive. Even case-preserving filesystems
1625 do not distinguish case in drive letters. */
1626 if (dbcs_p)
1627 p2 = CharNextExA (file_name_codepage, fp, 0);
1628 else
1629 p2 = fp + 1;
1631 if (*p2 == ':' && *fp >= 'A' && *fp <= 'Z')
1633 *fp += 'a' - 'A';
1634 fp += 2;
1637 if (multibyte || NILP (Vw32_downcase_file_names))
1639 while (*fp)
1641 if (*fp == '/' || *fp == '\\')
1642 *fp = path_sep;
1643 if (!dbcs_p)
1644 fp++;
1645 else
1646 fp = CharNextExA (file_name_codepage, fp, 0);
1648 return;
1651 sep = path_sep; /* convert to this path separator */
1652 elem = fp; /* start of current path element */
1654 do {
1655 if (*fp >= 'a' && *fp <= 'z')
1656 elem = 0; /* don't convert this element */
1658 if (*fp == 0 || *fp == ':')
1660 sep = *fp; /* restore current separator (or 0) */
1661 *fp = '/'; /* after conversion of this element */
1664 if (*fp == '/' || *fp == '\\')
1666 if (elem && elem != fp)
1668 *fp = 0; /* temporary end of string */
1669 _mbslwr (elem); /* while we convert to lower case */
1671 *fp = sep; /* convert (or restore) path separator */
1672 elem = fp + 1; /* next element starts after separator */
1673 sep = path_sep;
1675 if (*fp)
1677 if (!dbcs_p)
1678 fp++;
1679 else
1680 fp = CharNextExA (file_name_codepage, fp, 0);
1682 } while (*fp);
1685 /* Destructively turn backslashes into slashes. MULTIBYTE non-zero
1686 means the file name is a multibyte string in Emacs's internal
1687 representation. */
1688 void
1689 dostounix_filename (register char *p, int multibyte)
1691 normalize_filename (p, '/', multibyte);
1694 /* Destructively turn slashes into backslashes. */
1695 void
1696 unixtodos_filename (register char *p)
1698 normalize_filename (p, '\\', 0);
1701 /* Remove all CR's that are followed by a LF.
1702 (From msdos.c...probably should figure out a way to share it,
1703 although this code isn't going to ever change.) */
1704 static int
1705 crlf_to_lf (register int n, register unsigned char *buf)
1707 unsigned char *np = buf;
1708 unsigned char *startp = buf;
1709 unsigned char *endp = buf + n;
1711 if (n == 0)
1712 return n;
1713 while (buf < endp - 1)
1715 if (*buf == 0x0d)
1717 if (*(++buf) != 0x0a)
1718 *np++ = 0x0d;
1720 else
1721 *np++ = *buf++;
1723 if (buf < endp)
1724 *np++ = *buf++;
1725 return np - startp;
1728 /* Parse the root part of file name, if present. Return length and
1729 optionally store pointer to char after root. */
1730 static int
1731 parse_root (char * name, char ** pPath)
1733 char * start = name;
1735 if (name == NULL)
1736 return 0;
1738 /* find the root name of the volume if given */
1739 if (isalpha (name[0]) && name[1] == ':')
1741 /* skip past drive specifier */
1742 name += 2;
1743 if (IS_DIRECTORY_SEP (name[0]))
1744 name++;
1746 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1748 int slashes = 2;
1749 int dbcs_p = max_filename_mbslen () > 1;
1751 name += 2;
1754 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1755 break;
1756 if (dbcs_p)
1757 name = CharNextExA (file_name_codepage, name, 0);
1758 else
1759 name++;
1761 while ( *name );
1762 if (IS_DIRECTORY_SEP (name[0]))
1763 name++;
1766 if (pPath)
1767 *pPath = name;
1769 return name - start;
1772 /* Get long base name for name; name is assumed to be absolute. */
1773 static int
1774 get_long_basename (char * name, char * buf, int size)
1776 WIN32_FIND_DATA find_data;
1777 HANDLE dir_handle;
1778 int len = 0;
1780 /* must be valid filename, no wild cards or other invalid characters */
1781 if (_mbspbrk (name, "*?|<>\""))
1782 return 0;
1784 dir_handle = FindFirstFile (name, &find_data);
1785 if (dir_handle != INVALID_HANDLE_VALUE)
1787 if ((len = strlen (find_data.cFileName)) < size)
1788 memcpy (buf, find_data.cFileName, len + 1);
1789 else
1790 len = 0;
1791 FindClose (dir_handle);
1793 return len;
1796 /* Get long name for file, if possible (assumed to be absolute). */
1797 BOOL
1798 w32_get_long_filename (char * name, char * buf, int size)
1800 char * o = buf;
1801 char * p;
1802 char * q;
1803 char full[ MAX_PATH ];
1804 int len;
1806 len = strlen (name);
1807 if (len >= MAX_PATH)
1808 return FALSE;
1810 /* Use local copy for destructive modification. */
1811 memcpy (full, name, len+1);
1812 unixtodos_filename (full);
1814 /* Copy root part verbatim. */
1815 len = parse_root (full, &p);
1816 memcpy (o, full, len);
1817 o += len;
1818 *o = '\0';
1819 size -= len;
1821 while (p != NULL && *p)
1823 q = p;
1824 p = _mbschr (q, '\\');
1825 if (p) *p = '\0';
1826 len = get_long_basename (full, o, size);
1827 if (len > 0)
1829 o += len;
1830 size -= len;
1831 if (p != NULL)
1833 *p++ = '\\';
1834 if (size < 2)
1835 return FALSE;
1836 *o++ = '\\';
1837 size--;
1838 *o = '\0';
1841 else
1842 return FALSE;
1845 return TRUE;
1848 static int
1849 is_unc_volume (const char *filename)
1851 const char *ptr = filename;
1853 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
1854 return 0;
1856 if (_mbspbrk (ptr + 2, "*?|<>\"\\/"))
1857 return 0;
1859 return 1;
1862 /* Emulate the Posix unsetenv. */
1864 unsetenv (const char *name)
1866 char *var;
1867 size_t name_len;
1868 int retval;
1870 if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
1872 errno = EINVAL;
1873 return -1;
1875 name_len = strlen (name);
1876 /* MS docs says an environment variable cannot be longer than 32K. */
1877 if (name_len > 32767)
1879 errno = ENOMEM;
1880 return 0;
1882 /* It is safe to use 'alloca' with 32K size, since the stack is at
1883 least 2MB, and we set it to 8MB in the link command line. */
1884 var = alloca (name_len + 2);
1885 strncpy (var, name, name_len);
1886 var[name_len++] = '=';
1887 var[name_len] = '\0';
1888 return _putenv (var);
1891 /* MS _putenv doesn't support removing a variable when the argument
1892 does not include the '=' character, so we fix that here. */
1894 sys_putenv (char *str)
1896 const char *const name_end = strchr (str, '=');
1898 if (name_end == NULL)
1900 /* Remove the variable from the environment. */
1901 return unsetenv (str);
1904 return _putenv (str);
1907 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1909 LPBYTE
1910 w32_get_resource (char *key, LPDWORD lpdwtype)
1912 LPBYTE lpvalue;
1913 HKEY hrootkey = NULL;
1914 DWORD cbData;
1916 /* Check both the current user and the local machine to see if
1917 we have any resources. */
1919 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1921 lpvalue = NULL;
1923 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1924 && (lpvalue = xmalloc (cbData)) != NULL
1925 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1927 RegCloseKey (hrootkey);
1928 return (lpvalue);
1931 xfree (lpvalue);
1933 RegCloseKey (hrootkey);
1936 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1938 lpvalue = NULL;
1940 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1941 && (lpvalue = xmalloc (cbData)) != NULL
1942 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1944 RegCloseKey (hrootkey);
1945 return (lpvalue);
1948 xfree (lpvalue);
1950 RegCloseKey (hrootkey);
1953 return (NULL);
1956 char *get_emacs_configuration (void);
1958 void
1959 init_environment (char ** argv)
1961 static const char * const tempdirs[] = {
1962 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1965 int i;
1967 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
1969 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1970 temporary files and assume "/tmp" if $TMPDIR is unset, which
1971 will break on DOS/Windows. Refuse to work if we cannot find
1972 a directory, not even "c:/", usable for that purpose. */
1973 for (i = 0; i < imax ; i++)
1975 const char *tmp = tempdirs[i];
1977 if (*tmp == '$')
1978 tmp = getenv (tmp + 1);
1979 /* Note that `access' can lie to us if the directory resides on a
1980 read-only filesystem, like CD-ROM or a write-protected floppy.
1981 The only way to be really sure is to actually create a file and
1982 see if it succeeds. But I think that's too much to ask. */
1984 /* MSVCRT's _access crashes with D_OK. */
1985 if (tmp && faccessat (AT_FDCWD, tmp, D_OK, AT_EACCESS) == 0)
1987 char * var = alloca (strlen (tmp) + 8);
1988 sprintf (var, "TMPDIR=%s", tmp);
1989 _putenv (strdup (var));
1990 break;
1993 if (i >= imax)
1994 cmd_error_internal
1995 (Fcons (Qerror,
1996 Fcons (build_string ("no usable temporary directories found!!"),
1997 Qnil)),
1998 "While setting TMPDIR: ");
2000 /* Check for environment variables and use registry settings if they
2001 don't exist. Fallback on default values where applicable. */
2003 int i;
2004 LPBYTE lpval;
2005 DWORD dwType;
2006 char locale_name[32];
2007 char default_home[MAX_PATH];
2008 int appdata = 0;
2010 static const struct env_entry
2012 char * name;
2013 char * def_value;
2014 } dflt_envvars[] =
2016 /* If the default value is NULL, we will use the value from the
2017 outside environment or the Registry, but will not push the
2018 variable into the Emacs environment if it is defined neither
2019 in the Registry nor in the outside environment. */
2020 {"HOME", "C:/"},
2021 {"PRELOAD_WINSOCK", NULL},
2022 {"emacs_dir", "C:/emacs"},
2023 {"EMACSLOADPATH", NULL},
2024 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2025 {"EMACSDATA", NULL},
2026 {"EMACSPATH", NULL},
2027 {"INFOPATH", NULL},
2028 {"EMACSDOC", NULL},
2029 {"TERM", "cmd"},
2030 {"LANG", NULL},
2033 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2035 /* We need to copy dflt_envvars[] and work on the copy because we
2036 don't want the dumped Emacs to inherit the values of
2037 environment variables we saw during dumping (which could be on
2038 a different system). The defaults above must be left intact. */
2039 struct env_entry env_vars[N_ENV_VARS];
2041 for (i = 0; i < N_ENV_VARS; i++)
2042 env_vars[i] = dflt_envvars[i];
2044 /* For backwards compatibility, check if a .emacs file exists in C:/
2045 If not, then we can try to default to the appdata directory under the
2046 user's profile, which is more likely to be writable. */
2047 if (!check_existing ("C:/.emacs"))
2049 HRESULT profile_result;
2050 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2051 of Windows 95 and NT4 that have not been updated to include
2052 MSIE 5. */
2053 ShGetFolderPath_fn get_folder_path;
2054 get_folder_path = (ShGetFolderPath_fn)
2055 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2057 if (get_folder_path != NULL)
2059 profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
2060 0, default_home);
2062 /* If we can't get the appdata dir, revert to old behavior. */
2063 if (profile_result == S_OK)
2065 env_vars[0].def_value = default_home;
2066 appdata = 1;
2071 /* Get default locale info and use it for LANG. */
2072 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
2073 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
2074 locale_name, sizeof (locale_name)))
2076 for (i = 0; i < N_ENV_VARS; i++)
2078 if (strcmp (env_vars[i].name, "LANG") == 0)
2080 env_vars[i].def_value = locale_name;
2081 break;
2086 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2088 /* Treat emacs_dir specially: set it unconditionally based on our
2089 location. */
2091 char *p;
2092 char modname[MAX_PATH];
2094 if (!GetModuleFileName (NULL, modname, MAX_PATH))
2095 emacs_abort ();
2096 if ((p = _mbsrchr (modname, '\\')) == NULL)
2097 emacs_abort ();
2098 *p = 0;
2100 if ((p = _mbsrchr (modname, '\\'))
2101 /* From bin means installed Emacs, from src means uninstalled. */
2102 && (xstrcasecmp (p, "\\bin") == 0 || xstrcasecmp (p, "\\src") == 0))
2104 char buf[SET_ENV_BUF_SIZE];
2105 int within_build_tree = xstrcasecmp (p, "\\src") == 0;
2107 *p = 0;
2108 for (p = modname; *p; p = CharNext (p))
2109 if (*p == '\\') *p = '/';
2111 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
2112 _putenv (strdup (buf));
2113 /* If we are running from the Posix-like build tree, define
2114 SHELL to point to our own cmdproxy. The loop below will
2115 then disregard PATH_EXEC and the default value. */
2116 if (within_build_tree)
2118 _snprintf (buf, sizeof (buf) - 1,
2119 "SHELL=%s/nt/cmdproxy.exe", modname);
2120 _putenv (strdup (buf));
2123 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
2125 /* FIXME: should use substring of get_emacs_configuration ().
2126 But I don't think the Windows build supports alpha, mips etc
2127 anymore, so have taken the easy option for now. */
2128 else if (p && (xstrcasecmp (p, "\\i386") == 0
2129 || xstrcasecmp (p, "\\AMD64") == 0))
2131 *p = 0;
2132 p = _mbsrchr (modname, '\\');
2133 if (p != NULL)
2135 *p = 0;
2136 p = _mbsrchr (modname, '\\');
2137 if (p && xstrcasecmp (p, "\\src") == 0)
2139 char buf[SET_ENV_BUF_SIZE];
2141 *p = 0;
2142 for (p = modname; *p; p = CharNext (p))
2143 if (*p == '\\') *p = '/';
2145 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
2146 _putenv (strdup (buf));
2152 for (i = 0; i < N_ENV_VARS; i++)
2154 if (!getenv (env_vars[i].name))
2156 int dont_free = 0;
2157 char bufc[SET_ENV_BUF_SIZE];
2159 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL
2160 /* Also ignore empty environment variables. */
2161 || *lpval == 0)
2163 xfree (lpval);
2164 dont_free = 1;
2165 if (strcmp (env_vars[i].name, "SHELL") == 0)
2167 /* Look for cmdproxy.exe in every directory in
2168 PATH_EXEC. FIXME: This does not find cmdproxy
2169 in nt/ when we run uninstalled. */
2170 char fname[MAX_PATH];
2171 const char *pstart = PATH_EXEC, *pend;
2173 do {
2174 pend = _mbschr (pstart, ';');
2175 if (!pend)
2176 pend = pstart + strlen (pstart);
2177 /* Be defensive against series of ;;; characters. */
2178 if (pend > pstart)
2180 strncpy (fname, pstart, pend - pstart);
2181 fname[pend - pstart] = '/';
2182 strcpy (&fname[pend - pstart + 1], "cmdproxy.exe");
2183 ExpandEnvironmentStrings ((LPSTR) fname, bufc,
2184 sizeof (bufc));
2185 if (check_existing (bufc))
2187 lpval = bufc;
2188 dwType = REG_SZ;
2189 break;
2192 if (*pend)
2193 pstart = pend + 1;
2194 else
2195 pstart = pend;
2196 if (!*pstart)
2198 /* If not found in any directory, use the
2199 default as the last resort. */
2200 lpval = env_vars[i].def_value;
2201 dwType = REG_EXPAND_SZ;
2203 } while (*pstart);
2205 else
2207 lpval = env_vars[i].def_value;
2208 dwType = REG_EXPAND_SZ;
2210 if (strcmp (env_vars[i].name, "HOME") == 0 && !appdata)
2211 Vdelayed_warnings_list
2212 = Fcons (listn (CONSTYPE_HEAP, 2,
2213 intern ("initialization"),
2214 build_string ("Setting HOME to C:\\ by default is deprecated")),
2215 Vdelayed_warnings_list);
2218 if (lpval)
2220 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
2222 if (dwType == REG_EXPAND_SZ)
2223 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof (buf1));
2224 else if (dwType == REG_SZ)
2225 strcpy (buf1, lpval);
2226 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
2228 _snprintf (buf2, sizeof (buf2)-1, "%s=%s", env_vars[i].name,
2229 buf1);
2230 _putenv (strdup (buf2));
2233 if (!dont_free)
2234 xfree (lpval);
2240 /* Rebuild system configuration to reflect invoking system. */
2241 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
2243 /* Another special case: on NT, the PATH variable is actually named
2244 "Path" although cmd.exe (perhaps NT itself) arranges for
2245 environment variable lookup and setting to be case insensitive.
2246 However, Emacs assumes a fully case sensitive environment, so we
2247 need to change "Path" to "PATH" to match the expectations of
2248 various elisp packages. We do this by the sneaky method of
2249 modifying the string in the C runtime environ entry.
2251 The same applies to COMSPEC. */
2253 char ** envp;
2255 for (envp = environ; *envp; envp++)
2256 if (_strnicmp (*envp, "PATH=", 5) == 0)
2257 memcpy (*envp, "PATH=", 5);
2258 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
2259 memcpy (*envp, "COMSPEC=", 8);
2262 /* Remember the initial working directory for getcwd. */
2263 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2264 Does it matter anywhere in Emacs? */
2265 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
2266 emacs_abort ();
2269 static char modname[MAX_PATH];
2271 if (!GetModuleFileName (NULL, modname, MAX_PATH))
2272 emacs_abort ();
2273 argv[0] = modname;
2276 /* Determine if there is a middle mouse button, to allow parse_button
2277 to decide whether right mouse events should be mouse-2 or
2278 mouse-3. */
2279 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
2281 init_user_info ();
2284 /* Called from expand-file-name when default-directory is not a string. */
2286 char *
2287 emacs_root_dir (void)
2289 static char root_dir[FILENAME_MAX];
2290 const char *p;
2292 p = getenv ("emacs_dir");
2293 if (p == NULL)
2294 emacs_abort ();
2295 strcpy (root_dir, p);
2296 root_dir[parse_root (root_dir, NULL)] = '\0';
2297 dostounix_filename (root_dir, 0);
2298 return root_dir;
2301 /* We don't have scripts to automatically determine the system configuration
2302 for Emacs before it's compiled, and we don't want to have to make the
2303 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2304 routine. */
2306 char *
2307 get_emacs_configuration (void)
2309 char *arch, *oem, *os;
2310 int build_num;
2311 static char configuration_buffer[32];
2313 /* Determine the processor type. */
2314 switch (get_processor_type ())
2317 #ifdef PROCESSOR_INTEL_386
2318 case PROCESSOR_INTEL_386:
2319 case PROCESSOR_INTEL_486:
2320 case PROCESSOR_INTEL_PENTIUM:
2321 #ifdef _WIN64
2322 arch = "amd64";
2323 #else
2324 arch = "i386";
2325 #endif
2326 break;
2327 #endif
2328 #ifdef PROCESSOR_AMD_X8664
2329 case PROCESSOR_AMD_X8664:
2330 arch = "amd64";
2331 break;
2332 #endif
2334 #ifdef PROCESSOR_MIPS_R2000
2335 case PROCESSOR_MIPS_R2000:
2336 case PROCESSOR_MIPS_R3000:
2337 case PROCESSOR_MIPS_R4000:
2338 arch = "mips";
2339 break;
2340 #endif
2342 #ifdef PROCESSOR_ALPHA_21064
2343 case PROCESSOR_ALPHA_21064:
2344 arch = "alpha";
2345 break;
2346 #endif
2348 default:
2349 arch = "unknown";
2350 break;
2353 /* Use the OEM field to reflect the compiler/library combination. */
2354 #ifdef _MSC_VER
2355 #define COMPILER_NAME "msvc"
2356 #else
2357 #ifdef __GNUC__
2358 #define COMPILER_NAME "mingw"
2359 #else
2360 #define COMPILER_NAME "unknown"
2361 #endif
2362 #endif
2363 oem = COMPILER_NAME;
2365 switch (osinfo_cache.dwPlatformId) {
2366 case VER_PLATFORM_WIN32_NT:
2367 os = "nt";
2368 build_num = osinfo_cache.dwBuildNumber;
2369 break;
2370 case VER_PLATFORM_WIN32_WINDOWS:
2371 if (osinfo_cache.dwMinorVersion == 0) {
2372 os = "windows95";
2373 } else {
2374 os = "windows98";
2376 build_num = LOWORD (osinfo_cache.dwBuildNumber);
2377 break;
2378 case VER_PLATFORM_WIN32s:
2379 /* Not supported, should not happen. */
2380 os = "windows32s";
2381 build_num = LOWORD (osinfo_cache.dwBuildNumber);
2382 break;
2383 default:
2384 os = "unknown";
2385 build_num = 0;
2386 break;
2389 if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
2390 sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
2391 get_w32_major_version (), get_w32_minor_version (), build_num);
2392 } else {
2393 sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
2396 return configuration_buffer;
2399 char *
2400 get_emacs_configuration_options (void)
2402 static char *options_buffer;
2403 char cv[32]; /* Enough for COMPILER_VERSION. */
2404 char *options[] = {
2405 cv, /* To be filled later. */
2406 #ifdef EMACSDEBUG
2407 " --no-opt",
2408 #endif
2409 #ifdef ENABLE_CHECKING
2410 " --enable-checking",
2411 #endif
2412 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2413 with a starting space to save work here. */
2414 #ifdef USER_CFLAGS
2415 " --cflags", USER_CFLAGS,
2416 #endif
2417 #ifdef USER_LDFLAGS
2418 " --ldflags", USER_LDFLAGS,
2419 #endif
2420 NULL
2422 size_t size = 0;
2423 int i;
2425 /* Work out the effective configure options for this build. */
2426 #ifdef _MSC_VER
2427 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2428 #else
2429 #ifdef __GNUC__
2430 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2431 #else
2432 #define COMPILER_VERSION ""
2433 #endif
2434 #endif
2436 if (_snprintf (cv, sizeof (cv) - 1, COMPILER_VERSION) < 0)
2437 return "Error: not enough space for compiler version";
2438 cv[sizeof (cv) - 1] = '\0';
2440 for (i = 0; options[i]; i++)
2441 size += strlen (options[i]);
2443 options_buffer = xmalloc (size + 1);
2444 options_buffer[0] = '\0';
2446 for (i = 0; options[i]; i++)
2447 strcat (options_buffer, options[i]);
2449 return options_buffer;
2453 #include <sys/timeb.h>
2455 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2457 gettimeofday (struct timeval *__restrict tv, struct timezone *__restrict tz)
2459 struct _timeb tb;
2460 _ftime (&tb);
2462 tv->tv_sec = tb.time;
2463 tv->tv_usec = tb.millitm * 1000L;
2464 /* Implementation note: _ftime sometimes doesn't update the dstflag
2465 according to the new timezone when the system timezone is
2466 changed. We could fix that by using GetSystemTime and
2467 GetTimeZoneInformation, but that doesn't seem necessary, since
2468 Emacs always calls gettimeofday with the 2nd argument NULL (see
2469 current_emacs_time). */
2470 if (tz)
2472 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
2473 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
2475 return 0;
2478 /* Emulate fdutimens. */
2480 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2481 TIMESPEC[0] and TIMESPEC[1], respectively.
2482 FD must be either negative -- in which case it is ignored --
2483 or a file descriptor that is open on FILE.
2484 If FD is nonnegative, then FILE can be NULL, which means
2485 use just futimes instead of utimes.
2486 If TIMESPEC is null, FAIL.
2487 Return 0 on success, -1 (setting errno) on failure. */
2490 fdutimens (int fd, char const *file, struct timespec const timespec[2])
2492 struct _utimbuf ut;
2494 if (!timespec)
2496 errno = ENOSYS;
2497 return -1;
2499 if (fd < 0 && !file)
2501 errno = EBADF;
2502 return -1;
2504 ut.actime = timespec[0].tv_sec;
2505 ut.modtime = timespec[1].tv_sec;
2506 if (fd >= 0)
2507 return _futime (fd, &ut);
2508 else
2509 return _utime (file, &ut);
2513 /* ------------------------------------------------------------------------- */
2514 /* IO support and wrapper functions for the Windows API. */
2515 /* ------------------------------------------------------------------------- */
2517 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2518 on network directories, so we handle that case here.
2519 (Ulrich Leodolter, 1/11/95). */
2520 char *
2521 sys_ctime (const time_t *t)
2523 char *str = (char *) ctime (t);
2524 return (str ? str : "Sun Jan 01 00:00:00 1970");
2527 /* Emulate sleep...we could have done this with a define, but that
2528 would necessitate including windows.h in the files that used it.
2529 This is much easier. */
2530 void
2531 sys_sleep (int seconds)
2533 Sleep (seconds * 1000);
2536 /* Internal MSVC functions for low-level descriptor munging */
2537 extern int __cdecl _set_osfhnd (int fd, long h);
2538 extern int __cdecl _free_osfhnd (int fd);
2540 /* parallel array of private info on file handles */
2541 filedesc fd_info [ MAXDESC ];
2543 typedef struct volume_info_data {
2544 struct volume_info_data * next;
2546 /* time when info was obtained */
2547 DWORD timestamp;
2549 /* actual volume info */
2550 char * root_dir;
2551 DWORD serialnum;
2552 DWORD maxcomp;
2553 DWORD flags;
2554 char * name;
2555 char * type;
2556 } volume_info_data;
2558 /* Global referenced by various functions. */
2559 static volume_info_data volume_info;
2561 /* Vector to indicate which drives are local and fixed (for which cached
2562 data never expires). */
2563 static BOOL fixed_drives[26];
2565 /* Consider cached volume information to be stale if older than 10s,
2566 at least for non-local drives. Info for fixed drives is never stale. */
2567 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2568 #define VOLINFO_STILL_VALID( root_dir, info ) \
2569 ( ( isalpha (root_dir[0]) && \
2570 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2571 || GetTickCount () - info->timestamp < 10000 )
2573 /* Cache support functions. */
2575 /* Simple linked list with linear search is sufficient. */
2576 static volume_info_data *volume_cache = NULL;
2578 static volume_info_data *
2579 lookup_volume_info (char * root_dir)
2581 volume_info_data * info;
2583 for (info = volume_cache; info; info = info->next)
2584 if (xstrcasecmp (info->root_dir, root_dir) == 0)
2585 break;
2586 return info;
2589 static void
2590 add_volume_info (char * root_dir, volume_info_data * info)
2592 info->root_dir = xstrdup (root_dir);
2593 info->next = volume_cache;
2594 volume_cache = info;
2598 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2599 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2600 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2601 static volume_info_data *
2602 GetCachedVolumeInformation (char * root_dir)
2604 volume_info_data * info;
2605 char default_root[ MAX_PATH ];
2607 /* NULL for root_dir means use root from current directory. */
2608 if (root_dir == NULL)
2610 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
2611 return NULL;
2612 parse_root (default_root, &root_dir);
2613 *root_dir = 0;
2614 root_dir = default_root;
2617 /* Local fixed drives can be cached permanently. Removable drives
2618 cannot be cached permanently, since the volume name and serial
2619 number (if nothing else) can change. Remote drives should be
2620 treated as if they are removable, since there is no sure way to
2621 tell whether they are or not. Also, the UNC association of drive
2622 letters mapped to remote volumes can be changed at any time (even
2623 by other processes) without notice.
2625 As a compromise, so we can benefit from caching info for remote
2626 volumes, we use a simple expiry mechanism to invalidate cache
2627 entries that are more than ten seconds old. */
2629 #if 0
2630 /* No point doing this, because WNetGetConnection is even slower than
2631 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2632 GetDriveType is about the only call of this type which does not
2633 involve network access, and so is extremely quick). */
2635 /* Map drive letter to UNC if remote. */
2636 if (isalpha (root_dir[0]) && !fixed[DRIVE_INDEX (root_dir[0])])
2638 char remote_name[ 256 ];
2639 char drive[3] = { root_dir[0], ':' };
2641 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
2642 == NO_ERROR)
2643 /* do something */ ;
2645 #endif
2647 info = lookup_volume_info (root_dir);
2649 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
2651 char name[ 256 ];
2652 DWORD serialnum;
2653 DWORD maxcomp;
2654 DWORD flags;
2655 char type[ 256 ];
2657 /* Info is not cached, or is stale. */
2658 if (!GetVolumeInformation (root_dir,
2659 name, sizeof (name),
2660 &serialnum,
2661 &maxcomp,
2662 &flags,
2663 type, sizeof (type)))
2664 return NULL;
2666 /* Cache the volume information for future use, overwriting existing
2667 entry if present. */
2668 if (info == NULL)
2670 info = xmalloc (sizeof (volume_info_data));
2671 add_volume_info (root_dir, info);
2673 else
2675 xfree (info->name);
2676 xfree (info->type);
2679 info->name = xstrdup (name);
2680 info->serialnum = serialnum;
2681 info->maxcomp = maxcomp;
2682 info->flags = flags;
2683 info->type = xstrdup (type);
2684 info->timestamp = GetTickCount ();
2687 return info;
2690 /* Get information on the volume where NAME is held; set path pointer to
2691 start of pathname in NAME (past UNC header\volume header if present),
2692 if pPath is non-NULL.
2694 Note: if NAME includes symlinks, the information is for the volume
2695 of the symlink, not of its target. That's because, even though
2696 GetVolumeInformation returns information about the symlink target
2697 of its argument, we only pass the root directory to
2698 GetVolumeInformation, not the full NAME. */
2699 static int
2700 get_volume_info (const char * name, const char ** pPath)
2702 char temp[MAX_PATH];
2703 char *rootname = NULL; /* default to current volume */
2704 volume_info_data * info;
2706 if (name == NULL)
2707 return FALSE;
2709 /* Find the root name of the volume if given. */
2710 if (isalpha (name[0]) && name[1] == ':')
2712 rootname = temp;
2713 temp[0] = *name++;
2714 temp[1] = *name++;
2715 temp[2] = '\\';
2716 temp[3] = 0;
2718 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
2720 char *str = temp;
2721 int slashes = 4;
2722 int dbcs_p = max_filename_mbslen () > 1;
2724 rootname = temp;
2727 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
2728 break;
2729 if (!dbcs_p)
2730 *str++ = *name++;
2731 else
2733 const char *p = name;
2735 name = CharNextExA (file_name_codepage, name, 0);
2736 memcpy (str, p, name - p);
2737 str += name - p;
2740 while ( *name );
2742 *str++ = '\\';
2743 *str = 0;
2746 if (pPath)
2747 *pPath = name;
2749 info = GetCachedVolumeInformation (rootname);
2750 if (info != NULL)
2752 /* Set global referenced by other functions. */
2753 volume_info = *info;
2754 return TRUE;
2756 return FALSE;
2759 /* Determine if volume is FAT format (ie. only supports short 8.3
2760 names); also set path pointer to start of pathname in name, if
2761 pPath is non-NULL. */
2762 static int
2763 is_fat_volume (const char * name, const char ** pPath)
2765 if (get_volume_info (name, pPath))
2766 return (volume_info.maxcomp == 12);
2767 return FALSE;
2770 /* Map filename to a valid 8.3 name if necessary.
2771 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2772 const char *
2773 map_w32_filename (const char * name, const char ** pPath)
2775 static char shortname[MAX_PATH];
2776 char * str = shortname;
2777 char c;
2778 char * path;
2779 const char * save_name = name;
2781 if (strlen (name) >= MAX_PATH)
2783 /* Return a filename which will cause callers to fail. */
2784 strcpy (shortname, "?");
2785 return shortname;
2788 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
2790 register int left = 8; /* maximum number of chars in part */
2791 register int extn = 0; /* extension added? */
2792 register int dots = 2; /* maximum number of dots allowed */
2794 while (name < path)
2795 *str++ = *name++; /* skip past UNC header */
2797 while ((c = *name++))
2799 switch ( c )
2801 case ':':
2802 case '\\':
2803 case '/':
2804 *str++ = (c == ':' ? ':' : '\\');
2805 extn = 0; /* reset extension flags */
2806 dots = 2; /* max 2 dots */
2807 left = 8; /* max length 8 for main part */
2808 break;
2809 case '.':
2810 if ( dots )
2812 /* Convert path components of the form .xxx to _xxx,
2813 but leave . and .. as they are. This allows .emacs
2814 to be read as _emacs, for example. */
2816 if (! *name ||
2817 *name == '.' ||
2818 IS_DIRECTORY_SEP (*name))
2820 *str++ = '.';
2821 dots--;
2823 else
2825 *str++ = '_';
2826 left--;
2827 dots = 0;
2830 else if ( !extn )
2832 *str++ = '.';
2833 extn = 1; /* we've got an extension */
2834 left = 3; /* 3 chars in extension */
2836 else
2838 /* any embedded dots after the first are converted to _ */
2839 *str++ = '_';
2841 break;
2842 case '~':
2843 case '#': /* don't lose these, they're important */
2844 if ( ! left )
2845 str[-1] = c; /* replace last character of part */
2846 /* FALLTHRU */
2847 default:
2848 if ( left )
2850 *str++ = tolower (c); /* map to lower case (looks nicer) */
2851 left--;
2852 dots = 0; /* started a path component */
2854 break;
2857 *str = '\0';
2859 else
2861 strcpy (shortname, name);
2862 unixtodos_filename (shortname);
2865 if (pPath)
2866 *pPath = shortname + (path - save_name);
2868 return shortname;
2871 static int
2872 is_exec (const char * name)
2874 char * p = strrchr (name, '.');
2875 return
2876 (p != NULL
2877 && (xstrcasecmp (p, ".exe") == 0 ||
2878 xstrcasecmp (p, ".com") == 0 ||
2879 xstrcasecmp (p, ".bat") == 0 ||
2880 xstrcasecmp (p, ".cmd") == 0));
2883 /* Emulate the Unix directory procedures opendir, closedir,
2884 and readdir. We can't use the procedures supplied in sysdep.c,
2885 so we provide them here. */
2887 struct dirent dir_static; /* simulated directory contents */
2888 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
2889 static int dir_is_fat;
2890 static char dir_pathname[MAXPATHLEN+1];
2891 static WIN32_FIND_DATA dir_find_data;
2893 /* Support shares on a network resource as subdirectories of a read-only
2894 root directory. */
2895 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
2896 static HANDLE open_unc_volume (const char *);
2897 static char *read_unc_volume (HANDLE, char *, int);
2898 static void close_unc_volume (HANDLE);
2900 DIR *
2901 opendir (const char *filename)
2903 DIR *dirp;
2905 /* Opening is done by FindFirstFile. However, a read is inherent to
2906 this operation, so we defer the open until read time. */
2908 if (dir_find_handle != INVALID_HANDLE_VALUE)
2909 return NULL;
2910 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2911 return NULL;
2913 /* Note: We don't support traversal of UNC volumes via symlinks.
2914 Doing so would mean punishing 99.99% of use cases by resolving
2915 all the possible symlinks in FILENAME, recursively. */
2916 if (is_unc_volume (filename))
2918 wnet_enum_handle = open_unc_volume (filename);
2919 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
2920 return NULL;
2923 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
2924 return NULL;
2926 dirp->dd_fd = 0;
2927 dirp->dd_loc = 0;
2928 dirp->dd_size = 0;
2930 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
2931 dir_pathname[MAXPATHLEN] = '\0';
2932 /* Note: We don't support symlinks to file names on FAT volumes.
2933 Doing so would mean punishing 99.99% of use cases by resolving
2934 all the possible symlinks in FILENAME, recursively. */
2935 dir_is_fat = is_fat_volume (filename, NULL);
2937 return dirp;
2940 void
2941 closedir (DIR *dirp)
2943 /* If we have a find-handle open, close it. */
2944 if (dir_find_handle != INVALID_HANDLE_VALUE)
2946 FindClose (dir_find_handle);
2947 dir_find_handle = INVALID_HANDLE_VALUE;
2949 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2951 close_unc_volume (wnet_enum_handle);
2952 wnet_enum_handle = INVALID_HANDLE_VALUE;
2954 xfree ((char *) dirp);
2957 struct dirent *
2958 readdir (DIR *dirp)
2960 int downcase = !NILP (Vw32_downcase_file_names);
2962 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2964 if (!read_unc_volume (wnet_enum_handle,
2965 dir_find_data.cFileName,
2966 MAX_PATH))
2967 return NULL;
2969 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2970 else if (dir_find_handle == INVALID_HANDLE_VALUE)
2972 char filename[MAXNAMLEN + 3];
2973 int ln;
2974 int dbcs_p = max_filename_mbslen () > 1;
2976 strcpy (filename, dir_pathname);
2977 ln = strlen (filename) - 1;
2978 if (!dbcs_p)
2980 if (!IS_DIRECTORY_SEP (filename[ln]))
2981 strcat (filename, "\\");
2983 else
2985 char *end = filename + ln + 1;
2986 char *last_char = CharPrevExA (file_name_codepage, filename, end, 0);
2988 if (!IS_DIRECTORY_SEP (*last_char))
2989 strcat (filename, "\\");
2991 strcat (filename, "*");
2993 /* Note: No need to resolve symlinks in FILENAME, because
2994 FindFirst opens the directory that is the target of a
2995 symlink. */
2996 dir_find_handle = FindFirstFile (filename, &dir_find_data);
2998 if (dir_find_handle == INVALID_HANDLE_VALUE)
2999 return NULL;
3001 else
3003 if (!FindNextFile (dir_find_handle, &dir_find_data))
3004 return NULL;
3007 /* Emacs never uses this value, so don't bother making it match
3008 value returned by stat(). */
3009 dir_static.d_ino = 1;
3011 strcpy (dir_static.d_name, dir_find_data.cFileName);
3013 /* If the file name in cFileName[] includes `?' characters, it means
3014 the original file name used characters that cannot be represented
3015 by the current ANSI codepage. To avoid total lossage, retrieve
3016 the short 8+3 alias of the long file name. */
3017 if (_mbspbrk (dir_static.d_name, "?"))
3019 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
3020 downcase = 1; /* 8+3 aliases are returned in all caps */
3022 dir_static.d_namlen = strlen (dir_static.d_name);
3023 dir_static.d_reclen = sizeof (struct dirent) - MAXNAMLEN + 3 +
3024 dir_static.d_namlen - dir_static.d_namlen % 4;
3026 /* If the file name in cFileName[] includes `?' characters, it means
3027 the original file name used characters that cannot be represented
3028 by the current ANSI codepage. To avoid total lossage, retrieve
3029 the short 8+3 alias of the long file name. */
3030 if (_mbspbrk (dir_find_data.cFileName, "?"))
3032 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
3033 /* 8+3 aliases are returned in all caps, which could break
3034 various alists that look at filenames' extensions. */
3035 downcase = 1;
3037 else
3038 strcpy (dir_static.d_name, dir_find_data.cFileName);
3039 dir_static.d_namlen = strlen (dir_static.d_name);
3040 if (dir_is_fat)
3041 _mbslwr (dir_static.d_name);
3042 else if (downcase)
3044 register char *p;
3045 int dbcs_p = max_filename_mbslen () > 1;
3046 for (p = dir_static.d_name; *p; )
3048 if (*p >= 'a' && *p <= 'z')
3049 break;
3050 if (dbcs_p)
3051 p = CharNextExA (file_name_codepage, p, 0);
3052 else
3053 p++;
3055 if (!*p)
3056 _mbslwr (dir_static.d_name);
3059 return &dir_static;
3062 static HANDLE
3063 open_unc_volume (const char *path)
3065 NETRESOURCE nr;
3066 HANDLE henum;
3067 int result;
3069 nr.dwScope = RESOURCE_GLOBALNET;
3070 nr.dwType = RESOURCETYPE_DISK;
3071 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
3072 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
3073 nr.lpLocalName = NULL;
3074 nr.lpRemoteName = (LPSTR)map_w32_filename (path, NULL);
3075 nr.lpComment = NULL;
3076 nr.lpProvider = NULL;
3078 result = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
3079 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
3081 if (result == NO_ERROR)
3082 return henum;
3083 else
3084 return INVALID_HANDLE_VALUE;
3087 static char *
3088 read_unc_volume (HANDLE henum, char *readbuf, int size)
3090 DWORD count;
3091 int result;
3092 DWORD bufsize = 512;
3093 char *buffer;
3094 char *ptr;
3095 int dbcs_p = max_filename_mbslen () > 1;
3097 count = 1;
3098 buffer = alloca (bufsize);
3099 result = WNetEnumResource (henum, &count, buffer, &bufsize);
3100 if (result != NO_ERROR)
3101 return NULL;
3103 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3104 ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
3105 ptr += 2;
3106 if (!dbcs_p)
3107 while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
3108 else
3110 while (*ptr && !IS_DIRECTORY_SEP (*ptr))
3111 ptr = CharNextExA (file_name_codepage, ptr, 0);
3113 ptr++;
3115 strncpy (readbuf, ptr, size);
3116 return readbuf;
3119 static void
3120 close_unc_volume (HANDLE henum)
3122 if (henum != INVALID_HANDLE_VALUE)
3123 WNetCloseEnum (henum);
3126 static DWORD
3127 unc_volume_file_attributes (const char *path)
3129 HANDLE henum;
3130 DWORD attrs;
3132 henum = open_unc_volume (path);
3133 if (henum == INVALID_HANDLE_VALUE)
3134 return -1;
3136 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
3138 close_unc_volume (henum);
3140 return attrs;
3143 /* Ensure a network connection is authenticated. */
3144 static void
3145 logon_network_drive (const char *path)
3147 NETRESOURCE resource;
3148 char share[MAX_PATH];
3149 int n_slashes;
3150 char drive[4];
3151 UINT drvtype;
3152 char *p;
3153 int dbcs_p;
3155 if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
3156 drvtype = DRIVE_REMOTE;
3157 else if (path[0] == '\0' || path[1] != ':')
3158 drvtype = GetDriveType (NULL);
3159 else
3161 drive[0] = path[0];
3162 drive[1] = ':';
3163 drive[2] = '\\';
3164 drive[3] = '\0';
3165 drvtype = GetDriveType (drive);
3168 /* Only logon to networked drives. */
3169 if (drvtype != DRIVE_REMOTE)
3170 return;
3172 n_slashes = 2;
3173 strncpy (share, path, MAX_PATH);
3174 /* Truncate to just server and share name. */
3175 dbcs_p = max_filename_mbslen () > 1;
3176 for (p = share + 2; *p && p < share + MAX_PATH; )
3178 if (IS_DIRECTORY_SEP (*p) && ++n_slashes > 3)
3180 *p = '\0';
3181 break;
3183 if (dbcs_p)
3184 p = CharNextExA (file_name_codepage, p, 0);
3185 else
3186 p++;
3189 resource.dwType = RESOURCETYPE_DISK;
3190 resource.lpLocalName = NULL;
3191 resource.lpRemoteName = share;
3192 resource.lpProvider = NULL;
3194 WNetAddConnection2 (&resource, NULL, NULL, CONNECT_INTERACTIVE);
3197 /* Emulate faccessat(2). */
3199 faccessat (int dirfd, const char * path, int mode, int flags)
3201 DWORD attributes;
3203 if (dirfd != AT_FDCWD
3204 && !(IS_DIRECTORY_SEP (path[0])
3205 || IS_DEVICE_SEP (path[1])))
3207 errno = EBADF;
3208 return -1;
3211 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3212 newer versions blow up when passed D_OK. */
3213 path = map_w32_filename (path, NULL);
3214 /* If the last element of PATH is a symlink, we need to resolve it
3215 to get the attributes of its target file. Note: any symlinks in
3216 PATH elements other than the last one are transparently resolved
3217 by GetFileAttributes below. */
3218 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0
3219 && (flags & AT_SYMLINK_NOFOLLOW) == 0)
3220 path = chase_symlinks (path);
3222 if ((attributes = GetFileAttributes (path)) == -1)
3224 DWORD w32err = GetLastError ();
3226 switch (w32err)
3228 case ERROR_INVALID_NAME:
3229 case ERROR_BAD_PATHNAME:
3230 if (is_unc_volume (path))
3232 attributes = unc_volume_file_attributes (path);
3233 if (attributes == -1)
3235 errno = EACCES;
3236 return -1;
3238 break;
3240 /* FALLTHROUGH */
3241 case ERROR_FILE_NOT_FOUND:
3242 case ERROR_BAD_NETPATH:
3243 errno = ENOENT;
3244 break;
3245 default:
3246 errno = EACCES;
3247 break;
3249 return -1;
3251 if ((mode & X_OK) != 0
3252 && !(is_exec (path) || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0))
3254 errno = EACCES;
3255 return -1;
3257 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
3259 errno = EACCES;
3260 return -1;
3262 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
3264 errno = EACCES;
3265 return -1;
3267 return 0;
3270 /* Shadow some MSVC runtime functions to map requests for long filenames
3271 to reasonable short names if necessary. This was originally added to
3272 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3273 long file names. */
3276 sys_chdir (const char * path)
3278 return _chdir (map_w32_filename (path, NULL));
3282 sys_chmod (const char * path, int mode)
3284 path = chase_symlinks (map_w32_filename (path, NULL));
3285 return _chmod (path, mode);
3289 sys_creat (const char * path, int mode)
3291 return _creat (map_w32_filename (path, NULL), mode);
3294 FILE *
3295 sys_fopen (const char * path, const char * mode)
3297 int fd;
3298 int oflag;
3299 const char * mode_save = mode;
3301 /* Force all file handles to be non-inheritable. This is necessary to
3302 ensure child processes don't unwittingly inherit handles that might
3303 prevent future file access. */
3305 if (mode[0] == 'r')
3306 oflag = O_RDONLY;
3307 else if (mode[0] == 'w' || mode[0] == 'a')
3308 oflag = O_WRONLY | O_CREAT | O_TRUNC;
3309 else
3310 return NULL;
3312 /* Only do simplistic option parsing. */
3313 while (*++mode)
3314 if (mode[0] == '+')
3316 oflag &= ~(O_RDONLY | O_WRONLY);
3317 oflag |= O_RDWR;
3319 else if (mode[0] == 'b')
3321 oflag &= ~O_TEXT;
3322 oflag |= O_BINARY;
3324 else if (mode[0] == 't')
3326 oflag &= ~O_BINARY;
3327 oflag |= O_TEXT;
3329 else break;
3331 fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
3332 if (fd < 0)
3333 return NULL;
3335 return _fdopen (fd, mode_save);
3338 /* This only works on NTFS volumes, but is useful to have. */
3340 sys_link (const char * old, const char * new)
3342 HANDLE fileh;
3343 int result = -1;
3344 char oldname[MAX_PATH], newname[MAX_PATH];
3346 if (old == NULL || new == NULL)
3348 errno = ENOENT;
3349 return -1;
3352 strcpy (oldname, map_w32_filename (old, NULL));
3353 strcpy (newname, map_w32_filename (new, NULL));
3355 fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
3356 FILE_FLAG_BACKUP_SEMANTICS, NULL);
3357 if (fileh != INVALID_HANDLE_VALUE)
3359 int wlen;
3361 /* Confusingly, the "alternate" stream name field does not apply
3362 when restoring a hard link, and instead contains the actual
3363 stream data for the link (ie. the name of the link to create).
3364 The WIN32_STREAM_ID structure before the cStreamName field is
3365 the stream header, which is then immediately followed by the
3366 stream data. */
3368 struct {
3369 WIN32_STREAM_ID wid;
3370 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
3371 } data;
3373 wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
3374 data.wid.cStreamName, MAX_PATH);
3375 if (wlen > 0)
3377 LPVOID context = NULL;
3378 DWORD wbytes = 0;
3380 data.wid.dwStreamId = BACKUP_LINK;
3381 data.wid.dwStreamAttributes = 0;
3382 data.wid.Size.LowPart = wlen * sizeof (WCHAR);
3383 data.wid.Size.HighPart = 0;
3384 data.wid.dwStreamNameSize = 0;
3386 if (BackupWrite (fileh, (LPBYTE)&data,
3387 offsetof (WIN32_STREAM_ID, cStreamName)
3388 + data.wid.Size.LowPart,
3389 &wbytes, FALSE, FALSE, &context)
3390 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
3392 /* succeeded */
3393 result = 0;
3395 else
3397 /* Should try mapping GetLastError to errno; for now just
3398 indicate a general error (eg. links not supported). */
3399 errno = EINVAL; // perhaps EMLINK?
3403 CloseHandle (fileh);
3405 else
3406 errno = ENOENT;
3408 return result;
3412 sys_mkdir (const char * path)
3414 return _mkdir (map_w32_filename (path, NULL));
3417 /* Because of long name mapping issues, we need to implement this
3418 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
3419 a unique name, instead of setting the input template to an empty
3420 string.
3422 Standard algorithm seems to be use pid or tid with a letter on the
3423 front (in place of the 6 X's) and cycle through the letters to find a
3424 unique name. We extend that to allow any reasonable character as the
3425 first of the 6 X's. */
3426 char *
3427 sys_mktemp (char * template)
3429 char * p;
3430 int i;
3431 unsigned uid = GetCurrentThreadId ();
3432 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3434 if (template == NULL)
3435 return NULL;
3436 p = template + strlen (template);
3437 i = 5;
3438 /* replace up to the last 5 X's with uid in decimal */
3439 while (--p >= template && p[0] == 'X' && --i >= 0)
3441 p[0] = '0' + uid % 10;
3442 uid /= 10;
3445 if (i < 0 && p[0] == 'X')
3447 i = 0;
3450 int save_errno = errno;
3451 p[0] = first_char[i];
3452 if (faccessat (AT_FDCWD, template, F_OK, AT_EACCESS) < 0)
3454 errno = save_errno;
3455 return template;
3458 while (++i < sizeof (first_char));
3461 /* Template is badly formed or else we can't generate a unique name,
3462 so return empty string */
3463 template[0] = 0;
3464 return template;
3468 sys_open (const char * path, int oflag, int mode)
3470 const char* mpath = map_w32_filename (path, NULL);
3471 int res = -1;
3473 /* If possible, try to open file without _O_CREAT, to be able to
3474 write to existing hidden and system files. Force all file
3475 handles to be non-inheritable. */
3476 if ((oflag & (_O_CREAT | _O_EXCL)) != (_O_CREAT | _O_EXCL))
3477 res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
3478 if (res < 0)
3479 res = _open (mpath, oflag | _O_NOINHERIT, mode);
3481 return res;
3485 fchmod (int fd, mode_t mode)
3487 return 0;
3491 sys_rename_replace (const char *oldname, const char *newname, BOOL force)
3493 BOOL result;
3494 char temp[MAX_PATH];
3495 int newname_dev;
3496 int oldname_dev;
3498 /* MoveFile on Windows 95 doesn't correctly change the short file name
3499 alias in a number of circumstances (it is not easy to predict when
3500 just by looking at oldname and newname, unfortunately). In these
3501 cases, renaming through a temporary name avoids the problem.
3503 A second problem on Windows 95 is that renaming through a temp name when
3504 newname is uppercase fails (the final long name ends up in
3505 lowercase, although the short alias might be uppercase) UNLESS the
3506 long temp name is not 8.3.
3508 So, on Windows 95 we always rename through a temp name, and we make sure
3509 the temp name has a long extension to ensure correct renaming. */
3511 strcpy (temp, map_w32_filename (oldname, NULL));
3513 /* volume_info is set indirectly by map_w32_filename. */
3514 oldname_dev = volume_info.serialnum;
3516 if (os_subtype == OS_9X)
3518 char * o;
3519 char * p;
3520 int i = 0;
3522 oldname = map_w32_filename (oldname, NULL);
3523 if ((o = strrchr (oldname, '\\')))
3524 o++;
3525 else
3526 o = (char *) oldname;
3528 if ((p = strrchr (temp, '\\')))
3529 p++;
3530 else
3531 p = temp;
3535 /* Force temp name to require a manufactured 8.3 alias - this
3536 seems to make the second rename work properly. */
3537 sprintf (p, "_.%s.%u", o, i);
3538 i++;
3539 result = rename (oldname, temp);
3541 /* This loop must surely terminate! */
3542 while (result < 0 && errno == EEXIST);
3543 if (result < 0)
3544 return -1;
3547 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
3548 (at least if it is a file; don't do this for directories).
3550 Since we mustn't do this if we are just changing the case of the
3551 file name (we would end up deleting the file we are trying to
3552 rename!), we let rename detect if the destination file already
3553 exists - that way we avoid the possible pitfalls of trying to
3554 determine ourselves whether two names really refer to the same
3555 file, which is not always possible in the general case. (Consider
3556 all the permutations of shared or subst'd drives, etc.) */
3558 newname = map_w32_filename (newname, NULL);
3560 /* volume_info is set indirectly by map_w32_filename. */
3561 newname_dev = volume_info.serialnum;
3563 result = rename (temp, newname);
3565 if (result < 0 && force)
3567 DWORD w32err = GetLastError ();
3569 if (errno == EACCES
3570 && newname_dev != oldname_dev)
3572 /* The implementation of `rename' on Windows does not return
3573 errno = EXDEV when you are moving a directory to a
3574 different storage device (ex. logical disk). It returns
3575 EACCES instead. So here we handle such situations and
3576 return EXDEV. */
3577 DWORD attributes;
3579 if ((attributes = GetFileAttributes (temp)) != -1
3580 && (attributes & FILE_ATTRIBUTE_DIRECTORY))
3581 errno = EXDEV;
3583 else if (errno == EEXIST)
3585 if (_chmod (newname, 0666) != 0)
3586 return result;
3587 if (_unlink (newname) != 0)
3588 return result;
3589 result = rename (temp, newname);
3591 else if (w32err == ERROR_PRIVILEGE_NOT_HELD
3592 && is_symlink (temp))
3594 /* This is Windows prohibiting the user from creating a
3595 symlink in another place, since that requires
3596 privileges. */
3597 errno = EPERM;
3601 return result;
3605 sys_rename (char const *old, char const *new)
3607 return sys_rename_replace (old, new, TRUE);
3611 sys_rmdir (const char * path)
3613 return _rmdir (map_w32_filename (path, NULL));
3617 sys_unlink (const char * path)
3619 path = map_w32_filename (path, NULL);
3621 /* On Unix, unlink works without write permission. */
3622 _chmod (path, 0666);
3623 return _unlink (path);
3626 static FILETIME utc_base_ft;
3627 static ULONGLONG utc_base; /* In 100ns units */
3628 static int init = 0;
3630 #define FILETIME_TO_U64(result, ft) \
3631 do { \
3632 ULARGE_INTEGER uiTemp; \
3633 uiTemp.LowPart = (ft).dwLowDateTime; \
3634 uiTemp.HighPart = (ft).dwHighDateTime; \
3635 result = uiTemp.QuadPart; \
3636 } while (0)
3638 static void
3639 initialize_utc_base (void)
3641 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3642 SYSTEMTIME st;
3644 st.wYear = 1970;
3645 st.wMonth = 1;
3646 st.wDay = 1;
3647 st.wHour = 0;
3648 st.wMinute = 0;
3649 st.wSecond = 0;
3650 st.wMilliseconds = 0;
3652 SystemTimeToFileTime (&st, &utc_base_ft);
3653 FILETIME_TO_U64 (utc_base, utc_base_ft);
3656 static time_t
3657 convert_time (FILETIME ft)
3659 ULONGLONG tmp;
3661 if (!init)
3663 initialize_utc_base ();
3664 init = 1;
3667 if (CompareFileTime (&ft, &utc_base_ft) < 0)
3668 return 0;
3670 FILETIME_TO_U64 (tmp, ft);
3671 return (time_t) ((tmp - utc_base) / 10000000L);
3674 static void
3675 convert_from_time_t (time_t time, FILETIME * pft)
3677 ULARGE_INTEGER tmp;
3679 if (!init)
3681 initialize_utc_base ();
3682 init = 1;
3685 /* time in 100ns units since 1-Jan-1601 */
3686 tmp.QuadPart = (ULONGLONG) time * 10000000L + utc_base;
3687 pft->dwHighDateTime = tmp.HighPart;
3688 pft->dwLowDateTime = tmp.LowPart;
3691 #if 0
3692 /* No reason to keep this; faking inode values either by hashing or even
3693 using the file index from GetInformationByHandle, is not perfect and
3694 so by default Emacs doesn't use the inode values on Windows.
3695 Instead, we now determine file-truename correctly (except for
3696 possible drive aliasing etc). */
3698 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3699 static unsigned
3700 hashval (const unsigned char * str)
3702 unsigned h = 0;
3703 while (*str)
3705 h = (h << 4) + *str++;
3706 h ^= (h >> 28);
3708 return h;
3711 /* Return the hash value of the canonical pathname, excluding the
3712 drive/UNC header, to get a hopefully unique inode number. */
3713 static DWORD
3714 generate_inode_val (const char * name)
3716 char fullname[ MAX_PATH ];
3717 char * p;
3718 unsigned hash;
3720 /* Get the truly canonical filename, if it exists. (Note: this
3721 doesn't resolve aliasing due to subst commands, or recognize hard
3722 links. */
3723 if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
3724 emacs_abort ();
3726 parse_root (fullname, &p);
3727 /* Normal W32 filesystems are still case insensitive. */
3728 _strlwr (p);
3729 return hashval (p);
3732 #endif
3734 static PSECURITY_DESCRIPTOR
3735 get_file_security_desc_by_handle (HANDLE h)
3737 PSECURITY_DESCRIPTOR psd = NULL;
3738 DWORD err;
3739 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3740 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
3742 err = get_security_info (h, SE_FILE_OBJECT, si,
3743 NULL, NULL, NULL, NULL, &psd);
3744 if (err != ERROR_SUCCESS)
3745 return NULL;
3747 return psd;
3750 static PSECURITY_DESCRIPTOR
3751 get_file_security_desc_by_name (const char *fname)
3753 PSECURITY_DESCRIPTOR psd = NULL;
3754 DWORD sd_len, err;
3755 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3756 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
3758 if (!get_file_security (fname, si, psd, 0, &sd_len))
3760 err = GetLastError ();
3761 if (err != ERROR_INSUFFICIENT_BUFFER)
3762 return NULL;
3765 psd = xmalloc (sd_len);
3766 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
3768 xfree (psd);
3769 return NULL;
3772 return psd;
3775 static DWORD
3776 get_rid (PSID sid)
3778 unsigned n_subauthorities;
3780 /* Use the last sub-authority value of the RID, the relative
3781 portion of the SID, as user/group ID. */
3782 n_subauthorities = *get_sid_sub_authority_count (sid);
3783 if (n_subauthorities < 1)
3784 return 0; /* the "World" RID */
3785 return *get_sid_sub_authority (sid, n_subauthorities - 1);
3788 /* Caching SID and account values for faster lokup. */
3790 struct w32_id {
3791 unsigned rid;
3792 struct w32_id *next;
3793 char name[GNLEN+1];
3794 unsigned char sid[FLEXIBLE_ARRAY_MEMBER];
3797 static struct w32_id *w32_idlist;
3799 static int
3800 w32_cached_id (PSID sid, unsigned *id, char *name)
3802 struct w32_id *tail, *found;
3804 for (found = NULL, tail = w32_idlist; tail; tail = tail->next)
3806 if (equal_sid ((PSID)tail->sid, sid))
3808 found = tail;
3809 break;
3812 if (found)
3814 *id = found->rid;
3815 strcpy (name, found->name);
3816 return 1;
3818 else
3819 return 0;
3822 static void
3823 w32_add_to_cache (PSID sid, unsigned id, char *name)
3825 DWORD sid_len;
3826 struct w32_id *new_entry;
3828 /* We don't want to leave behind stale cache from when Emacs was
3829 dumped. */
3830 if (initialized)
3832 sid_len = get_length_sid (sid);
3833 new_entry = xmalloc (offsetof (struct w32_id, sid) + sid_len);
3834 if (new_entry)
3836 new_entry->rid = id;
3837 strcpy (new_entry->name, name);
3838 copy_sid (sid_len, (PSID)new_entry->sid, sid);
3839 new_entry->next = w32_idlist;
3840 w32_idlist = new_entry;
3845 #define UID 1
3846 #define GID 2
3848 static int
3849 get_name_and_id (PSECURITY_DESCRIPTOR psd, unsigned *id, char *nm, int what)
3851 PSID sid = NULL;
3852 BOOL dflt;
3853 SID_NAME_USE ignore;
3854 char name[UNLEN+1];
3855 DWORD name_len = sizeof (name);
3856 char domain[1024];
3857 DWORD domain_len = sizeof (domain);
3858 int use_dflt = 0;
3859 int result;
3861 if (what == UID)
3862 result = get_security_descriptor_owner (psd, &sid, &dflt);
3863 else if (what == GID)
3864 result = get_security_descriptor_group (psd, &sid, &dflt);
3865 else
3866 result = 0;
3868 if (!result || !is_valid_sid (sid))
3869 use_dflt = 1;
3870 else if (!w32_cached_id (sid, id, nm))
3872 if (!lookup_account_sid (NULL, sid, name, &name_len,
3873 domain, &domain_len, &ignore)
3874 || name_len > UNLEN+1)
3875 use_dflt = 1;
3876 else
3878 *id = get_rid (sid);
3879 strcpy (nm, name);
3880 w32_add_to_cache (sid, *id, name);
3883 return use_dflt;
3886 static void
3887 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd, struct stat *st)
3889 int dflt_usr = 0, dflt_grp = 0;
3891 if (!psd)
3893 dflt_usr = 1;
3894 dflt_grp = 1;
3896 else
3898 if (get_name_and_id (psd, &st->st_uid, st->st_uname, UID))
3899 dflt_usr = 1;
3900 if (get_name_and_id (psd, &st->st_gid, st->st_gname, GID))
3901 dflt_grp = 1;
3903 /* Consider files to belong to current user/group, if we cannot get
3904 more accurate information. */
3905 if (dflt_usr)
3907 st->st_uid = dflt_passwd.pw_uid;
3908 strcpy (st->st_uname, dflt_passwd.pw_name);
3910 if (dflt_grp)
3912 st->st_gid = dflt_passwd.pw_gid;
3913 strcpy (st->st_gname, dflt_group.gr_name);
3917 /* Return non-zero if NAME is a potentially slow filesystem. */
3919 is_slow_fs (const char *name)
3921 char drive_root[4];
3922 UINT devtype;
3924 if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
3925 devtype = DRIVE_REMOTE; /* assume UNC name is remote */
3926 else if (!(strlen (name) >= 2 && IS_DEVICE_SEP (name[1])))
3927 devtype = GetDriveType (NULL); /* use root of current drive */
3928 else
3930 /* GetDriveType needs the root directory of the drive. */
3931 strncpy (drive_root, name, 2);
3932 drive_root[2] = '\\';
3933 drive_root[3] = '\0';
3934 devtype = GetDriveType (drive_root);
3936 return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
3939 /* If this is non-zero, the caller wants accurate information about
3940 file's owner and group, which could be expensive to get. */
3941 int w32_stat_get_owner_group;
3943 /* MSVC stat function can't cope with UNC names and has other bugs, so
3944 replace it with our own. This also allows us to calculate consistent
3945 inode values and owner/group without hacks in the main Emacs code. */
3947 static int
3948 stat_worker (const char * path, struct stat * buf, int follow_symlinks)
3950 char *name, *save_name, *r;
3951 WIN32_FIND_DATA wfd;
3952 HANDLE fh;
3953 unsigned __int64 fake_inode = 0;
3954 int permission;
3955 int len;
3956 int rootdir = FALSE;
3957 PSECURITY_DESCRIPTOR psd = NULL;
3958 int is_a_symlink = 0;
3959 DWORD file_flags = FILE_FLAG_BACKUP_SEMANTICS;
3960 DWORD access_rights = 0;
3961 DWORD fattrs = 0, serialnum = 0, fs_high = 0, fs_low = 0, nlinks = 1;
3962 FILETIME ctime, atime, wtime;
3963 int dbcs_p;
3965 if (path == NULL || buf == NULL)
3967 errno = EFAULT;
3968 return -1;
3971 save_name = name = (char *) map_w32_filename (path, &path);
3972 /* Must be valid filename, no wild cards or other invalid
3973 characters. We use _mbspbrk to support multibyte strings that
3974 might look to strpbrk as if they included literal *, ?, and other
3975 characters mentioned below that are disallowed by Windows
3976 filesystems. */
3977 if (_mbspbrk (name, "*?|<>\""))
3979 errno = ENOENT;
3980 return -1;
3983 /* Remove trailing directory separator, unless name is the root
3984 directory of a drive or UNC volume in which case ensure there
3985 is a trailing separator. */
3986 len = strlen (name);
3987 name = strcpy (alloca (len + 2), name);
3989 /* Avoid a somewhat costly call to is_symlink if the filesystem
3990 doesn't support symlinks. */
3991 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
3992 is_a_symlink = is_symlink (name);
3994 /* Plan A: Open the file and get all the necessary information via
3995 the resulting handle. This solves several issues in one blow:
3997 . retrieves attributes for the target of a symlink, if needed
3998 . gets attributes of root directories and symlinks pointing to
3999 root directories, thus avoiding the need for special-casing
4000 these and detecting them by examining the file-name format
4001 . retrieves more accurate attributes (e.g., non-zero size for
4002 some directories, esp. directories that are junction points)
4003 . correctly resolves "c:/..", "/.." and similar file names
4004 . avoids run-time penalties for 99% of use cases
4006 Plan A is always tried first, unless the user asked not to (but
4007 if the file is a symlink and we need to follow links, we try Plan
4008 A even if the user asked not to).
4010 If Plan A fails, we go to Plan B (below), where various
4011 potentially expensive techniques must be used to handle "special"
4012 files such as UNC volumes etc. */
4013 if (!(NILP (Vw32_get_true_file_attributes)
4014 || (EQ (Vw32_get_true_file_attributes, Qlocal) && is_slow_fs (name)))
4015 /* Following symlinks requires getting the info by handle. */
4016 || (is_a_symlink && follow_symlinks))
4018 BY_HANDLE_FILE_INFORMATION info;
4020 if (is_a_symlink && !follow_symlinks)
4021 file_flags |= FILE_FLAG_OPEN_REPARSE_POINT;
4022 /* READ_CONTROL access rights are required to get security info
4023 by handle. But if the OS doesn't support security in the
4024 first place, we don't need to try. */
4025 if (is_windows_9x () != TRUE)
4026 access_rights |= READ_CONTROL;
4028 fh = CreateFile (name, access_rights, 0, NULL, OPEN_EXISTING,
4029 file_flags, NULL);
4030 /* If CreateFile fails with READ_CONTROL, try again with zero as
4031 access rights. */
4032 if (fh == INVALID_HANDLE_VALUE && access_rights)
4033 fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
4034 file_flags, NULL);
4035 if (fh == INVALID_HANDLE_VALUE)
4036 goto no_true_file_attributes;
4038 /* This is more accurate in terms of getting the correct number
4039 of links, but is quite slow (it is noticeable when Emacs is
4040 making a list of file name completions). */
4041 if (GetFileInformationByHandle (fh, &info))
4043 nlinks = info.nNumberOfLinks;
4044 /* Might as well use file index to fake inode values, but this
4045 is not guaranteed to be unique unless we keep a handle open
4046 all the time (even then there are situations where it is
4047 not unique). Reputedly, there are at most 48 bits of info
4048 (on NTFS, presumably less on FAT). */
4049 fake_inode = info.nFileIndexHigh;
4050 fake_inode <<= 32;
4051 fake_inode += info.nFileIndexLow;
4052 serialnum = info.dwVolumeSerialNumber;
4053 fs_high = info.nFileSizeHigh;
4054 fs_low = info.nFileSizeLow;
4055 ctime = info.ftCreationTime;
4056 atime = info.ftLastAccessTime;
4057 wtime = info.ftLastWriteTime;
4058 fattrs = info.dwFileAttributes;
4060 else
4062 /* We don't go to Plan B here, because it's not clear that
4063 it's a good idea. The only known use case where
4064 CreateFile succeeds, but GetFileInformationByHandle fails
4065 (with ERROR_INVALID_FUNCTION) is for character devices
4066 such as NUL, PRN, etc. For these, switching to Plan B is
4067 a net loss, because we lose the character device
4068 attribute returned by GetFileType below (FindFirstFile
4069 doesn't set that bit in the attributes), and the other
4070 fields don't make sense for character devices anyway.
4071 Emacs doesn't really care for non-file entities in the
4072 context of l?stat, so neither do we. */
4074 /* w32err is assigned so one could put a breakpoint here and
4075 examine its value, when GetFileInformationByHandle
4076 fails. */
4077 DWORD w32err = GetLastError ();
4079 switch (w32err)
4081 case ERROR_FILE_NOT_FOUND: /* can this ever happen? */
4082 errno = ENOENT;
4083 return -1;
4087 /* Test for a symlink before testing for a directory, since
4088 symlinks to directories have the directory bit set, but we
4089 don't want them to appear as directories. */
4090 if (is_a_symlink && !follow_symlinks)
4091 buf->st_mode = S_IFLNK;
4092 else if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4093 buf->st_mode = S_IFDIR;
4094 else
4096 DWORD ftype = GetFileType (fh);
4098 switch (ftype)
4100 case FILE_TYPE_DISK:
4101 buf->st_mode = S_IFREG;
4102 break;
4103 case FILE_TYPE_PIPE:
4104 buf->st_mode = S_IFIFO;
4105 break;
4106 case FILE_TYPE_CHAR:
4107 case FILE_TYPE_UNKNOWN:
4108 default:
4109 buf->st_mode = S_IFCHR;
4112 /* We produce the fallback owner and group data, based on the
4113 current user that runs Emacs, in the following cases:
4115 . caller didn't request owner and group info
4116 . this is Windows 9X
4117 . getting security by handle failed, and we need to produce
4118 information for the target of a symlink (this is better
4119 than producing a potentially misleading info about the
4120 symlink itself)
4122 If getting security by handle fails, and we don't need to
4123 resolve symlinks, we try getting security by name. */
4124 if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
4125 get_file_owner_and_group (NULL, buf);
4126 else
4128 psd = get_file_security_desc_by_handle (fh);
4129 if (psd)
4131 get_file_owner_and_group (psd, buf);
4132 LocalFree (psd);
4134 else if (!(is_a_symlink && follow_symlinks))
4136 psd = get_file_security_desc_by_name (name);
4137 get_file_owner_and_group (psd, buf);
4138 xfree (psd);
4140 else
4141 get_file_owner_and_group (NULL, buf);
4143 CloseHandle (fh);
4145 else
4147 no_true_file_attributes:
4148 /* Plan B: Either getting a handle on the file failed, or the
4149 caller explicitly asked us to not bother making this
4150 information more accurate.
4152 Implementation note: In Plan B, we never bother to resolve
4153 symlinks, even if we got here because we tried Plan A and
4154 failed. That's because, even if the caller asked for extra
4155 precision by setting Vw32_get_true_file_attributes to t,
4156 resolving symlinks requires acquiring a file handle to the
4157 symlink, which we already know will fail. And if the user
4158 did not ask for extra precision, resolving symlinks will fly
4159 in the face of that request, since the user then wants the
4160 lightweight version of the code. */
4161 dbcs_p = max_filename_mbslen () > 1;
4162 rootdir = (path >= save_name + len - 1
4163 && (IS_DIRECTORY_SEP (*path) || *path == 0));
4165 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4166 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
4167 if (IS_DIRECTORY_SEP (r[0])
4168 && r[1] == '.' && r[2] == '.' && r[3] == '\0')
4169 r[1] = r[2] = '\0';
4171 /* Note: If NAME is a symlink to the root of a UNC volume
4172 (i.e. "\\SERVER"), we will not detect that here, and we will
4173 return data about the symlink as result of FindFirst below.
4174 This is unfortunate, but that marginal use case does not
4175 justify a call to chase_symlinks which would impose a penalty
4176 on all the other use cases. (We get here for symlinks to
4177 roots of UNC volumes because CreateFile above fails for them,
4178 unlike with symlinks to root directories X:\ of drives.) */
4179 if (is_unc_volume (name))
4181 fattrs = unc_volume_file_attributes (name);
4182 if (fattrs == -1)
4183 return -1;
4185 ctime = atime = wtime = utc_base_ft;
4187 else if (rootdir)
4189 if (!dbcs_p)
4191 if (!IS_DIRECTORY_SEP (name[len-1]))
4192 strcat (name, "\\");
4194 else
4196 char *end = name + len;
4197 char *n = CharPrevExA (file_name_codepage, name, end, 0);
4199 if (!IS_DIRECTORY_SEP (*n))
4200 strcat (name, "\\");
4202 if (GetDriveType (name) < 2)
4204 errno = ENOENT;
4205 return -1;
4208 fattrs = FILE_ATTRIBUTE_DIRECTORY;
4209 ctime = atime = wtime = utc_base_ft;
4211 else
4213 if (!dbcs_p)
4215 if (IS_DIRECTORY_SEP (name[len-1]))
4216 name[len - 1] = 0;
4218 else
4220 char *end = name + len;
4221 char *n = CharPrevExA (file_name_codepage, name, end, 0);
4223 if (IS_DIRECTORY_SEP (*n))
4224 *n = 0;
4227 /* (This is hacky, but helps when doing file completions on
4228 network drives.) Optimize by using information available from
4229 active readdir if possible. */
4230 len = strlen (dir_pathname);
4231 if (!dbcs_p)
4233 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
4234 len--;
4236 else
4238 char *end = dir_pathname + len;
4239 char *n = CharPrevExA (file_name_codepage, dir_pathname, end, 0);
4241 if (IS_DIRECTORY_SEP (*n))
4242 len--;
4244 if (dir_find_handle != INVALID_HANDLE_VALUE
4245 && !(is_a_symlink && follow_symlinks)
4246 && strnicmp (save_name, dir_pathname, len) == 0
4247 && IS_DIRECTORY_SEP (name[len])
4248 && xstrcasecmp (name + len + 1, dir_static.d_name) == 0)
4250 /* This was the last entry returned by readdir. */
4251 wfd = dir_find_data;
4253 else
4255 logon_network_drive (name);
4257 fh = FindFirstFile (name, &wfd);
4258 if (fh == INVALID_HANDLE_VALUE)
4260 errno = ENOENT;
4261 return -1;
4263 FindClose (fh);
4265 /* Note: if NAME is a symlink, the information we get from
4266 FindFirstFile is for the symlink, not its target. */
4267 fattrs = wfd.dwFileAttributes;
4268 ctime = wfd.ftCreationTime;
4269 atime = wfd.ftLastAccessTime;
4270 wtime = wfd.ftLastWriteTime;
4271 fs_high = wfd.nFileSizeHigh;
4272 fs_low = wfd.nFileSizeLow;
4273 fake_inode = 0;
4274 nlinks = 1;
4275 serialnum = volume_info.serialnum;
4277 if (is_a_symlink && !follow_symlinks)
4278 buf->st_mode = S_IFLNK;
4279 else if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4280 buf->st_mode = S_IFDIR;
4281 else
4282 buf->st_mode = S_IFREG;
4284 get_file_owner_and_group (NULL, buf);
4287 #if 0
4288 /* Not sure if there is any point in this. */
4289 if (!NILP (Vw32_generate_fake_inodes))
4290 fake_inode = generate_inode_val (name);
4291 else if (fake_inode == 0)
4293 /* For want of something better, try to make everything unique. */
4294 static DWORD gen_num = 0;
4295 fake_inode = ++gen_num;
4297 #endif
4299 buf->st_ino = fake_inode;
4301 buf->st_dev = serialnum;
4302 buf->st_rdev = serialnum;
4304 buf->st_size = fs_high;
4305 buf->st_size <<= 32;
4306 buf->st_size += fs_low;
4307 buf->st_nlink = nlinks;
4309 /* Convert timestamps to Unix format. */
4310 buf->st_mtime = convert_time (wtime);
4311 buf->st_atime = convert_time (atime);
4312 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
4313 buf->st_ctime = convert_time (ctime);
4314 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
4316 /* determine rwx permissions */
4317 if (is_a_symlink && !follow_symlinks)
4318 permission = S_IREAD | S_IWRITE | S_IEXEC; /* Posix expectations */
4319 else
4321 if (fattrs & FILE_ATTRIBUTE_READONLY)
4322 permission = S_IREAD;
4323 else
4324 permission = S_IREAD | S_IWRITE;
4326 if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4327 permission |= S_IEXEC;
4328 else if (is_exec (name))
4329 permission |= S_IEXEC;
4332 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
4334 return 0;
4338 stat (const char * path, struct stat * buf)
4340 return stat_worker (path, buf, 1);
4344 lstat (const char * path, struct stat * buf)
4346 return stat_worker (path, buf, 0);
4350 fstatat (int fd, char const *name, struct stat *st, int flags)
4352 /* Rely on a hack: an open directory is modeled as file descriptor 0.
4353 This is good enough for the current usage in Emacs, but is fragile.
4355 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
4356 Gnulib does this and can serve as a model. */
4357 char fullname[MAX_PATH];
4359 if (fd != AT_FDCWD)
4361 if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
4362 < 0)
4364 errno = ENAMETOOLONG;
4365 return -1;
4367 name = fullname;
4370 return stat_worker (name, st, ! (flags & AT_SYMLINK_NOFOLLOW));
4373 /* Provide fstat and utime as well as stat for consistent handling of
4374 file timestamps. */
4376 fstat (int desc, struct stat * buf)
4378 HANDLE fh = (HANDLE) _get_osfhandle (desc);
4379 BY_HANDLE_FILE_INFORMATION info;
4380 unsigned __int64 fake_inode;
4381 int permission;
4383 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
4385 case FILE_TYPE_DISK:
4386 buf->st_mode = S_IFREG;
4387 if (!GetFileInformationByHandle (fh, &info))
4389 errno = EACCES;
4390 return -1;
4392 break;
4393 case FILE_TYPE_PIPE:
4394 buf->st_mode = S_IFIFO;
4395 goto non_disk;
4396 case FILE_TYPE_CHAR:
4397 case FILE_TYPE_UNKNOWN:
4398 default:
4399 buf->st_mode = S_IFCHR;
4400 non_disk:
4401 memset (&info, 0, sizeof (info));
4402 info.dwFileAttributes = 0;
4403 info.ftCreationTime = utc_base_ft;
4404 info.ftLastAccessTime = utc_base_ft;
4405 info.ftLastWriteTime = utc_base_ft;
4408 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
4409 buf->st_mode = S_IFDIR;
4411 buf->st_nlink = info.nNumberOfLinks;
4412 /* Might as well use file index to fake inode values, but this
4413 is not guaranteed to be unique unless we keep a handle open
4414 all the time (even then there are situations where it is
4415 not unique). Reputedly, there are at most 48 bits of info
4416 (on NTFS, presumably less on FAT). */
4417 fake_inode = info.nFileIndexHigh;
4418 fake_inode <<= 32;
4419 fake_inode += info.nFileIndexLow;
4421 /* MSVC defines _ino_t to be short; other libc's might not. */
4422 if (sizeof (buf->st_ino) == 2)
4423 buf->st_ino = fake_inode ^ (fake_inode >> 16);
4424 else
4425 buf->st_ino = fake_inode;
4427 /* If the caller so requested, get the true file owner and group.
4428 Otherwise, consider the file to belong to the current user. */
4429 if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
4430 get_file_owner_and_group (NULL, buf);
4431 else
4433 PSECURITY_DESCRIPTOR psd = NULL;
4435 psd = get_file_security_desc_by_handle (fh);
4436 if (psd)
4438 get_file_owner_and_group (psd, buf);
4439 LocalFree (psd);
4441 else
4442 get_file_owner_and_group (NULL, buf);
4445 buf->st_dev = info.dwVolumeSerialNumber;
4446 buf->st_rdev = info.dwVolumeSerialNumber;
4448 buf->st_size = info.nFileSizeHigh;
4449 buf->st_size <<= 32;
4450 buf->st_size += info.nFileSizeLow;
4452 /* Convert timestamps to Unix format. */
4453 buf->st_mtime = convert_time (info.ftLastWriteTime);
4454 buf->st_atime = convert_time (info.ftLastAccessTime);
4455 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
4456 buf->st_ctime = convert_time (info.ftCreationTime);
4457 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
4459 /* determine rwx permissions */
4460 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
4461 permission = S_IREAD;
4462 else
4463 permission = S_IREAD | S_IWRITE;
4465 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
4466 permission |= S_IEXEC;
4467 else
4469 #if 0 /* no way of knowing the filename */
4470 char * p = strrchr (name, '.');
4471 if (p != NULL &&
4472 (xstrcasecmp (p, ".exe") == 0 ||
4473 xstrcasecmp (p, ".com") == 0 ||
4474 xstrcasecmp (p, ".bat") == 0 ||
4475 xstrcasecmp (p, ".cmd") == 0))
4476 permission |= S_IEXEC;
4477 #endif
4480 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
4482 return 0;
4486 utime (const char *name, struct utimbuf *times)
4488 struct utimbuf deftime;
4489 HANDLE fh;
4490 FILETIME mtime;
4491 FILETIME atime;
4493 if (times == NULL)
4495 deftime.modtime = deftime.actime = time (NULL);
4496 times = &deftime;
4499 /* Need write access to set times. */
4500 fh = CreateFile (name, FILE_WRITE_ATTRIBUTES,
4501 /* If NAME specifies a directory, FILE_SHARE_DELETE
4502 allows other processes to delete files inside it,
4503 while we have the directory open. */
4504 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4505 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
4506 if (fh != INVALID_HANDLE_VALUE)
4508 convert_from_time_t (times->actime, &atime);
4509 convert_from_time_t (times->modtime, &mtime);
4510 if (!SetFileTime (fh, NULL, &atime, &mtime))
4512 CloseHandle (fh);
4513 errno = EACCES;
4514 return -1;
4516 CloseHandle (fh);
4518 else
4520 errno = EINVAL;
4521 return -1;
4523 return 0;
4527 /* Symlink-related functions. */
4528 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4529 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4530 #endif
4533 symlink (char const *filename, char const *linkname)
4535 char linkfn[MAX_PATH], *tgtfn;
4536 DWORD flags = 0;
4537 int dir_access, filename_ends_in_slash;
4538 int dbcs_p;
4540 /* Diagnostics follows Posix as much as possible. */
4541 if (filename == NULL || linkname == NULL)
4543 errno = EFAULT;
4544 return -1;
4546 if (!*filename)
4548 errno = ENOENT;
4549 return -1;
4551 if (strlen (filename) > MAX_PATH || strlen (linkname) > MAX_PATH)
4553 errno = ENAMETOOLONG;
4554 return -1;
4557 strcpy (linkfn, map_w32_filename (linkname, NULL));
4558 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) == 0)
4560 errno = EPERM;
4561 return -1;
4564 dbcs_p = max_filename_mbslen () > 1;
4566 /* Note: since empty FILENAME was already rejected, we can safely
4567 refer to FILENAME[1]. */
4568 if (!(IS_DIRECTORY_SEP (filename[0]) || IS_DEVICE_SEP (filename[1])))
4570 /* Non-absolute FILENAME is understood as being relative to
4571 LINKNAME's directory. We need to prepend that directory to
4572 FILENAME to get correct results from faccessat below, since
4573 otherwise it will interpret FILENAME relative to the
4574 directory where the Emacs process runs. Note that
4575 make-symbolic-link always makes sure LINKNAME is a fully
4576 expanded file name. */
4577 char tem[MAX_PATH];
4578 char *p = linkfn + strlen (linkfn);
4580 if (!dbcs_p)
4582 while (p > linkfn && !IS_ANY_SEP (p[-1]))
4583 p--;
4585 else
4587 char *p1 = CharPrevExA (file_name_codepage, linkfn, p, 0);
4589 while (p > linkfn && !IS_ANY_SEP (*p1))
4591 p = p1;
4592 p1 = CharPrevExA (file_name_codepage, linkfn, p1, 0);
4595 if (p > linkfn)
4596 strncpy (tem, linkfn, p - linkfn);
4597 tem[p - linkfn] = '\0';
4598 strcat (tem, filename);
4599 dir_access = faccessat (AT_FDCWD, tem, D_OK, AT_EACCESS);
4601 else
4602 dir_access = faccessat (AT_FDCWD, filename, D_OK, AT_EACCESS);
4604 /* Since Windows distinguishes between symlinks to directories and
4605 to files, we provide a kludgy feature: if FILENAME doesn't
4606 exist, but ends in a slash, we create a symlink to directory. If
4607 FILENAME exists and is a directory, we always create a symlink to
4608 directory. */
4609 if (!dbcs_p)
4610 filename_ends_in_slash = IS_DIRECTORY_SEP (filename[strlen (filename) - 1]);
4611 else
4613 const char *end = filename + strlen (filename);
4614 const char *n = CharPrevExA (file_name_codepage, filename, end, 0);
4616 filename_ends_in_slash = IS_DIRECTORY_SEP (*n);
4618 if (dir_access == 0 || filename_ends_in_slash)
4619 flags = SYMBOLIC_LINK_FLAG_DIRECTORY;
4621 tgtfn = (char *)map_w32_filename (filename, NULL);
4622 if (filename_ends_in_slash)
4623 tgtfn[strlen (tgtfn) - 1] = '\0';
4625 errno = 0;
4626 if (!create_symbolic_link (linkfn, tgtfn, flags))
4628 /* ENOSYS is set by create_symbolic_link, when it detects that
4629 the OS doesn't support the CreateSymbolicLink API. */
4630 if (errno != ENOSYS)
4632 DWORD w32err = GetLastError ();
4634 switch (w32err)
4636 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4637 TGTFN point to the same file name, go figure. */
4638 case ERROR_SUCCESS:
4639 case ERROR_FILE_EXISTS:
4640 errno = EEXIST;
4641 break;
4642 case ERROR_ACCESS_DENIED:
4643 errno = EACCES;
4644 break;
4645 case ERROR_FILE_NOT_FOUND:
4646 case ERROR_PATH_NOT_FOUND:
4647 case ERROR_BAD_NETPATH:
4648 case ERROR_INVALID_REPARSE_DATA:
4649 errno = ENOENT;
4650 break;
4651 case ERROR_DIRECTORY:
4652 errno = EISDIR;
4653 break;
4654 case ERROR_PRIVILEGE_NOT_HELD:
4655 case ERROR_NOT_ALL_ASSIGNED:
4656 errno = EPERM;
4657 break;
4658 case ERROR_DISK_FULL:
4659 errno = ENOSPC;
4660 break;
4661 default:
4662 errno = EINVAL;
4663 break;
4666 return -1;
4668 return 0;
4671 /* A quick inexpensive test of whether FILENAME identifies a file that
4672 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4673 must already be in the normalized form returned by
4674 map_w32_filename.
4676 Note: for repeated operations on many files, it is best to test
4677 whether the underlying volume actually supports symlinks, by
4678 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4679 avoid the call to this function if it doesn't. That's because the
4680 call to GetFileAttributes takes a non-negligible time, especially
4681 on non-local or removable filesystems. See stat_worker for an
4682 example of how to do that. */
4683 static int
4684 is_symlink (const char *filename)
4686 DWORD attrs;
4687 WIN32_FIND_DATA wfd;
4688 HANDLE fh;
4690 attrs = GetFileAttributes (filename);
4691 if (attrs == -1)
4693 DWORD w32err = GetLastError ();
4695 switch (w32err)
4697 case ERROR_BAD_NETPATH: /* network share, can't be a symlink */
4698 break;
4699 case ERROR_ACCESS_DENIED:
4700 errno = EACCES;
4701 break;
4702 case ERROR_FILE_NOT_FOUND:
4703 case ERROR_PATH_NOT_FOUND:
4704 default:
4705 errno = ENOENT;
4706 break;
4708 return 0;
4710 if ((attrs & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
4711 return 0;
4712 logon_network_drive (filename);
4713 fh = FindFirstFile (filename, &wfd);
4714 if (fh == INVALID_HANDLE_VALUE)
4715 return 0;
4716 FindClose (fh);
4717 return (wfd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
4718 && (wfd.dwReserved0 & IO_REPARSE_TAG_SYMLINK) == IO_REPARSE_TAG_SYMLINK;
4721 /* If NAME identifies a symbolic link, copy into BUF the file name of
4722 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4723 null-terminate the target name, even if it fits. Return the number
4724 of bytes copied, or -1 if NAME is not a symlink or any error was
4725 encountered while resolving it. The file name copied into BUF is
4726 encoded in the current ANSI codepage. */
4727 ssize_t
4728 readlink (const char *name, char *buf, size_t buf_size)
4730 const char *path;
4731 TOKEN_PRIVILEGES privs;
4732 int restore_privs = 0;
4733 HANDLE sh;
4734 ssize_t retval;
4736 if (name == NULL)
4738 errno = EFAULT;
4739 return -1;
4741 if (!*name)
4743 errno = ENOENT;
4744 return -1;
4747 path = map_w32_filename (name, NULL);
4749 if (strlen (path) > MAX_PATH)
4751 errno = ENAMETOOLONG;
4752 return -1;
4755 errno = 0;
4756 if (is_windows_9x () == TRUE
4757 || (volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) == 0
4758 || !is_symlink (path))
4760 if (!errno)
4761 errno = EINVAL; /* not a symlink */
4762 return -1;
4765 /* Done with simple tests, now we're in for some _real_ work. */
4766 if (enable_privilege (SE_BACKUP_NAME, TRUE, &privs))
4767 restore_privs = 1;
4768 /* Implementation note: From here and onward, don't return early,
4769 since that will fail to restore the original set of privileges of
4770 the calling thread. */
4772 retval = -1; /* not too optimistic, are we? */
4774 /* Note: In the next call to CreateFile, we use zero as the 2nd
4775 argument because, when the symlink is a hidden/system file,
4776 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4777 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4778 and directory symlinks. */
4779 sh = CreateFile (path, 0, 0, NULL, OPEN_EXISTING,
4780 FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
4781 NULL);
4782 if (sh != INVALID_HANDLE_VALUE)
4784 BYTE reparse_buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
4785 REPARSE_DATA_BUFFER *reparse_data = (REPARSE_DATA_BUFFER *)&reparse_buf[0];
4786 DWORD retbytes;
4788 if (!DeviceIoControl (sh, FSCTL_GET_REPARSE_POINT, NULL, 0,
4789 reparse_buf, MAXIMUM_REPARSE_DATA_BUFFER_SIZE,
4790 &retbytes, NULL))
4791 errno = EIO;
4792 else if (reparse_data->ReparseTag != IO_REPARSE_TAG_SYMLINK)
4793 errno = EINVAL;
4794 else
4796 /* Copy the link target name, in wide characters, from
4797 reparse_data, then convert it to multibyte encoding in
4798 the current locale's codepage. */
4799 WCHAR *lwname;
4800 BYTE lname[MAX_PATH];
4801 USHORT lname_len;
4802 USHORT lwname_len =
4803 reparse_data->SymbolicLinkReparseBuffer.PrintNameLength;
4804 WCHAR *lwname_src =
4805 reparse_data->SymbolicLinkReparseBuffer.PathBuffer
4806 + reparse_data->SymbolicLinkReparseBuffer.PrintNameOffset/sizeof(WCHAR);
4807 /* This updates file_name_codepage which we need below. */
4808 int dbcs_p = max_filename_mbslen () > 1;
4810 /* According to MSDN, PrintNameLength does not include the
4811 terminating null character. */
4812 lwname = alloca ((lwname_len + 1) * sizeof(WCHAR));
4813 memcpy (lwname, lwname_src, lwname_len);
4814 lwname[lwname_len/sizeof(WCHAR)] = 0; /* null-terminate */
4816 lname_len = WideCharToMultiByte (file_name_codepage, 0, lwname, -1,
4817 lname, MAX_PATH, NULL, NULL);
4818 if (!lname_len)
4820 /* WideCharToMultiByte failed. */
4821 DWORD w32err1 = GetLastError ();
4823 switch (w32err1)
4825 case ERROR_INSUFFICIENT_BUFFER:
4826 errno = ENAMETOOLONG;
4827 break;
4828 case ERROR_INVALID_PARAMETER:
4829 errno = EFAULT;
4830 break;
4831 case ERROR_NO_UNICODE_TRANSLATION:
4832 errno = ENOENT;
4833 break;
4834 default:
4835 errno = EINVAL;
4836 break;
4839 else
4841 size_t size_to_copy = buf_size;
4842 BYTE *p = lname, *p2;
4843 BYTE *pend = p + lname_len;
4845 /* Normalize like dostounix_filename does, but we don't
4846 want to assume that lname is null-terminated. */
4847 if (dbcs_p)
4848 p2 = CharNextExA (file_name_codepage, p, 0);
4849 else
4850 p2 = p + 1;
4851 if (*p && *p2 == ':' && *p >= 'A' && *p <= 'Z')
4853 *p += 'a' - 'A';
4854 p += 2;
4856 while (p <= pend)
4858 if (*p == '\\')
4859 *p = '/';
4860 if (dbcs_p)
4862 p = CharNextExA (file_name_codepage, p, 0);
4863 /* CharNextExA doesn't advance at null character. */
4864 if (!*p)
4865 break;
4867 else
4868 ++p;
4870 /* Testing for null-terminated LNAME is paranoia:
4871 WideCharToMultiByte should always return a
4872 null-terminated string when its 4th argument is -1
4873 and its 3rd argument is null-terminated (which they
4874 are, see above). */
4875 if (lname[lname_len - 1] == '\0')
4876 lname_len--;
4877 if (lname_len <= buf_size)
4878 size_to_copy = lname_len;
4879 strncpy (buf, lname, size_to_copy);
4880 /* Success! */
4881 retval = size_to_copy;
4884 CloseHandle (sh);
4886 else
4888 /* CreateFile failed. */
4889 DWORD w32err2 = GetLastError ();
4891 switch (w32err2)
4893 case ERROR_FILE_NOT_FOUND:
4894 case ERROR_PATH_NOT_FOUND:
4895 errno = ENOENT;
4896 break;
4897 case ERROR_ACCESS_DENIED:
4898 case ERROR_TOO_MANY_OPEN_FILES:
4899 errno = EACCES;
4900 break;
4901 default:
4902 errno = EPERM;
4903 break;
4906 if (restore_privs)
4908 restore_privilege (&privs);
4909 revert_to_self ();
4912 return retval;
4915 ssize_t
4916 readlinkat (int fd, char const *name, char *buffer,
4917 size_t buffer_size)
4919 /* Rely on a hack: an open directory is modeled as file descriptor 0,
4920 as in fstatat. FIXME: Add proper support for readlinkat. */
4921 char fullname[MAX_PATH];
4923 if (fd != AT_FDCWD)
4925 if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
4926 < 0)
4928 errno = ENAMETOOLONG;
4929 return -1;
4931 name = fullname;
4934 return readlink (name, buffer, buffer_size);
4937 /* If FILE is a symlink, return its target (stored in a static
4938 buffer); otherwise return FILE.
4940 This function repeatedly resolves symlinks in the last component of
4941 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4942 until it arrives at a file whose last component is not a symlink,
4943 or some error occurs. It returns the target of the last
4944 successfully resolved symlink in the chain. If it succeeds to
4945 resolve even a single symlink, the value returned is an absolute
4946 file name with backslashes (result of GetFullPathName). By
4947 contrast, if the original FILE is returned, it is unaltered.
4949 Note: This function can set errno even if it succeeds.
4951 Implementation note: we only resolve the last portion ("basename")
4952 of the argument FILE and of each following file in the chain,
4953 disregarding any possible symlinks in its leading directories.
4954 This is because Windows system calls and library functions
4955 transparently resolve symlinks in leading directories and return
4956 correct information, as long as the basename is not a symlink. */
4957 static char *
4958 chase_symlinks (const char *file)
4960 static char target[MAX_PATH];
4961 char link[MAX_PATH];
4962 ssize_t res, link_len;
4963 int loop_count = 0;
4964 int dbcs_p;
4966 if (is_windows_9x () == TRUE || !is_symlink (file))
4967 return (char *)file;
4969 if ((link_len = GetFullPathName (file, MAX_PATH, link, NULL)) == 0)
4970 return (char *)file;
4972 dbcs_p = max_filename_mbslen () > 1;
4973 target[0] = '\0';
4974 do {
4976 /* Remove trailing slashes, as we want to resolve the last
4977 non-trivial part of the link name. */
4978 if (!dbcs_p)
4980 while (link_len > 3 && IS_DIRECTORY_SEP (link[link_len-1]))
4981 link[link_len--] = '\0';
4983 else if (link_len > 3)
4985 char *n = CharPrevExA (file_name_codepage, link, link + link_len, 0);
4987 while (n >= link + 2 && IS_DIRECTORY_SEP (*n))
4989 n[1] = '\0';
4990 n = CharPrevExA (file_name_codepage, link, n, 0);
4994 res = readlink (link, target, MAX_PATH);
4995 if (res > 0)
4997 target[res] = '\0';
4998 if (!(IS_DEVICE_SEP (target[1])
4999 || (IS_DIRECTORY_SEP (target[0]) && IS_DIRECTORY_SEP (target[1]))))
5001 /* Target is relative. Append it to the directory part of
5002 the symlink, then copy the result back to target. */
5003 char *p = link + link_len;
5005 if (!dbcs_p)
5007 while (p > link && !IS_ANY_SEP (p[-1]))
5008 p--;
5010 else
5012 char *p1 = CharPrevExA (file_name_codepage, link, p, 0);
5014 while (p > link && !IS_ANY_SEP (*p1))
5016 p = p1;
5017 p1 = CharPrevExA (file_name_codepage, link, p1, 0);
5020 strcpy (p, target);
5021 strcpy (target, link);
5023 /* Resolve any "." and ".." to get a fully-qualified file name
5024 in link[] again. */
5025 link_len = GetFullPathName (target, MAX_PATH, link, NULL);
5027 } while (res > 0 && link_len > 0 && ++loop_count <= 100);
5029 if (loop_count > 100)
5030 errno = ELOOP;
5032 if (target[0] == '\0') /* not a single call to readlink succeeded */
5033 return (char *)file;
5034 return target;
5038 /* Posix ACL emulation. */
5041 acl_valid (acl_t acl)
5043 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR)acl) ? 0 : -1;
5046 char *
5047 acl_to_text (acl_t acl, ssize_t *size)
5049 LPTSTR str_acl;
5050 SECURITY_INFORMATION flags =
5051 OWNER_SECURITY_INFORMATION |
5052 GROUP_SECURITY_INFORMATION |
5053 DACL_SECURITY_INFORMATION;
5054 char *retval = NULL;
5055 ULONG local_size;
5056 int e = errno;
5058 errno = 0;
5060 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR)acl, SDDL_REVISION_1, flags, &str_acl, &local_size))
5062 errno = e;
5063 /* We don't want to mix heaps, so we duplicate the string in our
5064 heap and free the one allocated by the API. */
5065 retval = xstrdup (str_acl);
5066 if (size)
5067 *size = local_size;
5068 LocalFree (str_acl);
5070 else if (errno != ENOTSUP)
5071 errno = EINVAL;
5073 return retval;
5076 acl_t
5077 acl_from_text (const char *acl_str)
5079 PSECURITY_DESCRIPTOR psd, retval = NULL;
5080 ULONG sd_size;
5081 int e = errno;
5083 errno = 0;
5085 if (convert_sddl_to_sd (acl_str, SDDL_REVISION_1, &psd, &sd_size))
5087 errno = e;
5088 retval = xmalloc (sd_size);
5089 memcpy (retval, psd, sd_size);
5090 LocalFree (psd);
5092 else if (errno != ENOTSUP)
5093 errno = EINVAL;
5095 return retval;
5099 acl_free (void *ptr)
5101 xfree (ptr);
5102 return 0;
5105 acl_t
5106 acl_get_file (const char *fname, acl_type_t type)
5108 PSECURITY_DESCRIPTOR psd = NULL;
5109 const char *filename;
5111 if (type == ACL_TYPE_ACCESS)
5113 DWORD sd_len, err;
5114 SECURITY_INFORMATION si =
5115 OWNER_SECURITY_INFORMATION |
5116 GROUP_SECURITY_INFORMATION |
5117 DACL_SECURITY_INFORMATION ;
5118 int e = errno;
5120 filename = map_w32_filename (fname, NULL);
5121 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
5122 fname = chase_symlinks (filename);
5123 else
5124 fname = filename;
5126 errno = 0;
5127 if (!get_file_security (fname, si, psd, 0, &sd_len)
5128 && errno != ENOTSUP)
5130 err = GetLastError ();
5131 if (err == ERROR_INSUFFICIENT_BUFFER)
5133 psd = xmalloc (sd_len);
5134 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
5136 xfree (psd);
5137 errno = EIO;
5138 psd = NULL;
5141 else if (err == ERROR_FILE_NOT_FOUND
5142 || err == ERROR_PATH_NOT_FOUND)
5143 errno = ENOENT;
5144 else
5145 errno = EIO;
5147 else if (!errno)
5148 errno = e;
5150 else if (type != ACL_TYPE_DEFAULT)
5151 errno = EINVAL;
5153 return psd;
5157 acl_set_file (const char *fname, acl_type_t type, acl_t acl)
5159 TOKEN_PRIVILEGES old1, old2;
5160 DWORD err;
5161 int st = 0, retval = -1;
5162 SECURITY_INFORMATION flags = 0;
5163 PSID psid;
5164 PACL pacl;
5165 BOOL dflt;
5166 BOOL dacl_present;
5167 int e;
5168 const char *filename;
5170 if (acl_valid (acl) != 0
5171 || (type != ACL_TYPE_DEFAULT && type != ACL_TYPE_ACCESS))
5173 errno = EINVAL;
5174 return -1;
5177 if (type == ACL_TYPE_DEFAULT)
5179 errno = ENOSYS;
5180 return -1;
5183 filename = map_w32_filename (fname, NULL);
5184 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
5185 fname = chase_symlinks (filename);
5186 else
5187 fname = filename;
5189 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR)acl, &psid, &dflt)
5190 && psid)
5191 flags |= OWNER_SECURITY_INFORMATION;
5192 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR)acl, &psid, &dflt)
5193 && psid)
5194 flags |= GROUP_SECURITY_INFORMATION;
5195 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR)acl, &dacl_present,
5196 &pacl, &dflt)
5197 && dacl_present)
5198 flags |= DACL_SECURITY_INFORMATION;
5199 if (!flags)
5200 return 0;
5202 /* According to KB-245153, setting the owner will succeed if either:
5203 (1) the caller is the user who will be the new owner, and has the
5204 SE_TAKE_OWNERSHIP privilege, or
5205 (2) the caller has the SE_RESTORE privilege, in which case she can
5206 set any valid user or group as the owner
5208 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
5209 privileges, and disregard any failures in obtaining them. If
5210 these privileges cannot be obtained, and do not already exist in
5211 the calling thread's security token, this function could fail
5212 with EPERM. */
5213 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME, TRUE, &old1))
5214 st++;
5215 if (enable_privilege (SE_RESTORE_NAME, TRUE, &old2))
5216 st++;
5218 e = errno;
5219 errno = 0;
5220 if (!set_file_security ((char *)fname, flags, (PSECURITY_DESCRIPTOR)acl))
5222 err = GetLastError ();
5224 if (errno == ENOTSUP)
5226 else if (err == ERROR_INVALID_OWNER
5227 || err == ERROR_NOT_ALL_ASSIGNED
5228 || err == ERROR_ACCESS_DENIED)
5230 /* Maybe the requested ACL and the one the file already has
5231 are identical, in which case we can silently ignore the
5232 failure. (And no, Windows doesn't.) */
5233 acl_t current_acl = acl_get_file (fname, ACL_TYPE_ACCESS);
5235 errno = EPERM;
5236 if (current_acl)
5238 char *acl_from = acl_to_text (current_acl, NULL);
5239 char *acl_to = acl_to_text (acl, NULL);
5241 if (acl_from && acl_to && xstrcasecmp (acl_from, acl_to) == 0)
5243 retval = 0;
5244 errno = e;
5246 if (acl_from)
5247 acl_free (acl_from);
5248 if (acl_to)
5249 acl_free (acl_to);
5250 acl_free (current_acl);
5253 else if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND)
5254 errno = ENOENT;
5255 else
5256 errno = EACCES;
5258 else
5260 retval = 0;
5261 errno = e;
5264 if (st)
5266 if (st >= 2)
5267 restore_privilege (&old2);
5268 restore_privilege (&old1);
5269 revert_to_self ();
5272 return retval;
5276 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
5277 have a fixed max size for file names, so we don't need the kind of
5278 alloc/malloc/realloc dance the gnulib version does. We also don't
5279 support FD-relative symlinks. */
5280 char *
5281 careadlinkat (int fd, char const *filename,
5282 char *buffer, size_t buffer_size,
5283 struct allocator const *alloc,
5284 ssize_t (*preadlinkat) (int, char const *, char *, size_t))
5286 char linkname[MAX_PATH];
5287 ssize_t link_size;
5289 link_size = preadlinkat (fd, filename, linkname, sizeof(linkname));
5291 if (link_size > 0)
5293 char *retval = buffer;
5295 linkname[link_size++] = '\0';
5296 if (link_size > buffer_size)
5297 retval = (char *)(alloc ? alloc->allocate : xmalloc) (link_size);
5298 if (retval)
5299 memcpy (retval, linkname, link_size);
5301 return retval;
5303 return NULL;
5307 /* Support for browsing other processes and their attributes. See
5308 process.c for the Lisp bindings. */
5310 /* Helper wrapper functions. */
5312 static HANDLE WINAPI
5313 create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
5315 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
5317 if (g_b_init_create_toolhelp32_snapshot == 0)
5319 g_b_init_create_toolhelp32_snapshot = 1;
5320 s_pfn_Create_Toolhelp32_Snapshot = (CreateToolhelp32Snapshot_Proc)
5321 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5322 "CreateToolhelp32Snapshot");
5324 if (s_pfn_Create_Toolhelp32_Snapshot == NULL)
5326 return INVALID_HANDLE_VALUE;
5328 return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
5331 static BOOL WINAPI
5332 process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
5334 static Process32First_Proc s_pfn_Process32_First = NULL;
5336 if (g_b_init_process32_first == 0)
5338 g_b_init_process32_first = 1;
5339 s_pfn_Process32_First = (Process32First_Proc)
5340 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5341 "Process32First");
5343 if (s_pfn_Process32_First == NULL)
5345 return FALSE;
5347 return (s_pfn_Process32_First (hSnapshot, lppe));
5350 static BOOL WINAPI
5351 process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
5353 static Process32Next_Proc s_pfn_Process32_Next = NULL;
5355 if (g_b_init_process32_next == 0)
5357 g_b_init_process32_next = 1;
5358 s_pfn_Process32_Next = (Process32Next_Proc)
5359 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5360 "Process32Next");
5362 if (s_pfn_Process32_Next == NULL)
5364 return FALSE;
5366 return (s_pfn_Process32_Next (hSnapshot, lppe));
5369 static BOOL WINAPI
5370 open_thread_token (HANDLE ThreadHandle,
5371 DWORD DesiredAccess,
5372 BOOL OpenAsSelf,
5373 PHANDLE TokenHandle)
5375 static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
5376 HMODULE hm_advapi32 = NULL;
5377 if (is_windows_9x () == TRUE)
5379 SetLastError (ERROR_NOT_SUPPORTED);
5380 return FALSE;
5382 if (g_b_init_open_thread_token == 0)
5384 g_b_init_open_thread_token = 1;
5385 hm_advapi32 = LoadLibrary ("Advapi32.dll");
5386 s_pfn_Open_Thread_Token =
5387 (OpenThreadToken_Proc) GetProcAddress (hm_advapi32, "OpenThreadToken");
5389 if (s_pfn_Open_Thread_Token == NULL)
5391 SetLastError (ERROR_NOT_SUPPORTED);
5392 return FALSE;
5394 return (
5395 s_pfn_Open_Thread_Token (
5396 ThreadHandle,
5397 DesiredAccess,
5398 OpenAsSelf,
5399 TokenHandle)
5403 static BOOL WINAPI
5404 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
5406 static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
5407 HMODULE hm_advapi32 = NULL;
5408 if (is_windows_9x () == TRUE)
5410 return FALSE;
5412 if (g_b_init_impersonate_self == 0)
5414 g_b_init_impersonate_self = 1;
5415 hm_advapi32 = LoadLibrary ("Advapi32.dll");
5416 s_pfn_Impersonate_Self =
5417 (ImpersonateSelf_Proc) GetProcAddress (hm_advapi32, "ImpersonateSelf");
5419 if (s_pfn_Impersonate_Self == NULL)
5421 return FALSE;
5423 return s_pfn_Impersonate_Self (ImpersonationLevel);
5426 static BOOL WINAPI
5427 revert_to_self (void)
5429 static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
5430 HMODULE hm_advapi32 = NULL;
5431 if (is_windows_9x () == TRUE)
5433 return FALSE;
5435 if (g_b_init_revert_to_self == 0)
5437 g_b_init_revert_to_self = 1;
5438 hm_advapi32 = LoadLibrary ("Advapi32.dll");
5439 s_pfn_Revert_To_Self =
5440 (RevertToSelf_Proc) GetProcAddress (hm_advapi32, "RevertToSelf");
5442 if (s_pfn_Revert_To_Self == NULL)
5444 return FALSE;
5446 return s_pfn_Revert_To_Self ();
5449 static BOOL WINAPI
5450 get_process_memory_info (HANDLE h_proc,
5451 PPROCESS_MEMORY_COUNTERS mem_counters,
5452 DWORD bufsize)
5454 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
5455 HMODULE hm_psapi = NULL;
5456 if (is_windows_9x () == TRUE)
5458 return FALSE;
5460 if (g_b_init_get_process_memory_info == 0)
5462 g_b_init_get_process_memory_info = 1;
5463 hm_psapi = LoadLibrary ("Psapi.dll");
5464 if (hm_psapi)
5465 s_pfn_Get_Process_Memory_Info = (GetProcessMemoryInfo_Proc)
5466 GetProcAddress (hm_psapi, "GetProcessMemoryInfo");
5468 if (s_pfn_Get_Process_Memory_Info == NULL)
5470 return FALSE;
5472 return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
5475 static BOOL WINAPI
5476 get_process_working_set_size (HANDLE h_proc,
5477 PSIZE_T minrss,
5478 PSIZE_T maxrss)
5480 static GetProcessWorkingSetSize_Proc
5481 s_pfn_Get_Process_Working_Set_Size = NULL;
5483 if (is_windows_9x () == TRUE)
5485 return FALSE;
5487 if (g_b_init_get_process_working_set_size == 0)
5489 g_b_init_get_process_working_set_size = 1;
5490 s_pfn_Get_Process_Working_Set_Size = (GetProcessWorkingSetSize_Proc)
5491 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5492 "GetProcessWorkingSetSize");
5494 if (s_pfn_Get_Process_Working_Set_Size == NULL)
5496 return FALSE;
5498 return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
5501 static BOOL WINAPI
5502 global_memory_status (MEMORYSTATUS *buf)
5504 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
5506 if (is_windows_9x () == TRUE)
5508 return FALSE;
5510 if (g_b_init_global_memory_status == 0)
5512 g_b_init_global_memory_status = 1;
5513 s_pfn_Global_Memory_Status = (GlobalMemoryStatus_Proc)
5514 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5515 "GlobalMemoryStatus");
5517 if (s_pfn_Global_Memory_Status == NULL)
5519 return FALSE;
5521 return s_pfn_Global_Memory_Status (buf);
5524 static BOOL WINAPI
5525 global_memory_status_ex (MEMORY_STATUS_EX *buf)
5527 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
5529 if (is_windows_9x () == TRUE)
5531 return FALSE;
5533 if (g_b_init_global_memory_status_ex == 0)
5535 g_b_init_global_memory_status_ex = 1;
5536 s_pfn_Global_Memory_Status_Ex = (GlobalMemoryStatusEx_Proc)
5537 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5538 "GlobalMemoryStatusEx");
5540 if (s_pfn_Global_Memory_Status_Ex == NULL)
5542 return FALSE;
5544 return s_pfn_Global_Memory_Status_Ex (buf);
5547 Lisp_Object
5548 list_system_processes (void)
5550 struct gcpro gcpro1;
5551 Lisp_Object proclist = Qnil;
5552 HANDLE h_snapshot;
5554 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
5556 if (h_snapshot != INVALID_HANDLE_VALUE)
5558 PROCESSENTRY32 proc_entry;
5559 DWORD proc_id;
5560 BOOL res;
5562 GCPRO1 (proclist);
5564 proc_entry.dwSize = sizeof (PROCESSENTRY32);
5565 for (res = process32_first (h_snapshot, &proc_entry); res;
5566 res = process32_next (h_snapshot, &proc_entry))
5568 proc_id = proc_entry.th32ProcessID;
5569 proclist = Fcons (make_fixnum_or_float (proc_id), proclist);
5572 CloseHandle (h_snapshot);
5573 UNGCPRO;
5574 proclist = Fnreverse (proclist);
5577 return proclist;
5580 static int
5581 enable_privilege (LPCTSTR priv_name, BOOL enable_p, TOKEN_PRIVILEGES *old_priv)
5583 TOKEN_PRIVILEGES priv;
5584 DWORD priv_size = sizeof (priv);
5585 DWORD opriv_size = sizeof (*old_priv);
5586 HANDLE h_token = NULL;
5587 HANDLE h_thread = GetCurrentThread ();
5588 int ret_val = 0;
5589 BOOL res;
5591 res = open_thread_token (h_thread,
5592 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
5593 FALSE, &h_token);
5594 if (!res && GetLastError () == ERROR_NO_TOKEN)
5596 if (impersonate_self (SecurityImpersonation))
5597 res = open_thread_token (h_thread,
5598 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
5599 FALSE, &h_token);
5601 if (res)
5603 priv.PrivilegeCount = 1;
5604 priv.Privileges[0].Attributes = enable_p ? SE_PRIVILEGE_ENABLED : 0;
5605 LookupPrivilegeValue (NULL, priv_name, &priv.Privileges[0].Luid);
5606 if (AdjustTokenPrivileges (h_token, FALSE, &priv, priv_size,
5607 old_priv, &opriv_size)
5608 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
5609 ret_val = 1;
5611 if (h_token)
5612 CloseHandle (h_token);
5614 return ret_val;
5617 static int
5618 restore_privilege (TOKEN_PRIVILEGES *priv)
5620 DWORD priv_size = sizeof (*priv);
5621 HANDLE h_token = NULL;
5622 int ret_val = 0;
5624 if (open_thread_token (GetCurrentThread (),
5625 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
5626 FALSE, &h_token))
5628 if (AdjustTokenPrivileges (h_token, FALSE, priv, priv_size, NULL, NULL)
5629 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
5630 ret_val = 1;
5632 if (h_token)
5633 CloseHandle (h_token);
5635 return ret_val;
5638 static Lisp_Object
5639 ltime (ULONGLONG time_100ns)
5641 ULONGLONG time_sec = time_100ns / 10000000;
5642 int subsec = time_100ns % 10000000;
5643 return list4i (time_sec >> 16, time_sec & 0xffff,
5644 subsec / 10, subsec % 10 * 100000);
5647 #define U64_TO_LISP_TIME(time) ltime (time)
5649 static int
5650 process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
5651 Lisp_Object *stime, Lisp_Object *utime, Lisp_Object *ttime,
5652 double *pcpu)
5654 FILETIME ft_creation, ft_exit, ft_kernel, ft_user, ft_current;
5655 ULONGLONG tem1, tem2, tem3, tem;
5657 if (!h_proc
5658 || !get_process_times_fn
5659 || !(*get_process_times_fn) (h_proc, &ft_creation, &ft_exit,
5660 &ft_kernel, &ft_user))
5661 return 0;
5663 GetSystemTimeAsFileTime (&ft_current);
5665 FILETIME_TO_U64 (tem1, ft_kernel);
5666 *stime = U64_TO_LISP_TIME (tem1);
5668 FILETIME_TO_U64 (tem2, ft_user);
5669 *utime = U64_TO_LISP_TIME (tem2);
5671 tem3 = tem1 + tem2;
5672 *ttime = U64_TO_LISP_TIME (tem3);
5674 FILETIME_TO_U64 (tem, ft_creation);
5675 /* Process no 4 (System) returns zero creation time. */
5676 if (tem)
5677 tem -= utc_base;
5678 *ctime = U64_TO_LISP_TIME (tem);
5680 if (tem)
5682 FILETIME_TO_U64 (tem3, ft_current);
5683 tem = (tem3 - utc_base) - tem;
5685 *etime = U64_TO_LISP_TIME (tem);
5687 if (tem)
5689 *pcpu = 100.0 * (tem1 + tem2) / tem;
5690 if (*pcpu > 100)
5691 *pcpu = 100.0;
5693 else
5694 *pcpu = 0;
5696 return 1;
5699 Lisp_Object
5700 system_process_attributes (Lisp_Object pid)
5702 struct gcpro gcpro1, gcpro2, gcpro3;
5703 Lisp_Object attrs = Qnil;
5704 Lisp_Object cmd_str, decoded_cmd, tem;
5705 HANDLE h_snapshot, h_proc;
5706 DWORD proc_id;
5707 int found_proc = 0;
5708 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
5709 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
5710 DWORD glength = sizeof (gname);
5711 HANDLE token = NULL;
5712 SID_NAME_USE user_type;
5713 unsigned char *buf = NULL;
5714 DWORD blen = 0;
5715 TOKEN_USER user_token;
5716 TOKEN_PRIMARY_GROUP group_token;
5717 unsigned euid;
5718 unsigned egid;
5719 PROCESS_MEMORY_COUNTERS mem;
5720 PROCESS_MEMORY_COUNTERS_EX mem_ex;
5721 SIZE_T minrss, maxrss;
5722 MEMORYSTATUS memst;
5723 MEMORY_STATUS_EX memstex;
5724 double totphys = 0.0;
5725 Lisp_Object ctime, stime, utime, etime, ttime;
5726 double pcpu;
5727 BOOL result = FALSE;
5729 CHECK_NUMBER_OR_FLOAT (pid);
5730 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
5732 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
5734 GCPRO3 (attrs, decoded_cmd, tem);
5736 if (h_snapshot != INVALID_HANDLE_VALUE)
5738 PROCESSENTRY32 pe;
5739 BOOL res;
5741 pe.dwSize = sizeof (PROCESSENTRY32);
5742 for (res = process32_first (h_snapshot, &pe); res;
5743 res = process32_next (h_snapshot, &pe))
5745 if (proc_id == pe.th32ProcessID)
5747 if (proc_id == 0)
5748 decoded_cmd = build_string ("Idle");
5749 else
5751 /* Decode the command name from locale-specific
5752 encoding. */
5753 cmd_str = make_unibyte_string (pe.szExeFile,
5754 strlen (pe.szExeFile));
5755 decoded_cmd =
5756 code_convert_string_norecord (cmd_str,
5757 Vlocale_coding_system, 0);
5759 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
5760 attrs = Fcons (Fcons (Qppid,
5761 make_fixnum_or_float (pe.th32ParentProcessID)),
5762 attrs);
5763 attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
5764 attrs);
5765 attrs = Fcons (Fcons (Qthcount,
5766 make_fixnum_or_float (pe.cntThreads)),
5767 attrs);
5768 found_proc = 1;
5769 break;
5773 CloseHandle (h_snapshot);
5776 if (!found_proc)
5778 UNGCPRO;
5779 return Qnil;
5782 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
5783 FALSE, proc_id);
5784 /* If we were denied a handle to the process, try again after
5785 enabling the SeDebugPrivilege in our process. */
5786 if (!h_proc)
5788 TOKEN_PRIVILEGES priv_current;
5790 if (enable_privilege (SE_DEBUG_NAME, TRUE, &priv_current))
5792 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
5793 FALSE, proc_id);
5794 restore_privilege (&priv_current);
5795 revert_to_self ();
5798 if (h_proc)
5800 result = open_process_token (h_proc, TOKEN_QUERY, &token);
5801 if (result)
5803 result = get_token_information (token, TokenUser, NULL, 0, &blen);
5804 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
5806 buf = xmalloc (blen);
5807 result = get_token_information (token, TokenUser,
5808 (LPVOID)buf, blen, &needed);
5809 if (result)
5811 memcpy (&user_token, buf, sizeof (user_token));
5812 if (!w32_cached_id (user_token.User.Sid, &euid, uname))
5814 euid = get_rid (user_token.User.Sid);
5815 result = lookup_account_sid (NULL, user_token.User.Sid,
5816 uname, &ulength,
5817 domain, &dlength,
5818 &user_type);
5819 if (result)
5820 w32_add_to_cache (user_token.User.Sid, euid, uname);
5821 else
5823 strcpy (uname, "unknown");
5824 result = TRUE;
5827 ulength = strlen (uname);
5831 if (result)
5833 /* Determine a reasonable euid and gid values. */
5834 if (xstrcasecmp ("administrator", uname) == 0)
5836 euid = 500; /* well-known Administrator uid */
5837 egid = 513; /* well-known None gid */
5839 else
5841 /* Get group id and name. */
5842 result = get_token_information (token, TokenPrimaryGroup,
5843 (LPVOID)buf, blen, &needed);
5844 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
5846 buf = xrealloc (buf, blen = needed);
5847 result = get_token_information (token, TokenPrimaryGroup,
5848 (LPVOID)buf, blen, &needed);
5850 if (result)
5852 memcpy (&group_token, buf, sizeof (group_token));
5853 if (!w32_cached_id (group_token.PrimaryGroup, &egid, gname))
5855 egid = get_rid (group_token.PrimaryGroup);
5856 dlength = sizeof (domain);
5857 result =
5858 lookup_account_sid (NULL, group_token.PrimaryGroup,
5859 gname, &glength, NULL, &dlength,
5860 &user_type);
5861 if (result)
5862 w32_add_to_cache (group_token.PrimaryGroup,
5863 egid, gname);
5864 else
5866 strcpy (gname, "None");
5867 result = TRUE;
5870 glength = strlen (gname);
5874 xfree (buf);
5876 if (!result)
5878 if (!is_windows_9x ())
5880 /* We couldn't open the process token, presumably because of
5881 insufficient access rights. Assume this process is run
5882 by the system. */
5883 strcpy (uname, "SYSTEM");
5884 strcpy (gname, "None");
5885 euid = 18; /* SYSTEM */
5886 egid = 513; /* None */
5887 glength = strlen (gname);
5888 ulength = strlen (uname);
5890 /* If we are running under Windows 9X, where security calls are
5891 not supported, we assume all processes are run by the current
5892 user. */
5893 else if (GetUserName (uname, &ulength))
5895 if (xstrcasecmp ("administrator", uname) == 0)
5896 euid = 0;
5897 else
5898 euid = 123;
5899 egid = euid;
5900 strcpy (gname, "None");
5901 glength = strlen (gname);
5902 ulength = strlen (uname);
5904 else
5906 euid = 123;
5907 egid = 123;
5908 strcpy (uname, "administrator");
5909 ulength = strlen (uname);
5910 strcpy (gname, "None");
5911 glength = strlen (gname);
5913 if (token)
5914 CloseHandle (token);
5917 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (euid)), attrs);
5918 tem = make_unibyte_string (uname, ulength);
5919 attrs = Fcons (Fcons (Quser,
5920 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
5921 attrs);
5922 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (egid)), attrs);
5923 tem = make_unibyte_string (gname, glength);
5924 attrs = Fcons (Fcons (Qgroup,
5925 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
5926 attrs);
5928 if (global_memory_status_ex (&memstex))
5929 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5930 totphys = memstex.ullTotalPhys / 1024.0;
5931 #else
5932 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5933 double, so we need to do this for it... */
5935 DWORD tot_hi = memstex.ullTotalPhys >> 32;
5936 DWORD tot_md = (memstex.ullTotalPhys & 0x00000000ffffffff) >> 10;
5937 DWORD tot_lo = memstex.ullTotalPhys % 1024;
5939 totphys = tot_hi * 4194304.0 + tot_md + tot_lo / 1024.0;
5941 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5942 else if (global_memory_status (&memst))
5943 totphys = memst.dwTotalPhys / 1024.0;
5945 if (h_proc
5946 && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
5947 sizeof (mem_ex)))
5949 SIZE_T rss = mem_ex.WorkingSetSize / 1024;
5951 attrs = Fcons (Fcons (Qmajflt,
5952 make_fixnum_or_float (mem_ex.PageFaultCount)),
5953 attrs);
5954 attrs = Fcons (Fcons (Qvsize,
5955 make_fixnum_or_float (mem_ex.PrivateUsage / 1024)),
5956 attrs);
5957 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
5958 if (totphys)
5959 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
5961 else if (h_proc
5962 && get_process_memory_info (h_proc, &mem, sizeof (mem)))
5964 SIZE_T rss = mem_ex.WorkingSetSize / 1024;
5966 attrs = Fcons (Fcons (Qmajflt,
5967 make_fixnum_or_float (mem.PageFaultCount)),
5968 attrs);
5969 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
5970 if (totphys)
5971 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
5973 else if (h_proc
5974 && get_process_working_set_size (h_proc, &minrss, &maxrss))
5976 DWORD rss = maxrss / 1024;
5978 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (maxrss / 1024)), attrs);
5979 if (totphys)
5980 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
5983 if (process_times (h_proc, &ctime, &etime, &stime, &utime, &ttime, &pcpu))
5985 attrs = Fcons (Fcons (Qutime, utime), attrs);
5986 attrs = Fcons (Fcons (Qstime, stime), attrs);
5987 attrs = Fcons (Fcons (Qtime, ttime), attrs);
5988 attrs = Fcons (Fcons (Qstart, ctime), attrs);
5989 attrs = Fcons (Fcons (Qetime, etime), attrs);
5990 attrs = Fcons (Fcons (Qpcpu, make_float (pcpu)), attrs);
5993 /* FIXME: Retrieve command line by walking the PEB of the process. */
5995 if (h_proc)
5996 CloseHandle (h_proc);
5997 UNGCPRO;
5998 return attrs;
6002 /* Wrappers for winsock functions to map between our file descriptors
6003 and winsock's handles; also set h_errno for convenience.
6005 To allow Emacs to run on systems which don't have winsock support
6006 installed, we dynamically link to winsock on startup if present, and
6007 otherwise provide the minimum necessary functionality
6008 (eg. gethostname). */
6010 /* function pointers for relevant socket functions */
6011 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
6012 void (PASCAL *pfn_WSASetLastError) (int iError);
6013 int (PASCAL *pfn_WSAGetLastError) (void);
6014 int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
6015 HANDLE (PASCAL *pfn_WSACreateEvent) (void);
6016 int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
6017 int (PASCAL *pfn_socket) (int af, int type, int protocol);
6018 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
6019 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
6020 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
6021 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
6022 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
6023 int (PASCAL *pfn_closesocket) (SOCKET s);
6024 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
6025 int (PASCAL *pfn_WSACleanup) (void);
6027 u_short (PASCAL *pfn_htons) (u_short hostshort);
6028 u_short (PASCAL *pfn_ntohs) (u_short netshort);
6029 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
6030 int (PASCAL *pfn_gethostname) (char * name, int namelen);
6031 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
6032 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
6033 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
6034 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
6035 const char * optval, int optlen);
6036 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
6037 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
6038 int * namelen);
6039 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
6040 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
6041 struct sockaddr * from, int * fromlen);
6042 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
6043 const struct sockaddr * to, int tolen);
6045 /* SetHandleInformation is only needed to make sockets non-inheritable. */
6046 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
6047 #ifndef HANDLE_FLAG_INHERIT
6048 #define HANDLE_FLAG_INHERIT 1
6049 #endif
6051 HANDLE winsock_lib;
6052 static int winsock_inuse;
6054 BOOL
6055 term_winsock (void)
6057 if (winsock_lib != NULL && winsock_inuse == 0)
6059 /* Not sure what would cause WSAENETDOWN, or even if it can happen
6060 after WSAStartup returns successfully, but it seems reasonable
6061 to allow unloading winsock anyway in that case. */
6062 if (pfn_WSACleanup () == 0 ||
6063 pfn_WSAGetLastError () == WSAENETDOWN)
6065 if (FreeLibrary (winsock_lib))
6066 winsock_lib = NULL;
6067 return TRUE;
6070 return FALSE;
6073 BOOL
6074 init_winsock (int load_now)
6076 WSADATA winsockData;
6078 if (winsock_lib != NULL)
6079 return TRUE;
6081 pfn_SetHandleInformation
6082 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
6083 "SetHandleInformation");
6085 winsock_lib = LoadLibrary ("Ws2_32.dll");
6087 if (winsock_lib != NULL)
6089 /* dynamically link to socket functions */
6091 #define LOAD_PROC(fn) \
6092 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
6093 goto fail;
6095 LOAD_PROC (WSAStartup);
6096 LOAD_PROC (WSASetLastError);
6097 LOAD_PROC (WSAGetLastError);
6098 LOAD_PROC (WSAEventSelect);
6099 LOAD_PROC (WSACreateEvent);
6100 LOAD_PROC (WSACloseEvent);
6101 LOAD_PROC (socket);
6102 LOAD_PROC (bind);
6103 LOAD_PROC (connect);
6104 LOAD_PROC (ioctlsocket);
6105 LOAD_PROC (recv);
6106 LOAD_PROC (send);
6107 LOAD_PROC (closesocket);
6108 LOAD_PROC (shutdown);
6109 LOAD_PROC (htons);
6110 LOAD_PROC (ntohs);
6111 LOAD_PROC (inet_addr);
6112 LOAD_PROC (gethostname);
6113 LOAD_PROC (gethostbyname);
6114 LOAD_PROC (getservbyname);
6115 LOAD_PROC (getpeername);
6116 LOAD_PROC (WSACleanup);
6117 LOAD_PROC (setsockopt);
6118 LOAD_PROC (listen);
6119 LOAD_PROC (getsockname);
6120 LOAD_PROC (accept);
6121 LOAD_PROC (recvfrom);
6122 LOAD_PROC (sendto);
6123 #undef LOAD_PROC
6125 /* specify version 1.1 of winsock */
6126 if (pfn_WSAStartup (0x101, &winsockData) == 0)
6128 if (winsockData.wVersion != 0x101)
6129 goto fail;
6131 if (!load_now)
6133 /* Report that winsock exists and is usable, but leave
6134 socket functions disabled. I am assuming that calling
6135 WSAStartup does not require any network interaction,
6136 and in particular does not cause or require a dial-up
6137 connection to be established. */
6139 pfn_WSACleanup ();
6140 FreeLibrary (winsock_lib);
6141 winsock_lib = NULL;
6143 winsock_inuse = 0;
6144 return TRUE;
6147 fail:
6148 FreeLibrary (winsock_lib);
6149 winsock_lib = NULL;
6152 return FALSE;
6156 int h_errno = 0;
6158 /* Function to map winsock error codes to errno codes for those errno
6159 code defined in errno.h (errno values not defined by errno.h are
6160 already in nt/inc/sys/socket.h). */
6161 static void
6162 set_errno (void)
6164 int wsa_err;
6166 h_errno = 0;
6167 if (winsock_lib == NULL)
6168 wsa_err = EINVAL;
6169 else
6170 wsa_err = pfn_WSAGetLastError ();
6172 switch (wsa_err)
6174 case WSAEACCES: errno = EACCES; break;
6175 case WSAEBADF: errno = EBADF; break;
6176 case WSAEFAULT: errno = EFAULT; break;
6177 case WSAEINTR: errno = EINTR; break;
6178 case WSAEINVAL: errno = EINVAL; break;
6179 case WSAEMFILE: errno = EMFILE; break;
6180 case WSAENAMETOOLONG: errno = ENAMETOOLONG; break;
6181 case WSAENOTEMPTY: errno = ENOTEMPTY; break;
6182 default: errno = wsa_err; break;
6186 static void
6187 check_errno (void)
6189 h_errno = 0;
6190 if (winsock_lib != NULL)
6191 pfn_WSASetLastError (0);
6194 /* Extend strerror to handle the winsock-specific error codes. */
6195 struct {
6196 int errnum;
6197 char * msg;
6198 } _wsa_errlist[] = {
6199 {WSAEINTR , "Interrupted function call"},
6200 {WSAEBADF , "Bad file descriptor"},
6201 {WSAEACCES , "Permission denied"},
6202 {WSAEFAULT , "Bad address"},
6203 {WSAEINVAL , "Invalid argument"},
6204 {WSAEMFILE , "Too many open files"},
6206 {WSAEWOULDBLOCK , "Resource temporarily unavailable"},
6207 {WSAEINPROGRESS , "Operation now in progress"},
6208 {WSAEALREADY , "Operation already in progress"},
6209 {WSAENOTSOCK , "Socket operation on non-socket"},
6210 {WSAEDESTADDRREQ , "Destination address required"},
6211 {WSAEMSGSIZE , "Message too long"},
6212 {WSAEPROTOTYPE , "Protocol wrong type for socket"},
6213 {WSAENOPROTOOPT , "Bad protocol option"},
6214 {WSAEPROTONOSUPPORT , "Protocol not supported"},
6215 {WSAESOCKTNOSUPPORT , "Socket type not supported"},
6216 {WSAEOPNOTSUPP , "Operation not supported"},
6217 {WSAEPFNOSUPPORT , "Protocol family not supported"},
6218 {WSAEAFNOSUPPORT , "Address family not supported by protocol family"},
6219 {WSAEADDRINUSE , "Address already in use"},
6220 {WSAEADDRNOTAVAIL , "Cannot assign requested address"},
6221 {WSAENETDOWN , "Network is down"},
6222 {WSAENETUNREACH , "Network is unreachable"},
6223 {WSAENETRESET , "Network dropped connection on reset"},
6224 {WSAECONNABORTED , "Software caused connection abort"},
6225 {WSAECONNRESET , "Connection reset by peer"},
6226 {WSAENOBUFS , "No buffer space available"},
6227 {WSAEISCONN , "Socket is already connected"},
6228 {WSAENOTCONN , "Socket is not connected"},
6229 {WSAESHUTDOWN , "Cannot send after socket shutdown"},
6230 {WSAETOOMANYREFS , "Too many references"}, /* not sure */
6231 {WSAETIMEDOUT , "Connection timed out"},
6232 {WSAECONNREFUSED , "Connection refused"},
6233 {WSAELOOP , "Network loop"}, /* not sure */
6234 {WSAENAMETOOLONG , "Name is too long"},
6235 {WSAEHOSTDOWN , "Host is down"},
6236 {WSAEHOSTUNREACH , "No route to host"},
6237 {WSAENOTEMPTY , "Buffer not empty"}, /* not sure */
6238 {WSAEPROCLIM , "Too many processes"},
6239 {WSAEUSERS , "Too many users"}, /* not sure */
6240 {WSAEDQUOT , "Double quote in host name"}, /* really not sure */
6241 {WSAESTALE , "Data is stale"}, /* not sure */
6242 {WSAEREMOTE , "Remote error"}, /* not sure */
6244 {WSASYSNOTREADY , "Network subsystem is unavailable"},
6245 {WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range"},
6246 {WSANOTINITIALISED , "Winsock not initialized successfully"},
6247 {WSAEDISCON , "Graceful shutdown in progress"},
6248 #ifdef WSAENOMORE
6249 {WSAENOMORE , "No more operations allowed"}, /* not sure */
6250 {WSAECANCELLED , "Operation cancelled"}, /* not sure */
6251 {WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider"},
6252 {WSAEINVALIDPROVIDER , "Invalid service provider version number"},
6253 {WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider"},
6254 {WSASYSCALLFAILURE , "System call failure"},
6255 {WSASERVICE_NOT_FOUND , "Service not found"}, /* not sure */
6256 {WSATYPE_NOT_FOUND , "Class type not found"},
6257 {WSA_E_NO_MORE , "No more resources available"}, /* really not sure */
6258 {WSA_E_CANCELLED , "Operation already cancelled"}, /* really not sure */
6259 {WSAEREFUSED , "Operation refused"}, /* not sure */
6260 #endif
6262 {WSAHOST_NOT_FOUND , "Host not found"},
6263 {WSATRY_AGAIN , "Authoritative host not found during name lookup"},
6264 {WSANO_RECOVERY , "Non-recoverable error during name lookup"},
6265 {WSANO_DATA , "Valid name, no data record of requested type"},
6267 {-1, NULL}
6270 char *
6271 sys_strerror (int error_no)
6273 int i;
6274 static char unknown_msg[40];
6276 if (error_no >= 0 && error_no < sys_nerr)
6277 return sys_errlist[error_no];
6279 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
6280 if (_wsa_errlist[i].errnum == error_no)
6281 return _wsa_errlist[i].msg;
6283 sprintf (unknown_msg, "Unidentified error: %d", error_no);
6284 return unknown_msg;
6287 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6288 but I believe the method of keeping the socket handle separate (and
6289 insuring it is not inheritable) is the correct one. */
6291 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6293 static int socket_to_fd (SOCKET s);
6296 sys_socket (int af, int type, int protocol)
6298 SOCKET s;
6300 if (winsock_lib == NULL)
6302 errno = ENETDOWN;
6303 return INVALID_SOCKET;
6306 check_errno ();
6308 /* call the real socket function */
6309 s = pfn_socket (af, type, protocol);
6311 if (s != INVALID_SOCKET)
6312 return socket_to_fd (s);
6314 set_errno ();
6315 return -1;
6318 /* Convert a SOCKET to a file descriptor. */
6319 static int
6320 socket_to_fd (SOCKET s)
6322 int fd;
6323 child_process * cp;
6325 /* Although under NT 3.5 _open_osfhandle will accept a socket
6326 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6327 that does not work under NT 3.1. However, we can get the same
6328 effect by using a backdoor function to replace an existing
6329 descriptor handle with the one we want. */
6331 /* allocate a file descriptor (with appropriate flags) */
6332 fd = _open ("NUL:", _O_RDWR);
6333 if (fd >= 0)
6335 /* Make a non-inheritable copy of the socket handle. Note
6336 that it is possible that sockets aren't actually kernel
6337 handles, which appears to be the case on Windows 9x when
6338 the MS Proxy winsock client is installed. */
6340 /* Apparently there is a bug in NT 3.51 with some service
6341 packs, which prevents using DuplicateHandle to make a
6342 socket handle non-inheritable (causes WSACleanup to
6343 hang). The work-around is to use SetHandleInformation
6344 instead if it is available and implemented. */
6345 if (pfn_SetHandleInformation)
6347 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
6349 else
6351 HANDLE parent = GetCurrentProcess ();
6352 HANDLE new_s = INVALID_HANDLE_VALUE;
6354 if (DuplicateHandle (parent,
6355 (HANDLE) s,
6356 parent,
6357 &new_s,
6359 FALSE,
6360 DUPLICATE_SAME_ACCESS))
6362 /* It is possible that DuplicateHandle succeeds even
6363 though the socket wasn't really a kernel handle,
6364 because a real handle has the same value. So
6365 test whether the new handle really is a socket. */
6366 long nonblocking = 0;
6367 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
6369 pfn_closesocket (s);
6370 s = (SOCKET) new_s;
6372 else
6374 CloseHandle (new_s);
6379 eassert (fd < MAXDESC);
6380 fd_info[fd].hnd = (HANDLE) s;
6382 /* set our own internal flags */
6383 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
6385 cp = new_child ();
6386 if (cp)
6388 cp->fd = fd;
6389 cp->status = STATUS_READ_ACKNOWLEDGED;
6391 /* attach child_process to fd_info */
6392 if (fd_info[ fd ].cp != NULL)
6394 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
6395 emacs_abort ();
6398 fd_info[ fd ].cp = cp;
6400 /* success! */
6401 winsock_inuse++; /* count open sockets */
6402 return fd;
6405 /* clean up */
6406 _close (fd);
6408 else
6409 pfn_closesocket (s);
6410 errno = EMFILE;
6411 return -1;
6415 sys_bind (int s, const struct sockaddr * addr, int namelen)
6417 if (winsock_lib == NULL)
6419 errno = ENOTSOCK;
6420 return SOCKET_ERROR;
6423 check_errno ();
6424 if (fd_info[s].flags & FILE_SOCKET)
6426 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
6427 if (rc == SOCKET_ERROR)
6428 set_errno ();
6429 return rc;
6431 errno = ENOTSOCK;
6432 return SOCKET_ERROR;
6436 sys_connect (int s, const struct sockaddr * name, int namelen)
6438 if (winsock_lib == NULL)
6440 errno = ENOTSOCK;
6441 return SOCKET_ERROR;
6444 check_errno ();
6445 if (fd_info[s].flags & FILE_SOCKET)
6447 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
6448 if (rc == SOCKET_ERROR)
6449 set_errno ();
6450 return rc;
6452 errno = ENOTSOCK;
6453 return SOCKET_ERROR;
6456 u_short
6457 sys_htons (u_short hostshort)
6459 return (winsock_lib != NULL) ?
6460 pfn_htons (hostshort) : hostshort;
6463 u_short
6464 sys_ntohs (u_short netshort)
6466 return (winsock_lib != NULL) ?
6467 pfn_ntohs (netshort) : netshort;
6470 unsigned long
6471 sys_inet_addr (const char * cp)
6473 return (winsock_lib != NULL) ?
6474 pfn_inet_addr (cp) : INADDR_NONE;
6478 sys_gethostname (char * name, int namelen)
6480 if (winsock_lib != NULL)
6482 int retval;
6484 check_errno ();
6485 retval = pfn_gethostname (name, namelen);
6486 if (retval == SOCKET_ERROR)
6487 set_errno ();
6488 return retval;
6491 if (namelen > MAX_COMPUTERNAME_LENGTH)
6492 return !GetComputerName (name, (DWORD *)&namelen);
6494 errno = EFAULT;
6495 return SOCKET_ERROR;
6498 struct hostent *
6499 sys_gethostbyname (const char * name)
6501 struct hostent * host;
6502 int h_err = h_errno;
6504 if (winsock_lib == NULL)
6506 h_errno = NO_RECOVERY;
6507 errno = ENETDOWN;
6508 return NULL;
6511 check_errno ();
6512 host = pfn_gethostbyname (name);
6513 if (!host)
6515 set_errno ();
6516 h_errno = errno;
6518 else
6519 h_errno = h_err;
6520 return host;
6523 struct servent *
6524 sys_getservbyname (const char * name, const char * proto)
6526 struct servent * serv;
6528 if (winsock_lib == NULL)
6530 errno = ENETDOWN;
6531 return NULL;
6534 check_errno ();
6535 serv = pfn_getservbyname (name, proto);
6536 if (!serv)
6537 set_errno ();
6538 return serv;
6542 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
6544 if (winsock_lib == NULL)
6546 errno = ENETDOWN;
6547 return SOCKET_ERROR;
6550 check_errno ();
6551 if (fd_info[s].flags & FILE_SOCKET)
6553 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
6554 if (rc == SOCKET_ERROR)
6555 set_errno ();
6556 return rc;
6558 errno = ENOTSOCK;
6559 return SOCKET_ERROR;
6563 sys_shutdown (int s, int how)
6565 if (winsock_lib == NULL)
6567 errno = ENETDOWN;
6568 return SOCKET_ERROR;
6571 check_errno ();
6572 if (fd_info[s].flags & FILE_SOCKET)
6574 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
6575 if (rc == SOCKET_ERROR)
6576 set_errno ();
6577 return rc;
6579 errno = ENOTSOCK;
6580 return SOCKET_ERROR;
6584 sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
6586 if (winsock_lib == NULL)
6588 errno = ENETDOWN;
6589 return SOCKET_ERROR;
6592 check_errno ();
6593 if (fd_info[s].flags & FILE_SOCKET)
6595 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
6596 (const char *)optval, optlen);
6597 if (rc == SOCKET_ERROR)
6598 set_errno ();
6599 return rc;
6601 errno = ENOTSOCK;
6602 return SOCKET_ERROR;
6606 sys_listen (int s, int backlog)
6608 if (winsock_lib == NULL)
6610 errno = ENETDOWN;
6611 return SOCKET_ERROR;
6614 check_errno ();
6615 if (fd_info[s].flags & FILE_SOCKET)
6617 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
6618 if (rc == SOCKET_ERROR)
6619 set_errno ();
6620 else
6621 fd_info[s].flags |= FILE_LISTEN;
6622 return rc;
6624 errno = ENOTSOCK;
6625 return SOCKET_ERROR;
6629 sys_getsockname (int s, struct sockaddr * name, int * namelen)
6631 if (winsock_lib == NULL)
6633 errno = ENETDOWN;
6634 return SOCKET_ERROR;
6637 check_errno ();
6638 if (fd_info[s].flags & FILE_SOCKET)
6640 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
6641 if (rc == SOCKET_ERROR)
6642 set_errno ();
6643 return rc;
6645 errno = ENOTSOCK;
6646 return SOCKET_ERROR;
6650 sys_accept (int s, struct sockaddr * addr, int * addrlen)
6652 if (winsock_lib == NULL)
6654 errno = ENETDOWN;
6655 return -1;
6658 check_errno ();
6659 if (fd_info[s].flags & FILE_LISTEN)
6661 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
6662 int fd = -1;
6663 if (t == INVALID_SOCKET)
6664 set_errno ();
6665 else
6666 fd = socket_to_fd (t);
6668 if (fd >= 0)
6670 fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
6671 ResetEvent (fd_info[s].cp->char_avail);
6673 return fd;
6675 errno = ENOTSOCK;
6676 return -1;
6680 sys_recvfrom (int s, char * buf, int len, int flags,
6681 struct sockaddr * from, int * fromlen)
6683 if (winsock_lib == NULL)
6685 errno = ENETDOWN;
6686 return SOCKET_ERROR;
6689 check_errno ();
6690 if (fd_info[s].flags & FILE_SOCKET)
6692 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
6693 if (rc == SOCKET_ERROR)
6694 set_errno ();
6695 return rc;
6697 errno = ENOTSOCK;
6698 return SOCKET_ERROR;
6702 sys_sendto (int s, const char * buf, int len, int flags,
6703 const struct sockaddr * to, int tolen)
6705 if (winsock_lib == NULL)
6707 errno = ENETDOWN;
6708 return SOCKET_ERROR;
6711 check_errno ();
6712 if (fd_info[s].flags & FILE_SOCKET)
6714 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
6715 if (rc == SOCKET_ERROR)
6716 set_errno ();
6717 return rc;
6719 errno = ENOTSOCK;
6720 return SOCKET_ERROR;
6723 /* Windows does not have an fcntl function. Provide an implementation
6724 good enough for Emacs. */
6726 fcntl (int s, int cmd, int options)
6728 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
6729 invoked in a context where fd1 is closed and all descriptors less
6730 than fd1 are open, so sys_dup is an adequate implementation. */
6731 if (cmd == F_DUPFD_CLOEXEC)
6732 return sys_dup (s);
6734 if (winsock_lib == NULL)
6736 errno = ENETDOWN;
6737 return -1;
6740 check_errno ();
6741 if (fd_info[s].flags & FILE_SOCKET)
6743 if (cmd == F_SETFL && options == O_NONBLOCK)
6745 unsigned long nblock = 1;
6746 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
6747 if (rc == SOCKET_ERROR)
6748 set_errno ();
6749 /* Keep track of the fact that we set this to non-blocking. */
6750 fd_info[s].flags |= FILE_NDELAY;
6751 return rc;
6753 else
6755 errno = EINVAL;
6756 return SOCKET_ERROR;
6759 errno = ENOTSOCK;
6760 return SOCKET_ERROR;
6764 /* Shadow main io functions: we need to handle pipes and sockets more
6765 intelligently, and implement non-blocking mode as well. */
6768 sys_close (int fd)
6770 int rc;
6772 if (fd < 0)
6774 errno = EBADF;
6775 return -1;
6778 if (fd < MAXDESC && fd_info[fd].cp)
6780 child_process * cp = fd_info[fd].cp;
6782 fd_info[fd].cp = NULL;
6784 if (CHILD_ACTIVE (cp))
6786 /* if last descriptor to active child_process then cleanup */
6787 int i;
6788 for (i = 0; i < MAXDESC; i++)
6790 if (i == fd)
6791 continue;
6792 if (fd_info[i].cp == cp)
6793 break;
6795 if (i == MAXDESC)
6797 if (fd_info[fd].flags & FILE_SOCKET)
6799 if (winsock_lib == NULL) emacs_abort ();
6801 pfn_shutdown (SOCK_HANDLE (fd), 2);
6802 rc = pfn_closesocket (SOCK_HANDLE (fd));
6804 winsock_inuse--; /* count open sockets */
6806 /* If the process handle is NULL, it's either a socket
6807 or serial connection, or a subprocess that was
6808 already reaped by reap_subprocess, but whose
6809 resources were not yet freed, because its output was
6810 not fully read yet by the time it was reaped. (This
6811 usually happens with async subprocesses whose output
6812 is being read by Emacs.) Otherwise, this process was
6813 not reaped yet, so we set its FD to a negative value
6814 to make sure sys_select will eventually get to
6815 calling the SIGCHLD handler for it, which will then
6816 invoke waitpid and reap_subprocess. */
6817 if (cp->procinfo.hProcess == NULL)
6818 delete_child (cp);
6819 else
6820 cp->fd = -1;
6825 if (fd >= 0 && fd < MAXDESC)
6826 fd_info[fd].flags = 0;
6828 /* Note that sockets do not need special treatment here (at least on
6829 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6830 closesocket is equivalent to CloseHandle, which is to be expected
6831 because socket handles are fully fledged kernel handles. */
6832 rc = _close (fd);
6834 return rc;
6838 sys_dup (int fd)
6840 int new_fd;
6842 new_fd = _dup (fd);
6843 if (new_fd >= 0 && new_fd < MAXDESC)
6845 /* duplicate our internal info as well */
6846 fd_info[new_fd] = fd_info[fd];
6848 return new_fd;
6852 sys_dup2 (int src, int dst)
6854 int rc;
6856 if (dst < 0 || dst >= MAXDESC)
6858 errno = EBADF;
6859 return -1;
6862 /* make sure we close the destination first if it's a pipe or socket */
6863 if (src != dst && fd_info[dst].flags != 0)
6864 sys_close (dst);
6866 rc = _dup2 (src, dst);
6867 if (rc == 0)
6869 /* duplicate our internal info as well */
6870 fd_info[dst] = fd_info[src];
6872 return rc;
6876 pipe2 (int * phandles, int pipe2_flags)
6878 int rc;
6879 unsigned flags;
6881 eassert (pipe2_flags == O_CLOEXEC);
6883 /* make pipe handles non-inheritable; when we spawn a child, we
6884 replace the relevant handle with an inheritable one. Also put
6885 pipes into binary mode; we will do text mode translation ourselves
6886 if required. */
6887 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
6889 if (rc == 0)
6891 /* Protect against overflow, since Windows can open more handles than
6892 our fd_info array has room for. */
6893 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
6895 _close (phandles[0]);
6896 _close (phandles[1]);
6897 errno = EMFILE;
6898 rc = -1;
6900 else
6902 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
6903 fd_info[phandles[0]].flags = flags;
6905 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
6906 fd_info[phandles[1]].flags = flags;
6910 return rc;
6913 /* Function to do blocking read of one byte, needed to implement
6914 select. It is only allowed on communication ports, sockets, or
6915 pipes. */
6917 _sys_read_ahead (int fd)
6919 child_process * cp;
6920 int rc;
6922 if (fd < 0 || fd >= MAXDESC)
6923 return STATUS_READ_ERROR;
6925 cp = fd_info[fd].cp;
6927 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
6928 return STATUS_READ_ERROR;
6930 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SERIAL | FILE_SOCKET)) == 0
6931 || (fd_info[fd].flags & FILE_READ) == 0)
6933 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd));
6934 emacs_abort ();
6937 cp->status = STATUS_READ_IN_PROGRESS;
6939 if (fd_info[fd].flags & FILE_PIPE)
6941 rc = _read (fd, &cp->chr, sizeof (char));
6943 /* Give subprocess time to buffer some more output for us before
6944 reporting that input is available; we need this because Windows 95
6945 connects DOS programs to pipes by making the pipe appear to be
6946 the normal console stdout - as a result most DOS programs will
6947 write to stdout without buffering, ie. one character at a
6948 time. Even some W32 programs do this - "dir" in a command
6949 shell on NT is very slow if we don't do this. */
6950 if (rc > 0)
6952 int wait = w32_pipe_read_delay;
6954 if (wait > 0)
6955 Sleep (wait);
6956 else if (wait < 0)
6957 while (++wait <= 0)
6958 /* Yield remainder of our time slice, effectively giving a
6959 temporary priority boost to the child process. */
6960 Sleep (0);
6963 else if (fd_info[fd].flags & FILE_SERIAL)
6965 HANDLE hnd = fd_info[fd].hnd;
6966 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
6967 COMMTIMEOUTS ct;
6969 /* Configure timeouts for blocking read. */
6970 if (!GetCommTimeouts (hnd, &ct))
6972 cp->status = STATUS_READ_ERROR;
6973 return STATUS_READ_ERROR;
6975 ct.ReadIntervalTimeout = 0;
6976 ct.ReadTotalTimeoutMultiplier = 0;
6977 ct.ReadTotalTimeoutConstant = 0;
6978 if (!SetCommTimeouts (hnd, &ct))
6980 cp->status = STATUS_READ_ERROR;
6981 return STATUS_READ_ERROR;
6984 if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
6986 if (GetLastError () != ERROR_IO_PENDING)
6988 cp->status = STATUS_READ_ERROR;
6989 return STATUS_READ_ERROR;
6991 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
6993 cp->status = STATUS_READ_ERROR;
6994 return STATUS_READ_ERROR;
6998 else if (fd_info[fd].flags & FILE_SOCKET)
7000 unsigned long nblock = 0;
7001 /* We always want this to block, so temporarily disable NDELAY. */
7002 if (fd_info[fd].flags & FILE_NDELAY)
7003 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7005 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
7007 if (fd_info[fd].flags & FILE_NDELAY)
7009 nblock = 1;
7010 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7014 if (rc == sizeof (char))
7015 cp->status = STATUS_READ_SUCCEEDED;
7016 else
7017 cp->status = STATUS_READ_FAILED;
7019 return cp->status;
7023 _sys_wait_accept (int fd)
7025 HANDLE hEv;
7026 child_process * cp;
7027 int rc;
7029 if (fd < 0 || fd >= MAXDESC)
7030 return STATUS_READ_ERROR;
7032 cp = fd_info[fd].cp;
7034 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
7035 return STATUS_READ_ERROR;
7037 cp->status = STATUS_READ_FAILED;
7039 hEv = pfn_WSACreateEvent ();
7040 rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
7041 if (rc != SOCKET_ERROR)
7043 rc = WaitForSingleObject (hEv, INFINITE);
7044 pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
7045 if (rc == WAIT_OBJECT_0)
7046 cp->status = STATUS_READ_SUCCEEDED;
7048 pfn_WSACloseEvent (hEv);
7050 return cp->status;
7054 sys_read (int fd, char * buffer, unsigned int count)
7056 int nchars;
7057 int to_read;
7058 DWORD waiting;
7059 char * orig_buffer = buffer;
7061 if (fd < 0)
7063 errno = EBADF;
7064 return -1;
7067 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
7069 child_process *cp = fd_info[fd].cp;
7071 if ((fd_info[fd].flags & FILE_READ) == 0)
7073 errno = EBADF;
7074 return -1;
7077 nchars = 0;
7079 /* re-read CR carried over from last read */
7080 if (fd_info[fd].flags & FILE_LAST_CR)
7082 if (fd_info[fd].flags & FILE_BINARY) emacs_abort ();
7083 *buffer++ = 0x0d;
7084 count--;
7085 nchars++;
7086 fd_info[fd].flags &= ~FILE_LAST_CR;
7089 /* presence of a child_process structure means we are operating in
7090 non-blocking mode - otherwise we just call _read directly.
7091 Note that the child_process structure might be missing because
7092 reap_subprocess has been called; in this case the pipe is
7093 already broken, so calling _read on it is okay. */
7094 if (cp)
7096 int current_status = cp->status;
7098 switch (current_status)
7100 case STATUS_READ_FAILED:
7101 case STATUS_READ_ERROR:
7102 /* report normal EOF if nothing in buffer */
7103 if (nchars <= 0)
7104 fd_info[fd].flags |= FILE_AT_EOF;
7105 return nchars;
7107 case STATUS_READ_READY:
7108 case STATUS_READ_IN_PROGRESS:
7109 DebPrint (("sys_read called when read is in progress\n"));
7110 errno = EWOULDBLOCK;
7111 return -1;
7113 case STATUS_READ_SUCCEEDED:
7114 /* consume read-ahead char */
7115 *buffer++ = cp->chr;
7116 count--;
7117 nchars++;
7118 cp->status = STATUS_READ_ACKNOWLEDGED;
7119 ResetEvent (cp->char_avail);
7121 case STATUS_READ_ACKNOWLEDGED:
7122 break;
7124 default:
7125 DebPrint (("sys_read: bad status %d\n", current_status));
7126 errno = EBADF;
7127 return -1;
7130 if (fd_info[fd].flags & FILE_PIPE)
7132 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
7133 to_read = min (waiting, (DWORD) count);
7135 if (to_read > 0)
7136 nchars += _read (fd, buffer, to_read);
7138 else if (fd_info[fd].flags & FILE_SERIAL)
7140 HANDLE hnd = fd_info[fd].hnd;
7141 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
7142 int rc = 0;
7143 COMMTIMEOUTS ct;
7145 if (count > 0)
7147 /* Configure timeouts for non-blocking read. */
7148 if (!GetCommTimeouts (hnd, &ct))
7150 errno = EIO;
7151 return -1;
7153 ct.ReadIntervalTimeout = MAXDWORD;
7154 ct.ReadTotalTimeoutMultiplier = 0;
7155 ct.ReadTotalTimeoutConstant = 0;
7156 if (!SetCommTimeouts (hnd, &ct))
7158 errno = EIO;
7159 return -1;
7162 if (!ResetEvent (ovl->hEvent))
7164 errno = EIO;
7165 return -1;
7167 if (!ReadFile (hnd, buffer, count, (DWORD*) &rc, ovl))
7169 if (GetLastError () != ERROR_IO_PENDING)
7171 errno = EIO;
7172 return -1;
7174 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
7176 errno = EIO;
7177 return -1;
7180 nchars += rc;
7183 else /* FILE_SOCKET */
7185 if (winsock_lib == NULL) emacs_abort ();
7187 /* do the equivalent of a non-blocking read */
7188 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
7189 if (waiting == 0 && nchars == 0)
7191 errno = EWOULDBLOCK;
7192 return -1;
7195 if (waiting)
7197 /* always use binary mode for sockets */
7198 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
7199 if (res == SOCKET_ERROR)
7201 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
7202 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
7203 set_errno ();
7204 return -1;
7206 nchars += res;
7210 else
7212 int nread = _read (fd, buffer, count);
7213 if (nread >= 0)
7214 nchars += nread;
7215 else if (nchars == 0)
7216 nchars = nread;
7219 if (nchars <= 0)
7220 fd_info[fd].flags |= FILE_AT_EOF;
7221 /* Perform text mode translation if required. */
7222 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
7224 nchars = crlf_to_lf (nchars, orig_buffer);
7225 /* If buffer contains only CR, return that. To be absolutely
7226 sure we should attempt to read the next char, but in
7227 practice a CR to be followed by LF would not appear by
7228 itself in the buffer. */
7229 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
7231 fd_info[fd].flags |= FILE_LAST_CR;
7232 nchars--;
7236 else
7237 nchars = _read (fd, buffer, count);
7239 return nchars;
7242 /* From w32xfns.c */
7243 extern HANDLE interrupt_handle;
7245 /* For now, don't bother with a non-blocking mode */
7247 sys_write (int fd, const void * buffer, unsigned int count)
7249 int nchars;
7251 if (fd < 0)
7253 errno = EBADF;
7254 return -1;
7257 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
7259 if ((fd_info[fd].flags & FILE_WRITE) == 0)
7261 errno = EBADF;
7262 return -1;
7265 /* Perform text mode translation if required. */
7266 if ((fd_info[fd].flags & FILE_BINARY) == 0)
7268 char * tmpbuf = alloca (count * 2);
7269 unsigned char * src = (void *)buffer;
7270 unsigned char * dst = tmpbuf;
7271 int nbytes = count;
7273 while (1)
7275 unsigned char *next;
7276 /* copy next line or remaining bytes */
7277 next = _memccpy (dst, src, '\n', nbytes);
7278 if (next)
7280 /* copied one line ending with '\n' */
7281 int copied = next - dst;
7282 nbytes -= copied;
7283 src += copied;
7284 /* insert '\r' before '\n' */
7285 next[-1] = '\r';
7286 next[0] = '\n';
7287 dst = next + 1;
7288 count++;
7290 else
7291 /* copied remaining partial line -> now finished */
7292 break;
7294 buffer = tmpbuf;
7298 if (fd < MAXDESC && fd_info[fd].flags & FILE_SERIAL)
7300 HANDLE hnd = (HANDLE) _get_osfhandle (fd);
7301 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_write;
7302 HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
7303 DWORD active = 0;
7305 if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
7307 if (GetLastError () != ERROR_IO_PENDING)
7309 errno = EIO;
7310 return -1;
7312 if (detect_input_pending ())
7313 active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
7314 QS_ALLINPUT);
7315 else
7316 active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
7317 if (active == WAIT_OBJECT_0)
7318 { /* User pressed C-g, cancel write, then leave. Don't bother
7319 cleaning up as we may only get stuck in buggy drivers. */
7320 PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
7321 CancelIo (hnd);
7322 errno = EIO;
7323 return -1;
7325 if (active == WAIT_OBJECT_0 + 1
7326 && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
7328 errno = EIO;
7329 return -1;
7333 else if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
7335 unsigned long nblock = 0;
7336 if (winsock_lib == NULL) emacs_abort ();
7338 /* TODO: implement select() properly so non-blocking I/O works. */
7339 /* For now, make sure the write blocks. */
7340 if (fd_info[fd].flags & FILE_NDELAY)
7341 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7343 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
7345 /* Set the socket back to non-blocking if it was before,
7346 for other operations that support it. */
7347 if (fd_info[fd].flags & FILE_NDELAY)
7349 nblock = 1;
7350 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7353 if (nchars == SOCKET_ERROR)
7355 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7356 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
7357 set_errno ();
7360 else
7362 /* Some networked filesystems don't like too large writes, so
7363 break them into smaller chunks. See the Comments section of
7364 the MSDN documentation of WriteFile for details behind the
7365 choice of the value of CHUNK below. See also the thread
7366 http://thread.gmane.org/gmane.comp.version-control.git/145294
7367 in the git mailing list. */
7368 const unsigned char *p = buffer;
7369 const unsigned chunk = 30 * 1024 * 1024;
7371 nchars = 0;
7372 while (count > 0)
7374 unsigned this_chunk = count < chunk ? count : chunk;
7375 int n = _write (fd, p, this_chunk);
7377 nchars += n;
7378 if (n < 0)
7380 nchars = n;
7381 break;
7383 else if (n < this_chunk)
7384 break;
7385 count -= n;
7386 p += n;
7390 return nchars;
7393 /* The Windows CRT functions are "optimized for speed", so they don't
7394 check for timezone and DST changes if they were last called less
7395 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7396 all Emacs features that repeatedly call time functions (e.g.,
7397 display-time) are in real danger of missing timezone and DST
7398 changes. Calling tzset before each localtime call fixes that. */
7399 struct tm *
7400 sys_localtime (const time_t *t)
7402 tzset ();
7403 return localtime (t);
7408 /* Try loading LIBRARY_ID from the file(s) specified in
7409 Vdynamic_library_alist. If the library is loaded successfully,
7410 return the handle of the DLL, and record the filename in the
7411 property :loaded-from of LIBRARY_ID. If the library could not be
7412 found, or when it was already loaded (because the handle is not
7413 recorded anywhere, and so is lost after use), return NULL.
7415 We could also save the handle in :loaded-from, but currently
7416 there's no use case for it. */
7417 HMODULE
7418 w32_delayed_load (Lisp_Object library_id)
7420 HMODULE library_dll = NULL;
7422 CHECK_SYMBOL (library_id);
7424 if (CONSP (Vdynamic_library_alist)
7425 && NILP (Fassq (library_id, Vlibrary_cache)))
7427 Lisp_Object found = Qnil;
7428 Lisp_Object dlls = Fassq (library_id, Vdynamic_library_alist);
7430 if (CONSP (dlls))
7431 for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
7433 CHECK_STRING_CAR (dlls);
7434 if ((library_dll = LoadLibrary (SDATA (XCAR (dlls)))))
7436 char name[MAX_PATH];
7437 DWORD len;
7439 len = GetModuleFileNameA (library_dll, name, sizeof (name));
7440 found = Fcons (XCAR (dlls),
7441 (len > 0)
7442 /* Possibly truncated */
7443 ? make_specified_string (name, -1, len, 1)
7444 : Qnil);
7445 break;
7449 Fput (library_id, QCloaded_from, found);
7452 return library_dll;
7456 void
7457 check_windows_init_file (void)
7459 /* A common indication that Emacs is not installed properly is when
7460 it cannot find the Windows installation file. If this file does
7461 not exist in the expected place, tell the user. */
7463 if (!noninteractive && !inhibit_window_system
7464 /* Vload_path is not yet initialized when we are loading
7465 loadup.el. */
7466 && NILP (Vpurify_flag))
7468 Lisp_Object init_file;
7469 int fd;
7471 init_file = build_string ("term/w32-win");
7472 fd = openp (Vload_path, init_file, Fget_load_suffixes (), NULL, Qnil);
7473 if (fd < 0)
7475 Lisp_Object load_path_print = Fprin1_to_string (Vload_path, Qnil);
7476 char *init_file_name = SDATA (init_file);
7477 char *load_path = SDATA (load_path_print);
7478 char *buffer = alloca (1024
7479 + strlen (init_file_name)
7480 + strlen (load_path));
7482 sprintf (buffer,
7483 "The Emacs Windows initialization file \"%s.el\" "
7484 "could not be found in your Emacs installation. "
7485 "Emacs checked the following directories for this file:\n"
7486 "\n%s\n\n"
7487 "When Emacs cannot find this file, it usually means that it "
7488 "was not installed properly, or its distribution file was "
7489 "not unpacked properly.\nSee the README.W32 file in the "
7490 "top-level Emacs directory for more information.",
7491 init_file_name, load_path);
7492 MessageBox (NULL,
7493 buffer,
7494 "Emacs Abort Dialog",
7495 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
7496 /* Use the low-level system abort. */
7497 abort ();
7499 else
7501 _close (fd);
7506 void
7507 term_ntproc (int ignored)
7509 (void)ignored;
7511 term_timers ();
7513 /* shutdown the socket interface if necessary */
7514 term_winsock ();
7516 term_w32select ();
7519 void
7520 init_ntproc (int dumping)
7522 sigset_t initial_mask = 0;
7524 /* Initialize the socket interface now if available and requested by
7525 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7526 delayed until open-network-stream is called (w32-has-winsock can
7527 also be used to dynamically load or reload winsock).
7529 Conveniently, init_environment is called before us, so
7530 PRELOAD_WINSOCK can be set in the registry. */
7532 /* Always initialize this correctly. */
7533 winsock_lib = NULL;
7535 if (getenv ("PRELOAD_WINSOCK") != NULL)
7536 init_winsock (TRUE);
7538 /* Initial preparation for subprocess support: replace our standard
7539 handles with non-inheritable versions. */
7541 HANDLE parent;
7542 HANDLE stdin_save = INVALID_HANDLE_VALUE;
7543 HANDLE stdout_save = INVALID_HANDLE_VALUE;
7544 HANDLE stderr_save = INVALID_HANDLE_VALUE;
7546 parent = GetCurrentProcess ();
7548 /* ignore errors when duplicating and closing; typically the
7549 handles will be invalid when running as a gui program. */
7550 DuplicateHandle (parent,
7551 GetStdHandle (STD_INPUT_HANDLE),
7552 parent,
7553 &stdin_save,
7555 FALSE,
7556 DUPLICATE_SAME_ACCESS);
7558 DuplicateHandle (parent,
7559 GetStdHandle (STD_OUTPUT_HANDLE),
7560 parent,
7561 &stdout_save,
7563 FALSE,
7564 DUPLICATE_SAME_ACCESS);
7566 DuplicateHandle (parent,
7567 GetStdHandle (STD_ERROR_HANDLE),
7568 parent,
7569 &stderr_save,
7571 FALSE,
7572 DUPLICATE_SAME_ACCESS);
7574 fclose (stdin);
7575 fclose (stdout);
7576 fclose (stderr);
7578 if (stdin_save != INVALID_HANDLE_VALUE)
7579 _open_osfhandle ((intptr_t) stdin_save, O_TEXT);
7580 else
7581 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
7582 _fdopen (0, "r");
7584 if (stdout_save != INVALID_HANDLE_VALUE)
7585 _open_osfhandle ((intptr_t) stdout_save, O_TEXT);
7586 else
7587 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
7588 _fdopen (1, "w");
7590 if (stderr_save != INVALID_HANDLE_VALUE)
7591 _open_osfhandle ((intptr_t) stderr_save, O_TEXT);
7592 else
7593 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
7594 _fdopen (2, "w");
7597 /* unfortunately, atexit depends on implementation of malloc */
7598 /* atexit (term_ntproc); */
7599 if (!dumping)
7601 /* Make sure we start with all signals unblocked. */
7602 sigprocmask (SIG_SETMASK, &initial_mask, NULL);
7603 signal (SIGABRT, term_ntproc);
7605 init_timers ();
7607 /* determine which drives are fixed, for GetCachedVolumeInformation */
7609 /* GetDriveType must have trailing backslash. */
7610 char drive[] = "A:\\";
7612 /* Loop over all possible drive letters */
7613 while (*drive <= 'Z')
7615 /* Record if this drive letter refers to a fixed drive. */
7616 fixed_drives[DRIVE_INDEX (*drive)] =
7617 (GetDriveType (drive) == DRIVE_FIXED);
7619 (*drive)++;
7622 /* Reset the volume info cache. */
7623 volume_cache = NULL;
7628 shutdown_handler ensures that buffers' autosave files are
7629 up to date when the user logs off, or the system shuts down.
7631 static BOOL WINAPI
7632 shutdown_handler (DWORD type)
7634 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
7635 if (type == CTRL_CLOSE_EVENT /* User closes console window. */
7636 || type == CTRL_LOGOFF_EVENT /* User logs off. */
7637 || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown. */
7639 /* Shut down cleanly, making sure autosave files are up to date. */
7640 shut_down_emacs (0, Qnil);
7643 /* Allow other handlers to handle this signal. */
7644 return FALSE;
7648 globals_of_w32 is used to initialize those global variables that
7649 must always be initialized on startup even when the global variable
7650 initialized is non zero (see the function main in emacs.c).
7652 void
7653 globals_of_w32 (void)
7655 HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
7657 get_process_times_fn = (GetProcessTimes_Proc)
7658 GetProcAddress (kernel32, "GetProcessTimes");
7660 DEFSYM (QCloaded_from, ":loaded-from");
7662 g_b_init_is_windows_9x = 0;
7663 g_b_init_open_process_token = 0;
7664 g_b_init_get_token_information = 0;
7665 g_b_init_lookup_account_sid = 0;
7666 g_b_init_get_sid_sub_authority = 0;
7667 g_b_init_get_sid_sub_authority_count = 0;
7668 g_b_init_get_security_info = 0;
7669 g_b_init_get_file_security = 0;
7670 g_b_init_get_security_descriptor_owner = 0;
7671 g_b_init_get_security_descriptor_group = 0;
7672 g_b_init_is_valid_sid = 0;
7673 g_b_init_create_toolhelp32_snapshot = 0;
7674 g_b_init_process32_first = 0;
7675 g_b_init_process32_next = 0;
7676 g_b_init_open_thread_token = 0;
7677 g_b_init_impersonate_self = 0;
7678 g_b_init_revert_to_self = 0;
7679 g_b_init_get_process_memory_info = 0;
7680 g_b_init_get_process_working_set_size = 0;
7681 g_b_init_global_memory_status = 0;
7682 g_b_init_global_memory_status_ex = 0;
7683 g_b_init_equal_sid = 0;
7684 g_b_init_copy_sid = 0;
7685 g_b_init_get_length_sid = 0;
7686 g_b_init_get_native_system_info = 0;
7687 g_b_init_get_system_times = 0;
7688 g_b_init_create_symbolic_link = 0;
7689 g_b_init_get_security_descriptor_dacl = 0;
7690 g_b_init_convert_sd_to_sddl = 0;
7691 g_b_init_convert_sddl_to_sd = 0;
7692 g_b_init_is_valid_security_descriptor = 0;
7693 g_b_init_set_file_security = 0;
7694 num_of_processors = 0;
7695 /* The following sets a handler for shutdown notifications for
7696 console apps. This actually applies to Emacs in both console and
7697 GUI modes, since we had to fool windows into thinking emacs is a
7698 console application to get console mode to work. */
7699 SetConsoleCtrlHandler (shutdown_handler, TRUE);
7701 /* "None" is the default group name on standalone workstations. */
7702 strcpy (dflt_group_name, "None");
7704 /* Reset, in case it has some value inherited from dump time. */
7705 w32_stat_get_owner_group = 0;
7708 /* For make-serial-process */
7710 serial_open (Lisp_Object port_obj)
7712 char *port = SSDATA (port_obj);
7713 HANDLE hnd;
7714 child_process *cp;
7715 int fd = -1;
7717 hnd = CreateFile (port, GENERIC_READ | GENERIC_WRITE, 0, 0,
7718 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
7719 if (hnd == INVALID_HANDLE_VALUE)
7720 error ("Could not open %s", port);
7721 fd = (int) _open_osfhandle ((intptr_t) hnd, 0);
7722 if (fd == -1)
7723 error ("Could not open %s", port);
7725 cp = new_child ();
7726 if (!cp)
7727 error ("Could not create child process");
7728 cp->fd = fd;
7729 cp->status = STATUS_READ_ACKNOWLEDGED;
7730 fd_info[ fd ].hnd = hnd;
7731 fd_info[ fd ].flags |=
7732 FILE_READ | FILE_WRITE | FILE_BINARY | FILE_SERIAL;
7733 if (fd_info[ fd ].cp != NULL)
7735 error ("fd_info[fd = %d] is already in use", fd);
7737 fd_info[ fd ].cp = cp;
7738 cp->ovl_read.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
7739 if (cp->ovl_read.hEvent == NULL)
7740 error ("Could not create read event");
7741 cp->ovl_write.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
7742 if (cp->ovl_write.hEvent == NULL)
7743 error ("Could not create write event");
7745 return fd;
7748 /* For serial-process-configure */
7749 void
7750 serial_configure (struct Lisp_Process *p, Lisp_Object contact)
7752 Lisp_Object childp2 = Qnil;
7753 Lisp_Object tem = Qnil;
7754 HANDLE hnd;
7755 DCB dcb;
7756 COMMTIMEOUTS ct;
7757 char summary[4] = "???"; /* This usually becomes "8N1". */
7759 if ((fd_info[ p->outfd ].flags & FILE_SERIAL) == 0)
7760 error ("Not a serial process");
7761 hnd = fd_info[ p->outfd ].hnd;
7763 childp2 = Fcopy_sequence (p->childp);
7765 /* Initialize timeouts for blocking read and blocking write. */
7766 if (!GetCommTimeouts (hnd, &ct))
7767 error ("GetCommTimeouts() failed");
7768 ct.ReadIntervalTimeout = 0;
7769 ct.ReadTotalTimeoutMultiplier = 0;
7770 ct.ReadTotalTimeoutConstant = 0;
7771 ct.WriteTotalTimeoutMultiplier = 0;
7772 ct.WriteTotalTimeoutConstant = 0;
7773 if (!SetCommTimeouts (hnd, &ct))
7774 error ("SetCommTimeouts() failed");
7775 /* Read port attributes and prepare default configuration. */
7776 memset (&dcb, 0, sizeof (dcb));
7777 dcb.DCBlength = sizeof (DCB);
7778 if (!GetCommState (hnd, &dcb))
7779 error ("GetCommState() failed");
7780 dcb.fBinary = TRUE;
7781 dcb.fNull = FALSE;
7782 dcb.fAbortOnError = FALSE;
7783 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7784 dcb.ErrorChar = 0;
7785 dcb.EofChar = 0;
7786 dcb.EvtChar = 0;
7788 /* Configure speed. */
7789 if (!NILP (Fplist_member (contact, QCspeed)))
7790 tem = Fplist_get (contact, QCspeed);
7791 else
7792 tem = Fplist_get (p->childp, QCspeed);
7793 CHECK_NUMBER (tem);
7794 dcb.BaudRate = XINT (tem);
7795 childp2 = Fplist_put (childp2, QCspeed, tem);
7797 /* Configure bytesize. */
7798 if (!NILP (Fplist_member (contact, QCbytesize)))
7799 tem = Fplist_get (contact, QCbytesize);
7800 else
7801 tem = Fplist_get (p->childp, QCbytesize);
7802 if (NILP (tem))
7803 tem = make_number (8);
7804 CHECK_NUMBER (tem);
7805 if (XINT (tem) != 7 && XINT (tem) != 8)
7806 error (":bytesize must be nil (8), 7, or 8");
7807 dcb.ByteSize = XINT (tem);
7808 summary[0] = XINT (tem) + '0';
7809 childp2 = Fplist_put (childp2, QCbytesize, tem);
7811 /* Configure parity. */
7812 if (!NILP (Fplist_member (contact, QCparity)))
7813 tem = Fplist_get (contact, QCparity);
7814 else
7815 tem = Fplist_get (p->childp, QCparity);
7816 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
7817 error (":parity must be nil (no parity), `even', or `odd'");
7818 dcb.fParity = FALSE;
7819 dcb.Parity = NOPARITY;
7820 dcb.fErrorChar = FALSE;
7821 if (NILP (tem))
7823 summary[1] = 'N';
7825 else if (EQ (tem, Qeven))
7827 summary[1] = 'E';
7828 dcb.fParity = TRUE;
7829 dcb.Parity = EVENPARITY;
7830 dcb.fErrorChar = TRUE;
7832 else if (EQ (tem, Qodd))
7834 summary[1] = 'O';
7835 dcb.fParity = TRUE;
7836 dcb.Parity = ODDPARITY;
7837 dcb.fErrorChar = TRUE;
7839 childp2 = Fplist_put (childp2, QCparity, tem);
7841 /* Configure stopbits. */
7842 if (!NILP (Fplist_member (contact, QCstopbits)))
7843 tem = Fplist_get (contact, QCstopbits);
7844 else
7845 tem = Fplist_get (p->childp, QCstopbits);
7846 if (NILP (tem))
7847 tem = make_number (1);
7848 CHECK_NUMBER (tem);
7849 if (XINT (tem) != 1 && XINT (tem) != 2)
7850 error (":stopbits must be nil (1 stopbit), 1, or 2");
7851 summary[2] = XINT (tem) + '0';
7852 if (XINT (tem) == 1)
7853 dcb.StopBits = ONESTOPBIT;
7854 else if (XINT (tem) == 2)
7855 dcb.StopBits = TWOSTOPBITS;
7856 childp2 = Fplist_put (childp2, QCstopbits, tem);
7858 /* Configure flowcontrol. */
7859 if (!NILP (Fplist_member (contact, QCflowcontrol)))
7860 tem = Fplist_get (contact, QCflowcontrol);
7861 else
7862 tem = Fplist_get (p->childp, QCflowcontrol);
7863 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
7864 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7865 dcb.fOutxCtsFlow = FALSE;
7866 dcb.fOutxDsrFlow = FALSE;
7867 dcb.fDtrControl = DTR_CONTROL_DISABLE;
7868 dcb.fDsrSensitivity = FALSE;
7869 dcb.fTXContinueOnXoff = FALSE;
7870 dcb.fOutX = FALSE;
7871 dcb.fInX = FALSE;
7872 dcb.fRtsControl = RTS_CONTROL_DISABLE;
7873 dcb.XonChar = 17; /* Control-Q */
7874 dcb.XoffChar = 19; /* Control-S */
7875 if (NILP (tem))
7877 /* Already configured. */
7879 else if (EQ (tem, Qhw))
7881 dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
7882 dcb.fOutxCtsFlow = TRUE;
7884 else if (EQ (tem, Qsw))
7886 dcb.fOutX = TRUE;
7887 dcb.fInX = TRUE;
7889 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
7891 /* Activate configuration. */
7892 if (!SetCommState (hnd, &dcb))
7893 error ("SetCommState() failed");
7895 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
7896 pset_childp (p, childp2);
7899 #ifdef HAVE_GNUTLS
7901 ssize_t
7902 emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
7904 int n, err;
7905 SELECT_TYPE fdset;
7906 EMACS_TIME timeout;
7907 struct Lisp_Process *process = (struct Lisp_Process *)p;
7908 int fd = process->infd;
7910 n = sys_read (fd, (char*)buf, sz);
7912 if (n >= 0)
7913 return n;
7915 err = errno;
7917 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7918 if (err == EWOULDBLOCK)
7919 err = EAGAIN;
7921 emacs_gnutls_transport_set_errno (process->gnutls_state, err);
7923 return -1;
7926 ssize_t
7927 emacs_gnutls_push (gnutls_transport_ptr_t p, const void* buf, size_t sz)
7929 struct Lisp_Process *process = (struct Lisp_Process *)p;
7930 int fd = process->outfd;
7931 ssize_t n = sys_write (fd, buf, sz);
7933 /* 0 or more bytes written means everything went fine. */
7934 if (n >= 0)
7935 return n;
7937 /* Negative bytes written means we got an error in errno.
7938 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7939 emacs_gnutls_transport_set_errno (process->gnutls_state,
7940 errno == EWOULDBLOCK ? EAGAIN : errno);
7942 return -1;
7944 #endif /* HAVE_GNUTLS */
7946 /* end of w32.c */