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