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