HCoop / bpt / emacs.git / blob
? search:


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