]> code.delx.au - gnu-emacs/blob - src/w32.c
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* lisp/emacs-lisp/lisp.el (lisp--local-variables-1): Handle `quote'.
[gnu-emacs] / src / w32.c
1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2
3 Copyright (C) 1994-1995, 2000-2014 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19
20 /*
21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 */
23
24 #include <mingw_time.h>
25 #include <stddef.h> /* for offsetof */
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <float.h> /* for DBL_EPSILON */
29 #include <io.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <ctype.h>
33 #include <signal.h>
34 #include <sys/file.h>
35 #include <time.h> /* must be before nt/inc/sys/time.h, for MinGW64 */
36 #include <sys/time.h>
37 #include <sys/utime.h>
38 #include <math.h>
39
40 /* must include CRT headers *before* config.h */
41
42 #include <config.h>
43 #include <mbstring.h> /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
44
45 #undef access
46 #undef chdir
47 #undef chmod
48 #undef creat
49 #undef ctime
50 #undef fopen
51 #undef link
52 #undef mkdir
53 #undef open
54 #undef rename
55 #undef rmdir
56 #undef unlink
57
58 #undef close
59 #undef dup
60 #undef dup2
61 #undef pipe
62 #undef read
63 #undef write
64
65 #undef strerror
66
67 #undef localtime
68
69 #include "lisp.h"
70 #include "epaths.h" /* for SHELL */
71
72 #include <pwd.h>
73 #include <grp.h>
74
75 /* MinGW64 (_W64) defines these in its _mingw.h. */
76 #if defined(__GNUC__) && !defined(_W64)
77 #define _ANONYMOUS_UNION
78 #define _ANONYMOUS_STRUCT
79 #endif
80 #include <windows.h>
81 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
82 use a different name to avoid compilation problems. */
83 typedef struct _MEMORY_STATUS_EX {
84 DWORD dwLength;
85 DWORD dwMemoryLoad;
86 DWORDLONG ullTotalPhys;
87 DWORDLONG ullAvailPhys;
88 DWORDLONG ullTotalPageFile;
89 DWORDLONG ullAvailPageFile;
90 DWORDLONG ullTotalVirtual;
91 DWORDLONG ullAvailVirtual;
92 DWORDLONG ullAvailExtendedVirtual;
93 } MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
94
95 /* These are here so that GDB would know about these data types. This
96 allows to attach GDB to Emacs when a fatal exception is triggered
97 and Windows pops up the "application needs to be closed" dialog.
98 At that point, _gnu_exception_handler, the top-level exception
99 handler installed by the MinGW startup code, is somewhere on the
100 call-stack of the main thread, so going to that call frame and
101 looking at the argument to _gnu_exception_handler, which is a
102 PEXCEPTION_POINTERS pointer, can reveal the exception code
103 (excptr->ExceptionRecord->ExceptionCode) and the address where the
104 exception happened (excptr->ExceptionRecord->ExceptionAddress), as
105 well as some additional information specific to the exception. */
106 PEXCEPTION_POINTERS excptr;
107 PEXCEPTION_RECORD excprec;
108 PCONTEXT ctxrec;
109
110 #include <lmcons.h>
111 #include <shlobj.h>
112
113 #include <tlhelp32.h>
114 #include <psapi.h>
115 #ifndef _MSC_VER
116 #include <w32api.h>
117 #endif
118 #if _WIN32_WINNT < 0x0500
119 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
120 /* This either is not in psapi.h or guarded by higher value of
121 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
122 defines it in psapi.h */
123 typedef struct _PROCESS_MEMORY_COUNTERS_EX {
124 DWORD cb;
125 DWORD PageFaultCount;
126 SIZE_T PeakWorkingSetSize;
127 SIZE_T WorkingSetSize;
128 SIZE_T QuotaPeakPagedPoolUsage;
129 SIZE_T QuotaPagedPoolUsage;
130 SIZE_T QuotaPeakNonPagedPoolUsage;
131 SIZE_T QuotaNonPagedPoolUsage;
132 SIZE_T PagefileUsage;
133 SIZE_T PeakPagefileUsage;
134 SIZE_T PrivateUsage;
135 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
136 #endif
137 #endif
138
139 #include <winioctl.h>
140 #include <aclapi.h>
141 #include <sddl.h>
142
143 #include <sys/acl.h>
144 #include <acl.h>
145
146 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
147 define them by hand if not already defined. */
148 #ifndef SDDL_REVISION_1
149 #define SDDL_REVISION_1 1
150 #endif /* SDDL_REVISION_1 */
151
152 #if defined(_MSC_VER) || defined(_W64)
153 /* MSVC and MinGW64 don't provide the definition of
154 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
155 which cannot be included because it triggers conflicts with other
156 Windows API headers. So we define it here by hand. */
157
158 typedef struct _REPARSE_DATA_BUFFER {
159 ULONG ReparseTag;
160 USHORT ReparseDataLength;
161 USHORT Reserved;
162 union {
163 struct {
164 USHORT SubstituteNameOffset;
165 USHORT SubstituteNameLength;
166 USHORT PrintNameOffset;
167 USHORT PrintNameLength;
168 ULONG Flags;
169 WCHAR PathBuffer[1];
170 } SymbolicLinkReparseBuffer;
171 struct {
172 USHORT SubstituteNameOffset;
173 USHORT SubstituteNameLength;
174 USHORT PrintNameOffset;
175 USHORT PrintNameLength;
176 WCHAR PathBuffer[1];
177 } MountPointReparseBuffer;
178 struct {
179 UCHAR DataBuffer[1];
180 } GenericReparseBuffer;
181 } DUMMYUNIONNAME;
182 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
183
184 #ifndef FILE_DEVICE_FILE_SYSTEM
185 #define FILE_DEVICE_FILE_SYSTEM 9
186 #endif
187 #ifndef METHOD_BUFFERED
188 #define METHOD_BUFFERED 0
189 #endif
190 #ifndef FILE_ANY_ACCESS
191 #define FILE_ANY_ACCESS 0x00000000
192 #endif
193 #ifndef CTL_CODE
194 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
195 #endif
196 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
197 #ifndef FSCTL_GET_REPARSE_POINT
198 #define FSCTL_GET_REPARSE_POINT \
199 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
200 #endif
201 #endif
202
203 /* TCP connection support. */
204 #include <sys/socket.h>
205 #undef socket
206 #undef bind
207 #undef connect
208 #undef htons
209 #undef ntohs
210 #undef inet_addr
211 #undef gethostname
212 #undef gethostbyname
213 #undef getservbyname
214 #undef getpeername
215 #undef shutdown
216 #undef setsockopt
217 #undef listen
218 #undef getsockname
219 #undef accept
220 #undef recvfrom
221 #undef sendto
222
223 #include <iphlpapi.h> /* should be after winsock2.h */
224
225 #include "w32.h"
226 #include <dirent.h>
227 #include "w32common.h"
228 #include "w32heap.h"
229 #include "w32select.h"
230 #include "systime.h"
231 #include "dispextern.h" /* for xstrcasecmp */
232 #include "coding.h" /* for Vlocale_coding_system */
233
234 #include "careadlinkat.h"
235 #include "allocator.h"
236
237 /* For serial_configure and serial_open. */
238 #include "process.h"
239
240 typedef HRESULT (WINAPI * ShGetFolderPath_fn)
241 (IN HWND, IN int, IN HANDLE, IN DWORD, OUT char *);
242
243 Lisp_Object QCloaded_from;
244
245 void globals_of_w32 (void);
246 static DWORD get_rid (PSID);
247 static int is_symlink (const char *);
248 static char * chase_symlinks (const char *);
249 static int enable_privilege (LPCTSTR, BOOL, TOKEN_PRIVILEGES *);
250 static int restore_privilege (TOKEN_PRIVILEGES *);
251 static BOOL WINAPI revert_to_self (void);
252
253 static int sys_access (const char *, int);
254 extern void *e_malloc (size_t);
255 extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
256 struct timespec *, void *);
257 extern int sys_dup (int);
258
259
260
261 \f
262 /* Initialization states.
263
264 WARNING: If you add any more such variables for additional APIs,
265 you MUST add initialization for them to globals_of_w32
266 below. This is because these variables might get set
267 to non-NULL values during dumping, but the dumped Emacs
268 cannot reuse those values, because it could be run on a
269 different version of the OS, where API addresses are
270 different. */
271 static BOOL g_b_init_is_windows_9x;
272 static BOOL g_b_init_open_process_token;
273 static BOOL g_b_init_get_token_information;
274 static BOOL g_b_init_lookup_account_sid;
275 static BOOL g_b_init_get_sid_sub_authority;
276 static BOOL g_b_init_get_sid_sub_authority_count;
277 static BOOL g_b_init_get_security_info;
278 static BOOL g_b_init_get_file_security_w;
279 static BOOL g_b_init_get_file_security_a;
280 static BOOL g_b_init_get_security_descriptor_owner;
281 static BOOL g_b_init_get_security_descriptor_group;
282 static BOOL g_b_init_is_valid_sid;
283 static BOOL g_b_init_create_toolhelp32_snapshot;
284 static BOOL g_b_init_process32_first;
285 static BOOL g_b_init_process32_next;
286 static BOOL g_b_init_open_thread_token;
287 static BOOL g_b_init_impersonate_self;
288 static BOOL g_b_init_revert_to_self;
289 static BOOL g_b_init_get_process_memory_info;
290 static BOOL g_b_init_get_process_working_set_size;
291 static BOOL g_b_init_global_memory_status;
292 static BOOL g_b_init_global_memory_status_ex;
293 static BOOL g_b_init_get_length_sid;
294 static BOOL g_b_init_equal_sid;
295 static BOOL g_b_init_copy_sid;
296 static BOOL g_b_init_get_native_system_info;
297 static BOOL g_b_init_get_system_times;
298 static BOOL g_b_init_create_symbolic_link_w;
299 static BOOL g_b_init_create_symbolic_link_a;
300 static BOOL g_b_init_get_security_descriptor_dacl;
301 static BOOL g_b_init_convert_sd_to_sddl;
302 static BOOL g_b_init_convert_sddl_to_sd;
303 static BOOL g_b_init_is_valid_security_descriptor;
304 static BOOL g_b_init_set_file_security_w;
305 static BOOL g_b_init_set_file_security_a;
306 static BOOL g_b_init_set_named_security_info_w;
307 static BOOL g_b_init_set_named_security_info_a;
308 static BOOL g_b_init_get_adapters_info;
309
310 /*
311 BEGIN: Wrapper functions around OpenProcessToken
312 and other functions in advapi32.dll that are only
313 supported in Windows NT / 2k / XP
314 */
315 /* ** Function pointer typedefs ** */
316 typedef BOOL (WINAPI * OpenProcessToken_Proc) (
317 HANDLE ProcessHandle,
318 DWORD DesiredAccess,
319 PHANDLE TokenHandle);
320 typedef BOOL (WINAPI * GetTokenInformation_Proc) (
321 HANDLE TokenHandle,
322 TOKEN_INFORMATION_CLASS TokenInformationClass,
323 LPVOID TokenInformation,
324 DWORD TokenInformationLength,
325 PDWORD ReturnLength);
326 typedef BOOL (WINAPI * GetProcessTimes_Proc) (
327 HANDLE process_handle,
328 LPFILETIME creation_time,
329 LPFILETIME exit_time,
330 LPFILETIME kernel_time,
331 LPFILETIME user_time);
332
333 GetProcessTimes_Proc get_process_times_fn = NULL;
334
335 #ifdef _UNICODE
336 const char * const LookupAccountSid_Name = "LookupAccountSidW";
337 #else
338 const char * const LookupAccountSid_Name = "LookupAccountSidA";
339 #endif
340 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
341 LPCTSTR lpSystemName,
342 PSID Sid,
343 LPTSTR Name,
344 LPDWORD cbName,
345 LPTSTR DomainName,
346 LPDWORD cbDomainName,
347 PSID_NAME_USE peUse);
348 typedef PDWORD (WINAPI * GetSidSubAuthority_Proc) (
349 PSID pSid,
350 DWORD n);
351 typedef PUCHAR (WINAPI * GetSidSubAuthorityCount_Proc) (
352 PSID pSid);
353 typedef DWORD (WINAPI * GetSecurityInfo_Proc) (
354 HANDLE handle,
355 SE_OBJECT_TYPE ObjectType,
356 SECURITY_INFORMATION SecurityInfo,
357 PSID *ppsidOwner,
358 PSID *ppsidGroup,
359 PACL *ppDacl,
360 PACL *ppSacl,
361 PSECURITY_DESCRIPTOR *ppSecurityDescriptor);
362 typedef BOOL (WINAPI * GetFileSecurityW_Proc) (
363 LPCWSTR lpFileName,
364 SECURITY_INFORMATION RequestedInformation,
365 PSECURITY_DESCRIPTOR pSecurityDescriptor,
366 DWORD nLength,
367 LPDWORD lpnLengthNeeded);
368 typedef BOOL (WINAPI * GetFileSecurityA_Proc) (
369 LPCSTR lpFileName,
370 SECURITY_INFORMATION RequestedInformation,
371 PSECURITY_DESCRIPTOR pSecurityDescriptor,
372 DWORD nLength,
373 LPDWORD lpnLengthNeeded);
374 typedef BOOL (WINAPI *SetFileSecurityW_Proc) (
375 LPCWSTR lpFileName,
376 SECURITY_INFORMATION SecurityInformation,
377 PSECURITY_DESCRIPTOR pSecurityDescriptor);
378 typedef BOOL (WINAPI *SetFileSecurityA_Proc) (
379 LPCSTR lpFileName,
380 SECURITY_INFORMATION SecurityInformation,
381 PSECURITY_DESCRIPTOR pSecurityDescriptor);
382 typedef DWORD (WINAPI *SetNamedSecurityInfoW_Proc) (
383 LPCWSTR lpObjectName,
384 SE_OBJECT_TYPE ObjectType,
385 SECURITY_INFORMATION SecurityInformation,
386 PSID psidOwner,
387 PSID psidGroup,
388 PACL pDacl,
389 PACL pSacl);
390 typedef DWORD (WINAPI *SetNamedSecurityInfoA_Proc) (
391 LPCSTR lpObjectName,
392 SE_OBJECT_TYPE ObjectType,
393 SECURITY_INFORMATION SecurityInformation,
394 PSID psidOwner,
395 PSID psidGroup,
396 PACL pDacl,
397 PACL pSacl);
398 typedef BOOL (WINAPI * GetSecurityDescriptorOwner_Proc) (
399 PSECURITY_DESCRIPTOR pSecurityDescriptor,
400 PSID *pOwner,
401 LPBOOL lpbOwnerDefaulted);
402 typedef BOOL (WINAPI * GetSecurityDescriptorGroup_Proc) (
403 PSECURITY_DESCRIPTOR pSecurityDescriptor,
404 PSID *pGroup,
405 LPBOOL lpbGroupDefaulted);
406 typedef BOOL (WINAPI *GetSecurityDescriptorDacl_Proc) (
407 PSECURITY_DESCRIPTOR pSecurityDescriptor,
408 LPBOOL lpbDaclPresent,
409 PACL *pDacl,
410 LPBOOL lpbDaclDefaulted);
411 typedef BOOL (WINAPI * IsValidSid_Proc) (
412 PSID sid);
413 typedef HANDLE (WINAPI * CreateToolhelp32Snapshot_Proc) (
414 DWORD dwFlags,
415 DWORD th32ProcessID);
416 typedef BOOL (WINAPI * Process32First_Proc) (
417 HANDLE hSnapshot,
418 LPPROCESSENTRY32 lppe);
419 typedef BOOL (WINAPI * Process32Next_Proc) (
420 HANDLE hSnapshot,
421 LPPROCESSENTRY32 lppe);
422 typedef BOOL (WINAPI * OpenThreadToken_Proc) (
423 HANDLE ThreadHandle,
424 DWORD DesiredAccess,
425 BOOL OpenAsSelf,
426 PHANDLE TokenHandle);
427 typedef BOOL (WINAPI * ImpersonateSelf_Proc) (
428 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
429 typedef BOOL (WINAPI * RevertToSelf_Proc) (void);
430 typedef BOOL (WINAPI * GetProcessMemoryInfo_Proc) (
431 HANDLE Process,
432 PPROCESS_MEMORY_COUNTERS ppsmemCounters,
433 DWORD cb);
434 typedef BOOL (WINAPI * GetProcessWorkingSetSize_Proc) (
435 HANDLE hProcess,
436 PSIZE_T lpMinimumWorkingSetSize,
437 PSIZE_T lpMaximumWorkingSetSize);
438 typedef BOOL (WINAPI * GlobalMemoryStatus_Proc) (
439 LPMEMORYSTATUS lpBuffer);
440 typedef BOOL (WINAPI * GlobalMemoryStatusEx_Proc) (
441 LPMEMORY_STATUS_EX lpBuffer);
442 typedef BOOL (WINAPI * CopySid_Proc) (
443 DWORD nDestinationSidLength,
444 PSID pDestinationSid,
445 PSID pSourceSid);
446 typedef BOOL (WINAPI * EqualSid_Proc) (
447 PSID pSid1,
448 PSID pSid2);
449 typedef DWORD (WINAPI * GetLengthSid_Proc) (
450 PSID pSid);
451 typedef void (WINAPI * GetNativeSystemInfo_Proc) (
452 LPSYSTEM_INFO lpSystemInfo);
453 typedef BOOL (WINAPI * GetSystemTimes_Proc) (
454 LPFILETIME lpIdleTime,
455 LPFILETIME lpKernelTime,
456 LPFILETIME lpUserTime);
457 typedef BOOLEAN (WINAPI *CreateSymbolicLinkW_Proc) (
458 LPCWSTR lpSymlinkFileName,
459 LPCWSTR lpTargetFileName,
460 DWORD dwFlags);
461 typedef BOOLEAN (WINAPI *CreateSymbolicLinkA_Proc) (
462 LPCSTR lpSymlinkFileName,
463 LPCSTR lpTargetFileName,
464 DWORD dwFlags);
465 typedef BOOL (WINAPI *ConvertStringSecurityDescriptorToSecurityDescriptor_Proc) (
466 LPCTSTR StringSecurityDescriptor,
467 DWORD StringSDRevision,
468 PSECURITY_DESCRIPTOR *SecurityDescriptor,
469 PULONG SecurityDescriptorSize);
470 typedef BOOL (WINAPI *ConvertSecurityDescriptorToStringSecurityDescriptor_Proc) (
471 PSECURITY_DESCRIPTOR SecurityDescriptor,
472 DWORD RequestedStringSDRevision,
473 SECURITY_INFORMATION SecurityInformation,
474 LPTSTR *StringSecurityDescriptor,
475 PULONG StringSecurityDescriptorLen);
476 typedef BOOL (WINAPI *IsValidSecurityDescriptor_Proc) (PSECURITY_DESCRIPTOR);
477 typedef DWORD (WINAPI *GetAdaptersInfo_Proc) (
478 PIP_ADAPTER_INFO pAdapterInfo,
479 PULONG pOutBufLen);
480
481 int (WINAPI *pMultiByteToWideChar)(UINT,DWORD,LPCSTR,int,LPWSTR,int);
482 int (WINAPI *pWideCharToMultiByte)(UINT,DWORD,LPCWSTR,int,LPSTR,int,LPCSTR,LPBOOL);
483
484 /* ** A utility function ** */
485 static BOOL
486 is_windows_9x (void)
487 {
488 static BOOL s_b_ret = 0;
489 OSVERSIONINFO os_ver;
490 if (g_b_init_is_windows_9x == 0)
491 {
492 g_b_init_is_windows_9x = 1;
493 ZeroMemory (&os_ver, sizeof (OSVERSIONINFO));
494 os_ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
495 if (GetVersionEx (&os_ver))
496 {
497 s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
498 }
499 }
500 return s_b_ret;
501 }
502
503 static Lisp_Object ltime (ULONGLONG);
504
505 /* Get total user and system times for get-internal-run-time.
506 Returns a list of integers if the times are provided by the OS
507 (NT derivatives), otherwise it returns the result of current-time. */
508 Lisp_Object
509 w32_get_internal_run_time (void)
510 {
511 if (get_process_times_fn)
512 {
513 FILETIME create, exit, kernel, user;
514 HANDLE proc = GetCurrentProcess ();
515 if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
516 {
517 LARGE_INTEGER user_int, kernel_int, total;
518 user_int.LowPart = user.dwLowDateTime;
519 user_int.HighPart = user.dwHighDateTime;
520 kernel_int.LowPart = kernel.dwLowDateTime;
521 kernel_int.HighPart = kernel.dwHighDateTime;
522 total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
523 return ltime (total.QuadPart);
524 }
525 }
526
527 return Fcurrent_time ();
528 }
529
530 /* ** The wrapper functions ** */
531
532 static BOOL WINAPI
533 open_process_token (HANDLE ProcessHandle,
534 DWORD DesiredAccess,
535 PHANDLE TokenHandle)
536 {
537 static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
538 HMODULE hm_advapi32 = NULL;
539 if (is_windows_9x () == TRUE)
540 {
541 return FALSE;
542 }
543 if (g_b_init_open_process_token == 0)
544 {
545 g_b_init_open_process_token = 1;
546 hm_advapi32 = LoadLibrary ("Advapi32.dll");
547 s_pfn_Open_Process_Token =
548 (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
549 }
550 if (s_pfn_Open_Process_Token == NULL)
551 {
552 return FALSE;
553 }
554 return (
555 s_pfn_Open_Process_Token (
556 ProcessHandle,
557 DesiredAccess,
558 TokenHandle)
559 );
560 }
561
562 static BOOL WINAPI
563 get_token_information (HANDLE TokenHandle,
564 TOKEN_INFORMATION_CLASS TokenInformationClass,
565 LPVOID TokenInformation,
566 DWORD TokenInformationLength,
567 PDWORD ReturnLength)
568 {
569 static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
570 HMODULE hm_advapi32 = NULL;
571 if (is_windows_9x () == TRUE)
572 {
573 return FALSE;
574 }
575 if (g_b_init_get_token_information == 0)
576 {
577 g_b_init_get_token_information = 1;
578 hm_advapi32 = LoadLibrary ("Advapi32.dll");
579 s_pfn_Get_Token_Information =
580 (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
581 }
582 if (s_pfn_Get_Token_Information == NULL)
583 {
584 return FALSE;
585 }
586 return (
587 s_pfn_Get_Token_Information (
588 TokenHandle,
589 TokenInformationClass,
590 TokenInformation,
591 TokenInformationLength,
592 ReturnLength)
593 );
594 }
595
596 static BOOL WINAPI
597 lookup_account_sid (LPCTSTR lpSystemName,
598 PSID Sid,
599 LPTSTR Name,
600 LPDWORD cbName,
601 LPTSTR DomainName,
602 LPDWORD cbDomainName,
603 PSID_NAME_USE peUse)
604 {
605 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
606 HMODULE hm_advapi32 = NULL;
607 if (is_windows_9x () == TRUE)
608 {
609 return FALSE;
610 }
611 if (g_b_init_lookup_account_sid == 0)
612 {
613 g_b_init_lookup_account_sid = 1;
614 hm_advapi32 = LoadLibrary ("Advapi32.dll");
615 s_pfn_Lookup_Account_Sid =
616 (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
617 }
618 if (s_pfn_Lookup_Account_Sid == NULL)
619 {
620 return FALSE;
621 }
622 return (
623 s_pfn_Lookup_Account_Sid (
624 lpSystemName,
625 Sid,
626 Name,
627 cbName,
628 DomainName,
629 cbDomainName,
630 peUse)
631 );
632 }
633
634 static PDWORD WINAPI
635 get_sid_sub_authority (PSID pSid, DWORD n)
636 {
637 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority = NULL;
638 static DWORD zero = 0U;
639 HMODULE hm_advapi32 = NULL;
640 if (is_windows_9x () == TRUE)
641 {
642 return &zero;
643 }
644 if (g_b_init_get_sid_sub_authority == 0)
645 {
646 g_b_init_get_sid_sub_authority = 1;
647 hm_advapi32 = LoadLibrary ("Advapi32.dll");
648 s_pfn_Get_Sid_Sub_Authority =
649 (GetSidSubAuthority_Proc) GetProcAddress (
650 hm_advapi32, "GetSidSubAuthority");
651 }
652 if (s_pfn_Get_Sid_Sub_Authority == NULL)
653 {
654 return &zero;
655 }
656 return (s_pfn_Get_Sid_Sub_Authority (pSid, n));
657 }
658
659 static PUCHAR WINAPI
660 get_sid_sub_authority_count (PSID pSid)
661 {
662 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count = NULL;
663 static UCHAR zero = 0U;
664 HMODULE hm_advapi32 = NULL;
665 if (is_windows_9x () == TRUE)
666 {
667 return &zero;
668 }
669 if (g_b_init_get_sid_sub_authority_count == 0)
670 {
671 g_b_init_get_sid_sub_authority_count = 1;
672 hm_advapi32 = LoadLibrary ("Advapi32.dll");
673 s_pfn_Get_Sid_Sub_Authority_Count =
674 (GetSidSubAuthorityCount_Proc) GetProcAddress (
675 hm_advapi32, "GetSidSubAuthorityCount");
676 }
677 if (s_pfn_Get_Sid_Sub_Authority_Count == NULL)
678 {
679 return &zero;
680 }
681 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid));
682 }
683
684 static DWORD WINAPI
685 get_security_info (HANDLE handle,
686 SE_OBJECT_TYPE ObjectType,
687 SECURITY_INFORMATION SecurityInfo,
688 PSID *ppsidOwner,
689 PSID *ppsidGroup,
690 PACL *ppDacl,
691 PACL *ppSacl,
692 PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
693 {
694 static GetSecurityInfo_Proc s_pfn_Get_Security_Info = NULL;
695 HMODULE hm_advapi32 = NULL;
696 if (is_windows_9x () == TRUE)
697 {
698 return FALSE;
699 }
700 if (g_b_init_get_security_info == 0)
701 {
702 g_b_init_get_security_info = 1;
703 hm_advapi32 = LoadLibrary ("Advapi32.dll");
704 s_pfn_Get_Security_Info =
705 (GetSecurityInfo_Proc) GetProcAddress (
706 hm_advapi32, "GetSecurityInfo");
707 }
708 if (s_pfn_Get_Security_Info == NULL)
709 {
710 return FALSE;
711 }
712 return (s_pfn_Get_Security_Info (handle, ObjectType, SecurityInfo,
713 ppsidOwner, ppsidGroup, ppDacl, ppSacl,
714 ppSecurityDescriptor));
715 }
716
717 static BOOL WINAPI
718 get_file_security (const char *lpFileName,
719 SECURITY_INFORMATION RequestedInformation,
720 PSECURITY_DESCRIPTOR pSecurityDescriptor,
721 DWORD nLength,
722 LPDWORD lpnLengthNeeded)
723 {
724 static GetFileSecurityA_Proc s_pfn_Get_File_SecurityA = NULL;
725 static GetFileSecurityW_Proc s_pfn_Get_File_SecurityW = NULL;
726 HMODULE hm_advapi32 = NULL;
727 if (is_windows_9x () == TRUE)
728 {
729 errno = ENOTSUP;
730 return FALSE;
731 }
732 if (w32_unicode_filenames)
733 {
734 wchar_t filename_w[MAX_PATH];
735
736 if (g_b_init_get_file_security_w == 0)
737 {
738 g_b_init_get_file_security_w = 1;
739 hm_advapi32 = LoadLibrary ("Advapi32.dll");
740 s_pfn_Get_File_SecurityW =
741 (GetFileSecurityW_Proc) GetProcAddress (hm_advapi32,
742 "GetFileSecurityW");
743 }
744 if (s_pfn_Get_File_SecurityW == NULL)
745 {
746 errno = ENOTSUP;
747 return FALSE;
748 }
749 filename_to_utf16 (lpFileName, filename_w);
750 return (s_pfn_Get_File_SecurityW (filename_w, RequestedInformation,
751 pSecurityDescriptor, nLength,
752 lpnLengthNeeded));
753 }
754 else
755 {
756 char filename_a[MAX_PATH];
757
758 if (g_b_init_get_file_security_a == 0)
759 {
760 g_b_init_get_file_security_a = 1;
761 hm_advapi32 = LoadLibrary ("Advapi32.dll");
762 s_pfn_Get_File_SecurityA =
763 (GetFileSecurityA_Proc) GetProcAddress (hm_advapi32,
764 "GetFileSecurityA");
765 }
766 if (s_pfn_Get_File_SecurityA == NULL)
767 {
768 errno = ENOTSUP;
769 return FALSE;
770 }
771 filename_to_ansi (lpFileName, filename_a);
772 return (s_pfn_Get_File_SecurityA (filename_a, RequestedInformation,
773 pSecurityDescriptor, nLength,
774 lpnLengthNeeded));
775 }
776 }
777
778 static BOOL WINAPI
779 set_file_security (const char *lpFileName,
780 SECURITY_INFORMATION SecurityInformation,
781 PSECURITY_DESCRIPTOR pSecurityDescriptor)
782 {
783 static SetFileSecurityW_Proc s_pfn_Set_File_SecurityW = NULL;
784 static SetFileSecurityA_Proc s_pfn_Set_File_SecurityA = NULL;
785 HMODULE hm_advapi32 = NULL;
786 if (is_windows_9x () == TRUE)
787 {
788 errno = ENOTSUP;
789 return FALSE;
790 }
791 if (w32_unicode_filenames)
792 {
793 wchar_t filename_w[MAX_PATH];
794
795 if (g_b_init_set_file_security_w == 0)
796 {
797 g_b_init_set_file_security_w = 1;
798 hm_advapi32 = LoadLibrary ("Advapi32.dll");
799 s_pfn_Set_File_SecurityW =
800 (SetFileSecurityW_Proc) GetProcAddress (hm_advapi32,
801 "SetFileSecurityW");
802 }
803 if (s_pfn_Set_File_SecurityW == NULL)
804 {
805 errno = ENOTSUP;
806 return FALSE;
807 }
808 filename_to_utf16 (lpFileName, filename_w);
809 return (s_pfn_Set_File_SecurityW (filename_w, SecurityInformation,
810 pSecurityDescriptor));
811 }
812 else
813 {
814 char filename_a[MAX_PATH];
815
816 if (g_b_init_set_file_security_a == 0)
817 {
818 g_b_init_set_file_security_a = 1;
819 hm_advapi32 = LoadLibrary ("Advapi32.dll");
820 s_pfn_Set_File_SecurityA =
821 (SetFileSecurityA_Proc) GetProcAddress (hm_advapi32,
822 "SetFileSecurityA");
823 }
824 if (s_pfn_Set_File_SecurityA == NULL)
825 {
826 errno = ENOTSUP;
827 return FALSE;
828 }
829 filename_to_ansi (lpFileName, filename_a);
830 return (s_pfn_Set_File_SecurityA (filename_a, SecurityInformation,
831 pSecurityDescriptor));
832 }
833 }
834
835 static DWORD WINAPI
836 set_named_security_info (LPCTSTR lpObjectName,
837 SE_OBJECT_TYPE ObjectType,
838 SECURITY_INFORMATION SecurityInformation,
839 PSID psidOwner,
840 PSID psidGroup,
841 PACL pDacl,
842 PACL pSacl)
843 {
844 static SetNamedSecurityInfoW_Proc s_pfn_Set_Named_Security_InfoW = NULL;
845 static SetNamedSecurityInfoA_Proc s_pfn_Set_Named_Security_InfoA = NULL;
846 HMODULE hm_advapi32 = NULL;
847 if (is_windows_9x () == TRUE)
848 {
849 errno = ENOTSUP;
850 return ENOTSUP;
851 }
852 if (w32_unicode_filenames)
853 {
854 wchar_t filename_w[MAX_PATH];
855
856 if (g_b_init_set_named_security_info_w == 0)
857 {
858 g_b_init_set_named_security_info_w = 1;
859 hm_advapi32 = LoadLibrary ("Advapi32.dll");
860 s_pfn_Set_Named_Security_InfoW =
861 (SetNamedSecurityInfoW_Proc) GetProcAddress (hm_advapi32,
862 "SetNamedSecurityInfoW");
863 }
864 if (s_pfn_Set_Named_Security_InfoW == NULL)
865 {
866 errno = ENOTSUP;
867 return ENOTSUP;
868 }
869 filename_to_utf16 (lpObjectName, filename_w);
870 return (s_pfn_Set_Named_Security_InfoW (filename_w, ObjectType,
871 SecurityInformation, psidOwner,
872 psidGroup, pDacl, pSacl));
873 }
874 else
875 {
876 char filename_a[MAX_PATH];
877
878 if (g_b_init_set_named_security_info_a == 0)
879 {
880 g_b_init_set_named_security_info_a = 1;
881 hm_advapi32 = LoadLibrary ("Advapi32.dll");
882 s_pfn_Set_Named_Security_InfoA =
883 (SetNamedSecurityInfoA_Proc) GetProcAddress (hm_advapi32,
884 "SetNamedSecurityInfoA");
885 }
886 if (s_pfn_Set_Named_Security_InfoA == NULL)
887 {
888 errno = ENOTSUP;
889 return ENOTSUP;
890 }
891 filename_to_ansi (lpObjectName, filename_a);
892 return (s_pfn_Set_Named_Security_InfoA (filename_a, ObjectType,
893 SecurityInformation, psidOwner,
894 psidGroup, pDacl, pSacl));
895 }
896 }
897
898 static BOOL WINAPI
899 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
900 PSID *pOwner,
901 LPBOOL lpbOwnerDefaulted)
902 {
903 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner = NULL;
904 HMODULE hm_advapi32 = NULL;
905 if (is_windows_9x () == TRUE)
906 {
907 errno = ENOTSUP;
908 return FALSE;
909 }
910 if (g_b_init_get_security_descriptor_owner == 0)
911 {
912 g_b_init_get_security_descriptor_owner = 1;
913 hm_advapi32 = LoadLibrary ("Advapi32.dll");
914 s_pfn_Get_Security_Descriptor_Owner =
915 (GetSecurityDescriptorOwner_Proc) GetProcAddress (
916 hm_advapi32, "GetSecurityDescriptorOwner");
917 }
918 if (s_pfn_Get_Security_Descriptor_Owner == NULL)
919 {
920 errno = ENOTSUP;
921 return FALSE;
922 }
923 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor, pOwner,
924 lpbOwnerDefaulted));
925 }
926
927 static BOOL WINAPI
928 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
929 PSID *pGroup,
930 LPBOOL lpbGroupDefaulted)
931 {
932 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group = NULL;
933 HMODULE hm_advapi32 = NULL;
934 if (is_windows_9x () == TRUE)
935 {
936 errno = ENOTSUP;
937 return FALSE;
938 }
939 if (g_b_init_get_security_descriptor_group == 0)
940 {
941 g_b_init_get_security_descriptor_group = 1;
942 hm_advapi32 = LoadLibrary ("Advapi32.dll");
943 s_pfn_Get_Security_Descriptor_Group =
944 (GetSecurityDescriptorGroup_Proc) GetProcAddress (
945 hm_advapi32, "GetSecurityDescriptorGroup");
946 }
947 if (s_pfn_Get_Security_Descriptor_Group == NULL)
948 {
949 errno = ENOTSUP;
950 return FALSE;
951 }
952 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor, pGroup,
953 lpbGroupDefaulted));
954 }
955
956 static BOOL WINAPI
957 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor,
958 LPBOOL lpbDaclPresent,
959 PACL *pDacl,
960 LPBOOL lpbDaclDefaulted)
961 {
962 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl = NULL;
963 HMODULE hm_advapi32 = NULL;
964 if (is_windows_9x () == TRUE)
965 {
966 errno = ENOTSUP;
967 return FALSE;
968 }
969 if (g_b_init_get_security_descriptor_dacl == 0)
970 {
971 g_b_init_get_security_descriptor_dacl = 1;
972 hm_advapi32 = LoadLibrary ("Advapi32.dll");
973 s_pfn_Get_Security_Descriptor_Dacl =
974 (GetSecurityDescriptorDacl_Proc) GetProcAddress (
975 hm_advapi32, "GetSecurityDescriptorDacl");
976 }
977 if (s_pfn_Get_Security_Descriptor_Dacl == NULL)
978 {
979 errno = ENOTSUP;
980 return FALSE;
981 }
982 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor,
983 lpbDaclPresent, pDacl,
984 lpbDaclDefaulted));
985 }
986
987 static BOOL WINAPI
988 is_valid_sid (PSID sid)
989 {
990 static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
991 HMODULE hm_advapi32 = NULL;
992 if (is_windows_9x () == TRUE)
993 {
994 return FALSE;
995 }
996 if (g_b_init_is_valid_sid == 0)
997 {
998 g_b_init_is_valid_sid = 1;
999 hm_advapi32 = LoadLibrary ("Advapi32.dll");
1000 s_pfn_Is_Valid_Sid =
1001 (IsValidSid_Proc) GetProcAddress (
1002 hm_advapi32, "IsValidSid");
1003 }
1004 if (s_pfn_Is_Valid_Sid == NULL)
1005 {
1006 return FALSE;
1007 }
1008 return (s_pfn_Is_Valid_Sid (sid));
1009 }
1010
1011 static BOOL WINAPI
1012 equal_sid (PSID sid1, PSID sid2)
1013 {
1014 static EqualSid_Proc s_pfn_Equal_Sid = NULL;
1015 HMODULE hm_advapi32 = NULL;
1016 if (is_windows_9x () == TRUE)
1017 {
1018 return FALSE;
1019 }
1020 if (g_b_init_equal_sid == 0)
1021 {
1022 g_b_init_equal_sid = 1;
1023 hm_advapi32 = LoadLibrary ("Advapi32.dll");
1024 s_pfn_Equal_Sid =
1025 (EqualSid_Proc) GetProcAddress (
1026 hm_advapi32, "EqualSid");
1027 }
1028 if (s_pfn_Equal_Sid == NULL)
1029 {
1030 return FALSE;
1031 }
1032 return (s_pfn_Equal_Sid (sid1, sid2));
1033 }
1034
1035 static DWORD WINAPI
1036 get_length_sid (PSID sid)
1037 {
1038 static GetLengthSid_Proc s_pfn_Get_Length_Sid = NULL;
1039 HMODULE hm_advapi32 = NULL;
1040 if (is_windows_9x () == TRUE)
1041 {
1042 return 0;
1043 }
1044 if (g_b_init_get_length_sid == 0)
1045 {
1046 g_b_init_get_length_sid = 1;
1047 hm_advapi32 = LoadLibrary ("Advapi32.dll");
1048 s_pfn_Get_Length_Sid =
1049 (GetLengthSid_Proc) GetProcAddress (
1050 hm_advapi32, "GetLengthSid");
1051 }
1052 if (s_pfn_Get_Length_Sid == NULL)
1053 {
1054 return 0;
1055 }
1056 return (s_pfn_Get_Length_Sid (sid));
1057 }
1058
1059 static BOOL WINAPI
1060 copy_sid (DWORD destlen, PSID dest, PSID src)
1061 {
1062 static CopySid_Proc s_pfn_Copy_Sid = NULL;
1063 HMODULE hm_advapi32 = NULL;
1064 if (is_windows_9x () == TRUE)
1065 {
1066 return FALSE;
1067 }
1068 if (g_b_init_copy_sid == 0)
1069 {
1070 g_b_init_copy_sid = 1;
1071 hm_advapi32 = LoadLibrary ("Advapi32.dll");
1072 s_pfn_Copy_Sid =
1073 (CopySid_Proc) GetProcAddress (
1074 hm_advapi32, "CopySid");
1075 }
1076 if (s_pfn_Copy_Sid == NULL)
1077 {
1078 return FALSE;
1079 }
1080 return (s_pfn_Copy_Sid (destlen, dest, src));
1081 }
1082
1083 /*
1084 END: Wrapper functions around OpenProcessToken
1085 and other functions in advapi32.dll that are only
1086 supported in Windows NT / 2k / XP
1087 */
1088
1089 static void WINAPI
1090 get_native_system_info (LPSYSTEM_INFO lpSystemInfo)
1091 {
1092 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info = NULL;
1093 if (is_windows_9x () != TRUE)
1094 {
1095 if (g_b_init_get_native_system_info == 0)
1096 {
1097 g_b_init_get_native_system_info = 1;
1098 s_pfn_Get_Native_System_Info =
1099 (GetNativeSystemInfo_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1100 "GetNativeSystemInfo");
1101 }
1102 if (s_pfn_Get_Native_System_Info != NULL)
1103 s_pfn_Get_Native_System_Info (lpSystemInfo);
1104 }
1105 else
1106 lpSystemInfo->dwNumberOfProcessors = -1;
1107 }
1108
1109 static BOOL WINAPI
1110 get_system_times (LPFILETIME lpIdleTime,
1111 LPFILETIME lpKernelTime,
1112 LPFILETIME lpUserTime)
1113 {
1114 static GetSystemTimes_Proc s_pfn_Get_System_times = NULL;
1115 if (is_windows_9x () == TRUE)
1116 {
1117 return FALSE;
1118 }
1119 if (g_b_init_get_system_times == 0)
1120 {
1121 g_b_init_get_system_times = 1;
1122 s_pfn_Get_System_times =
1123 (GetSystemTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1124 "GetSystemTimes");
1125 }
1126 if (s_pfn_Get_System_times == NULL)
1127 return FALSE;
1128 return (s_pfn_Get_System_times (lpIdleTime, lpKernelTime, lpUserTime));
1129 }
1130
1131 static BOOLEAN WINAPI
1132 create_symbolic_link (LPCSTR lpSymlinkFilename,
1133 LPCSTR lpTargetFileName,
1134 DWORD dwFlags)
1135 {
1136 static CreateSymbolicLinkW_Proc s_pfn_Create_Symbolic_LinkW = NULL;
1137 static CreateSymbolicLinkA_Proc s_pfn_Create_Symbolic_LinkA = NULL;
1138 BOOLEAN retval;
1139
1140 if (is_windows_9x () == TRUE)
1141 {
1142 errno = ENOSYS;
1143 return 0;
1144 }
1145 if (w32_unicode_filenames)
1146 {
1147 wchar_t symfn_w[MAX_PATH], tgtfn_w[MAX_PATH];
1148
1149 if (g_b_init_create_symbolic_link_w == 0)
1150 {
1151 g_b_init_create_symbolic_link_w = 1;
1152 s_pfn_Create_Symbolic_LinkW =
1153 (CreateSymbolicLinkW_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1154 "CreateSymbolicLinkW");
1155 }
1156 if (s_pfn_Create_Symbolic_LinkW == NULL)
1157 {
1158 errno = ENOSYS;
1159 return 0;
1160 }
1161
1162 filename_to_utf16 (lpSymlinkFilename, symfn_w);
1163 filename_to_utf16 (lpTargetFileName, tgtfn_w);
1164 retval = s_pfn_Create_Symbolic_LinkW (symfn_w, tgtfn_w, dwFlags);
1165 /* If we were denied creation of the symlink, try again after
1166 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1167 if (!retval)
1168 {
1169 TOKEN_PRIVILEGES priv_current;
1170
1171 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME, TRUE,
1172 &priv_current))
1173 {
1174 retval = s_pfn_Create_Symbolic_LinkW (symfn_w, tgtfn_w, dwFlags);
1175 restore_privilege (&priv_current);
1176 revert_to_self ();
1177 }
1178 }
1179 }
1180 else
1181 {
1182 char symfn_a[MAX_PATH], tgtfn_a[MAX_PATH];
1183
1184 if (g_b_init_create_symbolic_link_a == 0)
1185 {
1186 g_b_init_create_symbolic_link_a = 1;
1187 s_pfn_Create_Symbolic_LinkA =
1188 (CreateSymbolicLinkA_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1189 "CreateSymbolicLinkA");
1190 }
1191 if (s_pfn_Create_Symbolic_LinkA == NULL)
1192 {
1193 errno = ENOSYS;
1194 return 0;
1195 }
1196
1197 filename_to_ansi (lpSymlinkFilename, symfn_a);
1198 filename_to_ansi (lpTargetFileName, tgtfn_a);
1199 retval = s_pfn_Create_Symbolic_LinkA (symfn_a, tgtfn_a, dwFlags);
1200 /* If we were denied creation of the symlink, try again after
1201 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1202 if (!retval)
1203 {
1204 TOKEN_PRIVILEGES priv_current;
1205
1206 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME, TRUE,
1207 &priv_current))
1208 {
1209 retval = s_pfn_Create_Symbolic_LinkA (symfn_a, tgtfn_a, dwFlags);
1210 restore_privilege (&priv_current);
1211 revert_to_self ();
1212 }
1213 }
1214 }
1215 return retval;
1216 }
1217
1218 static BOOL WINAPI
1219 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor)
1220 {
1221 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc = NULL;
1222
1223 if (is_windows_9x () == TRUE)
1224 {
1225 errno = ENOTSUP;
1226 return FALSE;
1227 }
1228
1229 if (g_b_init_is_valid_security_descriptor == 0)
1230 {
1231 g_b_init_is_valid_security_descriptor = 1;
1232 s_pfn_Is_Valid_Security_Descriptor_Proc =
1233 (IsValidSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1234 "IsValidSecurityDescriptor");
1235 }
1236 if (s_pfn_Is_Valid_Security_Descriptor_Proc == NULL)
1237 {
1238 errno = ENOTSUP;
1239 return FALSE;
1240 }
1241
1242 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor);
1243 }
1244
1245 static BOOL WINAPI
1246 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor,
1247 DWORD RequestedStringSDRevision,
1248 SECURITY_INFORMATION SecurityInformation,
1249 LPTSTR *StringSecurityDescriptor,
1250 PULONG StringSecurityDescriptorLen)
1251 {
1252 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL = NULL;
1253 BOOL retval;
1254
1255 if (is_windows_9x () == TRUE)
1256 {
1257 errno = ENOTSUP;
1258 return FALSE;
1259 }
1260
1261 if (g_b_init_convert_sd_to_sddl == 0)
1262 {
1263 g_b_init_convert_sd_to_sddl = 1;
1264 #ifdef _UNICODE
1265 s_pfn_Convert_SD_To_SDDL =
1266 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1267 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1268 #else
1269 s_pfn_Convert_SD_To_SDDL =
1270 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1271 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1272 #endif
1273 }
1274 if (s_pfn_Convert_SD_To_SDDL == NULL)
1275 {
1276 errno = ENOTSUP;
1277 return FALSE;
1278 }
1279
1280 retval = s_pfn_Convert_SD_To_SDDL (SecurityDescriptor,
1281 RequestedStringSDRevision,
1282 SecurityInformation,
1283 StringSecurityDescriptor,
1284 StringSecurityDescriptorLen);
1285
1286 return retval;
1287 }
1288
1289 static BOOL WINAPI
1290 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor,
1291 DWORD StringSDRevision,
1292 PSECURITY_DESCRIPTOR *SecurityDescriptor,
1293 PULONG SecurityDescriptorSize)
1294 {
1295 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD = NULL;
1296 BOOL retval;
1297
1298 if (is_windows_9x () == TRUE)
1299 {
1300 errno = ENOTSUP;
1301 return FALSE;
1302 }
1303
1304 if (g_b_init_convert_sddl_to_sd == 0)
1305 {
1306 g_b_init_convert_sddl_to_sd = 1;
1307 #ifdef _UNICODE
1308 s_pfn_Convert_SDDL_To_SD =
1309 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1310 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1311 #else
1312 s_pfn_Convert_SDDL_To_SD =
1313 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1314 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1315 #endif
1316 }
1317 if (s_pfn_Convert_SDDL_To_SD == NULL)
1318 {
1319 errno = ENOTSUP;
1320 return FALSE;
1321 }
1322
1323 retval = s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor,
1324 StringSDRevision,
1325 SecurityDescriptor,
1326 SecurityDescriptorSize);
1327
1328 return retval;
1329 }
1330
1331 static DWORD WINAPI
1332 get_adapters_info (PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
1333 {
1334 static GetAdaptersInfo_Proc s_pfn_Get_Adapters_Info = NULL;
1335 HMODULE hm_iphlpapi = NULL;
1336
1337 if (is_windows_9x () == TRUE)
1338 return ERROR_NOT_SUPPORTED;
1339
1340 if (g_b_init_get_adapters_info == 0)
1341 {
1342 g_b_init_get_adapters_info = 1;
1343 hm_iphlpapi = LoadLibrary ("Iphlpapi.dll");
1344 if (hm_iphlpapi)
1345 s_pfn_Get_Adapters_Info = (GetAdaptersInfo_Proc)
1346 GetProcAddress (hm_iphlpapi, "GetAdaptersInfo");
1347 }
1348 if (s_pfn_Get_Adapters_Info == NULL)
1349 return ERROR_NOT_SUPPORTED;
1350 return s_pfn_Get_Adapters_Info (pAdapterInfo, pOutBufLen);
1351 }
1352
1353 \f
1354
1355 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1356 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1357
1358 This is called from alloc.c:valid_pointer_p. */
1359 int
1360 w32_valid_pointer_p (void *p, int size)
1361 {
1362 SIZE_T done;
1363 HANDLE h = OpenProcess (PROCESS_VM_READ, FALSE, GetCurrentProcessId ());
1364
1365 if (h)
1366 {
1367 unsigned char *buf = alloca (size);
1368 int retval = ReadProcessMemory (h, p, buf, size, &done);
1369
1370 CloseHandle (h);
1371 return retval;
1372 }
1373 else
1374 return -1;
1375 }
1376
1377 \f
1378
1379 /* Here's an overview of how the Windows build supports file names
1380 that cannot be encoded by the current system codepage.
1381
1382 From the POV of Lisp and layers of C code above the functions here,
1383 Emacs on Windows pretends that its file names are encoded in UTF-8;
1384 see encode_file and decode_file on coding.c. Any file name that is
1385 passed as a unibyte string to C functions defined here is assumed
1386 to be in UTF-8 encoding. Any file name returned by functions
1387 defined here must be in UTF-8 encoding, with only a few exceptions
1388 reserved for a couple of special cases. (Be sure to use
1389 MAX_UTF8_PATH for char arrays that store UTF-8 encoded file names,
1390 as they can be much longer than MAX_PATH!)
1391
1392 The UTF-8 encoded file names cannot be passed to system APIs, as
1393 Windows does not support that. Therefore, they are converted
1394 either to UTF-16 or to the ANSI codepage, depending on the value of
1395 w32-unicode-filenames, before calling any system APIs or CRT library
1396 functions. The default value of that variable is determined by the
1397 OS on which Emacs runs: nil on Windows 9X and t otherwise, but the
1398 user can change that default (although I don't see why would she
1399 want to).
1400
1401 The 4 functions defined below, filename_to_utf16, filename_to_ansi,
1402 filename_from_utf16, and filename_from_ansi, are the workhorses of
1403 these conversions. They rely on Windows native APIs
1404 MultiByteToWideChar and WideCharToMultiByte; we cannot use
1405 functions from coding.c here, because they allocate memory, which
1406 is a bad idea on the level of libc, which is what the functions
1407 here emulate. (If you worry about performance due to constant
1408 conversion back and forth from UTF-8 to UTF-16, then don't: first,
1409 it was measured to take only a few microseconds on a not-so-fast
1410 machine, and second, that's exactly what the ANSI APIs we used
1411 before did anyway, because they are just thin wrappers around the
1412 Unicode APIs.)
1413
1414 The variables file-name-coding-system and default-file-name-coding-system
1415 still exist, but are actually used only when a file name needs to
1416 be converted to the ANSI codepage. This happens all the time when
1417 w32-unicode-filenames is nil, but can also happen from time to time
1418 when it is t. Otherwise, these variables have no effect on file-name
1419 encoding when w32-unicode-filenames is t; this is similar to
1420 selection-coding-system.
1421
1422 This arrangement works very well, but it has a few gotchas and
1423 limitations:
1424
1425 . Lisp code that encodes or decodes file names manually should
1426 normally use 'utf-8' as the coding-system on Windows,
1427 disregarding file-name-coding-system. This is a somewhat
1428 unpleasant consequence, but it cannot be avoided. Fortunately,
1429 very few Lisp packages need to do that.
1430
1431 More generally, passing to library functions (e.g., fopen or
1432 opendir) file names already encoded in the ANSI codepage is
1433 explicitly *verboten*, as all those functions, as shadowed and
1434 emulated here, assume they will receive UTF-8 encoded file names.
1435
1436 For the same reasons, no CRT function or Win32 API can be called
1437 directly in Emacs sources, without either converting the file
1438 names from UTF-8 to UTF-16 or ANSI codepage, or going through
1439 some shadowing function defined here.
1440
1441 . Environment variables stored in Vprocess_environment are encoded
1442 in the ANSI codepage, so if getenv/egetenv is used for a variable
1443 whose value is a file name or a list of directories, it needs to
1444 be converted to UTF-8, before it is used as argument to functions
1445 or decoded into a Lisp string.
1446
1447 . File names passed to external libraries, like the image libraries
1448 and GnuTLS, need special handling. These libraries generally
1449 don't support UTF-16 or UTF-8 file names, so they must get file
1450 names encoded in the ANSI codepage. To facilitate using these
1451 libraries with file names that are not encodable in the ANSI
1452 codepage, use the function ansi_encode_filename, which will try
1453 to use the short 8+3 alias of a file name if that file name is
1454 not encodable in the ANSI codepage. See image.c and gnutls.c for
1455 examples of how this should be done.
1456
1457 . Running subprocesses in non-ASCII directories and with non-ASCII
1458 file arguments is limited to the current codepage (even though
1459 Emacs is perfectly capable of finding an executable program file
1460 in a directory whose name cannot be encoded in the current
1461 codepage). This is because the command-line arguments are
1462 encoded _before_ they get to the w32-specific level, and the
1463 encoding is not known in advance (it doesn't have to be the
1464 current ANSI codepage), so w32proc.c functions cannot re-encode
1465 them in UTF-16. This should be fixed, but will also require
1466 changes in cmdproxy. The current limitation is not terribly bad
1467 anyway, since very few, if any, Windows console programs that are
1468 likely to be invoked by Emacs support UTF-16 encoded command
1469 lines.
1470
1471 . For similar reasons, server.el and emacsclient are also limited
1472 to the current ANSI codepage for now.
1473
1474 . Emacs itself can only handle command-line arguments encoded in
1475 the current codepage.
1476
1477 . Turning on w32-unicode-filename on Windows 9X (if it at all
1478 works) requires UNICOWS.DLL, which is thus a requirement even in
1479 non-GUI sessions, something the we previously avoided. */
1480
1481 \f
1482
1483 /* Converting file names from UTF-8 to either UTF-16 or the ANSI
1484 codepage defined by file-name-coding-system. */
1485
1486 /* Current codepage for encoding file names. */
1487 static int file_name_codepage;
1488
1489 /* Produce a Windows ANSI codepage suitable for encoding file names.
1490 Return the information about that codepage in CP_INFO. */
1491 static int
1492 codepage_for_filenames (CPINFO *cp_info)
1493 {
1494 /* A simple cache to avoid calling GetCPInfo every time we need to
1495 encode/decode a file name. The file-name encoding is not
1496 supposed to be changed too frequently, if ever. */
1497 static Lisp_Object last_file_name_encoding;
1498 static CPINFO cp;
1499 Lisp_Object current_encoding;
1500
1501 current_encoding = Vfile_name_coding_system;
1502 if (NILP (current_encoding))
1503 current_encoding = Vdefault_file_name_coding_system;
1504
1505 if (!EQ (last_file_name_encoding, current_encoding))
1506 {
1507 /* Default to the current ANSI codepage. */
1508 file_name_codepage = w32_ansi_code_page;
1509
1510 if (NILP (current_encoding))
1511 {
1512 char *cpname = SDATA (SYMBOL_NAME (current_encoding));
1513 char *cp = NULL, *end;
1514 int cpnum;
1515
1516 if (strncmp (cpname, "cp", 2) == 0)
1517 cp = cpname + 2;
1518 else if (strncmp (cpname, "windows-", 8) == 0)
1519 cp = cpname + 8;
1520
1521 if (cp)
1522 {
1523 end = cp;
1524 cpnum = strtol (cp, &end, 10);
1525 if (cpnum && *end == '\0' && end - cp >= 2)
1526 file_name_codepage = cpnum;
1527 }
1528 }
1529
1530 if (!file_name_codepage)
1531 file_name_codepage = CP_ACP; /* CP_ACP = 0, but let's not assume that */
1532
1533 if (!GetCPInfo (file_name_codepage, &cp))
1534 {
1535 file_name_codepage = CP_ACP;
1536 if (!GetCPInfo (file_name_codepage, &cp))
1537 emacs_abort ();
1538 }
1539 }
1540 if (cp_info)
1541 *cp_info = cp;
1542
1543 return file_name_codepage;
1544 }
1545
1546 int
1547 filename_to_utf16 (const char *fn_in, wchar_t *fn_out)
1548 {
1549 int result = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, fn_in, -1,
1550 fn_out, MAX_PATH);
1551
1552 if (!result)
1553 {
1554 DWORD err = GetLastError ();
1555
1556 switch (err)
1557 {
1558 case ERROR_INVALID_FLAGS:
1559 case ERROR_INVALID_PARAMETER:
1560 errno = EINVAL;
1561 break;
1562 case ERROR_INSUFFICIENT_BUFFER:
1563 case ERROR_NO_UNICODE_TRANSLATION:
1564 default:
1565 errno = ENOENT;
1566 break;
1567 }
1568 return -1;
1569 }
1570 return 0;
1571 }
1572
1573 int
1574 filename_from_utf16 (const wchar_t *fn_in, char *fn_out)
1575 {
1576 int result = pWideCharToMultiByte (CP_UTF8, 0, fn_in, -1,
1577 fn_out, MAX_UTF8_PATH, NULL, NULL);
1578
1579 if (!result)
1580 {
1581 DWORD err = GetLastError ();
1582
1583 switch (err)
1584 {
1585 case ERROR_INVALID_FLAGS:
1586 case ERROR_INVALID_PARAMETER:
1587 errno = EINVAL;
1588 break;
1589 case ERROR_INSUFFICIENT_BUFFER:
1590 case ERROR_NO_UNICODE_TRANSLATION:
1591 default:
1592 errno = ENOENT;
1593 break;
1594 }
1595 return -1;
1596 }
1597 return 0;
1598 }
1599
1600 int
1601 filename_to_ansi (const char *fn_in, char *fn_out)
1602 {
1603 wchar_t fn_utf16[MAX_PATH];
1604
1605 if (filename_to_utf16 (fn_in, fn_utf16) == 0)
1606 {
1607 int result;
1608 int codepage = codepage_for_filenames (NULL);
1609
1610 result = pWideCharToMultiByte (codepage, 0, fn_utf16, -1,
1611 fn_out, MAX_PATH, NULL, NULL);
1612 if (!result)
1613 {
1614 DWORD err = GetLastError ();
1615
1616 switch (err)
1617 {
1618 case ERROR_INVALID_FLAGS:
1619 case ERROR_INVALID_PARAMETER:
1620 errno = EINVAL;
1621 break;
1622 case ERROR_INSUFFICIENT_BUFFER:
1623 case ERROR_NO_UNICODE_TRANSLATION:
1624 default:
1625 errno = ENOENT;
1626 break;
1627 }
1628 return -1;
1629 }
1630 return 0;
1631 }
1632 return -1;
1633 }
1634
1635 int
1636 filename_from_ansi (const char *fn_in, char *fn_out)
1637 {
1638 wchar_t fn_utf16[MAX_PATH];
1639 int codepage = codepage_for_filenames (NULL);
1640 int result = pMultiByteToWideChar (codepage, MB_ERR_INVALID_CHARS, fn_in, -1,
1641 fn_utf16, MAX_PATH);
1642
1643 if (!result)
1644 {
1645 DWORD err = GetLastError ();
1646
1647 switch (err)
1648 {
1649 case ERROR_INVALID_FLAGS:
1650 case ERROR_INVALID_PARAMETER:
1651 errno = EINVAL;
1652 break;
1653 case ERROR_INSUFFICIENT_BUFFER:
1654 case ERROR_NO_UNICODE_TRANSLATION:
1655 default:
1656 errno = ENOENT;
1657 break;
1658 }
1659 return -1;
1660 }
1661 return filename_from_utf16 (fn_utf16, fn_out);
1662 }
1663
1664 \f
1665
1666 /* The directory where we started, in UTF-8. */
1667 static char startup_dir[MAX_UTF8_PATH];
1668
1669 /* Get the current working directory. */
1670 char *
1671 getcwd (char *dir, int dirsize)
1672 {
1673 if (!dirsize)
1674 {
1675 errno = EINVAL;
1676 return NULL;
1677 }
1678 if (dirsize <= strlen (startup_dir))
1679 {
1680 errno = ERANGE;
1681 return NULL;
1682 }
1683 #if 0
1684 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
1685 return dir;
1686 return NULL;
1687 #else
1688 /* Emacs doesn't actually change directory itself, it stays in the
1689 same directory where it was started. */
1690 strcpy (dir, startup_dir);
1691 return dir;
1692 #endif
1693 }
1694
1695 /* Emulate getloadavg. */
1696
1697 struct load_sample {
1698 time_t sample_time;
1699 ULONGLONG idle;
1700 ULONGLONG kernel;
1701 ULONGLONG user;
1702 };
1703
1704 /* Number of processors on this machine. */
1705 static unsigned num_of_processors;
1706
1707 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1708 static struct load_sample samples[16*60];
1709 static int first_idx = -1, last_idx = -1;
1710 static int max_idx = sizeof (samples) / sizeof (samples[0]);
1711
1712 static int
1713 buf_next (int from)
1714 {
1715 int next_idx = from + 1;
1716
1717 if (next_idx >= max_idx)
1718 next_idx = 0;
1719
1720 return next_idx;
1721 }
1722
1723 static int
1724 buf_prev (int from)
1725 {
1726 int prev_idx = from - 1;
1727
1728 if (prev_idx < 0)
1729 prev_idx = max_idx - 1;
1730
1731 return prev_idx;
1732 }
1733
1734 static void
1735 sample_system_load (ULONGLONG *idle, ULONGLONG *kernel, ULONGLONG *user)
1736 {
1737 SYSTEM_INFO sysinfo;
1738 FILETIME ft_idle, ft_user, ft_kernel;
1739
1740 /* Initialize the number of processors on this machine. */
1741 if (num_of_processors <= 0)
1742 {
1743 get_native_system_info (&sysinfo);
1744 num_of_processors = sysinfo.dwNumberOfProcessors;
1745 if (num_of_processors <= 0)
1746 {
1747 GetSystemInfo (&sysinfo);
1748 num_of_processors = sysinfo.dwNumberOfProcessors;
1749 }
1750 if (num_of_processors <= 0)
1751 num_of_processors = 1;
1752 }
1753
1754 /* TODO: Take into account threads that are ready to run, by
1755 sampling the "\System\Processor Queue Length" performance
1756 counter. The code below accounts only for threads that are
1757 actually running. */
1758
1759 if (get_system_times (&ft_idle, &ft_kernel, &ft_user))
1760 {
1761 ULARGE_INTEGER uidle, ukernel, uuser;
1762
1763 memcpy (&uidle, &ft_idle, sizeof (ft_idle));
1764 memcpy (&ukernel, &ft_kernel, sizeof (ft_kernel));
1765 memcpy (&uuser, &ft_user, sizeof (ft_user));
1766 *idle = uidle.QuadPart;
1767 *kernel = ukernel.QuadPart;
1768 *user = uuser.QuadPart;
1769 }
1770 else
1771 {
1772 *idle = 0;
1773 *kernel = 0;
1774 *user = 0;
1775 }
1776 }
1777
1778 /* Produce the load average for a given time interval, using the
1779 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1780 1-minute, 5-minute, or 15-minute average, respectively. */
1781 static double
1782 getavg (int which)
1783 {
1784 double retval = -1.0;
1785 double tdiff;
1786 int idx;
1787 double span = (which == 0 ? 1.0 : (which == 1 ? 5.0 : 15.0)) * 60;
1788 time_t now = samples[last_idx].sample_time;
1789
1790 if (first_idx != last_idx)
1791 {
1792 for (idx = buf_prev (last_idx); ; idx = buf_prev (idx))
1793 {
1794 tdiff = difftime (now, samples[idx].sample_time);
1795 if (tdiff >= span - 2*DBL_EPSILON*now)
1796 {
1797 long double sys =
1798 samples[last_idx].kernel + samples[last_idx].user
1799 - (samples[idx].kernel + samples[idx].user);
1800 long double idl = samples[last_idx].idle - samples[idx].idle;
1801
1802 retval = (1.0 - idl / sys) * num_of_processors;
1803 break;
1804 }
1805 if (idx == first_idx)
1806 break;
1807 }
1808 }
1809
1810 return retval;
1811 }
1812
1813 int
1814 getloadavg (double loadavg[], int nelem)
1815 {
1816 int elem;
1817 ULONGLONG idle, kernel, user;
1818 time_t now = time (NULL);
1819
1820 /* If system time jumped back for some reason, delete all samples
1821 whose time is later than the current wall-clock time. This
1822 prevents load average figures from becoming frozen for prolonged
1823 periods of time, when system time is reset backwards. */
1824 if (last_idx >= 0)
1825 {
1826 while (difftime (now, samples[last_idx].sample_time) < -1.0)
1827 {
1828 if (last_idx == first_idx)
1829 {
1830 first_idx = last_idx = -1;
1831 break;
1832 }
1833 last_idx = buf_prev (last_idx);
1834 }
1835 }
1836
1837 /* Store another sample. We ignore samples that are less than 1 sec
1838 apart. */
1839 if (last_idx < 0
1840 || (difftime (now, samples[last_idx].sample_time)
1841 >= 1.0 - 2*DBL_EPSILON*now))
1842 {
1843 sample_system_load (&idle, &kernel, &user);
1844 last_idx = buf_next (last_idx);
1845 samples[last_idx].sample_time = now;
1846 samples[last_idx].idle = idle;
1847 samples[last_idx].kernel = kernel;
1848 samples[last_idx].user = user;
1849 /* If the buffer has more that 15 min worth of samples, discard
1850 the old ones. */
1851 if (first_idx == -1)
1852 first_idx = last_idx;
1853 while (first_idx != last_idx
1854 && (difftime (now, samples[first_idx].sample_time)
1855 >= 15.0*60 + 2*DBL_EPSILON*now))
1856 first_idx = buf_next (first_idx);
1857 }
1858
1859 for (elem = 0; elem < nelem; elem++)
1860 {
1861 double avg = getavg (elem);
1862
1863 if (avg < 0)
1864 break;
1865 loadavg[elem] = avg;
1866 }
1867
1868 return elem;
1869 }
1870
1871 /* Emulate getpwuid, getpwnam and others. */
1872
1873 #define PASSWD_FIELD_SIZE 256
1874
1875 static char dflt_passwd_name[PASSWD_FIELD_SIZE];
1876 static char dflt_passwd_passwd[PASSWD_FIELD_SIZE];
1877 static char dflt_passwd_gecos[PASSWD_FIELD_SIZE];
1878 static char dflt_passwd_dir[MAX_UTF8_PATH];
1879 static char dflt_passwd_shell[MAX_UTF8_PATH];
1880
1881 static struct passwd dflt_passwd =
1882 {
1883 dflt_passwd_name,
1884 dflt_passwd_passwd,
1885 0,
1886 0,
1887 0,
1888 dflt_passwd_gecos,
1889 dflt_passwd_dir,
1890 dflt_passwd_shell,
1891 };
1892
1893 static char dflt_group_name[GNLEN+1];
1894
1895 static struct group dflt_group =
1896 {
1897 /* When group information is not available, we return this as the
1898 group for all files. */
1899 dflt_group_name,
1900 0,
1901 };
1902
1903 unsigned
1904 getuid (void)
1905 {
1906 return dflt_passwd.pw_uid;
1907 }
1908
1909 unsigned
1910 geteuid (void)
1911 {
1912 /* I could imagine arguing for checking to see whether the user is
1913 in the Administrators group and returning a UID of 0 for that
1914 case, but I don't know how wise that would be in the long run. */
1915 return getuid ();
1916 }
1917
1918 unsigned
1919 getgid (void)
1920 {
1921 return dflt_passwd.pw_gid;
1922 }
1923
1924 unsigned
1925 getegid (void)
1926 {
1927 return getgid ();
1928 }
1929
1930 struct passwd *
1931 getpwuid (unsigned uid)
1932 {
1933 if (uid == dflt_passwd.pw_uid)
1934 return &dflt_passwd;
1935 return NULL;
1936 }
1937
1938 struct group *
1939 getgrgid (gid_t gid)
1940 {
1941 return &dflt_group;
1942 }
1943
1944 struct passwd *
1945 getpwnam (char *name)
1946 {
1947 struct passwd *pw;
1948
1949 pw = getpwuid (getuid ());
1950 if (!pw)
1951 return pw;
1952
1953 if (xstrcasecmp (name, pw->pw_name))
1954 return NULL;
1955
1956 return pw;
1957 }
1958
1959 static void
1960 init_user_info (void)
1961 {
1962 /* Find the user's real name by opening the process token and
1963 looking up the name associated with the user-sid in that token.
1964
1965 Use the relative portion of the identifier authority value from
1966 the user-sid as the user id value (same for group id using the
1967 primary group sid from the process token). */
1968
1969 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
1970 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
1971 DWORD glength = sizeof (gname);
1972 HANDLE token = NULL;
1973 SID_NAME_USE user_type;
1974 unsigned char *buf = NULL;
1975 DWORD blen = 0;
1976 TOKEN_USER user_token;
1977 TOKEN_PRIMARY_GROUP group_token;
1978 BOOL result;
1979
1980 result = open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token);
1981 if (result)
1982 {
1983 result = get_token_information (token, TokenUser, NULL, 0, &blen);
1984 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1985 {
1986 buf = xmalloc (blen);
1987 result = get_token_information (token, TokenUser,
1988 (LPVOID)buf, blen, &needed);
1989 if (result)
1990 {
1991 memcpy (&user_token, buf, sizeof (user_token));
1992 result = lookup_account_sid (NULL, user_token.User.Sid,
1993 uname, &ulength,
1994 domain, &dlength, &user_type);
1995 }
1996 }
1997 else
1998 result = FALSE;
1999 }
2000 if (result)
2001 {
2002 strcpy (dflt_passwd.pw_name, uname);
2003 /* Determine a reasonable uid value. */
2004 if (xstrcasecmp ("administrator", uname) == 0)
2005 {
2006 dflt_passwd.pw_uid = 500; /* well-known Administrator uid */
2007 dflt_passwd.pw_gid = 513; /* well-known None gid */
2008 }
2009 else
2010 {
2011 /* Use the last sub-authority value of the RID, the relative
2012 portion of the SID, as user/group ID. */
2013 dflt_passwd.pw_uid = get_rid (user_token.User.Sid);
2014
2015 /* Get group id and name. */
2016 result = get_token_information (token, TokenPrimaryGroup,
2017 (LPVOID)buf, blen, &needed);
2018 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
2019 {
2020 buf = xrealloc (buf, blen = needed);
2021 result = get_token_information (token, TokenPrimaryGroup,
2022 (LPVOID)buf, blen, &needed);
2023 }
2024 if (result)
2025 {
2026 memcpy (&group_token, buf, sizeof (group_token));
2027 dflt_passwd.pw_gid = get_rid (group_token.PrimaryGroup);
2028 dlength = sizeof (domain);
2029 /* If we can get at the real Primary Group name, use that.
2030 Otherwise, the default group name was already set to
2031 "None" in globals_of_w32. */
2032 if (lookup_account_sid (NULL, group_token.PrimaryGroup,
2033 gname, &glength, NULL, &dlength,
2034 &user_type))
2035 strcpy (dflt_group_name, gname);
2036 }
2037 else
2038 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
2039 }
2040 }
2041 /* If security calls are not supported (presumably because we
2042 are running under Windows 9X), fallback to this: */
2043 else if (GetUserName (uname, &ulength))
2044 {
2045 strcpy (dflt_passwd.pw_name, uname);
2046 if (xstrcasecmp ("administrator", uname) == 0)
2047 dflt_passwd.pw_uid = 0;
2048 else
2049 dflt_passwd.pw_uid = 123;
2050 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
2051 }
2052 else
2053 {
2054 strcpy (dflt_passwd.pw_name, "unknown");
2055 dflt_passwd.pw_uid = 123;
2056 dflt_passwd.pw_gid = 123;
2057 }
2058 dflt_group.gr_gid = dflt_passwd.pw_gid;
2059
2060 /* Set dir and shell from environment variables. */
2061 if (w32_unicode_filenames)
2062 {
2063 wchar_t *home = _wgetenv (L"HOME");
2064 wchar_t *shell = _wgetenv (L"SHELL");
2065
2066 /* Ensure HOME and SHELL are defined. */
2067 if (home == NULL)
2068 emacs_abort ();
2069 if (shell == NULL)
2070 emacs_abort ();
2071 filename_from_utf16 (home, dflt_passwd.pw_dir);
2072 filename_from_utf16 (shell, dflt_passwd.pw_shell);
2073 }
2074 else
2075 {
2076 char *home = getenv ("HOME");
2077 char *shell = getenv ("SHELL");
2078
2079 if (home == NULL)
2080 emacs_abort ();
2081 if (shell == NULL)
2082 emacs_abort ();
2083 filename_from_ansi (home, dflt_passwd.pw_dir);
2084 filename_from_ansi (shell, dflt_passwd.pw_shell);
2085 }
2086
2087 xfree (buf);
2088 if (token)
2089 CloseHandle (token);
2090 }
2091
2092 int
2093 random (void)
2094 {
2095 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
2096 return ((rand () << 15) | rand ());
2097 }
2098
2099 void
2100 srandom (int seed)
2101 {
2102 srand (seed);
2103 }
2104
2105 /* Return the maximum length in bytes of a multibyte character
2106 sequence encoded in the current ANSI codepage. This is required to
2107 correctly walk the encoded file names one character at a time. */
2108 static int
2109 max_filename_mbslen (void)
2110 {
2111 CPINFO cp_info;
2112
2113 codepage_for_filenames (&cp_info);
2114 return cp_info.MaxCharSize;
2115 }
2116
2117 /* Normalize filename by converting in-place all of its path
2118 separators to the separator specified by PATH_SEP. */
2119
2120 static void
2121 normalize_filename (register char *fp, char path_sep)
2122 {
2123 char *p2;
2124
2125 /* Always lower-case drive letters a-z, even if the filesystem
2126 preserves case in filenames.
2127 This is so filenames can be compared by string comparison
2128 functions that are case-sensitive. Even case-preserving filesystems
2129 do not distinguish case in drive letters. */
2130 p2 = fp + 1;
2131
2132 if (*p2 == ':' && *fp >= 'A' && *fp <= 'Z')
2133 {
2134 *fp += 'a' - 'A';
2135 fp += 2;
2136 }
2137
2138 while (*fp)
2139 {
2140 if ((*fp == '/' || *fp == '\\') && *fp != path_sep)
2141 *fp = path_sep;
2142 fp++;
2143 }
2144 }
2145
2146 /* Destructively turn backslashes into slashes. */
2147 void
2148 dostounix_filename (register char *p)
2149 {
2150 normalize_filename (p, '/');
2151 }
2152
2153 /* Destructively turn slashes into backslashes. */
2154 void
2155 unixtodos_filename (register char *p)
2156 {
2157 normalize_filename (p, '\\');
2158 }
2159
2160 /* Remove all CR's that are followed by a LF.
2161 (From msdos.c...probably should figure out a way to share it,
2162 although this code isn't going to ever change.) */
2163 static int
2164 crlf_to_lf (register int n, register unsigned char *buf)
2165 {
2166 unsigned char *np = buf;
2167 unsigned char *startp = buf;
2168 unsigned char *endp = buf + n;
2169
2170 if (n == 0)
2171 return n;
2172 while (buf < endp - 1)
2173 {
2174 if (*buf == 0x0d)
2175 {
2176 if (*(++buf) != 0x0a)
2177 *np++ = 0x0d;
2178 }
2179 else
2180 *np++ = *buf++;
2181 }
2182 if (buf < endp)
2183 *np++ = *buf++;
2184 return np - startp;
2185 }
2186
2187 /* Parse the root part of file name, if present. Return length and
2188 optionally store pointer to char after root. */
2189 static int
2190 parse_root (const char * name, const char ** pPath)
2191 {
2192 const char * start = name;
2193
2194 if (name == NULL)
2195 return 0;
2196
2197 /* find the root name of the volume if given */
2198 if (isalpha (name[0]) && name[1] == ':')
2199 {
2200 /* skip past drive specifier */
2201 name += 2;
2202 if (IS_DIRECTORY_SEP (name[0]))
2203 name++;
2204 }
2205 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
2206 {
2207 int slashes = 2;
2208
2209 name += 2;
2210 do
2211 {
2212 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
2213 break;
2214 name++;
2215 }
2216 while ( *name );
2217 if (IS_DIRECTORY_SEP (name[0]))
2218 name++;
2219 }
2220
2221 if (pPath)
2222 *pPath = name;
2223
2224 return name - start;
2225 }
2226
2227 /* Get long base name for name; name is assumed to be absolute. */
2228 static int
2229 get_long_basename (char * name, char * buf, int size)
2230 {
2231 HANDLE dir_handle = INVALID_HANDLE_VALUE;
2232 char fname_utf8[MAX_UTF8_PATH];
2233 int len = 0;
2234 int cstatus = -1;
2235
2236 /* Must be valid filename, no wild cards or other invalid characters. */
2237 if (strpbrk (name, "*?|<>\""))
2238 return 0;
2239
2240 if (w32_unicode_filenames)
2241 {
2242 wchar_t fname_utf16[MAX_PATH];
2243 WIN32_FIND_DATAW find_data_wide;
2244
2245 filename_to_utf16 (name, fname_utf16);
2246 dir_handle = FindFirstFileW (fname_utf16, &find_data_wide);
2247 if (dir_handle != INVALID_HANDLE_VALUE)
2248 cstatus = filename_from_utf16 (find_data_wide.cFileName, fname_utf8);
2249 }
2250 else
2251 {
2252 char fname_ansi[MAX_PATH];
2253 WIN32_FIND_DATAA find_data_ansi;
2254
2255 filename_to_ansi (name, fname_ansi);
2256 /* If the ANSI name includes ? characters, it is not encodable
2257 in the ANSI codepage. In that case, we deliver the question
2258 marks to the caller; calling FindFirstFileA in this case
2259 could return some unrelated file name in the same
2260 directory. */
2261 if (_mbspbrk (fname_ansi, "?"))
2262 {
2263 /* Find the basename of fname_ansi. */
2264 char *p = strrchr (fname_ansi, '\\');
2265
2266 if (!p)
2267 p = fname_ansi;
2268 else
2269 p++;
2270 cstatus = filename_from_ansi (p, fname_utf8);
2271 }
2272 else
2273 {
2274 dir_handle = FindFirstFileA (fname_ansi, &find_data_ansi);
2275 if (dir_handle != INVALID_HANDLE_VALUE)
2276 cstatus = filename_from_ansi (find_data_ansi.cFileName, fname_utf8);
2277 }
2278 }
2279
2280 if (cstatus == 0 && (len = strlen (fname_utf8)) < size)
2281 memcpy (buf, fname_utf8, len + 1);
2282 else
2283 len = 0;
2284
2285 if (dir_handle != INVALID_HANDLE_VALUE)
2286 FindClose (dir_handle);
2287
2288 return len;
2289 }
2290
2291 /* Get long name for file, if possible (assumed to be absolute). */
2292 BOOL
2293 w32_get_long_filename (char * name, char * buf, int size)
2294 {
2295 char * o = buf;
2296 char * p;
2297 const char * q;
2298 char full[ MAX_UTF8_PATH ];
2299 int len;
2300
2301 len = strlen (name);
2302 if (len >= MAX_UTF8_PATH)
2303 return FALSE;
2304
2305 /* Use local copy for destructive modification. */
2306 memcpy (full, name, len+1);
2307 unixtodos_filename (full);
2308
2309 /* Copy root part verbatim. */
2310 len = parse_root (full, (const char **)&p);
2311 memcpy (o, full, len);
2312 o += len;
2313 *o = '\0';
2314 size -= len;
2315
2316 while (p != NULL && *p)
2317 {
2318 q = p;
2319 p = strchr (q, '\\');
2320 if (p) *p = '\0';
2321 len = get_long_basename (full, o, size);
2322 if (len > 0)
2323 {
2324 o += len;
2325 size -= len;
2326 if (p != NULL)
2327 {
2328 *p++ = '\\';
2329 if (size < 2)
2330 return FALSE;
2331 *o++ = '\\';
2332 size--;
2333 *o = '\0';
2334 }
2335 }
2336 else
2337 return FALSE;
2338 }
2339
2340 return TRUE;
2341 }
2342
2343 unsigned int
2344 w32_get_short_filename (char * name, char * buf, int size)
2345 {
2346 if (w32_unicode_filenames)
2347 {
2348 wchar_t name_utf16[MAX_PATH], short_name[MAX_PATH];
2349 unsigned int retval;
2350
2351 filename_to_utf16 (name, name_utf16);
2352 retval = GetShortPathNameW (name_utf16, short_name, size);
2353 if (retval && retval < size)
2354 filename_from_utf16 (short_name, buf);
2355 return retval;
2356 }
2357 else
2358 {
2359 char name_ansi[MAX_PATH];
2360
2361 filename_to_ansi (name, name_ansi);
2362 return GetShortPathNameA (name_ansi, buf, size);
2363 }
2364 }
2365
2366 /* Re-encode FILENAME, a UTF-8 encoded unibyte string, using the
2367 MS-Windows ANSI codepage. If FILENAME includes characters not
2368 supported by the ANSI codepage, return the 8+3 alias of FILENAME,
2369 if it exists. This is needed because the w32 build wants to
2370 support file names outside of the system locale, but image
2371 libraries typically don't support wide (a.k.a. "Unicode") APIs
2372 required for that. */
2373
2374 Lisp_Object
2375 ansi_encode_filename (Lisp_Object filename)
2376 {
2377 Lisp_Object encoded_filename;
2378 char fname[MAX_PATH];
2379
2380 filename_to_ansi (SSDATA (filename), fname);
2381 if (_mbspbrk (fname, "?"))
2382 {
2383 char shortname[MAX_PATH];
2384
2385 if (w32_get_short_filename (SDATA (filename), shortname, MAX_PATH))
2386 {
2387 dostounix_filename (shortname);
2388 encoded_filename = build_string (shortname);
2389 }
2390 else
2391 encoded_filename = build_unibyte_string (fname);
2392 }
2393 else
2394 encoded_filename = build_unibyte_string (fname);
2395 return encoded_filename;
2396 }
2397
2398 static int
2399 is_unc_volume (const char *filename)
2400 {
2401 const char *ptr = filename;
2402
2403 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
2404 return 0;
2405
2406 if (strpbrk (ptr + 2, "*?|<>\"\\/"))
2407 return 0;
2408
2409 return 1;
2410 }
2411
2412 /* Emulate the Posix unsetenv. */
2413 int
2414 unsetenv (const char *name)
2415 {
2416 char *var;
2417 size_t name_len;
2418 int retval;
2419
2420 if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
2421 {
2422 errno = EINVAL;
2423 return -1;
2424 }
2425 name_len = strlen (name);
2426 /* MS docs says an environment variable cannot be longer than 32K. */
2427 if (name_len > 32767)
2428 {
2429 errno = ENOMEM;
2430 return 0;
2431 }
2432 /* It is safe to use 'alloca' with 32K size, since the stack is at
2433 least 2MB, and we set it to 8MB in the link command line. */
2434 var = alloca (name_len + 2);
2435 strncpy (var, name, name_len);
2436 var[name_len++] = '=';
2437 var[name_len] = '\0';
2438 return _putenv (var);
2439 }
2440
2441 /* MS _putenv doesn't support removing a variable when the argument
2442 does not include the '=' character, so we fix that here. */
2443 int
2444 sys_putenv (char *str)
2445 {
2446 const char *const name_end = strchr (str, '=');
2447
2448 if (name_end == NULL)
2449 {
2450 /* Remove the variable from the environment. */
2451 return unsetenv (str);
2452 }
2453
2454 return _putenv (str);
2455 }
2456
2457 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
2458
2459 LPBYTE
2460 w32_get_resource (char *key, LPDWORD lpdwtype)
2461 {
2462 LPBYTE lpvalue;
2463 HKEY hrootkey = NULL;
2464 DWORD cbData;
2465
2466 /* Check both the current user and the local machine to see if
2467 we have any resources. */
2468
2469 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
2470 {
2471 lpvalue = NULL;
2472
2473 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
2474 && (lpvalue = xmalloc (cbData)) != NULL
2475 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
2476 {
2477 RegCloseKey (hrootkey);
2478 return (lpvalue);
2479 }
2480
2481 xfree (lpvalue);
2482
2483 RegCloseKey (hrootkey);
2484 }
2485
2486 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
2487 {
2488 lpvalue = NULL;
2489
2490 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
2491 && (lpvalue = xmalloc (cbData)) != NULL
2492 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
2493 {
2494 RegCloseKey (hrootkey);
2495 return (lpvalue);
2496 }
2497
2498 xfree (lpvalue);
2499
2500 RegCloseKey (hrootkey);
2501 }
2502
2503 return (NULL);
2504 }
2505
2506 /* The argv[] array holds ANSI-encoded strings, and so this function
2507 works with ANS_encoded strings. */
2508 void
2509 init_environment (char ** argv)
2510 {
2511 static const char * const tempdirs[] = {
2512 "$TMPDIR", "$TEMP", "$TMP", "c:/"
2513 };
2514
2515 int i;
2516
2517 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
2518
2519 /* Implementation note: This function explicitly works with ANSI
2520 file names, not with UTF-8 encoded file names. This is because
2521 this function pushes variables into the Emacs's environment, and
2522 the environment variables are always assumed to be in the
2523 locale-specific encoding. Do NOT call any functions that accept
2524 UTF-8 file names from this function! */
2525
2526 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
2527 temporary files and assume "/tmp" if $TMPDIR is unset, which
2528 will break on DOS/Windows. Refuse to work if we cannot find
2529 a directory, not even "c:/", usable for that purpose. */
2530 for (i = 0; i < imax ; i++)
2531 {
2532 const char *tmp = tempdirs[i];
2533
2534 if (*tmp == '$')
2535 tmp = getenv (tmp + 1);
2536 /* Note that `access' can lie to us if the directory resides on a
2537 read-only filesystem, like CD-ROM or a write-protected floppy.
2538 The only way to be really sure is to actually create a file and
2539 see if it succeeds. But I think that's too much to ask. */
2540
2541 /* MSVCRT's _access crashes with D_OK, so we use our replacement. */
2542 if (tmp && sys_access (tmp, D_OK) == 0)
2543 {
2544 char * var = alloca (strlen (tmp) + 8);
2545 sprintf (var, "TMPDIR=%s", tmp);
2546 _putenv (strdup (var));
2547 break;
2548 }
2549 }
2550 if (i >= imax)
2551 cmd_error_internal
2552 (Fcons (Qerror,
2553 Fcons (build_string ("no usable temporary directories found!!"),
2554 Qnil)),
2555 "While setting TMPDIR: ");
2556
2557 /* Check for environment variables and use registry settings if they
2558 don't exist. Fallback on default values where applicable. */
2559 {
2560 int i;
2561 LPBYTE lpval;
2562 DWORD dwType;
2563 char locale_name[32];
2564 char default_home[MAX_PATH];
2565 int appdata = 0;
2566
2567 static const struct env_entry
2568 {
2569 char * name;
2570 char * def_value;
2571 } dflt_envvars[] =
2572 {
2573 /* If the default value is NULL, we will use the value from the
2574 outside environment or the Registry, but will not push the
2575 variable into the Emacs environment if it is defined neither
2576 in the Registry nor in the outside environment. */
2577 {"HOME", "C:/"},
2578 {"PRELOAD_WINSOCK", NULL},
2579 {"emacs_dir", "C:/emacs"},
2580 {"EMACSLOADPATH", NULL},
2581 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2582 {"EMACSDATA", NULL},
2583 {"EMACSPATH", NULL},
2584 {"INFOPATH", NULL},
2585 {"EMACSDOC", NULL},
2586 {"TERM", "cmd"},
2587 {"LANG", NULL},
2588 };
2589
2590 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2591
2592 /* We need to copy dflt_envvars[] and work on the copy because we
2593 don't want the dumped Emacs to inherit the values of
2594 environment variables we saw during dumping (which could be on
2595 a different system). The defaults above must be left intact. */
2596 struct env_entry env_vars[N_ENV_VARS];
2597
2598 for (i = 0; i < N_ENV_VARS; i++)
2599 env_vars[i] = dflt_envvars[i];
2600
2601 /* For backwards compatibility, check if a .emacs file exists in C:/
2602 If not, then we can try to default to the appdata directory under the
2603 user's profile, which is more likely to be writable. */
2604 if (sys_access ("C:/.emacs", F_OK) != 0)
2605 {
2606 HRESULT profile_result;
2607 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2608 of Windows 95 and NT4 that have not been updated to include
2609 MSIE 5. */
2610 ShGetFolderPath_fn get_folder_path;
2611 get_folder_path = (ShGetFolderPath_fn)
2612 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2613
2614 if (get_folder_path != NULL)
2615 {
2616 profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
2617 0, default_home);
2618
2619 /* If we can't get the appdata dir, revert to old behavior. */
2620 if (profile_result == S_OK)
2621 {
2622 env_vars[0].def_value = default_home;
2623 appdata = 1;
2624 }
2625 }
2626 }
2627
2628 /* Get default locale info and use it for LANG. */
2629 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
2630 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
2631 locale_name, sizeof (locale_name)))
2632 {
2633 for (i = 0; i < N_ENV_VARS; i++)
2634 {
2635 if (strcmp (env_vars[i].name, "LANG") == 0)
2636 {
2637 env_vars[i].def_value = locale_name;
2638 break;
2639 }
2640 }
2641 }
2642
2643 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2644
2645 /* Treat emacs_dir specially: set it unconditionally based on our
2646 location. */
2647 {
2648 char *p;
2649 char modname[MAX_PATH];
2650
2651 if (!GetModuleFileNameA (NULL, modname, MAX_PATH))
2652 emacs_abort ();
2653 if ((p = _mbsrchr (modname, '\\')) == NULL)
2654 emacs_abort ();
2655 *p = 0;
2656
2657 if ((p = _mbsrchr (modname, '\\'))
2658 /* From bin means installed Emacs, from src means uninstalled. */
2659 && (xstrcasecmp (p, "\\bin") == 0 || xstrcasecmp (p, "\\src") == 0))
2660 {
2661 char buf[SET_ENV_BUF_SIZE];
2662 int within_build_tree = xstrcasecmp (p, "\\src") == 0;
2663
2664 *p = 0;
2665 for (p = modname; *p; p = CharNext (p))
2666 if (*p == '\\') *p = '/';
2667
2668 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
2669 _putenv (strdup (buf));
2670 /* If we are running from the Posix-like build tree, define
2671 SHELL to point to our own cmdproxy. The loop below will
2672 then disregard PATH_EXEC and the default value. */
2673 if (within_build_tree)
2674 {
2675 _snprintf (buf, sizeof (buf) - 1,
2676 "SHELL=%s/nt/cmdproxy.exe", modname);
2677 _putenv (strdup (buf));
2678 }
2679 }
2680 }
2681
2682 for (i = 0; i < N_ENV_VARS; i++)
2683 {
2684 if (!getenv (env_vars[i].name))
2685 {
2686 int dont_free = 0;
2687 char bufc[SET_ENV_BUF_SIZE];
2688
2689 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL
2690 /* Also ignore empty environment variables. */
2691 || *lpval == 0)
2692 {
2693 xfree (lpval);
2694 dont_free = 1;
2695 if (strcmp (env_vars[i].name, "SHELL") == 0)
2696 {
2697 /* Look for cmdproxy.exe in every directory in
2698 PATH_EXEC. FIXME: This does not find cmdproxy
2699 in nt/ when we run uninstalled. */
2700 char fname[MAX_PATH];
2701 const char *pstart = PATH_EXEC, *pend;
2702
2703 do {
2704 pend = _mbschr (pstart, ';');
2705 if (!pend)
2706 pend = pstart + strlen (pstart);
2707 /* Be defensive against series of ;;; characters. */
2708 if (pend > pstart)
2709 {
2710 strncpy (fname, pstart, pend - pstart);
2711 fname[pend - pstart] = '/';
2712 strcpy (&fname[pend - pstart + 1], "cmdproxy.exe");
2713 ExpandEnvironmentStrings ((LPSTR) fname, bufc,
2714 sizeof (bufc));
2715 if (sys_access (bufc, F_OK) == 0)
2716 {
2717 lpval = bufc;
2718 dwType = REG_SZ;
2719 break;
2720 }
2721 }
2722 if (*pend)
2723 pstart = pend + 1;
2724 else
2725 pstart = pend;
2726 if (!*pstart)
2727 {
2728 /* If not found in any directory, use the
2729 default as the last resort. */
2730 lpval = env_vars[i].def_value;
2731 dwType = REG_EXPAND_SZ;
2732 }
2733 } while (*pstart);
2734 }
2735 else
2736 {
2737 lpval = env_vars[i].def_value;
2738 dwType = REG_EXPAND_SZ;
2739 }
2740 if (strcmp (env_vars[i].name, "HOME") == 0 && !appdata)
2741 Vdelayed_warnings_list
2742 = Fcons (listn (CONSTYPE_HEAP, 2,
2743 intern ("initialization"),
2744 build_string ("Setting HOME to C:\\ by default is deprecated")),
2745 Vdelayed_warnings_list);
2746 }
2747
2748 if (lpval)
2749 {
2750 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
2751
2752 if (dwType == REG_EXPAND_SZ)
2753 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof (buf1));
2754 else if (dwType == REG_SZ)
2755 strcpy (buf1, lpval);
2756 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
2757 {
2758 _snprintf (buf2, sizeof (buf2)-1, "%s=%s", env_vars[i].name,
2759 buf1);
2760 _putenv (strdup (buf2));
2761 }
2762
2763 if (!dont_free)
2764 xfree (lpval);
2765 }
2766 }
2767 }
2768 }
2769
2770 /* Rebuild system configuration to reflect invoking system. */
2771 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
2772
2773 /* Another special case: on NT, the PATH variable is actually named
2774 "Path" although cmd.exe (perhaps NT itself) arranges for
2775 environment variable lookup and setting to be case insensitive.
2776 However, Emacs assumes a fully case sensitive environment, so we
2777 need to change "Path" to "PATH" to match the expectations of
2778 various elisp packages. We do this by the sneaky method of
2779 modifying the string in the C runtime environ entry.
2780
2781 The same applies to COMSPEC. */
2782 {
2783 char ** envp;
2784
2785 for (envp = environ; *envp; envp++)
2786 if (_strnicmp (*envp, "PATH=", 5) == 0)
2787 memcpy (*envp, "PATH=", 5);
2788 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
2789 memcpy (*envp, "COMSPEC=", 8);
2790 }
2791
2792 /* Remember the initial working directory for getcwd. */
2793 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2794 Does it matter anywhere in Emacs? */
2795 if (w32_unicode_filenames)
2796 {
2797 wchar_t wstartup_dir[MAX_PATH];
2798
2799 if (!GetCurrentDirectoryW (MAX_PATH, wstartup_dir))
2800 emacs_abort ();
2801 filename_from_utf16 (wstartup_dir, startup_dir);
2802 }
2803 else
2804 {
2805 char astartup_dir[MAX_PATH];
2806
2807 if (!GetCurrentDirectoryA (MAX_PATH, astartup_dir))
2808 emacs_abort ();
2809 filename_from_ansi (astartup_dir, startup_dir);
2810 }
2811
2812 {
2813 static char modname[MAX_PATH];
2814
2815 if (!GetModuleFileNameA (NULL, modname, MAX_PATH))
2816 emacs_abort ();
2817 argv[0] = modname;
2818 }
2819
2820 /* Determine if there is a middle mouse button, to allow parse_button
2821 to decide whether right mouse events should be mouse-2 or
2822 mouse-3. */
2823 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
2824
2825 init_user_info ();
2826 }
2827
2828 /* Called from expand-file-name when default-directory is not a string. */
2829
2830 char *
2831 emacs_root_dir (void)
2832 {
2833 static char root_dir[MAX_UTF8_PATH];
2834 const char *p;
2835
2836 p = getenv ("emacs_dir");
2837 if (p == NULL)
2838 emacs_abort ();
2839 filename_from_ansi (p, root_dir);
2840 root_dir[parse_root (root_dir, NULL)] = '\0';
2841 dostounix_filename (root_dir);
2842 return root_dir;
2843 }
2844
2845 #include <sys/timeb.h>
2846
2847 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2848 int
2849 gettimeofday (struct timeval *__restrict tv, struct timezone *__restrict tz)
2850 {
2851 struct _timeb tb;
2852 _ftime (&tb);
2853
2854 tv->tv_sec = tb.time;
2855 tv->tv_usec = tb.millitm * 1000L;
2856 /* Implementation note: _ftime sometimes doesn't update the dstflag
2857 according to the new timezone when the system timezone is
2858 changed. We could fix that by using GetSystemTime and
2859 GetTimeZoneInformation, but that doesn't seem necessary, since
2860 Emacs always calls gettimeofday with the 2nd argument NULL (see
2861 current_emacs_time). */
2862 if (tz)
2863 {
2864 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
2865 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
2866 }
2867 return 0;
2868 }
2869
2870 /* Emulate fdutimens. */
2871
2872 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2873 TIMESPEC[0] and TIMESPEC[1], respectively.
2874 FD must be either negative -- in which case it is ignored --
2875 or a file descriptor that is open on FILE.
2876 If FD is nonnegative, then FILE can be NULL, which means
2877 use just futimes instead of utimes.
2878 If TIMESPEC is null, FAIL.
2879 Return 0 on success, -1 (setting errno) on failure. */
2880
2881 int
2882 fdutimens (int fd, char const *file, struct timespec const timespec[2])
2883 {
2884 if (!timespec)
2885 {
2886 errno = ENOSYS;
2887 return -1;
2888 }
2889 if (fd < 0 && !file)
2890 {
2891 errno = EBADF;
2892 return -1;
2893 }
2894 /* _futime's prototype defines 2nd arg as having the type 'struct
2895 _utimbuf', while utime needs to accept 'struct utimbuf' for
2896 compatibility with Posix. So we need to use 2 different (but
2897 equivalent) types to avoid compiler warnings, sigh. */
2898 if (fd >= 0)
2899 {
2900 struct _utimbuf _ut;
2901
2902 _ut.actime = timespec[0].tv_sec;
2903 _ut.modtime = timespec[1].tv_sec;
2904 return _futime (fd, &_ut);
2905 }
2906 else
2907 {
2908 struct utimbuf ut;
2909
2910 ut.actime = timespec[0].tv_sec;
2911 ut.modtime = timespec[1].tv_sec;
2912 /* Call 'utime', which is implemented below, not the MS library
2913 function, which fails on directories. */
2914 return utime (file, &ut);
2915 }
2916 }
2917
2918
2919 /* ------------------------------------------------------------------------- */
2920 /* IO support and wrapper functions for the Windows API. */
2921 /* ------------------------------------------------------------------------- */
2922
2923 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2924 on network directories, so we handle that case here.
2925 (Ulrich Leodolter, 1/11/95). */
2926 char *
2927 sys_ctime (const time_t *t)
2928 {
2929 char *str = (char *) ctime (t);
2930 return (str ? str : "Sun Jan 01 00:00:00 1970");
2931 }
2932
2933 /* Emulate sleep...we could have done this with a define, but that
2934 would necessitate including windows.h in the files that used it.
2935 This is much easier. */
2936 void
2937 sys_sleep (int seconds)
2938 {
2939 Sleep (seconds * 1000);
2940 }
2941
2942 /* Internal MSVC functions for low-level descriptor munging */
2943 extern int __cdecl _set_osfhnd (int fd, long h);
2944 extern int __cdecl _free_osfhnd (int fd);
2945
2946 /* parallel array of private info on file handles */
2947 filedesc fd_info [ MAXDESC ];
2948
2949 typedef struct volume_info_data {
2950 struct volume_info_data * next;
2951
2952 /* time when info was obtained */
2953 DWORD timestamp;
2954
2955 /* actual volume info */
2956 char * root_dir;
2957 DWORD serialnum;
2958 DWORD maxcomp;
2959 DWORD flags;
2960 char * name;
2961 char * type;
2962 } volume_info_data;
2963
2964 /* Global referenced by various functions. */
2965 static volume_info_data volume_info;
2966
2967 /* Vector to indicate which drives are local and fixed (for which cached
2968 data never expires). */
2969 static BOOL fixed_drives[26];
2970
2971 /* Consider cached volume information to be stale if older than 10s,
2972 at least for non-local drives. Info for fixed drives is never stale. */
2973 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2974 #define VOLINFO_STILL_VALID( root_dir, info ) \
2975 ( ( isalpha (root_dir[0]) && \
2976 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2977 || GetTickCount () - info->timestamp < 10000 )
2978
2979 /* Cache support functions. */
2980
2981 /* Simple linked list with linear search is sufficient. */
2982 static volume_info_data *volume_cache = NULL;
2983
2984 static volume_info_data *
2985 lookup_volume_info (char * root_dir)
2986 {
2987 volume_info_data * info;
2988
2989 for (info = volume_cache; info; info = info->next)
2990 if (xstrcasecmp (info->root_dir, root_dir) == 0)
2991 break;
2992 return info;
2993 }
2994
2995 static void
2996 add_volume_info (char * root_dir, volume_info_data * info)
2997 {
2998 info->root_dir = xstrdup (root_dir);
2999 unixtodos_filename (info->root_dir);
3000 info->next = volume_cache;
3001 volume_cache = info;
3002 }
3003
3004
3005 /* Wrapper for GetVolumeInformation, which uses caching to avoid
3006 performance penalty (~2ms on 486 for local drives, 7.5ms for local
3007 cdrom drive, ~5-10ms or more for remote drives on LAN). */
3008 static volume_info_data *
3009 GetCachedVolumeInformation (char * root_dir)
3010 {
3011 volume_info_data * info;
3012 char default_root[ MAX_UTF8_PATH ];
3013 char name[MAX_PATH+1];
3014 char type[MAX_PATH+1];
3015
3016 /* NULL for root_dir means use root from current directory. */
3017 if (root_dir == NULL)
3018 {
3019 if (w32_unicode_filenames)
3020 {
3021 wchar_t curdirw[MAX_PATH];
3022
3023 if (GetCurrentDirectoryW (MAX_PATH, curdirw) == 0)
3024 return NULL;
3025 filename_from_utf16 (curdirw, default_root);
3026 }
3027 else
3028 {
3029 char curdira[MAX_PATH];
3030
3031 if (GetCurrentDirectoryA (MAX_PATH, curdira) == 0)
3032 return NULL;
3033 filename_from_ansi (curdira, default_root);
3034 }
3035 parse_root (default_root, (const char **)&root_dir);
3036 *root_dir = 0;
3037 root_dir = default_root;
3038 }
3039
3040 /* Local fixed drives can be cached permanently. Removable drives
3041 cannot be cached permanently, since the volume name and serial
3042 number (if nothing else) can change. Remote drives should be
3043 treated as if they are removable, since there is no sure way to
3044 tell whether they are or not. Also, the UNC association of drive
3045 letters mapped to remote volumes can be changed at any time (even
3046 by other processes) without notice.
3047
3048 As a compromise, so we can benefit from caching info for remote
3049 volumes, we use a simple expiry mechanism to invalidate cache
3050 entries that are more than ten seconds old. */
3051
3052 #if 0
3053 /* No point doing this, because WNetGetConnection is even slower than
3054 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
3055 GetDriveType is about the only call of this type which does not
3056 involve network access, and so is extremely quick). */
3057
3058 /* Map drive letter to UNC if remote. */
3059 if (isalpha (root_dir[0]) && !fixed[DRIVE_INDEX (root_dir[0])])
3060 {
3061 char remote_name[ 256 ];
3062 char drive[3] = { root_dir[0], ':' };
3063
3064 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
3065 == NO_ERROR)
3066 /* do something */ ;
3067 }
3068 #endif
3069
3070 info = lookup_volume_info (root_dir);
3071
3072 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
3073 {
3074 DWORD serialnum;
3075 DWORD maxcomp;
3076 DWORD flags;
3077
3078 /* Info is not cached, or is stale. */
3079 if (w32_unicode_filenames)
3080 {
3081 wchar_t root_w[MAX_PATH];
3082 wchar_t name_w[MAX_PATH+1];
3083 wchar_t type_w[MAX_PATH+1];
3084
3085 filename_to_utf16 (root_dir, root_w);
3086 if (!GetVolumeInformationW (root_w,
3087 name_w, sizeof (name_w),
3088 &serialnum,
3089 &maxcomp,
3090 &flags,
3091 type_w, sizeof (type_w)))
3092 return NULL;
3093 /* Hmm... not really 100% correct, as these 2 are not file
3094 names... */
3095 filename_from_utf16 (name_w, name);
3096 filename_from_utf16 (type_w, type);
3097 }
3098 else
3099 {
3100 char root_a[MAX_PATH];
3101 char name_a[MAX_PATH+1];
3102 char type_a[MAX_PATH+1];
3103
3104 filename_to_ansi (root_dir, root_a);
3105 if (!GetVolumeInformationA (root_a,
3106 name_a, sizeof (name_a),
3107 &serialnum,
3108 &maxcomp,
3109 &flags,
3110 type_a, sizeof (type_a)))
3111 return NULL;
3112 filename_from_ansi (name_a, name);
3113 filename_from_ansi (type_a, type);
3114 }
3115
3116 /* Cache the volume information for future use, overwriting existing
3117 entry if present. */
3118 if (info == NULL)
3119 {
3120 info = xmalloc (sizeof (volume_info_data));
3121 add_volume_info (root_dir, info);
3122 }
3123 else
3124 {
3125 xfree (info->name);
3126 xfree (info->type);
3127 }
3128
3129 info->name = xstrdup (name);
3130 unixtodos_filename (info->name);
3131 info->serialnum = serialnum;
3132 info->maxcomp = maxcomp;
3133 info->flags = flags;
3134 info->type = xstrdup (type);
3135 info->timestamp = GetTickCount ();
3136 }
3137
3138 return info;
3139 }
3140
3141 /* Get information on the volume where NAME is held; set path pointer to
3142 start of pathname in NAME (past UNC header\volume header if present),
3143 if pPath is non-NULL.
3144
3145 Note: if NAME includes symlinks, the information is for the volume
3146 of the symlink, not of its target. That's because, even though
3147 GetVolumeInformation returns information about the symlink target
3148 of its argument, we only pass the root directory to
3149 GetVolumeInformation, not the full NAME. */
3150 static int
3151 get_volume_info (const char * name, const char ** pPath)
3152 {
3153 char temp[MAX_UTF8_PATH];
3154 char *rootname = NULL; /* default to current volume */
3155 volume_info_data * info;
3156 int root_len = parse_root (name, pPath);
3157
3158 if (name == NULL)
3159 return FALSE;
3160
3161 /* Copy the root name of the volume, if given. */
3162 if (root_len)
3163 {
3164 strncpy (temp, name, root_len);
3165 temp[root_len] = '\0';
3166 unixtodos_filename (temp);
3167 rootname = temp;
3168 }
3169
3170 info = GetCachedVolumeInformation (rootname);
3171 if (info != NULL)
3172 {
3173 /* Set global referenced by other functions. */
3174 volume_info = *info;
3175 return TRUE;
3176 }
3177 return FALSE;
3178 }
3179
3180 /* Determine if volume is FAT format (ie. only supports short 8.3
3181 names); also set path pointer to start of pathname in name, if
3182 pPath is non-NULL. */
3183 static int
3184 is_fat_volume (const char * name, const char ** pPath)
3185 {
3186 if (get_volume_info (name, pPath))
3187 return (volume_info.maxcomp == 12);
3188 return FALSE;
3189 }
3190
3191 /* Convert all slashes in a filename to backslashes, and map filename
3192 to a valid 8.3 name if necessary. The result is a pointer to a
3193 static buffer, so CAVEAT EMPTOR! */
3194 const char *
3195 map_w32_filename (const char * name, const char ** pPath)
3196 {
3197 static char shortname[MAX_UTF8_PATH];
3198 char * str = shortname;
3199 char c;
3200 char * path;
3201 const char * save_name = name;
3202
3203 if (strlen (name) >= sizeof (shortname))
3204 {
3205 /* Return a filename which will cause callers to fail. */
3206 strcpy (shortname, "?");
3207 return shortname;
3208 }
3209
3210 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
3211 {
3212 register int left = 8; /* maximum number of chars in part */
3213 register int extn = 0; /* extension added? */
3214 register int dots = 2; /* maximum number of dots allowed */
3215
3216 while (name < path)
3217 *str++ = *name++; /* skip past UNC header */
3218
3219 while ((c = *name++))
3220 {
3221 switch ( c )
3222 {
3223 case ':':
3224 case '\\':
3225 case '/':
3226 *str++ = (c == ':' ? ':' : '\\');
3227 extn = 0; /* reset extension flags */
3228 dots = 2; /* max 2 dots */
3229 left = 8; /* max length 8 for main part */
3230 break;
3231 case '.':
3232 if ( dots )
3233 {
3234 /* Convert path components of the form .xxx to _xxx,
3235 but leave . and .. as they are. This allows .emacs
3236 to be read as _emacs, for example. */
3237
3238 if (! *name ||
3239 *name == '.' ||
3240 IS_DIRECTORY_SEP (*name))
3241 {
3242 *str++ = '.';
3243 dots--;
3244 }
3245 else
3246 {
3247 *str++ = '_';
3248 left--;
3249 dots = 0;
3250 }
3251 }
3252 else if ( !extn )
3253 {
3254 *str++ = '.';
3255 extn = 1; /* we've got an extension */
3256 left = 3; /* 3 chars in extension */
3257 }
3258 else
3259 {
3260 /* any embedded dots after the first are converted to _ */
3261 *str++ = '_';
3262 }
3263 break;
3264 case '~':
3265 case '#': /* don't lose these, they're important */
3266 if ( ! left )
3267 str[-1] = c; /* replace last character of part */
3268 /* FALLTHRU */
3269 default:
3270 if ( left && 'A' <= c && c <= 'Z' )
3271 {
3272 *str++ = tolower (c); /* map to lower case (looks nicer) */
3273 left--;
3274 dots = 0; /* started a path component */
3275 }
3276 break;
3277 }
3278 }
3279 *str = '\0';
3280 }
3281 else
3282 {
3283 strcpy (shortname, name);
3284 unixtodos_filename (shortname);
3285 }
3286
3287 if (pPath)
3288 *pPath = shortname + (path - save_name);
3289
3290 return shortname;
3291 }
3292
3293 static int
3294 is_exec (const char * name)
3295 {
3296 char * p = strrchr (name, '.');
3297 return
3298 (p != NULL
3299 && (xstrcasecmp (p, ".exe") == 0 ||
3300 xstrcasecmp (p, ".com") == 0 ||
3301 xstrcasecmp (p, ".bat") == 0 ||
3302 xstrcasecmp (p, ".cmd") == 0));
3303 }
3304
3305 /* Emulate the Unix directory procedures opendir, closedir, and
3306 readdir. We rename them to sys_* names because some versions of
3307 MinGW startup code call opendir and readdir to glob wildcards, and
3308 the code that calls them doesn't grok UTF-8 encoded file names we
3309 produce in dirent->d_name[]. */
3310
3311 struct dirent dir_static; /* simulated directory contents */
3312 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
3313 static int dir_is_fat;
3314 static char dir_pathname[MAX_UTF8_PATH];
3315 static WIN32_FIND_DATAW dir_find_data_w;
3316 static WIN32_FIND_DATAA dir_find_data_a;
3317 #define DIR_FIND_DATA_W 1
3318 #define DIR_FIND_DATA_A 2
3319 static int last_dir_find_data = -1;
3320
3321 /* Support shares on a network resource as subdirectories of a read-only
3322 root directory. */
3323 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
3324 static HANDLE open_unc_volume (const char *);
3325 static void *read_unc_volume (HANDLE, wchar_t *, char *, int);
3326 static void close_unc_volume (HANDLE);
3327
3328 DIR *
3329 sys_opendir (const char *filename)
3330 {
3331 DIR *dirp;
3332
3333 /* Opening is done by FindFirstFile. However, a read is inherent to
3334 this operation, so we defer the open until read time. */
3335
3336 if (dir_find_handle != INVALID_HANDLE_VALUE)
3337 return NULL;
3338 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
3339 return NULL;
3340
3341 /* Note: We don't support traversal of UNC volumes via symlinks.
3342 Doing so would mean punishing 99.99% of use cases by resolving
3343 all the possible symlinks in FILENAME, recursively. */
3344 if (is_unc_volume (filename))
3345 {
3346 wnet_enum_handle = open_unc_volume (filename);
3347 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
3348 return NULL;
3349 }
3350
3351 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
3352 return NULL;
3353
3354 dirp->dd_fd = 0;
3355 dirp->dd_loc = 0;
3356 dirp->dd_size = 0;
3357
3358 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAX_UTF8_PATH - 1);
3359 dir_pathname[MAX_UTF8_PATH - 1] = '\0';
3360 /* Note: We don't support symlinks to file names on FAT volumes.
3361 Doing so would mean punishing 99.99% of use cases by resolving
3362 all the possible symlinks in FILENAME, recursively. */
3363 dir_is_fat = is_fat_volume (filename, NULL);
3364
3365 return dirp;
3366 }
3367
3368 void
3369 sys_closedir (DIR *dirp)
3370 {
3371 /* If we have a find-handle open, close it. */
3372 if (dir_find_handle != INVALID_HANDLE_VALUE)
3373 {
3374 FindClose (dir_find_handle);
3375 dir_find_handle = INVALID_HANDLE_VALUE;
3376 }
3377 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
3378 {
3379 close_unc_volume (wnet_enum_handle);
3380 wnet_enum_handle = INVALID_HANDLE_VALUE;
3381 }
3382 xfree ((char *) dirp);
3383 }
3384
3385 struct dirent *
3386 sys_readdir (DIR *dirp)
3387 {
3388 int downcase = !NILP (Vw32_downcase_file_names);
3389
3390 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
3391 {
3392 if (!read_unc_volume (wnet_enum_handle,
3393 dir_find_data_w.cFileName,
3394 dir_find_data_a.cFileName,
3395 MAX_PATH))
3396 return NULL;
3397 }
3398 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3399 else if (dir_find_handle == INVALID_HANDLE_VALUE)
3400 {
3401 char filename[MAX_UTF8_PATH + 2];
3402 int ln;
3403
3404 strcpy (filename, dir_pathname);
3405 ln = strlen (filename) - 1;
3406 if (!IS_DIRECTORY_SEP (filename[ln]))
3407 strcat (filename, "\\");
3408 strcat (filename, "*");
3409
3410 /* Note: No need to resolve symlinks in FILENAME, because
3411 FindFirst opens the directory that is the target of a
3412 symlink. */
3413 if (w32_unicode_filenames)
3414 {
3415 wchar_t fnw[MAX_PATH];
3416
3417 filename_to_utf16 (filename, fnw);
3418 dir_find_handle = FindFirstFileW (fnw, &dir_find_data_w);
3419 }
3420 else
3421 {
3422 char fna[MAX_PATH];
3423
3424 filename_to_ansi (filename, fna);
3425 /* If FILENAME is not representable by the current ANSI
3426 codepage, we don't want FindFirstFileA to interpret the
3427 '?' characters as a wildcard. */
3428 if (_mbspbrk (fna, "?"))
3429 dir_find_handle = INVALID_HANDLE_VALUE;
3430 else
3431 dir_find_handle = FindFirstFileA (fna, &dir_find_data_a);
3432 }
3433
3434 if (dir_find_handle == INVALID_HANDLE_VALUE)
3435 return NULL;
3436 }
3437 else if (w32_unicode_filenames)
3438 {
3439 if (!FindNextFileW (dir_find_handle, &dir_find_data_w))
3440 return NULL;
3441 }
3442 else
3443 {
3444 if (!FindNextFileA (dir_find_handle, &dir_find_data_a))
3445 return NULL;
3446 }
3447
3448 /* Emacs never uses this value, so don't bother making it match
3449 value returned by stat(). */
3450 dir_static.d_ino = 1;
3451
3452 if (w32_unicode_filenames)
3453 {
3454 if (downcase || dir_is_fat)
3455 {
3456 wchar_t tem[MAX_PATH];
3457
3458 wcscpy (tem, dir_find_data_w.cFileName);
3459 CharLowerW (tem);
3460 filename_from_utf16 (tem, dir_static.d_name);
3461 }
3462 else
3463 filename_from_utf16 (dir_find_data_w.cFileName, dir_static.d_name);
3464 last_dir_find_data = DIR_FIND_DATA_W;
3465 }
3466 else
3467 {
3468 char tem[MAX_PATH];
3469
3470 /* If the file name in cFileName[] includes `?' characters, it
3471 means the original file name used characters that cannot be
3472 represented by the current ANSI codepage. To avoid total
3473 lossage, retrieve the short 8+3 alias of the long file
3474 name. */
3475 if (_mbspbrk (dir_find_data_a.cFileName, "?"))
3476 {
3477 strcpy (tem, dir_find_data_a.cAlternateFileName);
3478 /* 8+3 aliases are returned in all caps, which could break
3479 various alists that look at filenames' extensions. */
3480 downcase = 1;
3481 }
3482 else if (downcase || dir_is_fat)
3483 strcpy (tem, dir_find_data_a.cFileName);
3484 else
3485 filename_from_ansi (dir_find_data_a.cFileName, dir_static.d_name);
3486 if (downcase || dir_is_fat)
3487 {
3488 _mbslwr (tem);
3489 filename_from_ansi (tem, dir_static.d_name);
3490 }
3491 last_dir_find_data = DIR_FIND_DATA_A;
3492 }
3493
3494 dir_static.d_namlen = strlen (dir_static.d_name);
3495 dir_static.d_reclen = sizeof (struct dirent) - MAX_UTF8_PATH + 3 +
3496 dir_static.d_namlen - dir_static.d_namlen % 4;
3497
3498 return &dir_static;
3499 }
3500
3501 static HANDLE
3502 open_unc_volume (const char *path)
3503 {
3504 const char *fn = map_w32_filename (path, NULL);
3505 DWORD result;
3506 HANDLE henum;
3507
3508 if (w32_unicode_filenames)
3509 {
3510 NETRESOURCEW nrw;
3511 wchar_t fnw[MAX_PATH];
3512
3513 nrw.dwScope = RESOURCE_GLOBALNET;
3514 nrw.dwType = RESOURCETYPE_DISK;
3515 nrw.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
3516 nrw.dwUsage = RESOURCEUSAGE_CONTAINER;
3517 nrw.lpLocalName = NULL;
3518 filename_to_utf16 (fn, fnw);
3519 nrw.lpRemoteName = fnw;
3520 nrw.lpComment = NULL;
3521 nrw.lpProvider = NULL;
3522
3523 result = WNetOpenEnumW (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
3524 RESOURCEUSAGE_CONNECTABLE, &nrw, &henum);
3525 }
3526 else
3527 {
3528 NETRESOURCEA nra;
3529 char fna[MAX_PATH];
3530
3531 nra.dwScope = RESOURCE_GLOBALNET;
3532 nra.dwType = RESOURCETYPE_DISK;
3533 nra.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
3534 nra.dwUsage = RESOURCEUSAGE_CONTAINER;
3535 nra.lpLocalName = NULL;
3536 filename_to_ansi (fn, fna);
3537 nra.lpRemoteName = fna;
3538 nra.lpComment = NULL;
3539 nra.lpProvider = NULL;
3540
3541 result = WNetOpenEnumA (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
3542 RESOURCEUSAGE_CONNECTABLE, &nra, &henum);
3543 }
3544 if (result == NO_ERROR)
3545 return henum;
3546 else
3547 return INVALID_HANDLE_VALUE;
3548 }
3549
3550 static void *
3551 read_unc_volume (HANDLE henum, wchar_t *fname_w, char *fname_a, int size)
3552 {
3553 DWORD count;
3554 int result;
3555 char *buffer;
3556 DWORD bufsize = 512;
3557 void *retval;
3558
3559 count = 1;
3560 if (w32_unicode_filenames)
3561 {
3562 wchar_t *ptrw;
3563
3564 bufsize *= 2;
3565 buffer = alloca (bufsize);
3566 result = WNetEnumResourceW (henum, &count, buffer, &bufsize);
3567 if (result != NO_ERROR)
3568 return NULL;
3569 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3570 ptrw = ((LPNETRESOURCEW) buffer)->lpRemoteName;
3571 ptrw += 2;
3572 while (*ptrw && *ptrw != L'/' && *ptrw != L'\\') ptrw++;
3573 ptrw++;
3574 wcsncpy (fname_w, ptrw, size);
3575 retval = fname_w;
3576 }
3577 else
3578 {
3579 int dbcs_p = max_filename_mbslen () > 1;
3580 char *ptra;
3581
3582 buffer = alloca (bufsize);
3583 result = WNetEnumResourceA (henum, &count, buffer, &bufsize);
3584 if (result != NO_ERROR)
3585 return NULL;
3586 ptra = ((LPNETRESOURCEA) buffer)->lpRemoteName;
3587 ptra += 2;
3588 if (!dbcs_p)
3589 while (*ptra && !IS_DIRECTORY_SEP (*ptra)) ptra++;
3590 else
3591 {
3592 while (*ptra && !IS_DIRECTORY_SEP (*ptra))
3593 ptra = CharNextExA (file_name_codepage, ptra, 0);
3594 }
3595 ptra++;
3596 strncpy (fname_a, ptra, size);
3597 retval = fname_a;
3598 }
3599
3600 return retval;
3601 }
3602
3603 static void
3604 close_unc_volume (HANDLE henum)
3605 {
3606 if (henum != INVALID_HANDLE_VALUE)
3607 WNetCloseEnum (henum);
3608 }
3609
3610 static DWORD
3611 unc_volume_file_attributes (const char *path)
3612 {
3613 HANDLE henum;
3614 DWORD attrs;
3615
3616 henum = open_unc_volume (path);
3617 if (henum == INVALID_HANDLE_VALUE)
3618 return -1;
3619
3620 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
3621
3622 close_unc_volume (henum);
3623
3624 return attrs;
3625 }
3626
3627 /* Ensure a network connection is authenticated. */
3628 static void
3629 logon_network_drive (const char *path)
3630 {
3631 char share[MAX_UTF8_PATH];
3632 int n_slashes;
3633 char drive[4];
3634 UINT drvtype;
3635 char *p;
3636 DWORD val;
3637
3638 if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
3639 drvtype = DRIVE_REMOTE;
3640 else if (path[0] == '\0' || path[1] != ':')
3641 drvtype = GetDriveType (NULL);
3642 else
3643 {
3644 drive[0] = path[0];
3645 drive[1] = ':';
3646 drive[2] = '\\';
3647 drive[3] = '\0';
3648 drvtype = GetDriveType (drive);
3649 }
3650
3651 /* Only logon to networked drives. */
3652 if (drvtype != DRIVE_REMOTE)
3653 return;
3654
3655 n_slashes = 2;
3656 strncpy (share, path, MAX_UTF8_PATH);
3657 /* Truncate to just server and share name. */
3658 for (p = share + 2; *p && p < share + MAX_UTF8_PATH; p++)
3659 {
3660 if (IS_DIRECTORY_SEP (*p) && ++n_slashes > 3)
3661 {
3662 *p = '\0';
3663 break;
3664 }
3665 }
3666
3667 if (w32_unicode_filenames)
3668 {
3669 NETRESOURCEW resourcew;
3670 wchar_t share_w[MAX_PATH];
3671
3672 resourcew.dwScope = RESOURCE_GLOBALNET;
3673 resourcew.dwType = RESOURCETYPE_DISK;
3674 resourcew.dwDisplayType = RESOURCEDISPLAYTYPE_SHARE;
3675 resourcew.dwUsage = RESOURCEUSAGE_CONTAINER;
3676 resourcew.lpLocalName = NULL;
3677 filename_to_utf16 (share, share_w);
3678 resourcew.lpRemoteName = share_w;
3679 resourcew.lpProvider = NULL;
3680
3681 val = WNetAddConnection2W (&resourcew, NULL, NULL, CONNECT_INTERACTIVE);
3682 }
3683 else
3684 {
3685 NETRESOURCEA resourcea;
3686 char share_a[MAX_PATH];
3687
3688 resourcea.dwScope = RESOURCE_GLOBALNET;
3689 resourcea.dwType = RESOURCETYPE_DISK;
3690 resourcea.dwDisplayType = RESOURCEDISPLAYTYPE_SHARE;
3691 resourcea.dwUsage = RESOURCEUSAGE_CONTAINER;
3692 resourcea.lpLocalName = NULL;
3693 filename_to_ansi (share, share_a);
3694 resourcea.lpRemoteName = share_a;
3695 resourcea.lpProvider = NULL;
3696
3697 val = WNetAddConnection2A (&resourcea, NULL, NULL, CONNECT_INTERACTIVE);
3698 }
3699
3700 switch (val)
3701 {
3702 case NO_ERROR:
3703 case ERROR_ALREADY_ASSIGNED:
3704 break;
3705 case ERROR_ACCESS_DENIED:
3706 case ERROR_LOGON_FAILURE:
3707 errno = EACCES;
3708 break;
3709 case ERROR_BUSY:
3710 errno = EAGAIN;
3711 break;
3712 case ERROR_BAD_NET_NAME:
3713 case ERROR_NO_NET_OR_BAD_PATH:
3714 case ERROR_NO_NETWORK:
3715 case ERROR_CANCELLED:
3716 default:
3717 errno = ENOENT;
3718 break;
3719 }
3720 }
3721
3722 /* Emulate faccessat(2). */
3723 int
3724 faccessat (int dirfd, const char * path, int mode, int flags)
3725 {
3726 DWORD attributes;
3727
3728 if (dirfd != AT_FDCWD
3729 && !(IS_DIRECTORY_SEP (path[0])
3730 || IS_DEVICE_SEP (path[1])))
3731 {
3732 errno = EBADF;
3733 return -1;
3734 }
3735
3736 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3737 newer versions blow up when passed D_OK. */
3738 path = map_w32_filename (path, NULL);
3739 /* If the last element of PATH is a symlink, we need to resolve it
3740 to get the attributes of its target file. Note: any symlinks in
3741 PATH elements other than the last one are transparently resolved
3742 by GetFileAttributes below. */
3743 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0
3744 && (flags & AT_SYMLINK_NOFOLLOW) == 0)
3745 path = chase_symlinks (path);
3746
3747 if (w32_unicode_filenames)
3748 {
3749 wchar_t path_w[MAX_PATH];
3750
3751 filename_to_utf16 (path, path_w);
3752 attributes = GetFileAttributesW (path_w);
3753 }
3754 else
3755 {
3756 char path_a[MAX_PATH];
3757
3758 filename_to_ansi (path, path_a);
3759 attributes = GetFileAttributesA (path_a);
3760 }
3761
3762 if (attributes == -1)
3763 {
3764 DWORD w32err = GetLastError ();
3765
3766 switch (w32err)
3767 {
3768 case ERROR_INVALID_NAME:
3769 case ERROR_BAD_PATHNAME:
3770 if (is_unc_volume (path))
3771 {
3772 attributes = unc_volume_file_attributes (path);
3773 if (attributes == -1)
3774 {
3775 errno = EACCES;
3776 return -1;
3777 }
3778 break;
3779 }
3780 /* FALLTHROUGH */
3781 case ERROR_FILE_NOT_FOUND:
3782 case ERROR_BAD_NETPATH:
3783 errno = ENOENT;
3784 break;
3785 default:
3786 errno = EACCES;
3787 break;
3788 }
3789 return -1;
3790 }
3791 if ((mode & X_OK) != 0
3792 && !(is_exec (path) || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0))
3793 {
3794 errno = EACCES;
3795 return -1;
3796 }
3797 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
3798 {
3799 errno = EACCES;
3800 return -1;
3801 }
3802 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
3803 {
3804 errno = EACCES;
3805 return -1;
3806 }
3807 return 0;
3808 }
3809
3810 /* A version of 'access' to be used locally with file names in
3811 locale-specific encoding. Does not resolve symlinks and does not
3812 support file names on FAT12 and FAT16 volumes, but that's OK, since
3813 we only invoke this function for files inside the Emacs source or
3814 installation tree, on directories (so any symlinks should have the
3815 directory bit set), and on short file names such as "C:/.emacs". */
3816 static int
3817 sys_access (const char *fname, int mode)
3818 {
3819 char fname_copy[MAX_PATH], *p;
3820 DWORD attributes;
3821
3822 strcpy (fname_copy, fname);
3823 /* Do the equivalent of unixtodos_filename. */
3824 for (p = fname_copy; *p; p = CharNext (p))
3825 if (*p == '/')
3826 *p = '\\';
3827
3828 if ((attributes = GetFileAttributesA (fname_copy)) == -1)
3829 {
3830 DWORD w32err = GetLastError ();
3831
3832 switch (w32err)
3833 {
3834 case ERROR_INVALID_NAME:
3835 case ERROR_BAD_PATHNAME:
3836 case ERROR_FILE_NOT_FOUND:
3837 case ERROR_BAD_NETPATH:
3838 errno = ENOENT;
3839 break;
3840 default:
3841 errno = EACCES;
3842 break;
3843 }
3844 return -1;
3845 }
3846 if ((mode & X_OK) != 0
3847 && !(is_exec (fname_copy)
3848 || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0))
3849 {
3850 errno = EACCES;
3851 return -1;
3852 }
3853 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
3854 {
3855 errno = EACCES;
3856 return -1;
3857 }
3858 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
3859 {
3860 errno = EACCES;
3861 return -1;
3862 }
3863 return 0;
3864 }
3865
3866 /* Shadow some MSVC runtime functions to map requests for long filenames
3867 to reasonable short names if necessary. This was originally added to
3868 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3869 long file names. */
3870
3871 int
3872 sys_chdir (const char * path)
3873 {
3874 path = map_w32_filename (path, NULL);
3875 if (w32_unicode_filenames)
3876 {
3877 wchar_t newdir_w[MAX_PATH];
3878
3879 if (filename_to_utf16 (path, newdir_w) == 0)
3880 return _wchdir (newdir_w);
3881 return -1;
3882 }
3883 else
3884 {
3885 char newdir_a[MAX_PATH];
3886
3887 if (filename_to_ansi (path, newdir_a) == 0)
3888 return _chdir (newdir_a);
3889 return -1;
3890 }
3891 }
3892
3893 int
3894 sys_chmod (const char * path, int mode)
3895 {
3896 path = chase_symlinks (map_w32_filename (path, NULL));
3897 if (w32_unicode_filenames)
3898 {
3899 wchar_t path_w[MAX_PATH];
3900
3901 filename_to_utf16 (path, path_w);
3902 return _wchmod (path_w, mode);
3903 }
3904 else
3905 {
3906 char path_a[MAX_PATH];
3907
3908 filename_to_ansi (path, path_a);
3909 return _chmod (path_a, mode);
3910 }
3911 }
3912
3913 int
3914 sys_creat (const char * path, int mode)
3915 {
3916 path = map_w32_filename (path, NULL);
3917 if (w32_unicode_filenames)
3918 {
3919 wchar_t path_w[MAX_PATH];
3920
3921 filename_to_utf16 (path, path_w);
3922 return _wcreat (path_w, mode);
3923 }
3924 else
3925 {
3926 char path_a[MAX_PATH];
3927
3928 filename_to_ansi (path, path_a);
3929 return _creat (path_a, mode);
3930 }
3931 }
3932
3933 FILE *
3934 sys_fopen (const char * path, const char * mode)
3935 {
3936 int fd;
3937 int oflag;
3938 const char * mode_save = mode;
3939
3940 /* Force all file handles to be non-inheritable. This is necessary to
3941 ensure child processes don't unwittingly inherit handles that might
3942 prevent future file access. */
3943
3944 if (mode[0] == 'r')
3945 oflag = O_RDONLY;
3946 else if (mode[0] == 'w' || mode[0] == 'a')
3947 oflag = O_WRONLY | O_CREAT | O_TRUNC;
3948 else
3949 return NULL;
3950
3951 /* Only do simplistic option parsing. */
3952 while (*++mode)
3953 if (mode[0] == '+')
3954 {
3955 oflag &= ~(O_RDONLY | O_WRONLY);
3956 oflag |= O_RDWR;
3957 }
3958 else if (mode[0] == 'b')
3959 {
3960 oflag &= ~O_TEXT;
3961 oflag |= O_BINARY;
3962 }
3963 else if (mode[0] == 't')
3964 {
3965 oflag &= ~O_BINARY;
3966 oflag |= O_TEXT;
3967 }
3968 else break;
3969
3970 path = map_w32_filename (path, NULL);
3971 if (w32_unicode_filenames)
3972 {
3973 wchar_t path_w[MAX_PATH];
3974
3975 filename_to_utf16 (path, path_w);
3976 fd = _wopen (path_w, oflag | _O_NOINHERIT, 0644);
3977 }
3978 else
3979 {
3980 char path_a[MAX_PATH];
3981
3982 filename_to_ansi (path, path_a);
3983 fd = _open (path_a, oflag | _O_NOINHERIT, 0644);
3984 }
3985 if (fd < 0)
3986 return NULL;
3987
3988 return _fdopen (fd, mode_save);
3989 }
3990
3991 /* This only works on NTFS volumes, but is useful to have. */
3992 int
3993 sys_link (const char * old, const char * new)
3994 {
3995 HANDLE fileh;
3996 int result = -1;
3997 char oldname[MAX_UTF8_PATH], newname[MAX_UTF8_PATH];
3998 wchar_t oldname_w[MAX_PATH];
3999 char oldname_a[MAX_PATH];
4000
4001 if (old == NULL || new == NULL)
4002 {
4003 errno = ENOENT;
4004 return -1;
4005 }
4006
4007 strcpy (oldname, map_w32_filename (old, NULL));
4008 strcpy (newname, map_w32_filename (new, NULL));
4009
4010 if (w32_unicode_filenames)
4011 {
4012 filename_to_utf16 (oldname, oldname_w);
4013 fileh = CreateFileW (oldname_w, 0, 0, NULL, OPEN_EXISTING,
4014 FILE_FLAG_BACKUP_SEMANTICS, NULL);
4015 }
4016 else
4017 {
4018 filename_to_ansi (oldname, oldname_a);
4019 fileh = CreateFileA (oldname_a, 0, 0, NULL, OPEN_EXISTING,
4020 FILE_FLAG_BACKUP_SEMANTICS, NULL);
4021 }
4022 if (fileh != INVALID_HANDLE_VALUE)
4023 {
4024 int wlen;
4025
4026 /* Confusingly, the "alternate" stream name field does not apply
4027 when restoring a hard link, and instead contains the actual
4028 stream data for the link (ie. the name of the link to create).
4029 The WIN32_STREAM_ID structure before the cStreamName field is
4030 the stream header, which is then immediately followed by the
4031 stream data. */
4032
4033 struct {
4034 WIN32_STREAM_ID wid;
4035 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
4036 } data;
4037
4038 /* We used to pass MB_PRECOMPOSED as the 2nd arg here, but MSDN
4039 indicates that flag is unsupported for CP_UTF8, and OTOH says
4040 it is the default anyway. */
4041 wlen = pMultiByteToWideChar (CP_UTF8, 0, newname, -1,
4042 data.wid.cStreamName, MAX_PATH);
4043 if (wlen > 0)
4044 {
4045 LPVOID context = NULL;
4046 DWORD wbytes = 0;
4047
4048 data.wid.dwStreamId = BACKUP_LINK;
4049 data.wid.dwStreamAttributes = 0;
4050 data.wid.Size.LowPart = wlen * sizeof (WCHAR);
4051 data.wid.Size.HighPart = 0;
4052 data.wid.dwStreamNameSize = 0;
4053
4054 if (BackupWrite (fileh, (LPBYTE)&data,
4055 offsetof (WIN32_STREAM_ID, cStreamName)
4056 + data.wid.Size.LowPart,
4057 &wbytes, FALSE, FALSE, &context)
4058 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
4059 {
4060 /* succeeded */
4061 result = 0;
4062 }
4063 else
4064 {
4065 DWORD err = GetLastError ();
4066 DWORD attributes;
4067
4068 switch (err)
4069 {
4070 case ERROR_ACCESS_DENIED:
4071 /* This is what happens when OLDNAME is a directory,
4072 since Windows doesn't support hard links to
4073 directories. Posix says to set errno to EPERM in
4074 that case. */
4075 if (w32_unicode_filenames)
4076 attributes = GetFileAttributesW (oldname_w);
4077 else
4078 attributes = GetFileAttributesA (oldname_a);
4079 if (attributes != -1
4080 && (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
4081 errno = EPERM;
4082 else if (attributes == -1
4083 && is_unc_volume (oldname)
4084 && unc_volume_file_attributes (oldname) != -1)
4085 errno = EPERM;
4086 else
4087 errno = EACCES;
4088 break;
4089 case ERROR_TOO_MANY_LINKS:
4090 errno = EMLINK;
4091 break;
4092 case ERROR_NOT_SAME_DEVICE:
4093 errno = EXDEV;
4094 break;
4095 default:
4096 errno = EINVAL;
4097 break;
4098 }
4099 }
4100 }
4101
4102 CloseHandle (fileh);
4103 }
4104 else
4105 errno = ENOENT;
4106
4107 return result;
4108 }
4109
4110 int
4111 sys_mkdir (const char * path)
4112 {
4113 path = map_w32_filename (path, NULL);
4114
4115 if (w32_unicode_filenames)
4116 {
4117 wchar_t path_w[MAX_PATH];
4118
4119 filename_to_utf16 (path, path_w);
4120 return _wmkdir (path_w);
4121 }
4122 else
4123 {
4124 char path_a[MAX_PATH];
4125
4126 filename_to_ansi (path, path_a);
4127 return _mkdir (path_a);
4128 }
4129 }
4130
4131 int
4132 sys_open (const char * path, int oflag, int mode)
4133 {
4134 const char* mpath = map_w32_filename (path, NULL);
4135 int res = -1;
4136
4137 if (w32_unicode_filenames)
4138 {
4139 wchar_t mpath_w[MAX_PATH];
4140
4141 filename_to_utf16 (mpath, mpath_w);
4142 /* If possible, try to open file without _O_CREAT, to be able to
4143 write to existing hidden and system files. Force all file
4144 handles to be non-inheritable. */
4145 if ((oflag & (_O_CREAT | _O_EXCL)) != (_O_CREAT | _O_EXCL))
4146 res = _wopen (mpath_w, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
4147 if (res < 0)
4148 res = _wopen (mpath_w, oflag | _O_NOINHERIT, mode);
4149 }
4150 else
4151 {
4152 char mpath_a[MAX_PATH];
4153
4154 filename_to_ansi (mpath, mpath_a);
4155 if ((oflag & (_O_CREAT | _O_EXCL)) != (_O_CREAT | _O_EXCL))
4156 res = _open (mpath_a, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
4157 if (res < 0)
4158 res = _open (mpath_a, oflag | _O_NOINHERIT, mode);
4159 }
4160
4161 return res;
4162 }
4163
4164 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
4165 when using mktemp.
4166
4167 Standard algorithm for generating a temporary file name seems to be
4168 use pid or tid with a letter on the front (in place of the 6 X's)
4169 and cycle through the letters to find a unique name. We extend
4170 that to allow any reasonable character as the first of the 6 X's,
4171 so that the number of simultaneously used temporary files will be
4172 greater. */
4173
4174 int
4175 mkostemp (char * template, int flags)
4176 {
4177 char * p;
4178 int i, fd = -1;
4179 unsigned uid = GetCurrentThreadId ();
4180 int save_errno = errno;
4181 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
4182
4183 errno = EINVAL;
4184 if (template == NULL)
4185 return -1;
4186
4187 p = template + strlen (template);
4188 i = 5;
4189 /* replace up to the last 5 X's with uid in decimal */
4190 while (--p >= template && p[0] == 'X' && --i >= 0)
4191 {
4192 p[0] = '0' + uid % 10;
4193 uid /= 10;
4194 }
4195
4196 if (i < 0 && p[0] == 'X')
4197 {
4198 i = 0;
4199 do
4200 {
4201 p[0] = first_char[i];
4202 if ((fd = sys_open (template,
4203 flags | _O_CREAT | _O_EXCL | _O_RDWR,
4204 S_IRUSR | S_IWUSR)) >= 0
4205 || errno != EEXIST)
4206 {
4207 if (fd >= 0)
4208 errno = save_errno;
4209 return fd;
4210 }
4211 }
4212 while (++i < sizeof (first_char));
4213 }
4214
4215 /* Template is badly formed or else we can't generate a unique name. */
4216 return -1;
4217 }
4218
4219 int
4220 fchmod (int fd, mode_t mode)
4221 {
4222 return 0;
4223 }
4224
4225 int
4226 sys_rename_replace (const char *oldname, const char *newname, BOOL force)
4227 {
4228 BOOL result;
4229 char temp[MAX_UTF8_PATH], temp_a[MAX_PATH];;
4230 int newname_dev;
4231 int oldname_dev;
4232 bool have_temp_a = false;
4233
4234 /* MoveFile on Windows 95 doesn't correctly change the short file name
4235 alias in a number of circumstances (it is not easy to predict when
4236 just by looking at oldname and newname, unfortunately). In these
4237 cases, renaming through a temporary name avoids the problem.
4238
4239 A second problem on Windows 95 is that renaming through a temp name when
4240 newname is uppercase fails (the final long name ends up in
4241 lowercase, although the short alias might be uppercase) UNLESS the
4242 long temp name is not 8.3.
4243
4244 So, on Windows 95 we always rename through a temp name, and we make sure
4245 the temp name has a long extension to ensure correct renaming. */
4246
4247 strcpy (temp, map_w32_filename (oldname, NULL));
4248
4249 /* volume_info is set indirectly by map_w32_filename. */
4250 oldname_dev = volume_info.serialnum;
4251
4252 if (os_subtype == OS_9X)
4253 {
4254 char * o;
4255 char * p;
4256 int i = 0;
4257 char oldname_a[MAX_PATH];
4258
4259 oldname = map_w32_filename (oldname, NULL);
4260 filename_to_ansi (oldname, oldname_a);
4261 filename_to_ansi (temp, temp_a);
4262 if ((o = strrchr (oldname_a, '\\')))
4263 o++;
4264 else
4265 o = (char *) oldname_a;
4266
4267 if ((p = strrchr (temp_a, '\\')))
4268 p++;
4269 else
4270 p = temp_a;
4271
4272 do
4273 {
4274 /* Force temp name to require a manufactured 8.3 alias - this
4275 seems to make the second rename work properly. */
4276 sprintf (p, "_.%s.%u", o, i);
4277 i++;
4278 result = rename (oldname_a, temp_a);
4279 }
4280 /* This loop must surely terminate! */
4281 while (result < 0 && errno == EEXIST);
4282 if (result < 0)
4283 return -1;
4284 have_temp_a = true;
4285 }
4286
4287 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
4288 (at least if it is a file; don't do this for directories).
4289
4290 Since we mustn't do this if we are just changing the case of the
4291 file name (we would end up deleting the file we are trying to
4292 rename!), we let rename detect if the destination file already
4293 exists - that way we avoid the possible pitfalls of trying to
4294 determine ourselves whether two names really refer to the same
4295 file, which is not always possible in the general case. (Consider
4296 all the permutations of shared or subst'd drives, etc.) */
4297
4298 newname = map_w32_filename (newname, NULL);
4299
4300 /* volume_info is set indirectly by map_w32_filename. */
4301 newname_dev = volume_info.serialnum;
4302
4303 if (w32_unicode_filenames)
4304 {
4305 wchar_t temp_w[MAX_PATH], newname_w[MAX_PATH];
4306
4307 filename_to_utf16 (temp, temp_w);
4308 filename_to_utf16 (newname, newname_w);
4309 result = _wrename (temp_w, newname_w);
4310 if (result < 0 && force)
4311 {
4312 DWORD w32err = GetLastError ();
4313
4314 if (errno == EACCES
4315 && newname_dev != oldname_dev)
4316 {
4317 /* The implementation of `rename' on Windows does not return
4318 errno = EXDEV when you are moving a directory to a
4319 different storage device (ex. logical disk). It returns
4320 EACCES instead. So here we handle such situations and
4321 return EXDEV. */
4322 DWORD attributes;
4323
4324 if ((attributes = GetFileAttributesW (temp_w)) != -1
4325 && (attributes & FILE_ATTRIBUTE_DIRECTORY))
4326 errno = EXDEV;
4327 }
4328 else if (errno == EEXIST)
4329 {
4330 if (_wchmod (newname_w, 0666) != 0)
4331 return result;
4332 if (_wunlink (newname_w) != 0)
4333 return result;
4334 result = _wrename (temp_w, newname_w);
4335 }
4336 else if (w32err == ERROR_PRIVILEGE_NOT_HELD
4337 && is_symlink (temp))
4338 {
4339 /* This is Windows prohibiting the user from creating a
4340 symlink in another place, since that requires
4341 privileges. */
4342 errno = EPERM;
4343 }
4344 }
4345 }
4346 else
4347 {
4348 char newname_a[MAX_PATH];
4349
4350 if (!have_temp_a)
4351 filename_to_ansi (temp, temp_a);
4352 filename_to_ansi (newname, newname_a);
4353 result = rename (temp_a, newname_a);
4354 if (result < 0 && force)
4355 {
4356 DWORD w32err = GetLastError ();
4357
4358 if (errno == EACCES
4359 && newname_dev != oldname_dev)
4360 {
4361 DWORD attributes;
4362
4363 if ((attributes = GetFileAttributesA (temp_a)) != -1
4364 && (attributes & FILE_ATTRIBUTE_DIRECTORY))
4365 errno = EXDEV;
4366 }
4367 else if (errno == EEXIST)
4368 {
4369 if (_chmod (newname_a, 0666) != 0)
4370 return result;
4371 if (_unlink (newname_a) != 0)
4372 return result;
4373 result = rename (temp_a, newname_a);
4374 }
4375 else if (w32err == ERROR_PRIVILEGE_NOT_HELD
4376 && is_symlink (temp))
4377 errno = EPERM;
4378 }
4379 }
4380
4381 return result;
4382 }
4383
4384 int
4385 sys_rename (char const *old, char const *new)
4386 {
4387 return sys_rename_replace (old, new, TRUE);
4388 }
4389
4390 int
4391 sys_rmdir (const char * path)
4392 {
4393 path = map_w32_filename (path, NULL);
4394
4395 if (w32_unicode_filenames)
4396 {
4397 wchar_t path_w[MAX_PATH];
4398
4399 filename_to_utf16 (path, path_w);
4400 return _wrmdir (path_w);
4401 }
4402 else
4403 {
4404 char path_a[MAX_PATH];
4405
4406 filename_to_ansi (path, path_a);
4407 return _rmdir (path_a);
4408 }
4409 }
4410
4411 int
4412 sys_unlink (const char * path)
4413 {
4414 path = map_w32_filename (path, NULL);
4415
4416 if (w32_unicode_filenames)
4417 {
4418 wchar_t path_w[MAX_PATH];
4419
4420 filename_to_utf16 (path, path_w);
4421 /* On Unix, unlink works without write permission. */
4422 _wchmod (path_w, 0666);
4423 return _wunlink (path_w);
4424 }
4425 else
4426 {
4427 char path_a[MAX_PATH];
4428
4429 filename_to_ansi (path, path_a);
4430 _chmod (path_a, 0666);
4431 return _unlink (path_a);
4432 }
4433 }
4434
4435 static FILETIME utc_base_ft;
4436 static ULONGLONG utc_base; /* In 100ns units */
4437 static int init = 0;
4438
4439 #define FILETIME_TO_U64(result, ft) \
4440 do { \
4441 ULARGE_INTEGER uiTemp; \
4442 uiTemp.LowPart = (ft).dwLowDateTime; \
4443 uiTemp.HighPart = (ft).dwHighDateTime; \
4444 result = uiTemp.QuadPart; \
4445 } while (0)
4446
4447 static void
4448 initialize_utc_base (void)
4449 {
4450 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4451 SYSTEMTIME st;
4452
4453 st.wYear = 1970;
4454 st.wMonth = 1;
4455 st.wDay = 1;
4456 st.wHour = 0;
4457 st.wMinute = 0;
4458 st.wSecond = 0;
4459 st.wMilliseconds = 0;
4460
4461 SystemTimeToFileTime (&st, &utc_base_ft);
4462 FILETIME_TO_U64 (utc_base, utc_base_ft);
4463 }
4464
4465 static time_t
4466 convert_time (FILETIME ft)
4467 {
4468 ULONGLONG tmp;
4469
4470 if (!init)
4471 {
4472 initialize_utc_base ();
4473 init = 1;
4474 }
4475
4476 if (CompareFileTime (&ft, &utc_base_ft) < 0)
4477 return 0;
4478
4479 FILETIME_TO_U64 (tmp, ft);
4480 return (time_t) ((tmp - utc_base) / 10000000L);
4481 }
4482
4483 static void
4484 convert_from_time_t (time_t time, FILETIME * pft)
4485 {
4486 ULARGE_INTEGER tmp;
4487
4488 if (!init)
4489 {
4490 initialize_utc_base ();
4491 init = 1;
4492 }
4493
4494 /* time in 100ns units since 1-Jan-1601 */
4495 tmp.QuadPart = (ULONGLONG) time * 10000000L + utc_base;
4496 pft->dwHighDateTime = tmp.HighPart;
4497 pft->dwLowDateTime = tmp.LowPart;
4498 }
4499
4500 static PSECURITY_DESCRIPTOR
4501 get_file_security_desc_by_handle (HANDLE h)
4502 {
4503 PSECURITY_DESCRIPTOR psd = NULL;
4504 DWORD err;
4505 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
4506 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
4507
4508 err = get_security_info (h, SE_FILE_OBJECT, si,
4509 NULL, NULL, NULL, NULL, &psd);
4510 if (err != ERROR_SUCCESS)
4511 return NULL;
4512
4513 return psd;
4514 }
4515
4516 static PSECURITY_DESCRIPTOR
4517 get_file_security_desc_by_name (const char *fname)
4518 {
4519 PSECURITY_DESCRIPTOR psd = NULL;
4520 DWORD sd_len, err;
4521 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
4522 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
4523
4524 if (!get_file_security (fname, si, psd, 0, &sd_len))
4525 {
4526 err = GetLastError ();
4527 if (err != ERROR_INSUFFICIENT_BUFFER)
4528 return NULL;
4529 }
4530
4531 psd = xmalloc (sd_len);
4532 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
4533 {
4534 xfree (psd);
4535 return NULL;
4536 }
4537
4538 return psd;
4539 }
4540
4541 static DWORD
4542 get_rid (PSID sid)
4543 {
4544 unsigned n_subauthorities;
4545
4546 /* Use the last sub-authority value of the RID, the relative
4547 portion of the SID, as user/group ID. */
4548 n_subauthorities = *get_sid_sub_authority_count (sid);
4549 if (n_subauthorities < 1)
4550 return 0; /* the "World" RID */
4551 return *get_sid_sub_authority (sid, n_subauthorities - 1);
4552 }
4553
4554 /* Caching SID and account values for faster lokup. */
4555
4556 struct w32_id {
4557 unsigned rid;
4558 struct w32_id *next;
4559 char name[GNLEN+1];
4560 unsigned char sid[FLEXIBLE_ARRAY_MEMBER];
4561 };
4562
4563 static struct w32_id *w32_idlist;
4564
4565 static int
4566 w32_cached_id (PSID sid, unsigned *id, char *name)
4567 {
4568 struct w32_id *tail, *found;
4569
4570 for (found = NULL, tail = w32_idlist; tail; tail = tail->next)
4571 {
4572 if (equal_sid ((PSID)tail->sid, sid))
4573 {
4574 found = tail;
4575 break;
4576 }
4577 }
4578 if (found)
4579 {
4580 *id = found->rid;
4581 strcpy (name, found->name);
4582 return 1;
4583 }
4584 else
4585 return 0;
4586 }
4587
4588 static void
4589 w32_add_to_cache (PSID sid, unsigned id, char *name)
4590 {
4591 DWORD sid_len;
4592 struct w32_id *new_entry;
4593
4594 /* We don't want to leave behind stale cache from when Emacs was
4595 dumped. */
4596 if (initialized)
4597 {
4598 sid_len = get_length_sid (sid);
4599 new_entry = xmalloc (offsetof (struct w32_id, sid) + sid_len);
4600 if (new_entry)
4601 {
4602 new_entry->rid = id;
4603 strcpy (new_entry->name, name);
4604 copy_sid (sid_len, (PSID)new_entry->sid, sid);
4605 new_entry->next = w32_idlist;
4606 w32_idlist = new_entry;
4607 }
4608 }
4609 }
4610
4611 #define UID 1
4612 #define GID 2
4613
4614 static int
4615 get_name_and_id (PSECURITY_DESCRIPTOR psd, unsigned *id, char *nm, int what)
4616 {
4617 PSID sid = NULL;
4618 BOOL dflt;
4619 SID_NAME_USE ignore;
4620 char name[UNLEN+1];
4621 DWORD name_len = sizeof (name);
4622 char domain[1024];
4623 DWORD domain_len = sizeof (domain);
4624 int use_dflt = 0;
4625 int result;
4626
4627 if (what == UID)
4628 result = get_security_descriptor_owner (psd, &sid, &dflt);
4629 else if (what == GID)
4630 result = get_security_descriptor_group (psd, &sid, &dflt);
4631 else
4632 result = 0;
4633
4634 if (!result || !is_valid_sid (sid))
4635 use_dflt = 1;
4636 else if (!w32_cached_id (sid, id, nm))
4637 {
4638 if (!lookup_account_sid (NULL, sid, name, &name_len,
4639 domain, &domain_len, &ignore)
4640 || name_len > UNLEN+1)
4641 use_dflt = 1;
4642 else
4643 {
4644 *id = get_rid (sid);
4645 strcpy (nm, name);
4646 w32_add_to_cache (sid, *id, name);
4647 }
4648 }
4649 return use_dflt;
4650 }
4651
4652 static void
4653 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd, struct stat *st)
4654 {
4655 int dflt_usr = 0, dflt_grp = 0;
4656
4657 if (!psd)
4658 {
4659 dflt_usr = 1;
4660 dflt_grp = 1;
4661 }
4662 else
4663 {
4664 if (get_name_and_id (psd, &st->st_uid, st->st_uname, UID))
4665 dflt_usr = 1;
4666 if (get_name_and_id (psd, &st->st_gid, st->st_gname, GID))
4667 dflt_grp = 1;
4668 }
4669 /* Consider files to belong to current user/group, if we cannot get
4670 more accurate information. */
4671 if (dflt_usr)
4672 {
4673 st->st_uid = dflt_passwd.pw_uid;
4674 strcpy (st->st_uname, dflt_passwd.pw_name);
4675 }
4676 if (dflt_grp)
4677 {
4678 st->st_gid = dflt_passwd.pw_gid;
4679 strcpy (st->st_gname, dflt_group.gr_name);
4680 }
4681 }
4682
4683 /* Return non-zero if NAME is a potentially slow filesystem. */
4684 int
4685 is_slow_fs (const char *name)
4686 {
4687 char drive_root[4];
4688 UINT devtype;
4689
4690 if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
4691 devtype = DRIVE_REMOTE; /* assume UNC name is remote */
4692 else if (!(strlen (name) >= 2 && IS_DEVICE_SEP (name[1])))
4693 devtype = GetDriveType (NULL); /* use root of current drive */
4694 else
4695 {
4696 /* GetDriveType needs the root directory of the drive. */
4697 strncpy (drive_root, name, 2);
4698 drive_root[2] = '\\';
4699 drive_root[3] = '\0';
4700 devtype = GetDriveType (drive_root);
4701 }
4702 return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
4703 }
4704
4705 /* If this is non-zero, the caller wants accurate information about
4706 file's owner and group, which could be expensive to get. dired.c
4707 uses this flag when needed for the job at hand. */
4708 int w32_stat_get_owner_group;
4709
4710 /* MSVC stat function can't cope with UNC names and has other bugs, so
4711 replace it with our own. This also allows us to calculate consistent
4712 inode values and owner/group without hacks in the main Emacs code,
4713 and support file names encoded in UTF-8. */
4714
4715 static int
4716 stat_worker (const char * path, struct stat * buf, int follow_symlinks)
4717 {
4718 char *name, *save_name, *r;
4719 WIN32_FIND_DATAW wfd_w;
4720 WIN32_FIND_DATAA wfd_a;
4721 HANDLE fh;
4722 unsigned __int64 fake_inode = 0;
4723 int permission;
4724 int len;
4725 int rootdir = FALSE;
4726 PSECURITY_DESCRIPTOR psd = NULL;
4727 int is_a_symlink = 0;
4728 DWORD file_flags = FILE_FLAG_BACKUP_SEMANTICS;
4729 DWORD access_rights = 0;
4730 DWORD fattrs = 0, serialnum = 0, fs_high = 0, fs_low = 0, nlinks = 1;
4731 FILETIME ctime, atime, wtime;
4732 wchar_t name_w[MAX_PATH];
4733 char name_a[MAX_PATH];
4734
4735 if (path == NULL || buf == NULL)
4736 {
4737 errno = EFAULT;
4738 return -1;
4739 }
4740
4741 save_name = name = (char *) map_w32_filename (path, &path);
4742 /* Must be valid filename, no wild cards or other invalid
4743 characters. */
4744 if (strpbrk (name, "*?|<>\""))
4745 {
4746 errno = ENOENT;
4747 return -1;
4748 }
4749
4750 len = strlen (name);
4751 /* Allocate 1 extra byte so that we could append a slash to a root
4752 directory, down below. */
4753 name = strcpy (alloca (len + 2), name);
4754
4755 /* Avoid a somewhat costly call to is_symlink if the filesystem
4756 doesn't support symlinks. */
4757 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
4758 is_a_symlink = is_symlink (name);
4759
4760 /* Plan A: Open the file and get all the necessary information via
4761 the resulting handle. This solves several issues in one blow:
4762
4763 . retrieves attributes for the target of a symlink, if needed
4764 . gets attributes of root directories and symlinks pointing to
4765 root directories, thus avoiding the need for special-casing
4766 these and detecting them by examining the file-name format
4767 . retrieves more accurate attributes (e.g., non-zero size for
4768 some directories, esp. directories that are junction points)
4769 . correctly resolves "c:/..", "/.." and similar file names
4770 . avoids run-time penalties for 99% of use cases
4771
4772 Plan A is always tried first, unless the user asked not to (but
4773 if the file is a symlink and we need to follow links, we try Plan
4774 A even if the user asked not to).
4775
4776 If Plan A fails, we go to Plan B (below), where various
4777 potentially expensive techniques must be used to handle "special"
4778 files such as UNC volumes etc. */
4779 if (!(NILP (Vw32_get_true_file_attributes)
4780 || (EQ (Vw32_get_true_file_attributes, Qlocal) && is_slow_fs (name)))
4781 /* Following symlinks requires getting the info by handle. */
4782 || (is_a_symlink && follow_symlinks))
4783 {
4784 BY_HANDLE_FILE_INFORMATION info;
4785
4786 if (is_a_symlink && !follow_symlinks)
4787 file_flags |= FILE_FLAG_OPEN_REPARSE_POINT;
4788 /* READ_CONTROL access rights are required to get security info
4789 by handle. But if the OS doesn't support security in the
4790 first place, we don't need to try. */
4791 if (is_windows_9x () != TRUE)
4792 access_rights |= READ_CONTROL;
4793
4794 if (w32_unicode_filenames)
4795 {
4796 filename_to_utf16 (name, name_w);
4797 fh = CreateFileW (name_w, access_rights, 0, NULL, OPEN_EXISTING,
4798 file_flags, NULL);
4799 /* If CreateFile fails with READ_CONTROL, try again with
4800 zero as access rights. */
4801 if (fh == INVALID_HANDLE_VALUE && access_rights)
4802 fh = CreateFileW (name_w, 0, 0, NULL, OPEN_EXISTING,
4803 file_flags, NULL);
4804 }
4805 else
4806 {
4807 filename_to_ansi (name, name_a);
4808 fh = CreateFileA (name_a, access_rights, 0, NULL, OPEN_EXISTING,
4809 file_flags, NULL);
4810 if (fh == INVALID_HANDLE_VALUE && access_rights)
4811 fh = CreateFileA (name_a, 0, 0, NULL, OPEN_EXISTING,
4812 file_flags, NULL);
4813 }
4814 if (fh == INVALID_HANDLE_VALUE)
4815 goto no_true_file_attributes;
4816
4817 /* This is more accurate in terms of getting the correct number
4818 of links, but is quite slow (it is noticeable when Emacs is
4819 making a list of file name completions). */
4820 if (GetFileInformationByHandle (fh, &info))
4821 {
4822 nlinks = info.nNumberOfLinks;
4823 /* Might as well use file index to fake inode values, but this
4824 is not guaranteed to be unique unless we keep a handle open
4825 all the time (even then there are situations where it is
4826 not unique). Reputedly, there are at most 48 bits of info
4827 (on NTFS, presumably less on FAT). */
4828 fake_inode = info.nFileIndexHigh;
4829 fake_inode <<= 32;
4830 fake_inode += info.nFileIndexLow;
4831 serialnum = info.dwVolumeSerialNumber;
4832 fs_high = info.nFileSizeHigh;
4833 fs_low = info.nFileSizeLow;
4834 ctime = info.ftCreationTime;
4835 atime = info.ftLastAccessTime;
4836 wtime = info.ftLastWriteTime;
4837 fattrs = info.dwFileAttributes;
4838 }
4839 else
4840 {
4841 /* We don't go to Plan B here, because it's not clear that
4842 it's a good idea. The only known use case where
4843 CreateFile succeeds, but GetFileInformationByHandle fails
4844 (with ERROR_INVALID_FUNCTION) is for character devices
4845 such as NUL, PRN, etc. For these, switching to Plan B is
4846 a net loss, because we lose the character device
4847 attribute returned by GetFileType below (FindFirstFile
4848 doesn't set that bit in the attributes), and the other
4849 fields don't make sense for character devices anyway.
4850 Emacs doesn't really care for non-file entities in the
4851 context of l?stat, so neither do we. */
4852
4853 /* w32err is assigned so one could put a breakpoint here and
4854 examine its value, when GetFileInformationByHandle
4855 fails. */
4856 DWORD w32err = GetLastError ();
4857
4858 switch (w32err)
4859 {
4860 case ERROR_FILE_NOT_FOUND: /* can this ever happen? */
4861 errno = ENOENT;
4862 return -1;
4863 }
4864 }
4865
4866 /* Test for a symlink before testing for a directory, since
4867 symlinks to directories have the directory bit set, but we
4868 don't want them to appear as directories. */
4869 if (is_a_symlink && !follow_symlinks)
4870 buf->st_mode = S_IFLNK;
4871 else if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4872 buf->st_mode = S_IFDIR;
4873 else
4874 {
4875 DWORD ftype = GetFileType (fh);
4876
4877 switch (ftype)
4878 {
4879 case FILE_TYPE_DISK:
4880 buf->st_mode = S_IFREG;
4881 break;
4882 case FILE_TYPE_PIPE:
4883 buf->st_mode = S_IFIFO;
4884 break;
4885 case FILE_TYPE_CHAR:
4886 case FILE_TYPE_UNKNOWN:
4887 default:
4888 buf->st_mode = S_IFCHR;
4889 }
4890 }
4891 /* We produce the fallback owner and group data, based on the
4892 current user that runs Emacs, in the following cases:
4893
4894 . caller didn't request owner and group info
4895 . this is Windows 9X
4896 . getting security by handle failed, and we need to produce
4897 information for the target of a symlink (this is better
4898 than producing a potentially misleading info about the
4899 symlink itself)
4900
4901 If getting security by handle fails, and we don't need to
4902 resolve symlinks, we try getting security by name. */
4903 if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
4904 get_file_owner_and_group (NULL, buf);
4905 else
4906 {
4907 psd = get_file_security_desc_by_handle (fh);
4908 if (psd)
4909 {
4910 get_file_owner_and_group (psd, buf);
4911 LocalFree (psd);
4912 }
4913 else if (!(is_a_symlink && follow_symlinks))
4914 {
4915 psd = get_file_security_desc_by_name (name);
4916 get_file_owner_and_group (psd, buf);
4917 xfree (psd);
4918 }
4919 else
4920 get_file_owner_and_group (NULL, buf);
4921 }
4922 CloseHandle (fh);
4923 }
4924 else
4925 {
4926 no_true_file_attributes:
4927 /* Plan B: Either getting a handle on the file failed, or the
4928 caller explicitly asked us to not bother making this
4929 information more accurate.
4930
4931 Implementation note: In Plan B, we never bother to resolve
4932 symlinks, even if we got here because we tried Plan A and
4933 failed. That's because, even if the caller asked for extra
4934 precision by setting Vw32_get_true_file_attributes to t,
4935 resolving symlinks requires acquiring a file handle to the
4936 symlink, which we already know will fail. And if the user
4937 did not ask for extra precision, resolving symlinks will fly
4938 in the face of that request, since the user then wants the
4939 lightweight version of the code. */
4940 rootdir = (path >= save_name + len - 1
4941 && (IS_DIRECTORY_SEP (*path) || *path == 0));
4942
4943 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4944 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
4945 if (IS_DIRECTORY_SEP (r[0])
4946 && r[1] == '.' && r[2] == '.' && r[3] == '\0')
4947 r[1] = r[2] = '\0';
4948
4949 /* Note: If NAME is a symlink to the root of a UNC volume
4950 (i.e. "\\SERVER"), we will not detect that here, and we will
4951 return data about the symlink as result of FindFirst below.
4952 This is unfortunate, but that marginal use case does not
4953 justify a call to chase_symlinks which would impose a penalty
4954 on all the other use cases. (We get here for symlinks to
4955 roots of UNC volumes because CreateFile above fails for them,
4956 unlike with symlinks to root directories X:\ of drives.) */
4957 if (is_unc_volume (name))
4958 {
4959 fattrs = unc_volume_file_attributes (name);
4960 if (fattrs == -1)
4961 return -1;
4962
4963 ctime = atime = wtime = utc_base_ft;
4964 }
4965 else if (rootdir)
4966 {
4967 /* Make sure root directories end in a slash. */
4968 if (!IS_DIRECTORY_SEP (name[len-1]))
4969 strcat (name, "\\");
4970 if (GetDriveType (name) < 2)
4971 {
4972 errno = ENOENT;
4973 return -1;
4974 }
4975
4976 fattrs = FILE_ATTRIBUTE_DIRECTORY;
4977 ctime = atime = wtime = utc_base_ft;
4978 }
4979 else
4980 {
4981 int have_wfd = -1;
4982
4983 /* Make sure non-root directories do NOT end in a slash,
4984 otherwise FindFirstFile might fail. */
4985 if (IS_DIRECTORY_SEP (name[len-1]))
4986 name[len - 1] = 0;
4987
4988 /* (This is hacky, but helps when doing file completions on
4989 network drives.) Optimize by using information available from
4990 active readdir if possible. */
4991 len = strlen (dir_pathname);
4992 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
4993 len--;
4994 if (dir_find_handle != INVALID_HANDLE_VALUE
4995 && last_dir_find_data != -1
4996 && !(is_a_symlink && follow_symlinks)
4997 /* The 2 file-name comparisons below support only ASCII
4998 characters, and will lose (compare not equal) when
4999 the file names include non-ASCII characters that are
5000 the same but for the case. However, doing this
5001 properly involves: (a) converting both file names to
5002 UTF-16, (b) lower-casing both names using CharLowerW,
5003 and (c) comparing the results; this would be quite a
5004 bit slower, whereas Plan B is for users who want
5005 lightweight albeit inaccurate version of 'stat'. */
5006 && c_strncasecmp (save_name, dir_pathname, len) == 0
5007 && IS_DIRECTORY_SEP (name[len])
5008 && xstrcasecmp (name + len + 1, dir_static.d_name) == 0)
5009 {
5010 have_wfd = last_dir_find_data;
5011 /* This was the last entry returned by readdir. */
5012 if (last_dir_find_data == DIR_FIND_DATA_W)
5013 wfd_w = dir_find_data_w;
5014 else
5015 wfd_a = dir_find_data_a;
5016 }
5017 else
5018 {
5019 logon_network_drive (name);
5020
5021 if (w32_unicode_filenames)
5022 {
5023 filename_to_utf16 (name, name_w);
5024 fh = FindFirstFileW (name_w, &wfd_w);
5025 have_wfd = DIR_FIND_DATA_W;
5026 }
5027 else
5028 {
5029 filename_to_ansi (name, name_a);
5030 /* If NAME includes characters not representable by
5031 the current ANSI codepage, filename_to_ansi
5032 usually replaces them with a '?'. We don't want
5033 to let FindFirstFileA interpret those as wildcards,
5034 and "succeed", returning us data from some random
5035 file in the same directory. */
5036 if (_mbspbrk (name_a, "?"))
5037 fh = INVALID_HANDLE_VALUE;
5038 else
5039 fh = FindFirstFileA (name_a, &wfd_a);
5040 have_wfd = DIR_FIND_DATA_A;
5041 }
5042 if (fh == INVALID_HANDLE_VALUE)
5043 {
5044 errno = ENOENT;
5045 return -1;
5046 }
5047 FindClose (fh);
5048 }
5049 /* Note: if NAME is a symlink, the information we get from
5050 FindFirstFile is for the symlink, not its target. */
5051 if (have_wfd == DIR_FIND_DATA_W)
5052 {
5053 fattrs = wfd_w.dwFileAttributes;
5054 ctime = wfd_w.ftCreationTime;
5055 atime = wfd_w.ftLastAccessTime;
5056 wtime = wfd_w.ftLastWriteTime;
5057 fs_high = wfd_w.nFileSizeHigh;
5058 fs_low = wfd_w.nFileSizeLow;
5059 }
5060 else
5061 {
5062 fattrs = wfd_a.dwFileAttributes;
5063 ctime = wfd_a.ftCreationTime;
5064 atime = wfd_a.ftLastAccessTime;
5065 wtime = wfd_a.ftLastWriteTime;
5066 fs_high = wfd_a.nFileSizeHigh;
5067 fs_low = wfd_a.nFileSizeLow;
5068 }
5069 fake_inode = 0;
5070 nlinks = 1;
5071 serialnum = volume_info.serialnum;
5072 }
5073 if (is_a_symlink && !follow_symlinks)
5074 buf->st_mode = S_IFLNK;
5075 else if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
5076 buf->st_mode = S_IFDIR;
5077 else
5078 buf->st_mode = S_IFREG;
5079
5080 get_file_owner_and_group (NULL, buf);
5081 }
5082
5083 buf->st_ino = fake_inode;
5084
5085 buf->st_dev = serialnum;
5086 buf->st_rdev = serialnum;
5087
5088 buf->st_size = fs_high;
5089 buf->st_size <<= 32;
5090 buf->st_size += fs_low;
5091 buf->st_nlink = nlinks;
5092
5093 /* Convert timestamps to Unix format. */
5094 buf->st_mtime = convert_time (wtime);
5095 buf->st_atime = convert_time (atime);
5096 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
5097 buf->st_ctime = convert_time (ctime);
5098 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
5099
5100 /* determine rwx permissions */
5101 if (is_a_symlink && !follow_symlinks)
5102 permission = S_IREAD | S_IWRITE | S_IEXEC; /* Posix expectations */
5103 else
5104 {
5105 if (fattrs & FILE_ATTRIBUTE_READONLY)
5106 permission = S_IREAD;
5107 else
5108 permission = S_IREAD | S_IWRITE;
5109
5110 if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
5111 permission |= S_IEXEC;
5112 else if (is_exec (name))
5113 permission |= S_IEXEC;
5114 }
5115
5116 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
5117
5118 return 0;
5119 }
5120
5121 int
5122 stat (const char * path, struct stat * buf)
5123 {
5124 return stat_worker (path, buf, 1);
5125 }
5126
5127 int
5128 lstat (const char * path, struct stat * buf)
5129 {
5130 return stat_worker (path, buf, 0);
5131 }
5132
5133 int
5134 fstatat (int fd, char const *name, struct stat *st, int flags)
5135 {
5136 /* Rely on a hack: an open directory is modeled as file descriptor 0.
5137 This is good enough for the current usage in Emacs, but is fragile.
5138
5139 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
5140 Gnulib does this and can serve as a model. */
5141 char fullname[MAX_UTF8_PATH];
5142
5143 if (fd != AT_FDCWD)
5144 {
5145 char lastc = dir_pathname[strlen (dir_pathname) - 1];
5146
5147 if (_snprintf (fullname, sizeof fullname, "%s%s%s",
5148 dir_pathname, IS_DIRECTORY_SEP (lastc) ? "" : "/", name)
5149 < 0)
5150 {
5151 errno = ENAMETOOLONG;
5152 return -1;
5153 }
5154 name = fullname;
5155 }
5156
5157 return stat_worker (name, st, ! (flags & AT_SYMLINK_NOFOLLOW));
5158 }
5159
5160 /* Provide fstat and utime as well as stat for consistent handling of
5161 file timestamps. */
5162 int
5163 fstat (int desc, struct stat * buf)
5164 {
5165 HANDLE fh = (HANDLE) _get_osfhandle (desc);
5166 BY_HANDLE_FILE_INFORMATION info;
5167 unsigned __int64 fake_inode;
5168 int permission;
5169
5170 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
5171 {
5172 case FILE_TYPE_DISK:
5173 buf->st_mode = S_IFREG;
5174 if (!GetFileInformationByHandle (fh, &info))
5175 {
5176 errno = EACCES;
5177 return -1;
5178 }
5179 break;
5180 case FILE_TYPE_PIPE:
5181 buf->st_mode = S_IFIFO;
5182 goto non_disk;
5183 case FILE_TYPE_CHAR:
5184 case FILE_TYPE_UNKNOWN:
5185 default:
5186 buf->st_mode = S_IFCHR;
5187 non_disk:
5188 memset (&info, 0, sizeof (info));
5189 info.dwFileAttributes = 0;
5190 info.ftCreationTime = utc_base_ft;
5191 info.ftLastAccessTime = utc_base_ft;
5192 info.ftLastWriteTime = utc_base_ft;
5193 }
5194
5195 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
5196 buf->st_mode = S_IFDIR;
5197
5198 buf->st_nlink = info.nNumberOfLinks;
5199 /* Might as well use file index to fake inode values, but this
5200 is not guaranteed to be unique unless we keep a handle open
5201 all the time (even then there are situations where it is
5202 not unique). Reputedly, there are at most 48 bits of info
5203 (on NTFS, presumably less on FAT). */
5204 fake_inode = info.nFileIndexHigh;
5205 fake_inode <<= 32;
5206 fake_inode += info.nFileIndexLow;
5207
5208 /* MSVC defines _ino_t to be short; other libc's might not. */
5209 if (sizeof (buf->st_ino) == 2)
5210 buf->st_ino = fake_inode ^ (fake_inode >> 16);
5211 else
5212 buf->st_ino = fake_inode;
5213
5214 /* If the caller so requested, get the true file owner and group.
5215 Otherwise, consider the file to belong to the current user. */
5216 if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
5217 get_file_owner_and_group (NULL, buf);
5218 else
5219 {
5220 PSECURITY_DESCRIPTOR psd = NULL;
5221
5222 psd = get_file_security_desc_by_handle (fh);
5223 if (psd)
5224 {
5225 get_file_owner_and_group (psd, buf);
5226 LocalFree (psd);
5227 }
5228 else
5229 get_file_owner_and_group (NULL, buf);
5230 }
5231
5232 buf->st_dev = info.dwVolumeSerialNumber;
5233 buf->st_rdev = info.dwVolumeSerialNumber;
5234
5235 buf->st_size = info.nFileSizeHigh;
5236 buf->st_size <<= 32;
5237 buf->st_size += info.nFileSizeLow;
5238
5239 /* Convert timestamps to Unix format. */
5240 buf->st_mtime = convert_time (info.ftLastWriteTime);
5241 buf->st_atime = convert_time (info.ftLastAccessTime);
5242 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
5243 buf->st_ctime = convert_time (info.ftCreationTime);
5244 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
5245
5246 /* determine rwx permissions */
5247 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
5248 permission = S_IREAD;
5249 else
5250 permission = S_IREAD | S_IWRITE;
5251
5252 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
5253 permission |= S_IEXEC;
5254 else
5255 {
5256 #if 0 /* no way of knowing the filename */
5257 char * p = strrchr (name, '.');
5258 if (p != NULL &&
5259 (xstrcasecmp (p, ".exe") == 0 ||
5260 xstrcasecmp (p, ".com") == 0 ||
5261 xstrcasecmp (p, ".bat") == 0 ||
5262 xstrcasecmp (p, ".cmd") == 0))
5263 permission |= S_IEXEC;
5264 #endif
5265 }
5266
5267 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
5268
5269 return 0;
5270 }
5271
5272 /* A version of 'utime' which handles directories as well as
5273 files. */
5274
5275 int
5276 utime (const char *name, struct utimbuf *times)
5277 {
5278 struct utimbuf deftime;
5279 HANDLE fh;
5280 FILETIME mtime;
5281 FILETIME atime;
5282
5283 if (times == NULL)
5284 {
5285 deftime.modtime = deftime.actime = time (NULL);
5286 times = &deftime;
5287 }
5288
5289 if (w32_unicode_filenames)
5290 {
5291 wchar_t name_utf16[MAX_PATH];
5292
5293 if (filename_to_utf16 (name, name_utf16) != 0)
5294 return -1; /* errno set by filename_to_utf16 */
5295
5296 /* Need write access to set times. */
5297 fh = CreateFileW (name_utf16, FILE_WRITE_ATTRIBUTES,
5298 /* If NAME specifies a directory, FILE_SHARE_DELETE
5299 allows other processes to delete files inside it,
5300 while we have the directory open. */
5301 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
5302 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
5303 }
5304 else
5305 {
5306 char name_ansi[MAX_PATH];
5307
5308 if (filename_to_ansi (name, name_ansi) != 0)
5309 return -1; /* errno set by filename_to_ansi */
5310
5311 fh = CreateFileA (name_ansi, FILE_WRITE_ATTRIBUTES,
5312 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
5313 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
5314 }
5315 if (fh != INVALID_HANDLE_VALUE)
5316 {
5317 convert_from_time_t (times->actime, &atime);
5318 convert_from_time_t (times->modtime, &mtime);
5319 if (!SetFileTime (fh, NULL, &atime, &mtime))
5320 {
5321 CloseHandle (fh);
5322 errno = EACCES;
5323 return -1;
5324 }
5325 CloseHandle (fh);
5326 }
5327 else
5328 {
5329 DWORD err = GetLastError ();
5330
5331 switch (err)
5332 {
5333 case ERROR_FILE_NOT_FOUND:
5334 case ERROR_PATH_NOT_FOUND:
5335 case ERROR_INVALID_DRIVE:
5336 case ERROR_BAD_NETPATH:
5337 case ERROR_DEV_NOT_EXIST:
5338 /* ERROR_INVALID_NAME is the error CreateFile sets when the
5339 file name includes ?s, i.e. translation to ANSI failed. */
5340 case ERROR_INVALID_NAME:
5341 errno = ENOENT;
5342 break;
5343 case ERROR_TOO_MANY_OPEN_FILES:
5344 errno = ENFILE;
5345 break;
5346 case ERROR_ACCESS_DENIED:
5347 case ERROR_SHARING_VIOLATION:
5348 errno = EACCES;
5349 break;
5350 default:
5351 errno = EINVAL;
5352 break;
5353 }
5354 return -1;
5355 }
5356 return 0;
5357 }
5358
5359 int
5360 sys_umask (int mode)
5361 {
5362 static int current_mask;
5363 int retval, arg = 0;
5364
5365 /* The only bit we really support is the write bit. Files are
5366 always readable on MS-Windows, and the execute bit does not exist
5367 at all. */
5368 /* FIXME: if the GROUP and OTHER bits are reset, we should use ACLs
5369 to prevent access by other users on NTFS. */
5370 if ((mode & S_IWRITE) != 0)
5371 arg |= S_IWRITE;
5372
5373 retval = _umask (arg);
5374 /* Merge into the return value the bits they've set the last time,
5375 which msvcrt.dll ignores and never returns. Emacs insists on its
5376 notion of mask being identical to what we return. */
5377 retval |= (current_mask & ~S_IWRITE);
5378 current_mask = mode;
5379
5380 return retval;
5381 }
5382
5383 \f
5384 /* Symlink-related functions. */
5385 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
5386 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
5387 #endif
5388
5389 int
5390 symlink (char const *filename, char const *linkname)
5391 {
5392 char linkfn[MAX_UTF8_PATH], *tgtfn;
5393 DWORD flags = 0;
5394 int dir_access, filename_ends_in_slash;
5395
5396 /* Diagnostics follows Posix as much as possible. */
5397 if (filename == NULL || linkname == NULL)
5398 {
5399 errno = EFAULT;
5400 return -1;
5401 }
5402 if (!*filename)
5403 {
5404 errno = ENOENT;
5405 return -1;
5406 }
5407 if (strlen (filename) > MAX_UTF8_PATH || strlen (linkname) > MAX_UTF8_PATH)
5408 {
5409 errno = ENAMETOOLONG;
5410 return -1;
5411 }
5412
5413 strcpy (linkfn, map_w32_filename (linkname, NULL));
5414 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) == 0)
5415 {
5416 errno = EPERM;
5417 return -1;
5418 }
5419
5420 /* Note: since empty FILENAME was already rejected, we can safely
5421 refer to FILENAME[1]. */
5422 if (!(IS_DIRECTORY_SEP (filename[0]) || IS_DEVICE_SEP (filename[1])))
5423 {
5424 /* Non-absolute FILENAME is understood as being relative to
5425 LINKNAME's directory. We need to prepend that directory to
5426 FILENAME to get correct results from faccessat below, since
5427 otherwise it will interpret FILENAME relative to the
5428 directory where the Emacs process runs. Note that
5429 make-symbolic-link always makes sure LINKNAME is a fully
5430 expanded file name. */
5431 char tem[MAX_UTF8_PATH];
5432 char *p = linkfn + strlen (linkfn);
5433
5434 while (p > linkfn && !IS_ANY_SEP (p[-1]))
5435 p--;
5436 if (p > linkfn)
5437 strncpy (tem, linkfn, p - linkfn);
5438 tem[p - linkfn] = '\0';
5439 strcat (tem, filename);
5440 dir_access = faccessat (AT_FDCWD, tem, D_OK, AT_EACCESS);
5441 }
5442 else
5443 dir_access = faccessat (AT_FDCWD, filename, D_OK, AT_EACCESS);
5444
5445 /* Since Windows distinguishes between symlinks to directories and
5446 to files, we provide a kludgy feature: if FILENAME doesn't
5447 exist, but ends in a slash, we create a symlink to directory. If
5448 FILENAME exists and is a directory, we always create a symlink to
5449 directory. */
5450 filename_ends_in_slash = IS_DIRECTORY_SEP (filename[strlen (filename) - 1]);
5451 if (dir_access == 0 || filename_ends_in_slash)
5452 flags = SYMBOLIC_LINK_FLAG_DIRECTORY;
5453
5454 tgtfn = (char *)map_w32_filename (filename, NULL);
5455 if (filename_ends_in_slash)
5456 tgtfn[strlen (tgtfn) - 1] = '\0';
5457
5458 errno = 0;
5459 if (!create_symbolic_link (linkfn, tgtfn, flags))
5460 {
5461 /* ENOSYS is set by create_symbolic_link, when it detects that
5462 the OS doesn't support the CreateSymbolicLink API. */
5463 if (errno != ENOSYS)
5464 {
5465 DWORD w32err = GetLastError ();
5466
5467 switch (w32err)
5468 {
5469 /* ERROR_SUCCESS is sometimes returned when LINKFN and
5470 TGTFN point to the same file name, go figure. */
5471 case ERROR_SUCCESS:
5472 case ERROR_FILE_EXISTS:
5473 errno = EEXIST;
5474 break;
5475 case ERROR_ACCESS_DENIED:
5476 errno = EACCES;
5477 break;
5478 case ERROR_FILE_NOT_FOUND:
5479 case ERROR_PATH_NOT_FOUND:
5480 case ERROR_BAD_NETPATH:
5481 case ERROR_INVALID_REPARSE_DATA:
5482 errno = ENOENT;
5483 break;
5484 case ERROR_DIRECTORY:
5485 errno = EISDIR;
5486 break;
5487 case ERROR_PRIVILEGE_NOT_HELD:
5488 case ERROR_NOT_ALL_ASSIGNED:
5489 errno = EPERM;
5490 break;
5491 case ERROR_DISK_FULL:
5492 errno = ENOSPC;
5493 break;
5494 default:
5495 errno = EINVAL;
5496 break;
5497 }
5498 }
5499 return -1;
5500 }
5501 return 0;
5502 }
5503
5504 /* A quick inexpensive test of whether FILENAME identifies a file that
5505 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
5506 must already be in the normalized form returned by
5507 map_w32_filename.
5508
5509 Note: for repeated operations on many files, it is best to test
5510 whether the underlying volume actually supports symlinks, by
5511 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
5512 avoid the call to this function if it doesn't. That's because the
5513 call to GetFileAttributes takes a non-negligible time, especially
5514 on non-local or removable filesystems. See stat_worker for an
5515 example of how to do that. */
5516 static int
5517 is_symlink (const char *filename)
5518 {
5519 DWORD attrs;
5520 wchar_t filename_w[MAX_PATH];
5521 char filename_a[MAX_PATH];
5522 WIN32_FIND_DATAW wfdw;
5523 WIN32_FIND_DATAA wfda;
5524 HANDLE fh;
5525 int attrs_mean_symlink;
5526
5527 if (w32_unicode_filenames)
5528 {
5529 filename_to_utf16 (filename, filename_w);
5530 attrs = GetFileAttributesW (filename_w);
5531 }
5532 else
5533 {
5534 filename_to_ansi (filename, filename_a);
5535 attrs = GetFileAttributesA (filename_a);
5536 }
5537 if (attrs == -1)
5538 {
5539 DWORD w32err = GetLastError ();
5540
5541 switch (w32err)
5542 {
5543 case ERROR_BAD_NETPATH: /* network share, can't be a symlink */
5544 break;
5545 case ERROR_ACCESS_DENIED:
5546 errno = EACCES;
5547 break;
5548 case ERROR_FILE_NOT_FOUND:
5549 case ERROR_PATH_NOT_FOUND:
5550 default:
5551 errno = ENOENT;
5552 break;
5553 }
5554 return 0;
5555 }
5556 if ((attrs & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
5557 return 0;
5558 logon_network_drive (filename);
5559 if (w32_unicode_filenames)
5560 {
5561 fh = FindFirstFileW (filename_w, &wfdw);
5562 attrs_mean_symlink =
5563 (wfdw.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
5564 && (wfdw.dwReserved0 & IO_REPARSE_TAG_SYMLINK) == IO_REPARSE_TAG_SYMLINK;
5565 }
5566 else if (_mbspbrk (filename_a, "?"))
5567 {
5568 /* filename_to_ansi failed to convert the file name. */
5569 errno = ENOENT;
5570 return 0;
5571 }
5572 else
5573 {
5574 fh = FindFirstFileA (filename_a, &wfda);
5575 attrs_mean_symlink =
5576 (wfda.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
5577 && (wfda.dwReserved0 & IO_REPARSE_TAG_SYMLINK) == IO_REPARSE_TAG_SYMLINK;
5578 }
5579 if (fh == INVALID_HANDLE_VALUE)
5580 return 0;
5581 FindClose (fh);
5582 return attrs_mean_symlink;
5583 }
5584
5585 /* If NAME identifies a symbolic link, copy into BUF the file name of
5586 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
5587 null-terminate the target name, even if it fits. Return the number
5588 of bytes copied, or -1 if NAME is not a symlink or any error was
5589 encountered while resolving it. The file name copied into BUF is
5590 encoded in the current ANSI codepage. */
5591 ssize_t
5592 readlink (const char *name, char *buf, size_t buf_size)
5593 {
5594 const char *path;
5595 TOKEN_PRIVILEGES privs;
5596 int restore_privs = 0;
5597 HANDLE sh;
5598 ssize_t retval;
5599 char resolved[MAX_UTF8_PATH];
5600
5601 if (name == NULL)
5602 {
5603 errno = EFAULT;
5604 return -1;
5605 }
5606 if (!*name)
5607 {
5608 errno = ENOENT;
5609 return -1;
5610 }
5611
5612 path = map_w32_filename (name, NULL);
5613
5614 if (strlen (path) > MAX_UTF8_PATH)
5615 {
5616 errno = ENAMETOOLONG;
5617 return -1;
5618 }
5619
5620 errno = 0;
5621 if (is_windows_9x () == TRUE
5622 || (volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) == 0
5623 || !is_symlink (path))
5624 {
5625 if (!errno)
5626 errno = EINVAL; /* not a symlink */
5627 return -1;
5628 }
5629
5630 /* Done with simple tests, now we're in for some _real_ work. */
5631 if (enable_privilege (SE_BACKUP_NAME, TRUE, &privs))
5632 restore_privs = 1;
5633 /* Implementation note: From here and onward, don't return early,
5634 since that will fail to restore the original set of privileges of
5635 the calling thread. */
5636
5637 retval = -1; /* not too optimistic, are we? */
5638
5639 /* Note: In the next call to CreateFile, we use zero as the 2nd
5640 argument because, when the symlink is a hidden/system file,
5641 e.g. 'C:\Users\All Users', GENERIC_READ fails with
5642 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
5643 and directory symlinks. */
5644 if (w32_unicode_filenames)
5645 {
5646 wchar_t path_w[MAX_PATH];
5647
5648 filename_to_utf16 (path, path_w);
5649 sh = CreateFileW (path_w, 0, 0, NULL, OPEN_EXISTING,
5650 FILE_FLAG_OPEN_REPARSE_POINT
5651 | FILE_FLAG_BACKUP_SEMANTICS,
5652 NULL);
5653 }
5654 else
5655 {
5656 char path_a[MAX_PATH];
5657
5658 filename_to_ansi (path, path_a);
5659 sh = CreateFileA (path_a, 0, 0, NULL, OPEN_EXISTING,
5660 FILE_FLAG_OPEN_REPARSE_POINT
5661 | FILE_FLAG_BACKUP_SEMANTICS,
5662 NULL);
5663 }
5664 if (sh != INVALID_HANDLE_VALUE)
5665 {
5666 BYTE reparse_buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
5667 REPARSE_DATA_BUFFER *reparse_data = (REPARSE_DATA_BUFFER *)&reparse_buf[0];
5668 DWORD retbytes;
5669
5670 if (!DeviceIoControl (sh, FSCTL_GET_REPARSE_POINT, NULL, 0,
5671 reparse_buf, MAXIMUM_REPARSE_DATA_BUFFER_SIZE,
5672 &retbytes, NULL))
5673 errno = EIO;
5674 else if (reparse_data->ReparseTag != IO_REPARSE_TAG_SYMLINK)
5675 errno = EINVAL;
5676 else
5677 {
5678 /* Copy the link target name, in wide characters, from
5679 reparse_data, then convert it to multibyte encoding in
5680 the current locale's codepage. */
5681 WCHAR *lwname;
5682 size_t lname_size;
5683 USHORT lwname_len =
5684 reparse_data->SymbolicLinkReparseBuffer.PrintNameLength;
5685 WCHAR *lwname_src =
5686 reparse_data->SymbolicLinkReparseBuffer.PathBuffer
5687 + reparse_data->SymbolicLinkReparseBuffer.PrintNameOffset/sizeof(WCHAR);
5688 size_t size_to_copy = buf_size;
5689
5690 /* According to MSDN, PrintNameLength does not include the
5691 terminating null character. */
5692 lwname = alloca ((lwname_len + 1) * sizeof(WCHAR));
5693 memcpy (lwname, lwname_src, lwname_len);
5694 lwname[lwname_len/sizeof(WCHAR)] = 0; /* null-terminate */
5695 filename_from_utf16 (lwname, resolved);
5696 dostounix_filename (resolved);
5697 lname_size = strlen (resolved) + 1;
5698 if (lname_size <= buf_size)
5699 size_to_copy = lname_size;
5700 strncpy (buf, resolved, size_to_copy);
5701 /* Success! */
5702 retval = size_to_copy;
5703 }
5704 CloseHandle (sh);
5705 }
5706 else
5707 {
5708 /* CreateFile failed. */
5709 DWORD w32err2 = GetLastError ();
5710
5711 switch (w32err2)
5712 {
5713 case ERROR_FILE_NOT_FOUND:
5714 case ERROR_PATH_NOT_FOUND:
5715 errno = ENOENT;
5716 break;
5717 case ERROR_ACCESS_DENIED:
5718 case ERROR_TOO_MANY_OPEN_FILES:
5719 errno = EACCES;
5720 break;
5721 default:
5722 errno = EPERM;
5723 break;
5724 }
5725 }
5726 if (restore_privs)
5727 {
5728 restore_privilege (&privs);
5729 revert_to_self ();
5730 }
5731
5732 return retval;
5733 }
5734
5735 ssize_t
5736 readlinkat (int fd, char const *name, char *buffer,
5737 size_t buffer_size)
5738 {
5739 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5740 as in fstatat. FIXME: Add proper support for readlinkat. */
5741 char fullname[MAX_UTF8_PATH];
5742
5743 if (fd != AT_FDCWD)
5744 {
5745 if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
5746 < 0)
5747 {
5748 errno = ENAMETOOLONG;
5749 return -1;
5750 }
5751 name = fullname;
5752 }
5753
5754 return readlink (name, buffer, buffer_size);
5755 }
5756
5757 /* If FILE is a symlink, return its target (stored in a static
5758 buffer); otherwise return FILE.
5759
5760 This function repeatedly resolves symlinks in the last component of
5761 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5762 until it arrives at a file whose last component is not a symlink,
5763 or some error occurs. It returns the target of the last
5764 successfully resolved symlink in the chain. If it succeeds to
5765 resolve even a single symlink, the value returned is an absolute
5766 file name with backslashes (result of GetFullPathName). By
5767 contrast, if the original FILE is returned, it is unaltered.
5768
5769 Note: This function can set errno even if it succeeds.
5770
5771 Implementation note: we only resolve the last portion ("basename")
5772 of the argument FILE and of each following file in the chain,
5773 disregarding any possible symlinks in its leading directories.
5774 This is because Windows system calls and library functions
5775 transparently resolve symlinks in leading directories and return
5776 correct information, as long as the basename is not a symlink. */
5777 static char *
5778 chase_symlinks (const char *file)
5779 {
5780 static char target[MAX_UTF8_PATH];
5781 char link[MAX_UTF8_PATH];
5782 wchar_t target_w[MAX_PATH], link_w[MAX_PATH];
5783 char target_a[MAX_PATH], link_a[MAX_PATH];
5784 ssize_t res, link_len;
5785 int loop_count = 0;
5786
5787 if (is_windows_9x () == TRUE || !is_symlink (file))
5788 return (char *)file;
5789
5790 if (w32_unicode_filenames)
5791 {
5792 wchar_t file_w[MAX_PATH];
5793
5794 filename_to_utf16 (file, file_w);
5795 if (GetFullPathNameW (file_w, MAX_PATH, link_w, NULL) == 0)
5796 return (char *)file;
5797 filename_from_utf16 (link_w, link);
5798 }
5799 else
5800 {
5801 char file_a[MAX_PATH];
5802
5803 filename_to_ansi (file, file_a);
5804 if (GetFullPathNameA (file_a, MAX_PATH, link_a, NULL) == 0)
5805 return (char *)file;
5806 filename_from_ansi (link_a, link);
5807 }
5808 link_len = strlen (link);
5809
5810 target[0] = '\0';
5811 do {
5812
5813 /* Remove trailing slashes, as we want to resolve the last
5814 non-trivial part of the link name. */
5815 while (link_len > 3 && IS_DIRECTORY_SEP (link[link_len-1]))
5816 link[link_len--] = '\0';
5817
5818 res = readlink (link, target, MAX_UTF8_PATH);
5819 if (res > 0)
5820 {
5821 target[res] = '\0';
5822 if (!(IS_DEVICE_SEP (target[1])
5823 || (IS_DIRECTORY_SEP (target[0]) && IS_DIRECTORY_SEP (target[1]))))
5824 {
5825 /* Target is relative. Append it to the directory part of
5826 the symlink, then copy the result back to target. */
5827 char *p = link + link_len;
5828
5829 while (p > link && !IS_ANY_SEP (p[-1]))
5830 p--;
5831 strcpy (p, target);
5832 strcpy (target, link);
5833 }
5834 /* Resolve any "." and ".." to get a fully-qualified file name
5835 in link[] again. */
5836 if (w32_unicode_filenames)
5837 {
5838 filename_to_utf16 (target, target_w);
5839 link_len = GetFullPathNameW (target_w, MAX_PATH, link_w, NULL);
5840 if (link_len > 0)
5841 filename_from_utf16 (link_w, link);
5842 }
5843 else
5844 {
5845 filename_to_ansi (target, target_a);
5846 link_len = GetFullPathNameA (target_a, MAX_PATH, link_a, NULL);
5847 if (link_len > 0)
5848 filename_from_ansi (link_a, link);
5849 }
5850 link_len = strlen (link);
5851 }
5852 } while (res > 0 && link_len > 0 && ++loop_count <= 100);
5853
5854 if (loop_count > 100)
5855 errno = ELOOP;
5856
5857 if (target[0] == '\0') /* not a single call to readlink succeeded */
5858 return (char *)file;
5859 return target;
5860 }
5861
5862 \f
5863 /* Posix ACL emulation. */
5864
5865 int
5866 acl_valid (acl_t acl)
5867 {
5868 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR)acl) ? 0 : -1;
5869 }
5870
5871 char *
5872 acl_to_text (acl_t acl, ssize_t *size)
5873 {
5874 LPTSTR str_acl;
5875 SECURITY_INFORMATION flags =
5876 OWNER_SECURITY_INFORMATION |
5877 GROUP_SECURITY_INFORMATION |
5878 DACL_SECURITY_INFORMATION;
5879 char *retval = NULL;
5880 ULONG local_size;
5881 int e = errno;
5882
5883 errno = 0;
5884
5885 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR)acl, SDDL_REVISION_1, flags, &str_acl, &local_size))
5886 {
5887 errno = e;
5888 /* We don't want to mix heaps, so we duplicate the string in our
5889 heap and free the one allocated by the API. */
5890 retval = xstrdup (str_acl);
5891 if (size)
5892 *size = local_size;
5893 LocalFree (str_acl);
5894 }
5895 else if (errno != ENOTSUP)
5896 errno = EINVAL;
5897
5898 return retval;
5899 }
5900
5901 acl_t
5902 acl_from_text (const char *acl_str)
5903 {
5904 PSECURITY_DESCRIPTOR psd, retval = NULL;
5905 ULONG sd_size;
5906 int e = errno;
5907
5908 errno = 0;
5909
5910 if (convert_sddl_to_sd (acl_str, SDDL_REVISION_1, &psd, &sd_size))
5911 {
5912 errno = e;
5913 retval = xmalloc (sd_size);
5914 memcpy (retval, psd, sd_size);
5915 LocalFree (psd);
5916 }
5917 else if (errno != ENOTSUP)
5918 errno = EINVAL;
5919
5920 return retval;
5921 }
5922
5923 int
5924 acl_free (void *ptr)
5925 {
5926 xfree (ptr);
5927 return 0;
5928 }
5929
5930 acl_t
5931 acl_get_file (const char *fname, acl_type_t type)
5932 {
5933 PSECURITY_DESCRIPTOR psd = NULL;
5934 const char *filename;
5935
5936 if (type == ACL_TYPE_ACCESS)
5937 {
5938 DWORD sd_len, err;
5939 SECURITY_INFORMATION si =
5940 OWNER_SECURITY_INFORMATION |
5941 GROUP_SECURITY_INFORMATION |
5942 DACL_SECURITY_INFORMATION ;
5943 int e = errno;
5944
5945 filename = map_w32_filename (fname, NULL);
5946 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
5947 fname = chase_symlinks (filename);
5948 else
5949 fname = filename;
5950
5951 errno = 0;
5952 if (!get_file_security (fname, si, psd, 0, &sd_len)
5953 && errno != ENOTSUP)
5954 {
5955 err = GetLastError ();
5956 if (err == ERROR_INSUFFICIENT_BUFFER)
5957 {
5958 psd = xmalloc (sd_len);
5959 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
5960 {
5961 xfree (psd);
5962 errno = EIO;
5963 psd = NULL;
5964 }
5965 }
5966 else if (err == ERROR_FILE_NOT_FOUND
5967 || err == ERROR_PATH_NOT_FOUND
5968 /* ERROR_INVALID_NAME is what we get if
5969 w32-unicode-filenames is nil and the file cannot
5970 be encoded in the current ANSI codepage. */
5971 || err == ERROR_INVALID_NAME)
5972 errno = ENOENT;
5973 else
5974 errno = EIO;
5975 }
5976 else if (!errno)
5977 errno = e;
5978 }
5979 else if (type != ACL_TYPE_DEFAULT)
5980 errno = EINVAL;
5981
5982 return psd;
5983 }
5984
5985 int
5986 acl_set_file (const char *fname, acl_type_t type, acl_t acl)
5987 {
5988 TOKEN_PRIVILEGES old1, old2;
5989 DWORD err;
5990 int st = 0, retval = -1;
5991 SECURITY_INFORMATION flags = 0;
5992 PSID psidOwner, psidGroup;
5993 PACL pacl;
5994 BOOL dflt;
5995 BOOL dacl_present;
5996 int e;
5997 const char *filename;
5998
5999 if (acl_valid (acl) != 0
6000 || (type != ACL_TYPE_DEFAULT && type != ACL_TYPE_ACCESS))
6001 {
6002 errno = EINVAL;
6003 return -1;
6004 }
6005
6006 if (type == ACL_TYPE_DEFAULT)
6007 {
6008 errno = ENOSYS;
6009 return -1;
6010 }
6011
6012 filename = map_w32_filename (fname, NULL);
6013 if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
6014 fname = chase_symlinks (filename);
6015 else
6016 fname = filename;
6017
6018 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR)acl, &psidOwner,
6019 &dflt)
6020 && psidOwner)
6021 flags |= OWNER_SECURITY_INFORMATION;
6022 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR)acl, &psidGroup,
6023 &dflt)
6024 && psidGroup)
6025 flags |= GROUP_SECURITY_INFORMATION;
6026 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR)acl, &dacl_present,
6027 &pacl, &dflt)
6028 && dacl_present)
6029 flags |= DACL_SECURITY_INFORMATION;
6030 if (!flags)
6031 return 0;
6032
6033 /* According to KB-245153, setting the owner will succeed if either:
6034 (1) the caller is the user who will be the new owner, and has the
6035 SE_TAKE_OWNERSHIP privilege, or
6036 (2) the caller has the SE_RESTORE privilege, in which case she can
6037 set any valid user or group as the owner
6038
6039 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
6040 privileges, and disregard any failures in obtaining them. If
6041 these privileges cannot be obtained, and do not already exist in
6042 the calling thread's security token, this function could fail
6043 with EPERM. */
6044 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME, TRUE, &old1))
6045 st++;
6046 if (enable_privilege (SE_RESTORE_NAME, TRUE, &old2))
6047 st++;
6048
6049 e = errno;
6050 errno = 0;
6051 /* SetFileSecurity is deprecated by MS, and sometimes fails when
6052 DACL inheritance is involved, but it seems to preserve ownership
6053 better than SetNamedSecurityInfo, which is important e.g., in
6054 copy-file. */
6055 if (!set_file_security (fname, flags, (PSECURITY_DESCRIPTOR)acl))
6056 {
6057 err = GetLastError ();
6058
6059 if (errno != ENOTSUP)
6060 err = set_named_security_info (fname, SE_FILE_OBJECT, flags,
6061 psidOwner, psidGroup, pacl, NULL);
6062 }
6063 else
6064 err = ERROR_SUCCESS;
6065 if (err != ERROR_SUCCESS)
6066 {
6067 if (errno == ENOTSUP)
6068 ;
6069 else if (err == ERROR_INVALID_OWNER
6070 || err == ERROR_NOT_ALL_ASSIGNED
6071 || err == ERROR_ACCESS_DENIED)
6072 {
6073 /* Maybe the requested ACL and the one the file already has
6074 are identical, in which case we can silently ignore the
6075 failure. (And no, Windows doesn't.) */
6076 acl_t current_acl = acl_get_file (fname, ACL_TYPE_ACCESS);
6077
6078 errno = EPERM;
6079 if (current_acl)
6080 {
6081 char *acl_from = acl_to_text (current_acl, NULL);
6082 char *acl_to = acl_to_text (acl, NULL);
6083
6084 if (acl_from && acl_to && xstrcasecmp (acl_from, acl_to) == 0)
6085 {
6086 retval = 0;
6087 errno = e;
6088 }
6089 if (acl_from)
6090 acl_free (acl_from);
6091 if (acl_to)
6092 acl_free (acl_to);
6093 acl_free (current_acl);
6094 }
6095 }
6096 else if (err == ERROR_FILE_NOT_FOUND
6097 || err == ERROR_PATH_NOT_FOUND
6098 /* ERROR_INVALID_NAME is what we get if
6099 w32-unicode-filenames is nil and the file cannot be
6100 encoded in the current ANSI codepage. */
6101 || err == ERROR_INVALID_NAME)
6102 errno = ENOENT;
6103 else
6104 errno = EACCES;
6105 }
6106 else
6107 {
6108 retval = 0;
6109 errno = e;
6110 }
6111
6112 if (st)
6113 {
6114 if (st >= 2)
6115 restore_privilege (&old2);
6116 restore_privilege (&old1);
6117 revert_to_self ();
6118 }
6119
6120 return retval;
6121 }
6122
6123 \f
6124 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
6125 have a fixed max size for file names, so we don't need the kind of
6126 alloc/malloc/realloc dance the gnulib version does. We also don't
6127 support FD-relative symlinks. */
6128 char *
6129 careadlinkat (int fd, char const *filename,
6130 char *buffer, size_t buffer_size,
6131 struct allocator const *alloc,
6132 ssize_t (*preadlinkat) (int, char const *, char *, size_t))
6133 {
6134 char linkname[MAX_UTF8_PATH];
6135 ssize_t link_size;
6136
6137 link_size = preadlinkat (fd, filename, linkname, sizeof(linkname));
6138
6139 if (link_size > 0)
6140 {
6141 char *retval = buffer;
6142
6143 linkname[link_size++] = '\0';
6144 if (link_size > buffer_size)
6145 retval = (char *)(alloc ? alloc->allocate : xmalloc) (link_size);
6146 if (retval)
6147 memcpy (retval, linkname, link_size);
6148
6149 return retval;
6150 }
6151 return NULL;
6152 }
6153
6154 int
6155 w32_copy_file (const char *from, const char *to,
6156 int keep_time, int preserve_ownership, int copy_acls)
6157 {
6158 acl_t acl = NULL;
6159 BOOL copy_result;
6160 wchar_t from_w[MAX_PATH], to_w[MAX_PATH];
6161 char from_a[MAX_PATH], to_a[MAX_PATH];
6162
6163 /* We ignore preserve_ownership for now. */
6164 preserve_ownership = preserve_ownership;
6165
6166 if (copy_acls)
6167 {
6168 acl = acl_get_file (from, ACL_TYPE_ACCESS);
6169 if (acl == NULL && acl_errno_valid (errno))
6170 return -2;
6171 }
6172 if (w32_unicode_filenames)
6173 {
6174 filename_to_utf16 (from, from_w);
6175 filename_to_utf16 (to, to_w);
6176 copy_result = CopyFileW (from_w, to_w, FALSE);
6177 }
6178 else
6179 {
6180 filename_to_ansi (from, from_a);
6181 filename_to_ansi (to, to_a);
6182 copy_result = CopyFileA (from_a, to_a, FALSE);
6183 }
6184 if (!copy_result)
6185 {
6186 /* CopyFile doesn't set errno when it fails. By far the most
6187 "popular" reason is that the target is read-only. */
6188 DWORD err = GetLastError ();
6189
6190 switch (err)
6191 {
6192 case ERROR_FILE_NOT_FOUND:
6193 errno = ENOENT;
6194 break;
6195 case ERROR_ACCESS_DENIED:
6196 errno = EACCES;
6197 break;
6198 case ERROR_ENCRYPTION_FAILED:
6199 errno = EIO;
6200 break;
6201 default:
6202 errno = EPERM;
6203 break;
6204 }
6205
6206 if (acl)
6207 acl_free (acl);
6208 return -1;
6209 }
6210 /* CopyFile retains the timestamp by default. However, see
6211 "Community Additions" for CopyFile: it sounds like that is not
6212 entirely true. Testing on Windows XP confirms that modified time
6213 is copied, but creation and last-access times are not.
6214 FIXME? */
6215 else if (!keep_time)
6216 {
6217 struct timespec now;
6218 DWORD attributes;
6219
6220 if (w32_unicode_filenames)
6221 {
6222 /* Ensure file is writable while its times are set. */
6223 attributes = GetFileAttributesW (to_w);
6224 SetFileAttributesW (to_w, attributes & ~FILE_ATTRIBUTE_READONLY);
6225 now = current_timespec ();
6226 if (set_file_times (-1, to, now, now))
6227 {
6228 /* Restore original attributes. */
6229 SetFileAttributesW (to_w, attributes);
6230 if (acl)
6231 acl_free (acl);
6232 return -3;
6233 }
6234 /* Restore original attributes. */
6235 SetFileAttributesW (to_w, attributes);
6236 }
6237 else
6238 {
6239 attributes = GetFileAttributesA (to_a);
6240 SetFileAttributesA (to_a, attributes & ~FILE_ATTRIBUTE_READONLY);
6241 now = current_timespec ();
6242 if (set_file_times (-1, to, now, now))
6243 {
6244 SetFileAttributesA (to_a, attributes);
6245 if (acl)
6246 acl_free (acl);
6247 return -3;
6248 }
6249 SetFileAttributesA (to_a, attributes);
6250 }
6251 }
6252 if (acl != NULL)
6253 {
6254 bool fail =
6255 acl_set_file (to, ACL_TYPE_ACCESS, acl) != 0;
6256 acl_free (acl);
6257 if (fail && acl_errno_valid (errno))
6258 return -4;
6259 }
6260
6261 return 0;
6262 }
6263
6264 \f
6265 /* Support for browsing other processes and their attributes. See
6266 process.c for the Lisp bindings. */
6267
6268 /* Helper wrapper functions. */
6269
6270 static HANDLE WINAPI
6271 create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
6272 {
6273 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
6274
6275 if (g_b_init_create_toolhelp32_snapshot == 0)
6276 {
6277 g_b_init_create_toolhelp32_snapshot = 1;
6278 s_pfn_Create_Toolhelp32_Snapshot = (CreateToolhelp32Snapshot_Proc)
6279 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6280 "CreateToolhelp32Snapshot");
6281 }
6282 if (s_pfn_Create_Toolhelp32_Snapshot == NULL)
6283 {
6284 return INVALID_HANDLE_VALUE;
6285 }
6286 return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
6287 }
6288
6289 static BOOL WINAPI
6290 process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
6291 {
6292 static Process32First_Proc s_pfn_Process32_First = NULL;
6293
6294 if (g_b_init_process32_first == 0)
6295 {
6296 g_b_init_process32_first = 1;
6297 s_pfn_Process32_First = (Process32First_Proc)
6298 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6299 "Process32First");
6300 }
6301 if (s_pfn_Process32_First == NULL)
6302 {
6303 return FALSE;
6304 }
6305 return (s_pfn_Process32_First (hSnapshot, lppe));
6306 }
6307
6308 static BOOL WINAPI
6309 process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
6310 {
6311 static Process32Next_Proc s_pfn_Process32_Next = NULL;
6312
6313 if (g_b_init_process32_next == 0)
6314 {
6315 g_b_init_process32_next = 1;
6316 s_pfn_Process32_Next = (Process32Next_Proc)
6317 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6318 "Process32Next");
6319 }
6320 if (s_pfn_Process32_Next == NULL)
6321 {
6322 return FALSE;
6323 }
6324 return (s_pfn_Process32_Next (hSnapshot, lppe));
6325 }
6326
6327 static BOOL WINAPI
6328 open_thread_token (HANDLE ThreadHandle,
6329 DWORD DesiredAccess,
6330 BOOL OpenAsSelf,
6331 PHANDLE TokenHandle)
6332 {
6333 static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
6334 HMODULE hm_advapi32 = NULL;
6335 if (is_windows_9x () == TRUE)
6336 {
6337 SetLastError (ERROR_NOT_SUPPORTED);
6338 return FALSE;
6339 }
6340 if (g_b_init_open_thread_token == 0)
6341 {
6342 g_b_init_open_thread_token = 1;
6343 hm_advapi32 = LoadLibrary ("Advapi32.dll");
6344 s_pfn_Open_Thread_Token =
6345 (OpenThreadToken_Proc) GetProcAddress (hm_advapi32, "OpenThreadToken");
6346 }
6347 if (s_pfn_Open_Thread_Token == NULL)
6348 {
6349 SetLastError (ERROR_NOT_SUPPORTED);
6350 return FALSE;
6351 }
6352 return (
6353 s_pfn_Open_Thread_Token (
6354 ThreadHandle,
6355 DesiredAccess,
6356 OpenAsSelf,
6357 TokenHandle)
6358 );
6359 }
6360
6361 static BOOL WINAPI
6362 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
6363 {
6364 static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
6365 HMODULE hm_advapi32 = NULL;
6366 if (is_windows_9x () == TRUE)
6367 {
6368 return FALSE;
6369 }
6370 if (g_b_init_impersonate_self == 0)
6371 {
6372 g_b_init_impersonate_self = 1;
6373 hm_advapi32 = LoadLibrary ("Advapi32.dll");
6374 s_pfn_Impersonate_Self =
6375 (ImpersonateSelf_Proc) GetProcAddress (hm_advapi32, "ImpersonateSelf");
6376 }
6377 if (s_pfn_Impersonate_Self == NULL)
6378 {
6379 return FALSE;
6380 }
6381 return s_pfn_Impersonate_Self (ImpersonationLevel);
6382 }
6383
6384 static BOOL WINAPI
6385 revert_to_self (void)
6386 {
6387 static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
6388 HMODULE hm_advapi32 = NULL;
6389 if (is_windows_9x () == TRUE)
6390 {
6391 return FALSE;
6392 }
6393 if (g_b_init_revert_to_self == 0)
6394 {
6395 g_b_init_revert_to_self = 1;
6396 hm_advapi32 = LoadLibrary ("Advapi32.dll");
6397 s_pfn_Revert_To_Self =
6398 (RevertToSelf_Proc) GetProcAddress (hm_advapi32, "RevertToSelf");
6399 }
6400 if (s_pfn_Revert_To_Self == NULL)
6401 {
6402 return FALSE;
6403 }
6404 return s_pfn_Revert_To_Self ();
6405 }
6406
6407 static BOOL WINAPI
6408 get_process_memory_info (HANDLE h_proc,
6409 PPROCESS_MEMORY_COUNTERS mem_counters,
6410 DWORD bufsize)
6411 {
6412 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
6413 HMODULE hm_psapi = NULL;
6414 if (is_windows_9x () == TRUE)
6415 {
6416 return FALSE;
6417 }
6418 if (g_b_init_get_process_memory_info == 0)
6419 {
6420 g_b_init_get_process_memory_info = 1;
6421 hm_psapi = LoadLibrary ("Psapi.dll");
6422 if (hm_psapi)
6423 s_pfn_Get_Process_Memory_Info = (GetProcessMemoryInfo_Proc)
6424 GetProcAddress (hm_psapi, "GetProcessMemoryInfo");
6425 }
6426 if (s_pfn_Get_Process_Memory_Info == NULL)
6427 {
6428 return FALSE;
6429 }
6430 return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
6431 }
6432
6433 static BOOL WINAPI
6434 get_process_working_set_size (HANDLE h_proc,
6435 PSIZE_T minrss,
6436 PSIZE_T maxrss)
6437 {
6438 static GetProcessWorkingSetSize_Proc
6439 s_pfn_Get_Process_Working_Set_Size = NULL;
6440
6441 if (is_windows_9x () == TRUE)
6442 {
6443 return FALSE;
6444 }
6445 if (g_b_init_get_process_working_set_size == 0)
6446 {
6447 g_b_init_get_process_working_set_size = 1;
6448 s_pfn_Get_Process_Working_Set_Size = (GetProcessWorkingSetSize_Proc)
6449 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6450 "GetProcessWorkingSetSize");
6451 }
6452 if (s_pfn_Get_Process_Working_Set_Size == NULL)
6453 {
6454 return FALSE;
6455 }
6456 return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
6457 }
6458
6459 static BOOL WINAPI
6460 global_memory_status (MEMORYSTATUS *buf)
6461 {
6462 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
6463
6464 if (is_windows_9x () == TRUE)
6465 {
6466 return FALSE;
6467 }
6468 if (g_b_init_global_memory_status == 0)
6469 {
6470 g_b_init_global_memory_status = 1;
6471 s_pfn_Global_Memory_Status = (GlobalMemoryStatus_Proc)
6472 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6473 "GlobalMemoryStatus");
6474 }
6475 if (s_pfn_Global_Memory_Status == NULL)
6476 {
6477 return FALSE;
6478 }
6479 return s_pfn_Global_Memory_Status (buf);
6480 }
6481
6482 static BOOL WINAPI
6483 global_memory_status_ex (MEMORY_STATUS_EX *buf)
6484 {
6485 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
6486
6487 if (is_windows_9x () == TRUE)
6488 {
6489 return FALSE;
6490 }
6491 if (g_b_init_global_memory_status_ex == 0)
6492 {
6493 g_b_init_global_memory_status_ex = 1;
6494 s_pfn_Global_Memory_Status_Ex = (GlobalMemoryStatusEx_Proc)
6495 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6496 "GlobalMemoryStatusEx");
6497 }
6498 if (s_pfn_Global_Memory_Status_Ex == NULL)
6499 {
6500 return FALSE;
6501 }
6502 return s_pfn_Global_Memory_Status_Ex (buf);
6503 }
6504
6505 Lisp_Object
6506 list_system_processes (void)
6507 {
6508 struct gcpro gcpro1;
6509 Lisp_Object proclist = Qnil;
6510 HANDLE h_snapshot;
6511
6512 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
6513
6514 if (h_snapshot != INVALID_HANDLE_VALUE)
6515 {
6516 PROCESSENTRY32 proc_entry;
6517 DWORD proc_id;
6518 BOOL res;
6519
6520 GCPRO1 (proclist);
6521
6522 proc_entry.dwSize = sizeof (PROCESSENTRY32);
6523 for (res = process32_first (h_snapshot, &proc_entry); res;
6524 res = process32_next (h_snapshot, &proc_entry))
6525 {
6526 proc_id = proc_entry.th32ProcessID;
6527 proclist = Fcons (make_fixnum_or_float (proc_id), proclist);
6528 }
6529
6530 CloseHandle (h_snapshot);
6531 UNGCPRO;
6532 proclist = Fnreverse (proclist);
6533 }
6534
6535 return proclist;
6536 }
6537
6538 static int
6539 enable_privilege (LPCTSTR priv_name, BOOL enable_p, TOKEN_PRIVILEGES *old_priv)
6540 {
6541 TOKEN_PRIVILEGES priv;
6542 DWORD priv_size = sizeof (priv);
6543 DWORD opriv_size = sizeof (*old_priv);
6544 HANDLE h_token = NULL;
6545 HANDLE h_thread = GetCurrentThread ();
6546 int ret_val = 0;
6547 BOOL res;
6548
6549 res = open_thread_token (h_thread,
6550 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
6551 FALSE, &h_token);
6552 if (!res && GetLastError () == ERROR_NO_TOKEN)
6553 {
6554 if (impersonate_self (SecurityImpersonation))
6555 res = open_thread_token (h_thread,
6556 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
6557 FALSE, &h_token);
6558 }
6559 if (res)
6560 {
6561 priv.PrivilegeCount = 1;
6562 priv.Privileges[0].Attributes = enable_p ? SE_PRIVILEGE_ENABLED : 0;
6563 LookupPrivilegeValue (NULL, priv_name, &priv.Privileges[0].Luid);
6564 if (AdjustTokenPrivileges (h_token, FALSE, &priv, priv_size,
6565 old_priv, &opriv_size)
6566 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
6567 ret_val = 1;
6568 }
6569 if (h_token)
6570 CloseHandle (h_token);
6571
6572 return ret_val;
6573 }
6574
6575 static int
6576 restore_privilege (TOKEN_PRIVILEGES *priv)
6577 {
6578 DWORD priv_size = sizeof (*priv);
6579 HANDLE h_token = NULL;
6580 int ret_val = 0;
6581
6582 if (open_thread_token (GetCurrentThread (),
6583 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
6584 FALSE, &h_token))
6585 {
6586 if (AdjustTokenPrivileges (h_token, FALSE, priv, priv_size, NULL, NULL)
6587 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
6588 ret_val = 1;
6589 }
6590 if (h_token)
6591 CloseHandle (h_token);
6592
6593 return ret_val;
6594 }
6595
6596 static Lisp_Object
6597 ltime (ULONGLONG time_100ns)
6598 {
6599 ULONGLONG time_sec = time_100ns / 10000000;
6600 int subsec = time_100ns % 10000000;
6601 return list4i (time_sec >> 16, time_sec & 0xffff,
6602 subsec / 10, subsec % 10 * 100000);
6603 }
6604
6605 #define U64_TO_LISP_TIME(time) ltime (time)
6606
6607 static int
6608 process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
6609 Lisp_Object *stime, Lisp_Object *utime, Lisp_Object *ttime,
6610 double *pcpu)
6611 {
6612 FILETIME ft_creation, ft_exit, ft_kernel, ft_user, ft_current;
6613 ULONGLONG tem1, tem2, tem3, tem;
6614
6615 if (!h_proc
6616 || !get_process_times_fn
6617 || !(*get_process_times_fn) (h_proc, &ft_creation, &ft_exit,
6618 &ft_kernel, &ft_user))
6619 return 0;
6620
6621 GetSystemTimeAsFileTime (&ft_current);
6622
6623 FILETIME_TO_U64 (tem1, ft_kernel);
6624 *stime = U64_TO_LISP_TIME (tem1);
6625
6626 FILETIME_TO_U64 (tem2, ft_user);
6627 *utime = U64_TO_LISP_TIME (tem2);
6628
6629 tem3 = tem1 + tem2;
6630 *ttime = U64_TO_LISP_TIME (tem3);
6631
6632 FILETIME_TO_U64 (tem, ft_creation);
6633 /* Process no 4 (System) returns zero creation time. */
6634 if (tem)
6635 tem -= utc_base;
6636 *ctime = U64_TO_LISP_TIME (tem);
6637
6638 if (tem)
6639 {
6640 FILETIME_TO_U64 (tem3, ft_current);
6641 tem = (tem3 - utc_base) - tem;
6642 }
6643 *etime = U64_TO_LISP_TIME (tem);
6644
6645 if (tem)
6646 {
6647 *pcpu = 100.0 * (tem1 + tem2) / tem;
6648 if (*pcpu > 100)
6649 *pcpu = 100.0;
6650 }
6651 else
6652 *pcpu = 0;
6653
6654 return 1;
6655 }
6656
6657 Lisp_Object
6658 system_process_attributes (Lisp_Object pid)
6659 {
6660 struct gcpro gcpro1, gcpro2, gcpro3;
6661 Lisp_Object attrs = Qnil;
6662 Lisp_Object cmd_str, decoded_cmd, tem;
6663 HANDLE h_snapshot, h_proc;
6664 DWORD proc_id;
6665 int found_proc = 0;
6666 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
6667 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
6668 DWORD glength = sizeof (gname);
6669 HANDLE token = NULL;
6670 SID_NAME_USE user_type;
6671 unsigned char *buf = NULL;
6672 DWORD blen = 0;
6673 TOKEN_USER user_token;
6674 TOKEN_PRIMARY_GROUP group_token;
6675 unsigned euid;
6676 unsigned egid;
6677 PROCESS_MEMORY_COUNTERS mem;
6678 PROCESS_MEMORY_COUNTERS_EX mem_ex;
6679 SIZE_T minrss, maxrss;
6680 MEMORYSTATUS memst;
6681 MEMORY_STATUS_EX memstex;
6682 double totphys = 0.0;
6683 Lisp_Object ctime, stime, utime, etime, ttime;
6684 double pcpu;
6685 BOOL result = FALSE;
6686
6687 CHECK_NUMBER_OR_FLOAT (pid);
6688 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
6689
6690 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
6691
6692 GCPRO3 (attrs, decoded_cmd, tem);
6693
6694 if (h_snapshot != INVALID_HANDLE_VALUE)
6695 {
6696 PROCESSENTRY32 pe;
6697 BOOL res;
6698
6699 pe.dwSize = sizeof (PROCESSENTRY32);
6700 for (res = process32_first (h_snapshot, &pe); res;
6701 res = process32_next (h_snapshot, &pe))
6702 {
6703 if (proc_id == pe.th32ProcessID)
6704 {
6705 if (proc_id == 0)
6706 decoded_cmd = build_string ("Idle");
6707 else
6708 {
6709 /* Decode the command name from locale-specific
6710 encoding. */
6711 cmd_str = build_unibyte_string (pe.szExeFile);
6712
6713 decoded_cmd =
6714 code_convert_string_norecord (cmd_str,
6715 Vlocale_coding_system, 0);
6716 }
6717 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
6718 attrs = Fcons (Fcons (Qppid,
6719 make_fixnum_or_float (pe.th32ParentProcessID)),
6720 attrs);
6721 attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
6722 attrs);
6723 attrs = Fcons (Fcons (Qthcount,
6724 make_fixnum_or_float (pe.cntThreads)),
6725 attrs);
6726 found_proc = 1;
6727 break;
6728 }
6729 }
6730
6731 CloseHandle (h_snapshot);
6732 }
6733
6734 if (!found_proc)
6735 {
6736 UNGCPRO;
6737 return Qnil;
6738 }
6739
6740 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
6741 FALSE, proc_id);
6742 /* If we were denied a handle to the process, try again after
6743 enabling the SeDebugPrivilege in our process. */
6744 if (!h_proc)
6745 {
6746 TOKEN_PRIVILEGES priv_current;
6747
6748 if (enable_privilege (SE_DEBUG_NAME, TRUE, &priv_current))
6749 {
6750 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
6751 FALSE, proc_id);
6752 restore_privilege (&priv_current);
6753 revert_to_self ();
6754 }
6755 }
6756 if (h_proc)
6757 {
6758 result = open_process_token (h_proc, TOKEN_QUERY, &token);
6759 if (result)
6760 {
6761 result = get_token_information (token, TokenUser, NULL, 0, &blen);
6762 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
6763 {
6764 buf = xmalloc (blen);
6765 result = get_token_information (token, TokenUser,
6766 (LPVOID)buf, blen, &needed);
6767 if (result)
6768 {
6769 memcpy (&user_token, buf, sizeof (user_token));
6770 if (!w32_cached_id (user_token.User.Sid, &euid, uname))
6771 {
6772 euid = get_rid (user_token.User.Sid);
6773 result = lookup_account_sid (NULL, user_token.User.Sid,
6774 uname, &ulength,
6775 domain, &dlength,
6776 &user_type);
6777 if (result)
6778 w32_add_to_cache (user_token.User.Sid, euid, uname);
6779 else
6780 {
6781 strcpy (uname, "unknown");
6782 result = TRUE;
6783 }
6784 }
6785 ulength = strlen (uname);
6786 }
6787 }
6788 }
6789 if (result)
6790 {
6791 /* Determine a reasonable euid and gid values. */
6792 if (xstrcasecmp ("administrator", uname) == 0)
6793 {
6794 euid = 500; /* well-known Administrator uid */
6795 egid = 513; /* well-known None gid */
6796 }
6797 else
6798 {
6799 /* Get group id and name. */
6800 result = get_token_information (token, TokenPrimaryGroup,
6801 (LPVOID)buf, blen, &needed);
6802 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
6803 {
6804 buf = xrealloc (buf, blen = needed);
6805 result = get_token_information (token, TokenPrimaryGroup,
6806 (LPVOID)buf, blen, &needed);
6807 }
6808 if (result)
6809 {
6810 memcpy (&group_token, buf, sizeof (group_token));
6811 if (!w32_cached_id (group_token.PrimaryGroup, &egid, gname))
6812 {
6813 egid = get_rid (group_token.PrimaryGroup);
6814 dlength = sizeof (domain);
6815 result =
6816 lookup_account_sid (NULL, group_token.PrimaryGroup,
6817 gname, &glength, NULL, &dlength,
6818 &user_type);
6819 if (result)
6820 w32_add_to_cache (group_token.PrimaryGroup,
6821 egid, gname);
6822 else
6823 {
6824 strcpy (gname, "None");
6825 result = TRUE;
6826 }
6827 }
6828 glength = strlen (gname);
6829 }
6830 }
6831 }
6832 xfree (buf);
6833 }
6834 if (!result)
6835 {
6836 if (!is_windows_9x ())
6837 {
6838 /* We couldn't open the process token, presumably because of
6839 insufficient access rights. Assume this process is run
6840 by the system. */
6841 strcpy (uname, "SYSTEM");
6842 strcpy (gname, "None");
6843 euid = 18; /* SYSTEM */
6844 egid = 513; /* None */
6845 glength = strlen (gname);
6846 ulength = strlen (uname);
6847 }
6848 /* If we are running under Windows 9X, where security calls are
6849 not supported, we assume all processes are run by the current
6850 user. */
6851 else if (GetUserName (uname, &ulength))
6852 {
6853 if (xstrcasecmp ("administrator", uname) == 0)
6854 euid = 0;
6855 else
6856 euid = 123;
6857 egid = euid;
6858 strcpy (gname, "None");
6859 glength = strlen (gname);
6860 ulength = strlen (uname);
6861 }
6862 else
6863 {
6864 euid = 123;
6865 egid = 123;
6866 strcpy (uname, "administrator");
6867 ulength = strlen (uname);
6868 strcpy (gname, "None");
6869 glength = strlen (gname);
6870 }
6871 if (token)
6872 CloseHandle (token);
6873 }
6874
6875 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (euid)), attrs);
6876 tem = make_unibyte_string (uname, ulength);
6877 attrs = Fcons (Fcons (Quser,
6878 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
6879 attrs);
6880 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (egid)), attrs);
6881 tem = make_unibyte_string (gname, glength);
6882 attrs = Fcons (Fcons (Qgroup,
6883 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
6884 attrs);
6885
6886 if (global_memory_status_ex (&memstex))
6887 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
6888 totphys = memstex.ullTotalPhys / 1024.0;
6889 #else
6890 /* Visual Studio 6 cannot convert an unsigned __int64 type to
6891 double, so we need to do this for it... */
6892 {
6893 DWORD tot_hi = memstex.ullTotalPhys >> 32;
6894 DWORD tot_md = (memstex.ullTotalPhys & 0x00000000ffffffff) >> 10;
6895 DWORD tot_lo = memstex.ullTotalPhys % 1024;
6896
6897 totphys = tot_hi * 4194304.0 + tot_md + tot_lo / 1024.0;
6898 }
6899 #endif /* __GNUC__ || _MSC_VER >= 1300 */
6900 else if (global_memory_status (&memst))
6901 totphys = memst.dwTotalPhys / 1024.0;
6902
6903 if (h_proc
6904 && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
6905 sizeof (mem_ex)))
6906 {
6907 SIZE_T rss = mem_ex.WorkingSetSize / 1024;
6908
6909 attrs = Fcons (Fcons (Qmajflt,
6910 make_fixnum_or_float (mem_ex.PageFaultCount)),
6911 attrs);
6912 attrs = Fcons (Fcons (Qvsize,
6913 make_fixnum_or_float (mem_ex.PrivateUsage / 1024)),
6914 attrs);
6915 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
6916 if (totphys)
6917 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
6918 }
6919 else if (h_proc
6920 && get_process_memory_info (h_proc, &mem, sizeof (mem)))
6921 {
6922 SIZE_T rss = mem_ex.WorkingSetSize / 1024;
6923
6924 attrs = Fcons (Fcons (Qmajflt,
6925 make_fixnum_or_float (mem.PageFaultCount)),
6926 attrs);
6927 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
6928 if (totphys)
6929 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
6930 }
6931 else if (h_proc
6932 && get_process_working_set_size (h_proc, &minrss, &maxrss))
6933 {
6934 DWORD rss = maxrss / 1024;
6935
6936 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (maxrss / 1024)), attrs);
6937 if (totphys)
6938 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
6939 }
6940
6941 if (process_times (h_proc, &ctime, &etime, &stime, &utime, &ttime, &pcpu))
6942 {
6943 attrs = Fcons (Fcons (Qutime, utime), attrs);
6944 attrs = Fcons (Fcons (Qstime, stime), attrs);
6945 attrs = Fcons (Fcons (Qtime, ttime), attrs);
6946 attrs = Fcons (Fcons (Qstart, ctime), attrs);
6947 attrs = Fcons (Fcons (Qetime, etime), attrs);
6948 attrs = Fcons (Fcons (Qpcpu, make_float (pcpu)), attrs);
6949 }
6950
6951 /* FIXME: Retrieve command line by walking the PEB of the process. */
6952
6953 if (h_proc)
6954 CloseHandle (h_proc);
6955 UNGCPRO;
6956 return attrs;
6957 }
6958
6959 \f
6960 /* Wrappers for winsock functions to map between our file descriptors
6961 and winsock's handles; also set h_errno for convenience.
6962
6963 To allow Emacs to run on systems which don't have winsock support
6964 installed, we dynamically link to winsock on startup if present, and
6965 otherwise provide the minimum necessary functionality
6966 (eg. gethostname). */
6967
6968 /* function pointers for relevant socket functions */
6969 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
6970 void (PASCAL *pfn_WSASetLastError) (int iError);
6971 int (PASCAL *pfn_WSAGetLastError) (void);
6972 int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
6973 HANDLE (PASCAL *pfn_WSACreateEvent) (void);
6974 int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
6975 int (PASCAL *pfn_socket) (int af, int type, int protocol);
6976 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
6977 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
6978 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
6979 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
6980 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
6981 int (PASCAL *pfn_closesocket) (SOCKET s);
6982 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
6983 int (PASCAL *pfn_WSACleanup) (void);
6984
6985 u_short (PASCAL *pfn_htons) (u_short hostshort);
6986 u_short (PASCAL *pfn_ntohs) (u_short netshort);
6987 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
6988 int (PASCAL *pfn_gethostname) (char * name, int namelen);
6989 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
6990 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
6991 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
6992 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
6993 const char * optval, int optlen);
6994 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
6995 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
6996 int * namelen);
6997 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
6998 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
6999 struct sockaddr * from, int * fromlen);
7000 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
7001 const struct sockaddr * to, int tolen);
7002
7003 /* SetHandleInformation is only needed to make sockets non-inheritable. */
7004 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
7005 #ifndef HANDLE_FLAG_INHERIT
7006 #define HANDLE_FLAG_INHERIT 1
7007 #endif
7008
7009 HANDLE winsock_lib;
7010 static int winsock_inuse;
7011
7012 BOOL
7013 term_winsock (void)
7014 {
7015 if (winsock_lib != NULL && winsock_inuse == 0)
7016 {
7017 release_listen_threads ();
7018 /* Not sure what would cause WSAENETDOWN, or even if it can happen
7019 after WSAStartup returns successfully, but it seems reasonable
7020 to allow unloading winsock anyway in that case. */
7021 if (pfn_WSACleanup () == 0 ||
7022 pfn_WSAGetLastError () == WSAENETDOWN)
7023 {
7024 if (FreeLibrary (winsock_lib))
7025 winsock_lib = NULL;
7026 return TRUE;
7027 }
7028 }
7029 return FALSE;
7030 }
7031
7032 BOOL
7033 init_winsock (int load_now)
7034 {
7035 WSADATA winsockData;
7036
7037 if (winsock_lib != NULL)
7038 return TRUE;
7039
7040 pfn_SetHandleInformation
7041 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
7042 "SetHandleInformation");
7043
7044 winsock_lib = LoadLibrary ("Ws2_32.dll");
7045
7046 if (winsock_lib != NULL)
7047 {
7048 /* dynamically link to socket functions */
7049
7050 #define LOAD_PROC(fn) \
7051 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
7052 goto fail;
7053
7054 LOAD_PROC (WSAStartup);
7055 LOAD_PROC (WSASetLastError);
7056 LOAD_PROC (WSAGetLastError);
7057 LOAD_PROC (WSAEventSelect);
7058 LOAD_PROC (WSACreateEvent);
7059 LOAD_PROC (WSACloseEvent);
7060 LOAD_PROC (socket);
7061 LOAD_PROC (bind);
7062 LOAD_PROC (connect);
7063 LOAD_PROC (ioctlsocket);
7064 LOAD_PROC (recv);
7065 LOAD_PROC (send);
7066 LOAD_PROC (closesocket);
7067 LOAD_PROC (shutdown);
7068 LOAD_PROC (htons);
7069 LOAD_PROC (ntohs);
7070 LOAD_PROC (inet_addr);
7071 LOAD_PROC (gethostname);
7072 LOAD_PROC (gethostbyname);
7073 LOAD_PROC (getservbyname);
7074 LOAD_PROC (getpeername);
7075 LOAD_PROC (WSACleanup);
7076 LOAD_PROC (setsockopt);
7077 LOAD_PROC (listen);
7078 LOAD_PROC (getsockname);
7079 LOAD_PROC (accept);
7080 LOAD_PROC (recvfrom);
7081 LOAD_PROC (sendto);
7082 #undef LOAD_PROC
7083
7084 /* specify version 1.1 of winsock */
7085 if (pfn_WSAStartup (0x101, &winsockData) == 0)
7086 {
7087 if (winsockData.wVersion != 0x101)
7088 goto fail;
7089
7090 if (!load_now)
7091 {
7092 /* Report that winsock exists and is usable, but leave
7093 socket functions disabled. I am assuming that calling
7094 WSAStartup does not require any network interaction,
7095 and in particular does not cause or require a dial-up
7096 connection to be established. */
7097
7098 pfn_WSACleanup ();
7099 FreeLibrary (winsock_lib);
7100 winsock_lib = NULL;
7101 }
7102 winsock_inuse = 0;
7103 return TRUE;
7104 }
7105
7106 fail:
7107 FreeLibrary (winsock_lib);
7108 winsock_lib = NULL;
7109 }
7110
7111 return FALSE;
7112 }
7113
7114
7115 int h_errno = 0;
7116
7117 /* Function to map winsock error codes to errno codes for those errno
7118 code defined in errno.h (errno values not defined by errno.h are
7119 already in nt/inc/sys/socket.h). */
7120 static void
7121 set_errno (void)
7122 {
7123 int wsa_err;
7124
7125 h_errno = 0;
7126 if (winsock_lib == NULL)
7127 wsa_err = EINVAL;
7128 else
7129 wsa_err = pfn_WSAGetLastError ();
7130
7131 switch (wsa_err)
7132 {
7133 case WSAEACCES: errno = EACCES; break;
7134 case WSAEBADF: errno = EBADF; break;
7135 case WSAEFAULT: errno = EFAULT; break;
7136 case WSAEINTR: errno = EINTR; break;
7137 case WSAEINVAL: errno = EINVAL; break;
7138 case WSAEMFILE: errno = EMFILE; break;
7139 case WSAENAMETOOLONG: errno = ENAMETOOLONG; break;
7140 case WSAENOTEMPTY: errno = ENOTEMPTY; break;
7141 default: errno = wsa_err; break;
7142 }
7143 }
7144
7145 static void
7146 check_errno (void)
7147 {
7148 h_errno = 0;
7149 if (winsock_lib != NULL)
7150 pfn_WSASetLastError (0);
7151 }
7152
7153 /* Extend strerror to handle the winsock-specific error codes. */
7154 struct {
7155 int errnum;
7156 char * msg;
7157 } _wsa_errlist[] = {
7158 {WSAEINTR , "Interrupted function call"},
7159 {WSAEBADF , "Bad file descriptor"},
7160 {WSAEACCES , "Permission denied"},
7161 {WSAEFAULT , "Bad address"},
7162 {WSAEINVAL , "Invalid argument"},
7163 {WSAEMFILE , "Too many open files"},
7164
7165 {WSAEWOULDBLOCK , "Resource temporarily unavailable"},
7166 {WSAEINPROGRESS , "Operation now in progress"},
7167 {WSAEALREADY , "Operation already in progress"},
7168 {WSAENOTSOCK , "Socket operation on non-socket"},
7169 {WSAEDESTADDRREQ , "Destination address required"},
7170 {WSAEMSGSIZE , "Message too long"},
7171 {WSAEPROTOTYPE , "Protocol wrong type for socket"},
7172 {WSAENOPROTOOPT , "Bad protocol option"},
7173 {WSAEPROTONOSUPPORT , "Protocol not supported"},
7174 {WSAESOCKTNOSUPPORT , "Socket type not supported"},
7175 {WSAEOPNOTSUPP , "Operation not supported"},
7176 {WSAEPFNOSUPPORT , "Protocol family not supported"},
7177 {WSAEAFNOSUPPORT , "Address family not supported by protocol family"},
7178 {WSAEADDRINUSE , "Address already in use"},
7179 {WSAEADDRNOTAVAIL , "Cannot assign requested address"},
7180 {WSAENETDOWN , "Network is down"},
7181 {WSAENETUNREACH , "Network is unreachable"},
7182 {WSAENETRESET , "Network dropped connection on reset"},
7183 {WSAECONNABORTED , "Software caused connection abort"},
7184 {WSAECONNRESET , "Connection reset by peer"},
7185 {WSAENOBUFS , "No buffer space available"},
7186 {WSAEISCONN , "Socket is already connected"},
7187 {WSAENOTCONN , "Socket is not connected"},
7188 {WSAESHUTDOWN , "Cannot send after socket shutdown"},
7189 {WSAETOOMANYREFS , "Too many references"}, /* not sure */
7190 {WSAETIMEDOUT , "Connection timed out"},
7191 {WSAECONNREFUSED , "Connection refused"},
7192 {WSAELOOP , "Network loop"}, /* not sure */
7193 {WSAENAMETOOLONG , "Name is too long"},
7194 {WSAEHOSTDOWN , "Host is down"},
7195 {WSAEHOSTUNREACH , "No route to host"},
7196 {WSAENOTEMPTY , "Buffer not empty"}, /* not sure */
7197 {WSAEPROCLIM , "Too many processes"},
7198 {WSAEUSERS , "Too many users"}, /* not sure */
7199 {WSAEDQUOT , "Double quote in host name"}, /* really not sure */
7200 {WSAESTALE , "Data is stale"}, /* not sure */
7201 {WSAEREMOTE , "Remote error"}, /* not sure */
7202
7203 {WSASYSNOTREADY , "Network subsystem is unavailable"},
7204 {WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range"},
7205 {WSANOTINITIALISED , "Winsock not initialized successfully"},
7206 {WSAEDISCON , "Graceful shutdown in progress"},
7207 #ifdef WSAENOMORE
7208 {WSAENOMORE , "No more operations allowed"}, /* not sure */
7209 {WSAECANCELLED , "Operation cancelled"}, /* not sure */
7210 {WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider"},
7211 {WSAEINVALIDPROVIDER , "Invalid service provider version number"},
7212 {WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider"},
7213 {WSASYSCALLFAILURE , "System call failure"},
7214 {WSASERVICE_NOT_FOUND , "Service not found"}, /* not sure */
7215 {WSATYPE_NOT_FOUND , "Class type not found"},
7216 {WSA_E_NO_MORE , "No more resources available"}, /* really not sure */
7217 {WSA_E_CANCELLED , "Operation already cancelled"}, /* really not sure */
7218 {WSAEREFUSED , "Operation refused"}, /* not sure */
7219 #endif
7220
7221 {WSAHOST_NOT_FOUND , "Host not found"},
7222 {WSATRY_AGAIN , "Authoritative host not found during name lookup"},
7223 {WSANO_RECOVERY , "Non-recoverable error during name lookup"},
7224 {WSANO_DATA , "Valid name, no data record of requested type"},
7225
7226 {-1, NULL}
7227 };
7228
7229 char *
7230 sys_strerror (int error_no)
7231 {
7232 int i;
7233 static char unknown_msg[40];
7234
7235 if (error_no >= 0 && error_no < sys_nerr)
7236 return sys_errlist[error_no];
7237
7238 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
7239 if (_wsa_errlist[i].errnum == error_no)
7240 return _wsa_errlist[i].msg;
7241
7242 sprintf (unknown_msg, "Unidentified error: %d", error_no);
7243 return unknown_msg;
7244 }
7245
7246 /* [andrewi 3-May-96] I've had conflicting results using both methods,
7247 but I believe the method of keeping the socket handle separate (and
7248 insuring it is not inheritable) is the correct one. */
7249
7250 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
7251
7252 static int socket_to_fd (SOCKET s);
7253
7254 int
7255 sys_socket (int af, int type, int protocol)
7256 {
7257 SOCKET s;
7258
7259 if (winsock_lib == NULL)
7260 {
7261 errno = ENETDOWN;
7262 return INVALID_SOCKET;
7263 }
7264
7265 check_errno ();
7266
7267 /* call the real socket function */
7268 s = pfn_socket (af, type, protocol);
7269
7270 if (s != INVALID_SOCKET)
7271 return socket_to_fd (s);
7272
7273 set_errno ();
7274 return -1;
7275 }
7276
7277 /* Convert a SOCKET to a file descriptor. */
7278 static int
7279 socket_to_fd (SOCKET s)
7280 {
7281 int fd;
7282 child_process * cp;
7283
7284 /* Although under NT 3.5 _open_osfhandle will accept a socket
7285 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
7286 that does not work under NT 3.1. However, we can get the same
7287 effect by using a backdoor function to replace an existing
7288 descriptor handle with the one we want. */
7289
7290 /* allocate a file descriptor (with appropriate flags) */
7291 fd = _open ("NUL:", _O_RDWR);
7292 if (fd >= 0)
7293 {
7294 /* Make a non-inheritable copy of the socket handle. Note
7295 that it is possible that sockets aren't actually kernel
7296 handles, which appears to be the case on Windows 9x when
7297 the MS Proxy winsock client is installed. */
7298 {
7299 /* Apparently there is a bug in NT 3.51 with some service
7300 packs, which prevents using DuplicateHandle to make a
7301 socket handle non-inheritable (causes WSACleanup to
7302 hang). The work-around is to use SetHandleInformation
7303 instead if it is available and implemented. */
7304 if (pfn_SetHandleInformation)
7305 {
7306 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
7307 }
7308 else
7309 {
7310 HANDLE parent = GetCurrentProcess ();
7311 HANDLE new_s = INVALID_HANDLE_VALUE;
7312
7313 if (DuplicateHandle (parent,
7314 (HANDLE) s,
7315 parent,
7316 &new_s,
7317 0,
7318 FALSE,
7319 DUPLICATE_SAME_ACCESS))
7320 {
7321 /* It is possible that DuplicateHandle succeeds even
7322 though the socket wasn't really a kernel handle,
7323 because a real handle has the same value. So
7324 test whether the new handle really is a socket. */
7325 long nonblocking = 0;
7326 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
7327 {
7328 pfn_closesocket (s);
7329 s = (SOCKET) new_s;
7330 }
7331 else
7332 {
7333 CloseHandle (new_s);
7334 }
7335 }
7336 }
7337 }
7338 eassert (fd < MAXDESC);
7339 fd_info[fd].hnd = (HANDLE) s;
7340
7341 /* set our own internal flags */
7342 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
7343
7344 cp = new_child ();
7345 if (cp)
7346 {
7347 cp->fd = fd;
7348 cp->status = STATUS_READ_ACKNOWLEDGED;
7349
7350 /* attach child_process to fd_info */
7351 if (fd_info[ fd ].cp != NULL)
7352 {
7353 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
7354 emacs_abort ();
7355 }
7356
7357 fd_info[ fd ].cp = cp;
7358
7359 /* success! */
7360 winsock_inuse++; /* count open sockets */
7361 return fd;
7362 }
7363
7364 /* clean up */
7365 _close (fd);
7366 }
7367 else
7368 pfn_closesocket (s);
7369 errno = EMFILE;
7370 return -1;
7371 }
7372
7373 int
7374 sys_bind (int s, const struct sockaddr * addr, int namelen)
7375 {
7376 if (winsock_lib == NULL)
7377 {
7378 errno = ENOTSOCK;
7379 return SOCKET_ERROR;
7380 }
7381
7382 check_errno ();
7383 if (fd_info[s].flags & FILE_SOCKET)
7384 {
7385 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
7386 if (rc == SOCKET_ERROR)
7387 set_errno ();
7388 return rc;
7389 }
7390 errno = ENOTSOCK;
7391 return SOCKET_ERROR;
7392 }
7393
7394 int
7395 sys_connect (int s, const struct sockaddr * name, int namelen)
7396 {
7397 if (winsock_lib == NULL)
7398 {
7399 errno = ENOTSOCK;
7400 return SOCKET_ERROR;
7401 }
7402
7403 check_errno ();
7404 if (fd_info[s].flags & FILE_SOCKET)
7405 {
7406 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
7407 if (rc == SOCKET_ERROR)
7408 set_errno ();
7409 return rc;
7410 }
7411 errno = ENOTSOCK;
7412 return SOCKET_ERROR;
7413 }
7414
7415 u_short
7416 sys_htons (u_short hostshort)
7417 {
7418 return (winsock_lib != NULL) ?
7419 pfn_htons (hostshort) : hostshort;
7420 }
7421
7422 u_short
7423 sys_ntohs (u_short netshort)
7424 {
7425 return (winsock_lib != NULL) ?
7426 pfn_ntohs (netshort) : netshort;
7427 }
7428
7429 unsigned long
7430 sys_inet_addr (const char * cp)
7431 {
7432 return (winsock_lib != NULL) ?
7433 pfn_inet_addr (cp) : INADDR_NONE;
7434 }
7435
7436 int
7437 sys_gethostname (char * name, int namelen)
7438 {
7439 if (winsock_lib != NULL)
7440 {
7441 int retval;
7442
7443 check_errno ();
7444 retval = pfn_gethostname (name, namelen);
7445 if (retval == SOCKET_ERROR)
7446 set_errno ();
7447 return retval;
7448 }
7449
7450 if (namelen > MAX_COMPUTERNAME_LENGTH)
7451 return !GetComputerName (name, (DWORD *)&namelen);
7452
7453 errno = EFAULT;
7454 return SOCKET_ERROR;
7455 }
7456
7457 struct hostent *
7458 sys_gethostbyname (const char * name)
7459 {
7460 struct hostent * host;
7461 int h_err = h_errno;
7462
7463 if (winsock_lib == NULL)
7464 {
7465 h_errno = NO_RECOVERY;
7466 errno = ENETDOWN;
7467 return NULL;
7468 }
7469
7470 check_errno ();
7471 host = pfn_gethostbyname (name);
7472 if (!host)
7473 {
7474 set_errno ();
7475 h_errno = errno;
7476 }
7477 else
7478 h_errno = h_err;
7479 return host;
7480 }
7481
7482 struct servent *
7483 sys_getservbyname (const char * name, const char * proto)
7484 {
7485 struct servent * serv;
7486
7487 if (winsock_lib == NULL)
7488 {
7489 errno = ENETDOWN;
7490 return NULL;
7491 }
7492
7493 check_errno ();
7494 serv = pfn_getservbyname (name, proto);
7495 if (!serv)
7496 set_errno ();
7497 return serv;
7498 }
7499
7500 int
7501 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
7502 {
7503 if (winsock_lib == NULL)
7504 {
7505 errno = ENETDOWN;
7506 return SOCKET_ERROR;
7507 }
7508
7509 check_errno ();
7510 if (fd_info[s].flags & FILE_SOCKET)
7511 {
7512 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
7513 if (rc == SOCKET_ERROR)
7514 set_errno ();
7515 return rc;
7516 }
7517 errno = ENOTSOCK;
7518 return SOCKET_ERROR;
7519 }
7520
7521 int
7522 sys_shutdown (int s, int how)
7523 {
7524 if (winsock_lib == NULL)
7525 {
7526 errno = ENETDOWN;
7527 return SOCKET_ERROR;
7528 }
7529
7530 check_errno ();
7531 if (fd_info[s].flags & FILE_SOCKET)
7532 {
7533 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
7534 if (rc == SOCKET_ERROR)
7535 set_errno ();
7536 return rc;
7537 }
7538 errno = ENOTSOCK;
7539 return SOCKET_ERROR;
7540 }
7541
7542 int
7543 sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
7544 {
7545 if (winsock_lib == NULL)
7546 {
7547 errno = ENETDOWN;
7548 return SOCKET_ERROR;
7549 }
7550
7551 check_errno ();
7552 if (fd_info[s].flags & FILE_SOCKET)
7553 {
7554 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
7555 (const char *)optval, optlen);
7556 if (rc == SOCKET_ERROR)
7557 set_errno ();
7558 return rc;
7559 }
7560 errno = ENOTSOCK;
7561 return SOCKET_ERROR;
7562 }
7563
7564 int
7565 sys_listen (int s, int backlog)
7566 {
7567 if (winsock_lib == NULL)
7568 {
7569 errno = ENETDOWN;
7570 return SOCKET_ERROR;
7571 }
7572
7573 check_errno ();
7574 if (fd_info[s].flags & FILE_SOCKET)
7575 {
7576 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
7577 if (rc == SOCKET_ERROR)
7578 set_errno ();
7579 else
7580 fd_info[s].flags |= FILE_LISTEN;
7581 return rc;
7582 }
7583 errno = ENOTSOCK;
7584 return SOCKET_ERROR;
7585 }
7586
7587 int
7588 sys_getsockname (int s, struct sockaddr * name, int * namelen)
7589 {
7590 if (winsock_lib == NULL)
7591 {
7592 errno = ENETDOWN;
7593 return SOCKET_ERROR;
7594 }
7595
7596 check_errno ();
7597 if (fd_info[s].flags & FILE_SOCKET)
7598 {
7599 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
7600 if (rc == SOCKET_ERROR)
7601 set_errno ();
7602 return rc;
7603 }
7604 errno = ENOTSOCK;
7605 return SOCKET_ERROR;
7606 }
7607
7608 int
7609 sys_accept (int s, struct sockaddr * addr, int * addrlen)
7610 {
7611 if (winsock_lib == NULL)
7612 {
7613 errno = ENETDOWN;
7614 return -1;
7615 }
7616
7617 check_errno ();
7618 if (fd_info[s].flags & FILE_LISTEN)
7619 {
7620 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
7621 int fd = -1;
7622 if (t == INVALID_SOCKET)
7623 set_errno ();
7624 else
7625 fd = socket_to_fd (t);
7626
7627 if (fd >= 0)
7628 {
7629 fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
7630 ResetEvent (fd_info[s].cp->char_avail);
7631 }
7632 return fd;
7633 }
7634 errno = ENOTSOCK;
7635 return -1;
7636 }
7637
7638 int
7639 sys_recvfrom (int s, char * buf, int len, int flags,
7640 struct sockaddr * from, int * fromlen)
7641 {
7642 if (winsock_lib == NULL)
7643 {
7644 errno = ENETDOWN;
7645 return SOCKET_ERROR;
7646 }
7647
7648 check_errno ();
7649 if (fd_info[s].flags & FILE_SOCKET)
7650 {
7651 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
7652 if (rc == SOCKET_ERROR)
7653 set_errno ();
7654 return rc;
7655 }
7656 errno = ENOTSOCK;
7657 return SOCKET_ERROR;
7658 }
7659
7660 int
7661 sys_sendto (int s, const char * buf, int len, int flags,
7662 const struct sockaddr * to, int tolen)
7663 {
7664 if (winsock_lib == NULL)
7665 {
7666 errno = ENETDOWN;
7667 return SOCKET_ERROR;
7668 }
7669
7670 check_errno ();
7671 if (fd_info[s].flags & FILE_SOCKET)
7672 {
7673 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
7674 if (rc == SOCKET_ERROR)
7675 set_errno ();
7676 return rc;
7677 }
7678 errno = ENOTSOCK;
7679 return SOCKET_ERROR;
7680 }
7681
7682 /* Windows does not have an fcntl function. Provide an implementation
7683 good enough for Emacs. */
7684 int
7685 fcntl (int s, int cmd, int options)
7686 {
7687 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
7688 invoked in a context where fd1 is closed and all descriptors less
7689 than fd1 are open, so sys_dup is an adequate implementation. */
7690 if (cmd == F_DUPFD_CLOEXEC)
7691 return sys_dup (s);
7692
7693 check_errno ();
7694 if (fd_info[s].flags & FILE_SOCKET)
7695 {
7696 if (winsock_lib == NULL)
7697 {
7698 errno = ENETDOWN;
7699 return -1;
7700 }
7701
7702 if (cmd == F_SETFL && options == O_NONBLOCK)
7703 {
7704 unsigned long nblock = 1;
7705 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
7706 if (rc == SOCKET_ERROR)
7707 set_errno ();
7708 /* Keep track of the fact that we set this to non-blocking. */
7709 fd_info[s].flags |= FILE_NDELAY;
7710 return rc;
7711 }
7712 else
7713 {
7714 errno = EINVAL;
7715 return SOCKET_ERROR;
7716 }
7717 }
7718 else if ((fd_info[s].flags & (FILE_PIPE | FILE_WRITE))
7719 == (FILE_PIPE | FILE_WRITE))
7720 {
7721 /* Force our writes to pipes be non-blocking. */
7722 if (cmd == F_SETFL && options == O_NONBLOCK)
7723 {
7724 HANDLE h = (HANDLE)_get_osfhandle (s);
7725 DWORD pipe_mode = PIPE_NOWAIT;
7726
7727 if (!SetNamedPipeHandleState (h, &pipe_mode, NULL, NULL))
7728 {
7729 DebPrint (("SetNamedPipeHandleState: %lu\n", GetLastError ()));
7730 return SOCKET_ERROR;
7731 }
7732 fd_info[s].flags |= FILE_NDELAY;
7733 return 0;
7734 }
7735 else
7736 {
7737 errno = EINVAL;
7738 return SOCKET_ERROR;
7739 }
7740 }
7741 errno = ENOTSOCK;
7742 return SOCKET_ERROR;
7743 }
7744
7745
7746 /* Shadow main io functions: we need to handle pipes and sockets more
7747 intelligently. */
7748
7749 int
7750 sys_close (int fd)
7751 {
7752 int rc;
7753
7754 if (fd < 0)
7755 {
7756 errno = EBADF;
7757 return -1;
7758 }
7759
7760 if (fd < MAXDESC && fd_info[fd].cp)
7761 {
7762 child_process * cp = fd_info[fd].cp;
7763
7764 fd_info[fd].cp = NULL;
7765
7766 if (CHILD_ACTIVE (cp))
7767 {
7768 /* if last descriptor to active child_process then cleanup */
7769 int i;
7770 for (i = 0; i < MAXDESC; i++)
7771 {
7772 if (i == fd)
7773 continue;
7774 if (fd_info[i].cp == cp)
7775 break;
7776 }
7777 if (i == MAXDESC)
7778 {
7779 if (fd_info[fd].flags & FILE_SOCKET)
7780 {
7781 if (winsock_lib == NULL) emacs_abort ();
7782
7783 pfn_shutdown (SOCK_HANDLE (fd), 2);
7784 rc = pfn_closesocket (SOCK_HANDLE (fd));
7785
7786 winsock_inuse--; /* count open sockets */
7787 }
7788 /* If the process handle is NULL, it's either a socket
7789 or serial connection, or a subprocess that was
7790 already reaped by reap_subprocess, but whose
7791 resources were not yet freed, because its output was
7792 not fully read yet by the time it was reaped. (This
7793 usually happens with async subprocesses whose output
7794 is being read by Emacs.) Otherwise, this process was
7795 not reaped yet, so we set its FD to a negative value
7796 to make sure sys_select will eventually get to
7797 calling the SIGCHLD handler for it, which will then
7798 invoke waitpid and reap_subprocess. */
7799 if (cp->procinfo.hProcess == NULL)
7800 delete_child (cp);
7801 else
7802 cp->fd = -1;
7803 }
7804 }
7805 }
7806
7807 if (fd >= 0 && fd < MAXDESC)
7808 fd_info[fd].flags = 0;
7809
7810 /* Note that sockets do not need special treatment here (at least on
7811 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
7812 closesocket is equivalent to CloseHandle, which is to be expected
7813 because socket handles are fully fledged kernel handles. */
7814 rc = _close (fd);
7815
7816 return rc;
7817 }
7818
7819 int
7820 sys_dup (int fd)
7821 {
7822 int new_fd;
7823
7824 new_fd = _dup (fd);
7825 if (new_fd >= 0 && new_fd < MAXDESC)
7826 {
7827 /* duplicate our internal info as well */
7828 fd_info[new_fd] = fd_info[fd];
7829 }
7830 return new_fd;
7831 }
7832
7833 int
7834 sys_dup2 (int src, int dst)
7835 {
7836 int rc;
7837
7838 if (dst < 0 || dst >= MAXDESC)
7839 {
7840 errno = EBADF;
7841 return -1;
7842 }
7843
7844 /* make sure we close the destination first if it's a pipe or socket */
7845 if (src != dst && fd_info[dst].flags != 0)
7846 sys_close (dst);
7847
7848 rc = _dup2 (src, dst);
7849 if (rc == 0)
7850 {
7851 /* duplicate our internal info as well */
7852 fd_info[dst] = fd_info[src];
7853 }
7854 return rc;
7855 }
7856
7857 int
7858 pipe2 (int * phandles, int pipe2_flags)
7859 {
7860 int rc;
7861 unsigned flags;
7862
7863 eassert (pipe2_flags == O_CLOEXEC);
7864
7865 /* make pipe handles non-inheritable; when we spawn a child, we
7866 replace the relevant handle with an inheritable one. Also put
7867 pipes into binary mode; we will do text mode translation ourselves
7868 if required. */
7869 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
7870
7871 if (rc == 0)
7872 {
7873 /* Protect against overflow, since Windows can open more handles than
7874 our fd_info array has room for. */
7875 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
7876 {
7877 _close (phandles[0]);
7878 _close (phandles[1]);
7879 errno = EMFILE;
7880 rc = -1;
7881 }
7882 else
7883 {
7884 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
7885 fd_info[phandles[0]].flags = flags;
7886
7887 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
7888 fd_info[phandles[1]].flags = flags;
7889 }
7890 }
7891
7892 return rc;
7893 }
7894
7895 /* Function to do blocking read of one byte, needed to implement
7896 select. It is only allowed on communication ports, sockets, or
7897 pipes. */
7898 int
7899 _sys_read_ahead (int fd)
7900 {
7901 child_process * cp;
7902 int rc;
7903
7904 if (fd < 0 || fd >= MAXDESC)
7905 return STATUS_READ_ERROR;
7906
7907 cp = fd_info[fd].cp;
7908
7909 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
7910 return STATUS_READ_ERROR;
7911
7912 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SERIAL | FILE_SOCKET)) == 0
7913 || (fd_info[fd].flags & FILE_READ) == 0)
7914 {
7915 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd));
7916 emacs_abort ();
7917 }
7918
7919 cp->status = STATUS_READ_IN_PROGRESS;
7920
7921 if (fd_info[fd].flags & FILE_PIPE)
7922 {
7923 rc = _read (fd, &cp->chr, sizeof (char));
7924
7925 /* Give subprocess time to buffer some more output for us before
7926 reporting that input is available; we need this because Windows 95
7927 connects DOS programs to pipes by making the pipe appear to be
7928 the normal console stdout - as a result most DOS programs will
7929 write to stdout without buffering, ie. one character at a
7930 time. Even some W32 programs do this - "dir" in a command
7931 shell on NT is very slow if we don't do this. */
7932 if (rc > 0)
7933 {
7934 int wait = w32_pipe_read_delay;
7935
7936 if (wait > 0)
7937 Sleep (wait);
7938 else if (wait < 0)
7939 while (++wait <= 0)
7940 /* Yield remainder of our time slice, effectively giving a
7941 temporary priority boost to the child process. */
7942 Sleep (0);
7943 }
7944 }
7945 else if (fd_info[fd].flags & FILE_SERIAL)
7946 {
7947 HANDLE hnd = fd_info[fd].hnd;
7948 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
7949 COMMTIMEOUTS ct;
7950
7951 /* Configure timeouts for blocking read. */
7952 if (!GetCommTimeouts (hnd, &ct))
7953 {
7954 cp->status = STATUS_READ_ERROR;
7955 return STATUS_READ_ERROR;
7956 }
7957 ct.ReadIntervalTimeout = 0;
7958 ct.ReadTotalTimeoutMultiplier = 0;
7959 ct.ReadTotalTimeoutConstant = 0;
7960 if (!SetCommTimeouts (hnd, &ct))
7961 {
7962 cp->status = STATUS_READ_ERROR;
7963 return STATUS_READ_ERROR;
7964 }
7965
7966 if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
7967 {
7968 if (GetLastError () != ERROR_IO_PENDING)
7969 {
7970 cp->status = STATUS_READ_ERROR;
7971 return STATUS_READ_ERROR;
7972 }
7973 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
7974 {
7975 cp->status = STATUS_READ_ERROR;
7976 return STATUS_READ_ERROR;
7977 }
7978 }
7979 }
7980 else if (fd_info[fd].flags & FILE_SOCKET)
7981 {
7982 unsigned long nblock = 0;
7983 /* We always want this to block, so temporarily disable NDELAY. */
7984 if (fd_info[fd].flags & FILE_NDELAY)
7985 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7986
7987 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
7988
7989 if (fd_info[fd].flags & FILE_NDELAY)
7990 {
7991 nblock = 1;
7992 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7993 }
7994 }
7995
7996 if (rc == sizeof (char))
7997 cp->status = STATUS_READ_SUCCEEDED;
7998 else
7999 cp->status = STATUS_READ_FAILED;
8000
8001 return cp->status;
8002 }
8003
8004 int
8005 _sys_wait_accept (int fd)
8006 {
8007 HANDLE hEv;
8008 child_process * cp;
8009 int rc;
8010
8011 if (fd < 0 || fd >= MAXDESC)
8012 return STATUS_READ_ERROR;
8013
8014 cp = fd_info[fd].cp;
8015
8016 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
8017 return STATUS_READ_ERROR;
8018
8019 cp->status = STATUS_READ_FAILED;
8020
8021 hEv = pfn_WSACreateEvent ();
8022 rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
8023 if (rc != SOCKET_ERROR)
8024 {
8025 do {
8026 rc = WaitForSingleObject (hEv, 500);
8027 Sleep (5);
8028 } while (rc == WAIT_TIMEOUT
8029 && cp->status != STATUS_READ_ERROR
8030 && cp->char_avail);
8031 pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
8032 if (rc == WAIT_OBJECT_0)
8033 cp->status = STATUS_READ_SUCCEEDED;
8034 }
8035 pfn_WSACloseEvent (hEv);
8036
8037 return cp->status;
8038 }
8039
8040 int
8041 sys_read (int fd, char * buffer, unsigned int count)
8042 {
8043 int nchars;
8044 int to_read;
8045 DWORD waiting;
8046 char * orig_buffer = buffer;
8047
8048 if (fd < 0)
8049 {
8050 errno = EBADF;
8051 return -1;
8052 }
8053
8054 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
8055 {
8056 child_process *cp = fd_info[fd].cp;
8057
8058 if ((fd_info[fd].flags & FILE_READ) == 0)
8059 {
8060 errno = EBADF;
8061 return -1;
8062 }
8063
8064 nchars = 0;
8065
8066 /* re-read CR carried over from last read */
8067 if (fd_info[fd].flags & FILE_LAST_CR)
8068 {
8069 if (fd_info[fd].flags & FILE_BINARY) emacs_abort ();
8070 *buffer++ = 0x0d;
8071 count--;
8072 nchars++;
8073 fd_info[fd].flags &= ~FILE_LAST_CR;
8074 }
8075
8076 /* presence of a child_process structure means we are operating in
8077 non-blocking mode - otherwise we just call _read directly.
8078 Note that the child_process structure might be missing because
8079 reap_subprocess has been called; in this case the pipe is
8080 already broken, so calling _read on it is okay. */
8081 if (cp)
8082 {
8083 int current_status = cp->status;
8084
8085 switch (current_status)
8086 {
8087 case STATUS_READ_FAILED:
8088 case STATUS_READ_ERROR:
8089 /* report normal EOF if nothing in buffer */
8090 if (nchars <= 0)
8091 fd_info[fd].flags |= FILE_AT_EOF;
8092 return nchars;
8093
8094 case STATUS_READ_READY:
8095 case STATUS_READ_IN_PROGRESS:
8096 DebPrint (("sys_read called when read is in progress\n"));
8097 errno = EWOULDBLOCK;
8098 return -1;
8099
8100 case STATUS_READ_SUCCEEDED:
8101 /* consume read-ahead char */
8102 *buffer++ = cp->chr;
8103 count--;
8104 nchars++;
8105 cp->status = STATUS_READ_ACKNOWLEDGED;
8106 ResetEvent (cp->char_avail);
8107
8108 case STATUS_READ_ACKNOWLEDGED:
8109 break;
8110
8111 default:
8112 DebPrint (("sys_read: bad status %d\n", current_status));
8113 errno = EBADF;
8114 return -1;
8115 }
8116
8117 if (fd_info[fd].flags & FILE_PIPE)
8118 {
8119 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
8120 to_read = min (waiting, (DWORD) count);
8121
8122 if (to_read > 0)
8123 nchars += _read (fd, buffer, to_read);
8124 }
8125 else if (fd_info[fd].flags & FILE_SERIAL)
8126 {
8127 HANDLE hnd = fd_info[fd].hnd;
8128 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
8129 int rc = 0;
8130 COMMTIMEOUTS ct;
8131
8132 if (count > 0)
8133 {
8134 /* Configure timeouts for non-blocking read. */
8135 if (!GetCommTimeouts (hnd, &ct))
8136 {
8137 errno = EIO;
8138 return -1;
8139 }
8140 ct.ReadIntervalTimeout = MAXDWORD;
8141 ct.ReadTotalTimeoutMultiplier = 0;
8142 ct.ReadTotalTimeoutConstant = 0;
8143 if (!SetCommTimeouts (hnd, &ct))
8144 {
8145 errno = EIO;
8146 return -1;
8147 }
8148
8149 if (!ResetEvent (ovl->hEvent))
8150 {
8151 errno = EIO;
8152 return -1;
8153 }
8154 if (!ReadFile (hnd, buffer, count, (DWORD*) &rc, ovl))
8155 {
8156 if (GetLastError () != ERROR_IO_PENDING)
8157 {
8158 errno = EIO;
8159 return -1;
8160 }
8161 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
8162 {
8163 errno = EIO;
8164 return -1;
8165 }
8166 }
8167 nchars += rc;
8168 }
8169 }
8170 else /* FILE_SOCKET */
8171 {
8172 if (winsock_lib == NULL) emacs_abort ();
8173
8174 /* do the equivalent of a non-blocking read */
8175 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
8176 if (waiting == 0 && nchars == 0)
8177 {
8178 errno = EWOULDBLOCK;
8179 return -1;
8180 }
8181
8182 if (waiting)
8183 {
8184 /* always use binary mode for sockets */
8185 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
8186 if (res == SOCKET_ERROR)
8187 {
8188 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
8189 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
8190 set_errno ();
8191 return -1;
8192 }
8193 nchars += res;
8194 }
8195 }
8196 }
8197 else
8198 {
8199 int nread = _read (fd, buffer, count);
8200 if (nread >= 0)
8201 nchars += nread;
8202 else if (nchars == 0)
8203 nchars = nread;
8204 }
8205
8206 if (nchars <= 0)
8207 fd_info[fd].flags |= FILE_AT_EOF;
8208 /* Perform text mode translation if required. */
8209 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
8210 {
8211 nchars = crlf_to_lf (nchars, orig_buffer);
8212 /* If buffer contains only CR, return that. To be absolutely
8213 sure we should attempt to read the next char, but in
8214 practice a CR to be followed by LF would not appear by
8215 itself in the buffer. */
8216 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
8217 {
8218 fd_info[fd].flags |= FILE_LAST_CR;
8219 nchars--;
8220 }
8221 }
8222 }
8223 else
8224 nchars = _read (fd, buffer, count);
8225
8226 return nchars;
8227 }
8228
8229 /* From w32xfns.c */
8230 extern HANDLE interrupt_handle;
8231
8232 int
8233 sys_write (int fd, const void * buffer, unsigned int count)
8234 {
8235 int nchars;
8236
8237 if (fd < 0)
8238 {
8239 errno = EBADF;
8240 return -1;
8241 }
8242
8243 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
8244 {
8245 if ((fd_info[fd].flags & FILE_WRITE) == 0)
8246 {
8247 errno = EBADF;
8248 return -1;
8249 }
8250
8251 /* Perform text mode translation if required. */
8252 if ((fd_info[fd].flags & FILE_BINARY) == 0)
8253 {
8254 char * tmpbuf = alloca (count * 2);
8255 unsigned char * src = (void *)buffer;
8256 unsigned char * dst = tmpbuf;
8257 int nbytes = count;
8258
8259 while (1)
8260 {
8261 unsigned char *next;
8262 /* copy next line or remaining bytes */
8263 next = _memccpy (dst, src, '\n', nbytes);
8264 if (next)
8265 {
8266 /* copied one line ending with '\n' */
8267 int copied = next - dst;
8268 nbytes -= copied;
8269 src += copied;
8270 /* insert '\r' before '\n' */
8271 next[-1] = '\r';
8272 next[0] = '\n';
8273 dst = next + 1;
8274 count++;
8275 }
8276 else
8277 /* copied remaining partial line -> now finished */
8278 break;
8279 }
8280 buffer = tmpbuf;
8281 }
8282 }
8283
8284 if (fd < MAXDESC && fd_info[fd].flags & FILE_SERIAL)
8285 {
8286 HANDLE hnd = (HANDLE) _get_osfhandle (fd);
8287 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_write;
8288 HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
8289 DWORD active = 0;
8290
8291 if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
8292 {
8293 if (GetLastError () != ERROR_IO_PENDING)
8294 {
8295 errno = EIO;
8296 return -1;
8297 }
8298 if (detect_input_pending ())
8299 active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
8300 QS_ALLINPUT);
8301 else
8302 active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
8303 if (active == WAIT_OBJECT_0)
8304 { /* User pressed C-g, cancel write, then leave. Don't bother
8305 cleaning up as we may only get stuck in buggy drivers. */
8306 PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
8307 CancelIo (hnd);
8308 errno = EIO;
8309 return -1;
8310 }
8311 if (active == WAIT_OBJECT_0 + 1
8312 && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
8313 {
8314 errno = EIO;
8315 return -1;
8316 }
8317 }
8318 }
8319 else if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
8320 {
8321 unsigned long nblock = 0;
8322 if (winsock_lib == NULL) emacs_abort ();
8323
8324 /* TODO: implement select() properly so non-blocking I/O works. */
8325 /* For now, make sure the write blocks. */
8326 if (fd_info[fd].flags & FILE_NDELAY)
8327 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
8328
8329 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
8330
8331 /* Set the socket back to non-blocking if it was before,
8332 for other operations that support it. */
8333 if (fd_info[fd].flags & FILE_NDELAY)
8334 {
8335 nblock = 1;
8336 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
8337 }
8338
8339 if (nchars == SOCKET_ERROR)
8340 {
8341 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
8342 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
8343 set_errno ();
8344 }
8345 }
8346 else
8347 {
8348 /* Some networked filesystems don't like too large writes, so
8349 break them into smaller chunks. See the Comments section of
8350 the MSDN documentation of WriteFile for details behind the
8351 choice of the value of CHUNK below. See also the thread
8352 http://thread.gmane.org/gmane.comp.version-control.git/145294
8353 in the git mailing list. */
8354 const unsigned char *p = buffer;
8355 const unsigned chunk = 30 * 1024 * 1024;
8356
8357 nchars = 0;
8358 while (count > 0)
8359 {
8360 unsigned this_chunk = count < chunk ? count : chunk;
8361 int n = _write (fd, p, this_chunk);
8362
8363 nchars += n;
8364 if (n < 0)
8365 {
8366 /* When there's no buffer space in a pipe that is in the
8367 non-blocking mode, _write returns ENOSPC. We return
8368 EAGAIN instead, which should trigger the logic in
8369 send_process that enters waiting loop and calls
8370 wait_reading_process_output to allow process input to
8371 be accepted during the wait. Those calls to
8372 wait_reading_process_output allow sys_select to
8373 notice when process input becomes available, thus
8374 avoiding deadlock whereby each side of the pipe is
8375 blocked on write, waiting for the other party to read
8376 its end of the pipe. */
8377 if (errno == ENOSPC
8378 && fd < MAXDESC
8379 && ((fd_info[fd].flags & (FILE_PIPE | FILE_NDELAY))
8380 == (FILE_PIPE | FILE_NDELAY)))
8381 errno = EAGAIN;
8382 nchars = n;
8383 break;
8384 }
8385 else if (n < this_chunk)
8386 break;
8387 count -= n;
8388 p += n;
8389 }
8390 }
8391
8392 return nchars;
8393 }
8394
8395 \f
8396 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
8397
8398 extern Lisp_Object conv_sockaddr_to_lisp (struct sockaddr *, int);
8399
8400 /* Return information about network interface IFNAME, or about all
8401 interfaces (if IFNAME is nil). */
8402 static Lisp_Object
8403 network_interface_get_info (Lisp_Object ifname)
8404 {
8405 ULONG ainfo_len = sizeof (IP_ADAPTER_INFO);
8406 IP_ADAPTER_INFO *adapter, *ainfo = xmalloc (ainfo_len);
8407 DWORD retval = get_adapters_info (ainfo, &ainfo_len);
8408 Lisp_Object res = Qnil;
8409
8410 if (retval == ERROR_BUFFER_OVERFLOW)
8411 {
8412 ainfo = xrealloc (ainfo, ainfo_len);
8413 retval = get_adapters_info (ainfo, &ainfo_len);
8414 }
8415
8416 if (retval == ERROR_SUCCESS)
8417 {
8418 int eth_count = 0, tr_count = 0, fddi_count = 0, ppp_count = 0;
8419 int sl_count = 0, wlan_count = 0, lo_count = 0, ifx_count = 0;
8420 int if_num;
8421 struct sockaddr_in sa;
8422
8423 /* For the below, we need some winsock functions, so make sure
8424 the winsock DLL is loaded. If we cannot successfully load
8425 it, they will have no use of the information we provide,
8426 anyway, so punt. */
8427 if (!winsock_lib && !init_winsock (1))
8428 goto done;
8429
8430 for (adapter = ainfo; adapter; adapter = adapter->Next)
8431 {
8432 char namebuf[MAX_ADAPTER_NAME_LENGTH + 4];
8433 u_long ip_addr;
8434 /* Present Unix-compatible interface names, instead of the
8435 Windows names, which are really GUIDs not readable by
8436 humans. */
8437 static const char *ifmt[] = {
8438 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
8439 "lo", "ifx%d"
8440 };
8441 enum {
8442 NONE = -1,
8443 ETHERNET = 0,
8444 TOKENRING = 1,
8445 FDDI = 2,
8446 PPP = 3,
8447 SLIP = 4,
8448 WLAN = 5,
8449 LOOPBACK = 6,
8450 OTHER_IF = 7
8451 } ifmt_idx;
8452
8453 switch (adapter->Type)
8454 {
8455 case MIB_IF_TYPE_ETHERNET:
8456 /* Windows before Vista reports wireless adapters as
8457 Ethernet. Work around by looking at the Description
8458 string. */
8459 if (strstr (adapter->Description, "Wireless "))
8460 {
8461 ifmt_idx = WLAN;
8462 if_num = wlan_count++;
8463 }
8464 else
8465 {
8466 ifmt_idx = ETHERNET;
8467 if_num = eth_count++;
8468 }
8469 break;
8470 case MIB_IF_TYPE_TOKENRING:
8471 ifmt_idx = TOKENRING;
8472 if_num = tr_count++;
8473 break;
8474 case MIB_IF_TYPE_FDDI:
8475 ifmt_idx = FDDI;
8476 if_num = fddi_count++;
8477 break;
8478 case MIB_IF_TYPE_PPP:
8479 ifmt_idx = PPP;
8480 if_num = ppp_count++;
8481 break;
8482 case MIB_IF_TYPE_SLIP:
8483 ifmt_idx = SLIP;
8484 if_num = sl_count++;
8485 break;
8486 case IF_TYPE_IEEE80211:
8487 ifmt_idx = WLAN;
8488 if_num = wlan_count++;
8489 break;
8490 case MIB_IF_TYPE_LOOPBACK:
8491 if (lo_count < 0)
8492 {
8493 ifmt_idx = LOOPBACK;
8494 if_num = lo_count++;
8495 }
8496 else
8497 ifmt_idx = NONE;
8498 break;
8499 default:
8500 ifmt_idx = OTHER_IF;
8501 if_num = ifx_count++;
8502 break;
8503 }
8504 if (ifmt_idx == NONE)
8505 continue;
8506 sprintf (namebuf, ifmt[ifmt_idx], if_num);
8507
8508 sa.sin_family = AF_INET;
8509 ip_addr = sys_inet_addr (adapter->IpAddressList.IpAddress.String);
8510 if (ip_addr == INADDR_NONE)
8511 {
8512 /* Bogus address, skip this interface. */
8513 continue;
8514 }
8515 sa.sin_addr.s_addr = ip_addr;
8516 sa.sin_port = 0;
8517 if (NILP (ifname))
8518 res = Fcons (Fcons (build_string (namebuf),
8519 conv_sockaddr_to_lisp ((struct sockaddr*) &sa,
8520 sizeof (struct sockaddr))),
8521 res);
8522 else if (strcmp (namebuf, SSDATA (ifname)) == 0)
8523 {
8524 Lisp_Object hwaddr = Fmake_vector (make_number (6), Qnil);
8525 register struct Lisp_Vector *p = XVECTOR (hwaddr);
8526 Lisp_Object flags = Qnil;
8527 int n;
8528 u_long net_mask;
8529
8530 /* Flags. We guess most of them by type, since the
8531 Windows flags are different and hard to get by. */
8532 flags = Fcons (intern ("up"), flags);
8533 if (ifmt_idx == ETHERNET || ifmt_idx == WLAN)
8534 {
8535 flags = Fcons (intern ("broadcast"), flags);
8536 flags = Fcons (intern ("multicast"), flags);
8537 }
8538 flags = Fcons (intern ("running"), flags);
8539 if (ifmt_idx == PPP)
8540 {
8541 flags = Fcons (intern ("pointopoint"), flags);
8542 flags = Fcons (intern ("noarp"), flags);
8543 }
8544 if (adapter->HaveWins)
8545 flags = Fcons (intern ("WINS"), flags);
8546 if (adapter->DhcpEnabled)
8547 flags = Fcons (intern ("dynamic"), flags);
8548
8549 res = Fcons (flags, res);
8550
8551 /* Hardware address and its family. */
8552 for (n = 0; n < adapter->AddressLength; n++)
8553 p->contents[n] = make_number ((int) adapter->Address[n]);
8554 /* Windows does not support AF_LINK or AF_PACKET family
8555 of addresses. Use an arbitrary family number that is
8556 identical to what GNU/Linux returns. */
8557 res = Fcons (Fcons (make_number (1), hwaddr), res);
8558
8559 /* Network mask. */
8560 sa.sin_family = AF_INET;
8561 net_mask = sys_inet_addr (adapter->IpAddressList.IpMask.String);
8562 if (net_mask != INADDR_NONE)
8563 {
8564 sa.sin_addr.s_addr = net_mask;
8565 sa.sin_port = 0;
8566 res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
8567 sizeof (struct sockaddr)),
8568 res);
8569 }
8570 else
8571 res = Fcons (Qnil, res);
8572
8573 sa.sin_family = AF_INET;
8574 if (ip_addr != INADDR_NONE)
8575 {
8576 /* Broadcast address is only reported by
8577 GetAdaptersAddresses, which is of limited
8578 availability. Generate it on our own. */
8579 u_long bcast_addr = (ip_addr & net_mask) | ~net_mask;
8580
8581 sa.sin_addr.s_addr = bcast_addr;
8582 sa.sin_port = 0;
8583 res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
8584 sizeof (struct sockaddr)),
8585 res);
8586
8587 /* IP address. */
8588 sa.sin_addr.s_addr = ip_addr;
8589 sa.sin_port = 0;
8590 res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
8591 sizeof (struct sockaddr)),
8592 res);
8593 }
8594 else
8595 res = Fcons (Qnil, Fcons (Qnil, res));
8596 }
8597 }
8598 /* GetAdaptersInfo is documented to not report loopback
8599 interfaces, so we generate one out of thin air. */
8600 if (!lo_count)
8601 {
8602 sa.sin_family = AF_INET;
8603 sa.sin_port = 0;
8604 if (NILP (ifname))
8605 {
8606 sa.sin_addr.s_addr = sys_inet_addr ("127.0.0.1");
8607 res = Fcons (Fcons (build_string ("lo"),
8608 conv_sockaddr_to_lisp ((struct sockaddr*) &sa,
8609 sizeof (struct sockaddr))),
8610 res);
8611 }
8612 else if (strcmp (SSDATA (ifname), "lo") == 0)
8613 {
8614 res = Fcons (Fcons (intern ("running"),
8615 Fcons (intern ("loopback"),
8616 Fcons (intern ("up"), Qnil))), Qnil);
8617 /* 772 is what 3 different GNU/Linux systems report for
8618 the loopback interface. */
8619 res = Fcons (Fcons (make_number (772),
8620 Fmake_vector (make_number (6),
8621 make_number (0))),
8622 res);
8623 sa.sin_addr.s_addr = sys_inet_addr ("255.0.0.0");
8624 res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
8625 sizeof (struct sockaddr)),
8626 res);
8627 sa.sin_addr.s_addr = sys_inet_addr ("0.0.0.0");
8628 res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
8629 sizeof (struct sockaddr)),
8630 res);
8631 sa.sin_addr.s_addr = sys_inet_addr ("127.0.0.1");
8632 res = Fcons (conv_sockaddr_to_lisp ((struct sockaddr *) &sa,
8633 sizeof (struct sockaddr)),
8634 res);
8635 }
8636
8637 }
8638 }
8639
8640 done:
8641 xfree (ainfo);
8642 return res;
8643 }
8644
8645 Lisp_Object
8646 network_interface_list (void)
8647 {
8648 return network_interface_get_info (Qnil);
8649 }
8650
8651 Lisp_Object
8652 network_interface_info (Lisp_Object ifname)
8653 {
8654 CHECK_STRING (ifname);
8655 return network_interface_get_info (ifname);
8656 }
8657
8658 \f
8659 /* The Windows CRT functions are "optimized for speed", so they don't
8660 check for timezone and DST changes if they were last called less
8661 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
8662 all Emacs features that repeatedly call time functions (e.g.,
8663 display-time) are in real danger of missing timezone and DST
8664 changes. Calling tzset before each localtime call fixes that. */
8665 struct tm *
8666 sys_localtime (const time_t *t)
8667 {
8668 tzset ();
8669 return localtime (t);
8670 }
8671
8672
8673 \f
8674 /* Try loading LIBRARY_ID from the file(s) specified in
8675 Vdynamic_library_alist. If the library is loaded successfully,
8676 return the handle of the DLL, and record the filename in the
8677 property :loaded-from of LIBRARY_ID. If the library could not be
8678 found, or when it was already loaded (because the handle is not
8679 recorded anywhere, and so is lost after use), return NULL.
8680
8681 We could also save the handle in :loaded-from, but currently
8682 there's no use case for it. */
8683 HMODULE
8684 w32_delayed_load (Lisp_Object library_id)
8685 {
8686 HMODULE dll_handle = NULL;
8687
8688 CHECK_SYMBOL (library_id);
8689
8690 if (CONSP (Vdynamic_library_alist)
8691 && NILP (Fassq (library_id, Vlibrary_cache)))
8692 {
8693 Lisp_Object found = Qnil;
8694 Lisp_Object dlls = Fassq (library_id, Vdynamic_library_alist);
8695
8696 if (CONSP (dlls))
8697 for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
8698 {
8699 Lisp_Object dll = XCAR (dlls);
8700 char name[MAX_UTF8_PATH];
8701 DWORD res = -1;
8702
8703 CHECK_STRING (dll);
8704 dll = ENCODE_FILE (dll);
8705 if (w32_unicode_filenames)
8706 {
8707 wchar_t name_w[MAX_PATH];
8708
8709 filename_to_utf16 (SSDATA (dll), name_w);
8710 dll_handle = LoadLibraryW (name_w);
8711 if (dll_handle)
8712 {
8713 res = GetModuleFileNameW (dll_handle, name_w,
8714 sizeof (name_w));
8715 if (res > 0)
8716 filename_from_utf16 (name_w, name);
8717 }
8718 }
8719 else
8720 {
8721 char name_a[MAX_PATH];
8722
8723 filename_to_ansi (SSDATA (dll), name_a);
8724 dll_handle = LoadLibraryA (name_a);
8725 if (dll_handle)
8726 {
8727 res = GetModuleFileNameA (dll_handle, name_a,
8728 sizeof (name_a));
8729 if (res > 0)
8730 filename_from_ansi (name_a, name);
8731 }
8732 }
8733 if (dll_handle)
8734 {
8735 ptrdiff_t len = strlen (name);
8736 found = Fcons (dll,
8737 (res > 0)
8738 /* Possibly truncated */
8739 ? make_specified_string (name, -1, len, 1)
8740 : Qnil);
8741 break;
8742 }
8743 }
8744
8745 Fput (library_id, QCloaded_from, found);
8746 }
8747
8748 return dll_handle;
8749 }
8750
8751 \f
8752 void
8753 check_windows_init_file (void)
8754 {
8755 /* A common indication that Emacs is not installed properly is when
8756 it cannot find the Windows installation file. If this file does
8757 not exist in the expected place, tell the user. */
8758
8759 if (!noninteractive && !inhibit_window_system
8760 /* Vload_path is not yet initialized when we are loading
8761 loadup.el. */
8762 && NILP (Vpurify_flag))
8763 {
8764 Lisp_Object init_file;
8765 int fd;
8766
8767 /* Implementation note: this function runs early during Emacs
8768 startup, before startup.el is run. So Vload_path is still in
8769 its initial unibyte form, but it holds UTF-8 encoded file
8770 names, since init_callproc was already called. So we do not
8771 need to ENCODE_FILE here, but we do need to convert the file
8772 names from UTF-8 to ANSI. */
8773 init_file = build_string ("term/w32-win");
8774 fd = openp (Vload_path, init_file, Fget_load_suffixes (), NULL, Qnil, 0);
8775 if (fd < 0)
8776 {
8777 Lisp_Object load_path_print = Fprin1_to_string (Vload_path, Qnil);
8778 char *init_file_name = SDATA (init_file);
8779 char *load_path = SDATA (load_path_print);
8780 char *buffer = alloca (1024
8781 + strlen (init_file_name)
8782 + strlen (load_path));
8783 char *msg = buffer;
8784 int needed;
8785
8786 sprintf (buffer,
8787 "The Emacs Windows initialization file \"%s.el\" "
8788 "could not be found in your Emacs installation. "
8789 "Emacs checked the following directories for this file:\n"
8790 "\n%s\n\n"
8791 "When Emacs cannot find this file, it usually means that it "
8792 "was not installed properly, or its distribution file was "
8793 "not unpacked properly.\nSee the README.W32 file in the "
8794 "top-level Emacs directory for more information.",
8795 init_file_name, load_path);
8796 needed = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, buffer,
8797 -1, NULL, 0);
8798 if (needed > 0)
8799 {
8800 wchar_t *msg_w = alloca ((needed + 1) * sizeof (wchar_t));
8801
8802 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, buffer, -1,
8803 msg_w, needed);
8804 needed = pWideCharToMultiByte (CP_ACP, 0, msg_w, -1,
8805 NULL, 0, NULL, NULL);
8806 if (needed > 0)
8807 {
8808 char *msg_a = alloca (needed + 1);
8809
8810 pWideCharToMultiByte (CP_ACP, 0, msg_w, -1, msg_a, needed,
8811 NULL, NULL);
8812 msg = msg_a;
8813 }
8814 }
8815 MessageBox (NULL,
8816 msg,
8817 "Emacs Abort Dialog",
8818 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
8819 /* Use the low-level system abort. */
8820 abort ();
8821 }
8822 else
8823 {
8824 _close (fd);
8825 }
8826 }
8827 }
8828
8829 void
8830 term_ntproc (int ignored)
8831 {
8832 (void)ignored;
8833
8834 term_timers ();
8835
8836 /* shutdown the socket interface if necessary */
8837 term_winsock ();
8838
8839 term_w32select ();
8840 }
8841
8842 void
8843 init_ntproc (int dumping)
8844 {
8845 sigset_t initial_mask = 0;
8846
8847 /* Initialize the socket interface now if available and requested by
8848 the user by defining PRELOAD_WINSOCK; otherwise loading will be
8849 delayed until open-network-stream is called (w32-has-winsock can
8850 also be used to dynamically load or reload winsock).
8851
8852 Conveniently, init_environment is called before us, so
8853 PRELOAD_WINSOCK can be set in the registry. */
8854
8855 /* Always initialize this correctly. */
8856 winsock_lib = NULL;
8857
8858 if (getenv ("PRELOAD_WINSOCK") != NULL)
8859 init_winsock (TRUE);
8860
8861 /* Initial preparation for subprocess support: replace our standard
8862 handles with non-inheritable versions. */
8863 {
8864 HANDLE parent;
8865 HANDLE stdin_save = INVALID_HANDLE_VALUE;
8866 HANDLE stdout_save = INVALID_HANDLE_VALUE;
8867 HANDLE stderr_save = INVALID_HANDLE_VALUE;
8868
8869 parent = GetCurrentProcess ();
8870
8871 /* ignore errors when duplicating and closing; typically the
8872 handles will be invalid when running as a gui program. */
8873 DuplicateHandle (parent,
8874 GetStdHandle (STD_INPUT_HANDLE),
8875 parent,
8876 &stdin_save,
8877 0,
8878 FALSE,
8879 DUPLICATE_SAME_ACCESS);
8880
8881 DuplicateHandle (parent,
8882 GetStdHandle (STD_OUTPUT_HANDLE),
8883 parent,
8884 &stdout_save,
8885 0,
8886 FALSE,
8887 DUPLICATE_SAME_ACCESS);
8888
8889 DuplicateHandle (parent,
8890 GetStdHandle (STD_ERROR_HANDLE),
8891 parent,
8892 &stderr_save,
8893 0,
8894 FALSE,
8895 DUPLICATE_SAME_ACCESS);
8896
8897 fclose (stdin);
8898 fclose (stdout);
8899 fclose (stderr);
8900
8901 if (stdin_save != INVALID_HANDLE_VALUE)
8902 _open_osfhandle ((intptr_t) stdin_save, O_TEXT);
8903 else
8904 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
8905 _fdopen (0, "r");
8906
8907 if (stdout_save != INVALID_HANDLE_VALUE)
8908 _open_osfhandle ((intptr_t) stdout_save, O_TEXT);
8909 else
8910 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
8911 _fdopen (1, "w");
8912
8913 if (stderr_save != INVALID_HANDLE_VALUE)
8914 _open_osfhandle ((intptr_t) stderr_save, O_TEXT);
8915 else
8916 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
8917 _fdopen (2, "w");
8918 }
8919
8920 /* unfortunately, atexit depends on implementation of malloc */
8921 /* atexit (term_ntproc); */
8922 if (!dumping)
8923 {
8924 /* Make sure we start with all signals unblocked. */
8925 sigprocmask (SIG_SETMASK, &initial_mask, NULL);
8926 signal (SIGABRT, term_ntproc);
8927 }
8928 init_timers ();
8929
8930 /* determine which drives are fixed, for GetCachedVolumeInformation */
8931 {
8932 /* GetDriveType must have trailing backslash. */
8933 char drive[] = "A:\\";
8934
8935 /* Loop over all possible drive letters */
8936 while (*drive <= 'Z')
8937 {
8938 /* Record if this drive letter refers to a fixed drive. */
8939 fixed_drives[DRIVE_INDEX (*drive)] =
8940 (GetDriveType (drive) == DRIVE_FIXED);
8941
8942 (*drive)++;
8943 }
8944
8945 /* Reset the volume info cache. */
8946 volume_cache = NULL;
8947 }
8948 }
8949
8950 /*
8951 shutdown_handler ensures that buffers' autosave files are
8952 up to date when the user logs off, or the system shuts down.
8953 */
8954 static BOOL WINAPI
8955 shutdown_handler (DWORD type)
8956 {
8957 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
8958 if (type == CTRL_CLOSE_EVENT /* User closes console window. */
8959 || type == CTRL_LOGOFF_EVENT /* User logs off. */
8960 || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown. */
8961 {
8962 /* Shut down cleanly, making sure autosave files are up to date. */
8963 shut_down_emacs (0, Qnil);
8964 }
8965
8966 /* Allow other handlers to handle this signal. */
8967 return FALSE;
8968 }
8969
8970 /* On Windows 9X, load UNICOWS.DLL and return its handle, or die. On
8971 NT, return a handle to GDI32.DLL. */
8972 HANDLE
8973 maybe_load_unicows_dll (void)
8974 {
8975 if (os_subtype == OS_9X)
8976 {
8977 HANDLE ret = LoadLibrary ("Unicows.dll");
8978 if (ret)
8979 {
8980 /* These two functions are present on Windows 9X as stubs
8981 that always fail. We need the real implementations from
8982 UNICOWS.DLL, so we must call these functions through
8983 pointers, and assign the correct addresses to these
8984 pointers at program startup (see emacs.c, which calls
8985 this function early on). */
8986 pMultiByteToWideChar = GetProcAddress (ret, "MultiByteToWideChar");
8987 pWideCharToMultiByte = GetProcAddress (ret, "WideCharToMultiByte");
8988 return ret;
8989 }
8990 else
8991 {
8992 int button;
8993
8994 button = MessageBox (NULL,
8995 "Emacs cannot load the UNICOWS.DLL library.\n"
8996 "This library is essential for using Emacs\n"
8997 "on this system. You need to install it.\n\n"
8998 "Emacs will exit when you click OK.",
8999 "Emacs cannot load UNICOWS.DLL",
9000 MB_ICONERROR | MB_TASKMODAL
9001 | MB_SETFOREGROUND | MB_OK);
9002 switch (button)
9003 {
9004 case IDOK:
9005 default:
9006 exit (1);
9007 }
9008 }
9009 }
9010 else
9011 {
9012 /* On NT family of Windows, these two functions are always
9013 linked in, so we just assign their addresses to the 2
9014 pointers; no need for the LoadLibrary dance. */
9015 pMultiByteToWideChar = MultiByteToWideChar;
9016 pWideCharToMultiByte = WideCharToMultiByte;
9017 return LoadLibrary ("Gdi32.dll");
9018 }
9019 }
9020
9021 /*
9022 globals_of_w32 is used to initialize those global variables that
9023 must always be initialized on startup even when the global variable
9024 initialized is non zero (see the function main in emacs.c).
9025 */
9026 void
9027 globals_of_w32 (void)
9028 {
9029 HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
9030
9031 get_process_times_fn = (GetProcessTimes_Proc)
9032 GetProcAddress (kernel32, "GetProcessTimes");
9033
9034 DEFSYM (QCloaded_from, ":loaded-from");
9035
9036 g_b_init_is_windows_9x = 0;
9037 g_b_init_open_process_token = 0;
9038 g_b_init_get_token_information = 0;
9039 g_b_init_lookup_account_sid = 0;
9040 g_b_init_get_sid_sub_authority = 0;
9041 g_b_init_get_sid_sub_authority_count = 0;
9042 g_b_init_get_security_info = 0;
9043 g_b_init_get_file_security_w = 0;
9044 g_b_init_get_file_security_a = 0;
9045 g_b_init_get_security_descriptor_owner = 0;
9046 g_b_init_get_security_descriptor_group = 0;
9047 g_b_init_is_valid_sid = 0;
9048 g_b_init_create_toolhelp32_snapshot = 0;
9049 g_b_init_process32_first = 0;
9050 g_b_init_process32_next = 0;
9051 g_b_init_open_thread_token = 0;
9052 g_b_init_impersonate_self = 0;
9053 g_b_init_revert_to_self = 0;
9054 g_b_init_get_process_memory_info = 0;
9055 g_b_init_get_process_working_set_size = 0;
9056 g_b_init_global_memory_status = 0;
9057 g_b_init_global_memory_status_ex = 0;
9058 g_b_init_equal_sid = 0;
9059 g_b_init_copy_sid = 0;
9060 g_b_init_get_length_sid = 0;
9061 g_b_init_get_native_system_info = 0;
9062 g_b_init_get_system_times = 0;
9063 g_b_init_create_symbolic_link_w = 0;
9064 g_b_init_create_symbolic_link_a = 0;
9065 g_b_init_get_security_descriptor_dacl = 0;
9066 g_b_init_convert_sd_to_sddl = 0;
9067 g_b_init_convert_sddl_to_sd = 0;
9068 g_b_init_is_valid_security_descriptor = 0;
9069 g_b_init_set_file_security_w = 0;
9070 g_b_init_set_file_security_a = 0;
9071 g_b_init_set_named_security_info_w = 0;
9072 g_b_init_set_named_security_info_a = 0;
9073 g_b_init_get_adapters_info = 0;
9074 num_of_processors = 0;
9075 /* The following sets a handler for shutdown notifications for
9076 console apps. This actually applies to Emacs in both console and
9077 GUI modes, since we had to fool windows into thinking emacs is a
9078 console application to get console mode to work. */
9079 SetConsoleCtrlHandler (shutdown_handler, TRUE);
9080
9081 /* "None" is the default group name on standalone workstations. */
9082 strcpy (dflt_group_name, "None");
9083
9084 /* Reset, in case it has some value inherited from dump time. */
9085 w32_stat_get_owner_group = 0;
9086
9087 /* If w32_unicode_filenames is non-zero, we will be using Unicode
9088 (a.k.a. "wide") APIs to invoke functions that accept file
9089 names. */
9090 if (is_windows_9x ())
9091 w32_unicode_filenames = 0;
9092 else
9093 w32_unicode_filenames = 1;
9094 }
9095
9096 /* For make-serial-process */
9097 int
9098 serial_open (Lisp_Object port_obj)
9099 {
9100 char *port = SSDATA (port_obj);
9101 HANDLE hnd;
9102 child_process *cp;
9103 int fd = -1;
9104
9105 hnd = CreateFile (port, GENERIC_READ | GENERIC_WRITE, 0, 0,
9106 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
9107 if (hnd == INVALID_HANDLE_VALUE)
9108 error ("Could not open %s", port);
9109 fd = (int) _open_osfhandle ((intptr_t) hnd, 0);
9110 if (fd == -1)
9111 error ("Could not open %s", port);
9112
9113 cp = new_child ();
9114 if (!cp)
9115 error ("Could not create child process");
9116 cp->fd = fd;
9117 cp->status = STATUS_READ_ACKNOWLEDGED;
9118 fd_info[ fd ].hnd = hnd;
9119 fd_info[ fd ].flags |=
9120 FILE_READ | FILE_WRITE | FILE_BINARY | FILE_SERIAL;
9121 if (fd_info[ fd ].cp != NULL)
9122 {
9123 error ("fd_info[fd = %d] is already in use", fd);
9124 }
9125 fd_info[ fd ].cp = cp;
9126 cp->ovl_read.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
9127 if (cp->ovl_read.hEvent == NULL)
9128 error ("Could not create read event");
9129 cp->ovl_write.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
9130 if (cp->ovl_write.hEvent == NULL)
9131 error ("Could not create write event");
9132
9133 return fd;
9134 }
9135
9136 /* For serial-process-configure */
9137 void
9138 serial_configure (struct Lisp_Process *p, Lisp_Object contact)
9139 {
9140 Lisp_Object childp2 = Qnil;
9141 Lisp_Object tem = Qnil;
9142 HANDLE hnd;
9143 DCB dcb;
9144 COMMTIMEOUTS ct;
9145 char summary[4] = "???"; /* This usually becomes "8N1". */
9146
9147 if ((fd_info[ p->outfd ].flags & FILE_SERIAL) == 0)
9148 error ("Not a serial process");
9149 hnd = fd_info[ p->outfd ].hnd;
9150
9151 childp2 = Fcopy_sequence (p->childp);
9152
9153 /* Initialize timeouts for blocking read and blocking write. */
9154 if (!GetCommTimeouts (hnd, &ct))
9155 error ("GetCommTimeouts() failed");
9156 ct.ReadIntervalTimeout = 0;
9157 ct.ReadTotalTimeoutMultiplier = 0;
9158 ct.ReadTotalTimeoutConstant = 0;
9159 ct.WriteTotalTimeoutMultiplier = 0;
9160 ct.WriteTotalTimeoutConstant = 0;
9161 if (!SetCommTimeouts (hnd, &ct))
9162 error ("SetCommTimeouts() failed");
9163 /* Read port attributes and prepare default configuration. */
9164 memset (&dcb, 0, sizeof (dcb));
9165 dcb.DCBlength = sizeof (DCB);
9166 if (!GetCommState (hnd, &dcb))
9167 error ("GetCommState() failed");
9168 dcb.fBinary = TRUE;
9169 dcb.fNull = FALSE;
9170 dcb.fAbortOnError = FALSE;
9171 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
9172 dcb.ErrorChar = 0;
9173 dcb.EofChar = 0;
9174 dcb.EvtChar = 0;
9175
9176 /* Configure speed. */
9177 if (!NILP (Fplist_member (contact, QCspeed)))
9178 tem = Fplist_get (contact, QCspeed);
9179 else
9180 tem = Fplist_get (p->childp, QCspeed);
9181 CHECK_NUMBER (tem);
9182 dcb.BaudRate = XINT (tem);
9183 childp2 = Fplist_put (childp2, QCspeed, tem);
9184
9185 /* Configure bytesize. */
9186 if (!NILP (Fplist_member (contact, QCbytesize)))
9187 tem = Fplist_get (contact, QCbytesize);
9188 else
9189 tem = Fplist_get (p->childp, QCbytesize);
9190 if (NILP (tem))
9191 tem = make_number (8);
9192 CHECK_NUMBER (tem);
9193 if (XINT (tem) != 7 && XINT (tem) != 8)
9194 error (":bytesize must be nil (8), 7, or 8");
9195 dcb.ByteSize = XINT (tem);
9196 summary[0] = XINT (tem) + '0';
9197 childp2 = Fplist_put (childp2, QCbytesize, tem);
9198
9199 /* Configure parity. */
9200 if (!NILP (Fplist_member (contact, QCparity)))
9201 tem = Fplist_get (contact, QCparity);
9202 else
9203 tem = Fplist_get (p->childp, QCparity);
9204 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
9205 error (":parity must be nil (no parity), `even', or `odd'");
9206 dcb.fParity = FALSE;
9207 dcb.Parity = NOPARITY;
9208 dcb.fErrorChar = FALSE;
9209 if (NILP (tem))
9210 {
9211 summary[1] = 'N';
9212 }
9213 else if (EQ (tem, Qeven))
9214 {
9215 summary[1] = 'E';
9216 dcb.fParity = TRUE;
9217 dcb.Parity = EVENPARITY;
9218 dcb.fErrorChar = TRUE;
9219 }
9220 else if (EQ (tem, Qodd))
9221 {
9222 summary[1] = 'O';
9223 dcb.fParity = TRUE;
9224 dcb.Parity = ODDPARITY;
9225 dcb.fErrorChar = TRUE;
9226 }
9227 childp2 = Fplist_put (childp2, QCparity, tem);
9228
9229 /* Configure stopbits. */
9230 if (!NILP (Fplist_member (contact, QCstopbits)))
9231 tem = Fplist_get (contact, QCstopbits);
9232 else
9233 tem = Fplist_get (p->childp, QCstopbits);
9234 if (NILP (tem))
9235 tem = make_number (1);
9236 CHECK_NUMBER (tem);
9237 if (XINT (tem) != 1 && XINT (tem) != 2)
9238 error (":stopbits must be nil (1 stopbit), 1, or 2");
9239 summary[2] = XINT (tem) + '0';
9240 if (XINT (tem) == 1)
9241 dcb.StopBits = ONESTOPBIT;
9242 else if (XINT (tem) == 2)
9243 dcb.StopBits = TWOSTOPBITS;
9244 childp2 = Fplist_put (childp2, QCstopbits, tem);
9245
9246 /* Configure flowcontrol. */
9247 if (!NILP (Fplist_member (contact, QCflowcontrol)))
9248 tem = Fplist_get (contact, QCflowcontrol);
9249 else
9250 tem = Fplist_get (p->childp, QCflowcontrol);
9251 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
9252 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
9253 dcb.fOutxCtsFlow = FALSE;
9254 dcb.fOutxDsrFlow = FALSE;
9255 dcb.fDtrControl = DTR_CONTROL_DISABLE;
9256 dcb.fDsrSensitivity = FALSE;
9257 dcb.fTXContinueOnXoff = FALSE;
9258 dcb.fOutX = FALSE;
9259 dcb.fInX = FALSE;
9260 dcb.fRtsControl = RTS_CONTROL_DISABLE;
9261 dcb.XonChar = 17; /* Control-Q */
9262 dcb.XoffChar = 19; /* Control-S */
9263 if (NILP (tem))
9264 {
9265 /* Already configured. */
9266 }
9267 else if (EQ (tem, Qhw))
9268 {
9269 dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
9270 dcb.fOutxCtsFlow = TRUE;
9271 }
9272 else if (EQ (tem, Qsw))
9273 {
9274 dcb.fOutX = TRUE;
9275 dcb.fInX = TRUE;
9276 }
9277 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
9278
9279 /* Activate configuration. */
9280 if (!SetCommState (hnd, &dcb))
9281 error ("SetCommState() failed");
9282
9283 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
9284 pset_childp (p, childp2);
9285 }
9286
9287 #ifdef HAVE_GNUTLS
9288
9289 ssize_t
9290 emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
9291 {
9292 int n, err;
9293 SELECT_TYPE fdset;
9294 struct timespec timeout;
9295 struct Lisp_Process *process = (struct Lisp_Process *)p;
9296 int fd = process->infd;
9297
9298 n = sys_read (fd, (char*)buf, sz);
9299
9300 if (n >= 0)
9301 return n;
9302
9303 err = errno;
9304
9305 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9306 if (err == EWOULDBLOCK)
9307 err = EAGAIN;
9308
9309 emacs_gnutls_transport_set_errno (process->gnutls_state, err);
9310
9311 return -1;
9312 }
9313
9314 ssize_t
9315 emacs_gnutls_push (gnutls_transport_ptr_t p, const void* buf, size_t sz)
9316 {
9317 struct Lisp_Process *process = (struct Lisp_Process *)p;
9318 int fd = process->outfd;
9319 ssize_t n = sys_write (fd, buf, sz);
9320
9321 /* 0 or more bytes written means everything went fine. */
9322 if (n >= 0)
9323 return n;
9324
9325 /* Negative bytes written means we got an error in errno.
9326 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9327 emacs_gnutls_transport_set_errno (process->gnutls_state,
9328 errno == EWOULDBLOCK ? EAGAIN : errno);
9329
9330 return -1;
9331 }
9332 #endif /* HAVE_GNUTLS */
9333
9334 /* end of w32.c */