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