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