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