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