Fix typos.
[emacs.git] / src / w32.c
blobc752333c68d9df5d1fa709286bd0f931acb1d4d2
1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994-1995, 2000-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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.
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.
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/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 #include <stddef.h> /* for offsetof */
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <float.h> /* for DBL_EPSILON */
26 #include <io.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <ctype.h>
30 #include <signal.h>
31 #include <sys/file.h>
32 #include <sys/time.h>
33 #include <sys/utime.h>
34 #include <mbstring.h> /* for _mbspbrk */
35 #include <math.h>
36 #include <setjmp.h>
37 #include <time.h>
39 /* must include CRT headers *before* config.h */
41 #include <config.h>
43 #undef access
44 #undef chdir
45 #undef chmod
46 #undef creat
47 #undef ctime
48 #undef fopen
49 #undef link
50 #undef mkdir
51 #undef mktemp
52 #undef open
53 #undef rename
54 #undef rmdir
55 #undef unlink
57 #undef close
58 #undef dup
59 #undef dup2
60 #undef pipe
61 #undef read
62 #undef write
64 #undef strerror
66 #undef localtime
68 #include "lisp.h"
70 #include <pwd.h>
71 #include <grp.h>
73 #ifdef __GNUC__
74 #define _ANONYMOUS_UNION
75 #define _ANONYMOUS_STRUCT
76 #endif
77 #include <windows.h>
78 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
79 use a different name to avoid compilation problems. */
80 typedef struct _MEMORY_STATUS_EX {
81 DWORD dwLength;
82 DWORD dwMemoryLoad;
83 DWORDLONG ullTotalPhys;
84 DWORDLONG ullAvailPhys;
85 DWORDLONG ullTotalPageFile;
86 DWORDLONG ullAvailPageFile;
87 DWORDLONG ullTotalVirtual;
88 DWORDLONG ullAvailVirtual;
89 DWORDLONG ullAvailExtendedVirtual;
90 } MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
92 #include <lmcons.h>
93 #include <shlobj.h>
95 #include <tlhelp32.h>
96 #include <psapi.h>
97 #ifndef _MSC_VER
98 #include <w32api.h>
99 #endif
100 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
101 /* This either is not in psapi.h or guarded by higher value of
102 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
103 defines it in psapi.h */
104 typedef struct _PROCESS_MEMORY_COUNTERS_EX {
105 DWORD cb;
106 DWORD PageFaultCount;
107 DWORD PeakWorkingSetSize;
108 DWORD WorkingSetSize;
109 DWORD QuotaPeakPagedPoolUsage;
110 DWORD QuotaPagedPoolUsage;
111 DWORD QuotaPeakNonPagedPoolUsage;
112 DWORD QuotaNonPagedPoolUsage;
113 DWORD PagefileUsage;
114 DWORD PeakPagefileUsage;
115 DWORD PrivateUsage;
116 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
117 #endif
119 /* TCP connection support. */
120 #include <sys/socket.h>
121 #undef socket
122 #undef bind
123 #undef connect
124 #undef htons
125 #undef ntohs
126 #undef inet_addr
127 #undef gethostname
128 #undef gethostbyname
129 #undef getservbyname
130 #undef getpeername
131 #undef shutdown
132 #undef setsockopt
133 #undef listen
134 #undef getsockname
135 #undef accept
136 #undef recvfrom
137 #undef sendto
139 #include "w32.h"
140 #include "ndir.h"
141 #include "w32heap.h"
142 #include "systime.h"
143 #include "dispextern.h" /* for xstrcasecmp */
144 #include "coding.h" /* for Vlocale_coding_system */
146 #include "careadlinkat.h"
147 #include "allocator.h"
149 /* For serial_configure and serial_open. */
150 #include "process.h"
152 typedef HRESULT (WINAPI * ShGetFolderPath_fn)
153 (IN HWND, IN int, IN HANDLE, IN DWORD, OUT char *);
155 Lisp_Object QCloaded_from;
157 void globals_of_w32 (void);
158 static DWORD get_rid (PSID);
161 /* Initialization states.
163 WARNING: If you add any more such variables for additional APIs,
164 you MUST add initialization for them to globals_of_w32
165 below. This is because these variables might get set
166 to non-NULL values during dumping, but the dumped Emacs
167 cannot reuse those values, because it could be run on a
168 different version of the OS, where API addresses are
169 different. */
170 static BOOL g_b_init_is_windows_9x;
171 static BOOL g_b_init_open_process_token;
172 static BOOL g_b_init_get_token_information;
173 static BOOL g_b_init_lookup_account_sid;
174 static BOOL g_b_init_get_sid_sub_authority;
175 static BOOL g_b_init_get_sid_sub_authority_count;
176 static BOOL g_b_init_get_file_security;
177 static BOOL g_b_init_get_security_descriptor_owner;
178 static BOOL g_b_init_get_security_descriptor_group;
179 static BOOL g_b_init_is_valid_sid;
180 static BOOL g_b_init_create_toolhelp32_snapshot;
181 static BOOL g_b_init_process32_first;
182 static BOOL g_b_init_process32_next;
183 static BOOL g_b_init_open_thread_token;
184 static BOOL g_b_init_impersonate_self;
185 static BOOL g_b_init_revert_to_self;
186 static BOOL g_b_init_get_process_memory_info;
187 static BOOL g_b_init_get_process_working_set_size;
188 static BOOL g_b_init_global_memory_status;
189 static BOOL g_b_init_global_memory_status_ex;
190 static BOOL g_b_init_get_length_sid;
191 static BOOL g_b_init_equal_sid;
192 static BOOL g_b_init_copy_sid;
193 static BOOL g_b_init_get_native_system_info;
194 static BOOL g_b_init_get_system_times;
197 BEGIN: Wrapper functions around OpenProcessToken
198 and other functions in advapi32.dll that are only
199 supported in Windows NT / 2k / XP
201 /* ** Function pointer typedefs ** */
202 typedef BOOL (WINAPI * OpenProcessToken_Proc) (
203 HANDLE ProcessHandle,
204 DWORD DesiredAccess,
205 PHANDLE TokenHandle);
206 typedef BOOL (WINAPI * GetTokenInformation_Proc) (
207 HANDLE TokenHandle,
208 TOKEN_INFORMATION_CLASS TokenInformationClass,
209 LPVOID TokenInformation,
210 DWORD TokenInformationLength,
211 PDWORD ReturnLength);
212 typedef BOOL (WINAPI * GetProcessTimes_Proc) (
213 HANDLE process_handle,
214 LPFILETIME creation_time,
215 LPFILETIME exit_time,
216 LPFILETIME kernel_time,
217 LPFILETIME user_time);
219 GetProcessTimes_Proc get_process_times_fn = NULL;
221 #ifdef _UNICODE
222 const char * const LookupAccountSid_Name = "LookupAccountSidW";
223 const char * const GetFileSecurity_Name = "GetFileSecurityW";
224 #else
225 const char * const LookupAccountSid_Name = "LookupAccountSidA";
226 const char * const GetFileSecurity_Name = "GetFileSecurityA";
227 #endif
228 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
229 LPCTSTR lpSystemName,
230 PSID Sid,
231 LPTSTR Name,
232 LPDWORD cbName,
233 LPTSTR DomainName,
234 LPDWORD cbDomainName,
235 PSID_NAME_USE peUse);
236 typedef PDWORD (WINAPI * GetSidSubAuthority_Proc) (
237 PSID pSid,
238 DWORD n);
239 typedef PUCHAR (WINAPI * GetSidSubAuthorityCount_Proc) (
240 PSID pSid);
241 typedef BOOL (WINAPI * GetFileSecurity_Proc) (
242 LPCTSTR lpFileName,
243 SECURITY_INFORMATION RequestedInformation,
244 PSECURITY_DESCRIPTOR pSecurityDescriptor,
245 DWORD nLength,
246 LPDWORD lpnLengthNeeded);
247 typedef BOOL (WINAPI * GetSecurityDescriptorOwner_Proc) (
248 PSECURITY_DESCRIPTOR pSecurityDescriptor,
249 PSID *pOwner,
250 LPBOOL lpbOwnerDefaulted);
251 typedef BOOL (WINAPI * GetSecurityDescriptorGroup_Proc) (
252 PSECURITY_DESCRIPTOR pSecurityDescriptor,
253 PSID *pGroup,
254 LPBOOL lpbGroupDefaulted);
255 typedef BOOL (WINAPI * IsValidSid_Proc) (
256 PSID sid);
257 typedef HANDLE (WINAPI * CreateToolhelp32Snapshot_Proc) (
258 DWORD dwFlags,
259 DWORD th32ProcessID);
260 typedef BOOL (WINAPI * Process32First_Proc) (
261 HANDLE hSnapshot,
262 LPPROCESSENTRY32 lppe);
263 typedef BOOL (WINAPI * Process32Next_Proc) (
264 HANDLE hSnapshot,
265 LPPROCESSENTRY32 lppe);
266 typedef BOOL (WINAPI * OpenThreadToken_Proc) (
267 HANDLE ThreadHandle,
268 DWORD DesiredAccess,
269 BOOL OpenAsSelf,
270 PHANDLE TokenHandle);
271 typedef BOOL (WINAPI * ImpersonateSelf_Proc) (
272 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
273 typedef BOOL (WINAPI * RevertToSelf_Proc) (void);
274 typedef BOOL (WINAPI * GetProcessMemoryInfo_Proc) (
275 HANDLE Process,
276 PPROCESS_MEMORY_COUNTERS ppsmemCounters,
277 DWORD cb);
278 typedef BOOL (WINAPI * GetProcessWorkingSetSize_Proc) (
279 HANDLE hProcess,
280 DWORD * lpMinimumWorkingSetSize,
281 DWORD * lpMaximumWorkingSetSize);
282 typedef BOOL (WINAPI * GlobalMemoryStatus_Proc) (
283 LPMEMORYSTATUS lpBuffer);
284 typedef BOOL (WINAPI * GlobalMemoryStatusEx_Proc) (
285 LPMEMORY_STATUS_EX lpBuffer);
286 typedef BOOL (WINAPI * CopySid_Proc) (
287 DWORD nDestinationSidLength,
288 PSID pDestinationSid,
289 PSID pSourceSid);
290 typedef BOOL (WINAPI * EqualSid_Proc) (
291 PSID pSid1,
292 PSID pSid2);
293 typedef DWORD (WINAPI * GetLengthSid_Proc) (
294 PSID pSid);
295 typedef void (WINAPI * GetNativeSystemInfo_Proc) (
296 LPSYSTEM_INFO lpSystemInfo);
297 typedef BOOL (WINAPI * GetSystemTimes_Proc) (
298 LPFILETIME lpIdleTime,
299 LPFILETIME lpKernelTime,
300 LPFILETIME lpUserTime);
302 /* ** A utility function ** */
303 static BOOL
304 is_windows_9x (void)
306 static BOOL s_b_ret = 0;
307 OSVERSIONINFO os_ver;
308 if (g_b_init_is_windows_9x == 0)
310 g_b_init_is_windows_9x = 1;
311 ZeroMemory (&os_ver, sizeof (OSVERSIONINFO));
312 os_ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
313 if (GetVersionEx (&os_ver))
315 s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
318 return s_b_ret;
321 /* Get total user and system times for get-internal-run-time.
322 Returns a list of three integers if the times are provided by the OS
323 (NT derivatives), otherwise it returns the result of current-time. */
324 Lisp_Object
325 w32_get_internal_run_time (void)
327 if (get_process_times_fn)
329 FILETIME create, exit, kernel, user;
330 HANDLE proc = GetCurrentProcess ();
331 if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
333 LARGE_INTEGER user_int, kernel_int, total;
334 int microseconds;
335 user_int.LowPart = user.dwLowDateTime;
336 user_int.HighPart = user.dwHighDateTime;
337 kernel_int.LowPart = kernel.dwLowDateTime;
338 kernel_int.HighPart = kernel.dwHighDateTime;
339 total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
340 /* FILETIME is 100 nanosecond increments, Emacs only wants
341 microsecond resolution. */
342 total.QuadPart /= 10;
343 microseconds = total.QuadPart % 1000000;
344 total.QuadPart /= 1000000;
346 /* Sanity check to make sure we can represent the result. */
347 if (total.HighPart == 0)
349 int secs = total.LowPart;
351 return list3 (make_number ((secs >> 16) & 0xffff),
352 make_number (secs & 0xffff),
353 make_number (microseconds));
358 return Fcurrent_time ();
361 /* ** The wrapper functions ** */
363 static BOOL WINAPI
364 open_process_token (HANDLE ProcessHandle,
365 DWORD DesiredAccess,
366 PHANDLE TokenHandle)
368 static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
369 HMODULE hm_advapi32 = NULL;
370 if (is_windows_9x () == TRUE)
372 return FALSE;
374 if (g_b_init_open_process_token == 0)
376 g_b_init_open_process_token = 1;
377 hm_advapi32 = LoadLibrary ("Advapi32.dll");
378 s_pfn_Open_Process_Token =
379 (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
381 if (s_pfn_Open_Process_Token == NULL)
383 return FALSE;
385 return (
386 s_pfn_Open_Process_Token (
387 ProcessHandle,
388 DesiredAccess,
389 TokenHandle)
393 static BOOL WINAPI
394 get_token_information (HANDLE TokenHandle,
395 TOKEN_INFORMATION_CLASS TokenInformationClass,
396 LPVOID TokenInformation,
397 DWORD TokenInformationLength,
398 PDWORD ReturnLength)
400 static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
401 HMODULE hm_advapi32 = NULL;
402 if (is_windows_9x () == TRUE)
404 return FALSE;
406 if (g_b_init_get_token_information == 0)
408 g_b_init_get_token_information = 1;
409 hm_advapi32 = LoadLibrary ("Advapi32.dll");
410 s_pfn_Get_Token_Information =
411 (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
413 if (s_pfn_Get_Token_Information == NULL)
415 return FALSE;
417 return (
418 s_pfn_Get_Token_Information (
419 TokenHandle,
420 TokenInformationClass,
421 TokenInformation,
422 TokenInformationLength,
423 ReturnLength)
427 static BOOL WINAPI
428 lookup_account_sid (LPCTSTR lpSystemName,
429 PSID Sid,
430 LPTSTR Name,
431 LPDWORD cbName,
432 LPTSTR DomainName,
433 LPDWORD cbDomainName,
434 PSID_NAME_USE peUse)
436 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
437 HMODULE hm_advapi32 = NULL;
438 if (is_windows_9x () == TRUE)
440 return FALSE;
442 if (g_b_init_lookup_account_sid == 0)
444 g_b_init_lookup_account_sid = 1;
445 hm_advapi32 = LoadLibrary ("Advapi32.dll");
446 s_pfn_Lookup_Account_Sid =
447 (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
449 if (s_pfn_Lookup_Account_Sid == NULL)
451 return FALSE;
453 return (
454 s_pfn_Lookup_Account_Sid (
455 lpSystemName,
456 Sid,
457 Name,
458 cbName,
459 DomainName,
460 cbDomainName,
461 peUse)
465 static PDWORD WINAPI
466 get_sid_sub_authority (PSID pSid, DWORD n)
468 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority = NULL;
469 static DWORD zero = 0U;
470 HMODULE hm_advapi32 = NULL;
471 if (is_windows_9x () == TRUE)
473 return &zero;
475 if (g_b_init_get_sid_sub_authority == 0)
477 g_b_init_get_sid_sub_authority = 1;
478 hm_advapi32 = LoadLibrary ("Advapi32.dll");
479 s_pfn_Get_Sid_Sub_Authority =
480 (GetSidSubAuthority_Proc) GetProcAddress (
481 hm_advapi32, "GetSidSubAuthority");
483 if (s_pfn_Get_Sid_Sub_Authority == NULL)
485 return &zero;
487 return (s_pfn_Get_Sid_Sub_Authority (pSid, n));
490 static PUCHAR WINAPI
491 get_sid_sub_authority_count (PSID pSid)
493 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count = NULL;
494 static UCHAR zero = 0U;
495 HMODULE hm_advapi32 = NULL;
496 if (is_windows_9x () == TRUE)
498 return &zero;
500 if (g_b_init_get_sid_sub_authority_count == 0)
502 g_b_init_get_sid_sub_authority_count = 1;
503 hm_advapi32 = LoadLibrary ("Advapi32.dll");
504 s_pfn_Get_Sid_Sub_Authority_Count =
505 (GetSidSubAuthorityCount_Proc) GetProcAddress (
506 hm_advapi32, "GetSidSubAuthorityCount");
508 if (s_pfn_Get_Sid_Sub_Authority_Count == NULL)
510 return &zero;
512 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid));
515 static BOOL WINAPI
516 get_file_security (LPCTSTR lpFileName,
517 SECURITY_INFORMATION RequestedInformation,
518 PSECURITY_DESCRIPTOR pSecurityDescriptor,
519 DWORD nLength,
520 LPDWORD lpnLengthNeeded)
522 static GetFileSecurity_Proc s_pfn_Get_File_Security = NULL;
523 HMODULE hm_advapi32 = NULL;
524 if (is_windows_9x () == TRUE)
526 return FALSE;
528 if (g_b_init_get_file_security == 0)
530 g_b_init_get_file_security = 1;
531 hm_advapi32 = LoadLibrary ("Advapi32.dll");
532 s_pfn_Get_File_Security =
533 (GetFileSecurity_Proc) GetProcAddress (
534 hm_advapi32, GetFileSecurity_Name);
536 if (s_pfn_Get_File_Security == NULL)
538 return FALSE;
540 return (s_pfn_Get_File_Security (lpFileName, RequestedInformation,
541 pSecurityDescriptor, nLength,
542 lpnLengthNeeded));
545 static BOOL WINAPI
546 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
547 PSID *pOwner,
548 LPBOOL lpbOwnerDefaulted)
550 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner = NULL;
551 HMODULE hm_advapi32 = NULL;
552 if (is_windows_9x () == TRUE)
554 return FALSE;
556 if (g_b_init_get_security_descriptor_owner == 0)
558 g_b_init_get_security_descriptor_owner = 1;
559 hm_advapi32 = LoadLibrary ("Advapi32.dll");
560 s_pfn_Get_Security_Descriptor_Owner =
561 (GetSecurityDescriptorOwner_Proc) GetProcAddress (
562 hm_advapi32, "GetSecurityDescriptorOwner");
564 if (s_pfn_Get_Security_Descriptor_Owner == NULL)
566 return FALSE;
568 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor, pOwner,
569 lpbOwnerDefaulted));
572 static BOOL WINAPI
573 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
574 PSID *pGroup,
575 LPBOOL lpbGroupDefaulted)
577 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group = NULL;
578 HMODULE hm_advapi32 = NULL;
579 if (is_windows_9x () == TRUE)
581 return FALSE;
583 if (g_b_init_get_security_descriptor_group == 0)
585 g_b_init_get_security_descriptor_group = 1;
586 hm_advapi32 = LoadLibrary ("Advapi32.dll");
587 s_pfn_Get_Security_Descriptor_Group =
588 (GetSecurityDescriptorGroup_Proc) GetProcAddress (
589 hm_advapi32, "GetSecurityDescriptorGroup");
591 if (s_pfn_Get_Security_Descriptor_Group == NULL)
593 return FALSE;
595 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor, pGroup,
596 lpbGroupDefaulted));
599 static BOOL WINAPI
600 is_valid_sid (PSID sid)
602 static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
603 HMODULE hm_advapi32 = NULL;
604 if (is_windows_9x () == TRUE)
606 return FALSE;
608 if (g_b_init_is_valid_sid == 0)
610 g_b_init_is_valid_sid = 1;
611 hm_advapi32 = LoadLibrary ("Advapi32.dll");
612 s_pfn_Is_Valid_Sid =
613 (IsValidSid_Proc) GetProcAddress (
614 hm_advapi32, "IsValidSid");
616 if (s_pfn_Is_Valid_Sid == NULL)
618 return FALSE;
620 return (s_pfn_Is_Valid_Sid (sid));
623 static BOOL WINAPI
624 equal_sid (PSID sid1, PSID sid2)
626 static EqualSid_Proc s_pfn_Equal_Sid = NULL;
627 HMODULE hm_advapi32 = NULL;
628 if (is_windows_9x () == TRUE)
630 return FALSE;
632 if (g_b_init_equal_sid == 0)
634 g_b_init_equal_sid = 1;
635 hm_advapi32 = LoadLibrary ("Advapi32.dll");
636 s_pfn_Equal_Sid =
637 (EqualSid_Proc) GetProcAddress (
638 hm_advapi32, "EqualSid");
640 if (s_pfn_Equal_Sid == NULL)
642 return FALSE;
644 return (s_pfn_Equal_Sid (sid1, sid2));
647 static DWORD WINAPI
648 get_length_sid (PSID sid)
650 static GetLengthSid_Proc s_pfn_Get_Length_Sid = NULL;
651 HMODULE hm_advapi32 = NULL;
652 if (is_windows_9x () == TRUE)
654 return 0;
656 if (g_b_init_get_length_sid == 0)
658 g_b_init_get_length_sid = 1;
659 hm_advapi32 = LoadLibrary ("Advapi32.dll");
660 s_pfn_Get_Length_Sid =
661 (GetLengthSid_Proc) GetProcAddress (
662 hm_advapi32, "GetLengthSid");
664 if (s_pfn_Get_Length_Sid == NULL)
666 return 0;
668 return (s_pfn_Get_Length_Sid (sid));
671 static BOOL WINAPI
672 copy_sid (DWORD destlen, PSID dest, PSID src)
674 static CopySid_Proc s_pfn_Copy_Sid = NULL;
675 HMODULE hm_advapi32 = NULL;
676 if (is_windows_9x () == TRUE)
678 return FALSE;
680 if (g_b_init_copy_sid == 0)
682 g_b_init_copy_sid = 1;
683 hm_advapi32 = LoadLibrary ("Advapi32.dll");
684 s_pfn_Copy_Sid =
685 (CopySid_Proc) GetProcAddress (
686 hm_advapi32, "CopySid");
688 if (s_pfn_Copy_Sid == NULL)
690 return FALSE;
692 return (s_pfn_Copy_Sid (destlen, dest, src));
696 END: Wrapper functions around OpenProcessToken
697 and other functions in advapi32.dll that are only
698 supported in Windows NT / 2k / XP
701 static void WINAPI
702 get_native_system_info (LPSYSTEM_INFO lpSystemInfo)
704 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info = NULL;
705 if (is_windows_9x () != TRUE)
707 if (g_b_init_get_native_system_info == 0)
709 g_b_init_get_native_system_info = 1;
710 s_pfn_Get_Native_System_Info =
711 (GetNativeSystemInfo_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
712 "GetNativeSystemInfo");
714 if (s_pfn_Get_Native_System_Info != NULL)
715 s_pfn_Get_Native_System_Info (lpSystemInfo);
717 else
718 lpSystemInfo->dwNumberOfProcessors = -1;
721 static BOOL WINAPI
722 get_system_times (LPFILETIME lpIdleTime,
723 LPFILETIME lpKernelTime,
724 LPFILETIME lpUserTime)
726 static GetSystemTimes_Proc s_pfn_Get_System_times = NULL;
727 if (is_windows_9x () == TRUE)
729 return FALSE;
731 if (g_b_init_get_system_times == 0)
733 g_b_init_get_system_times = 1;
734 s_pfn_Get_System_times =
735 (GetSystemTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
736 "GetSystemTimes");
738 if (s_pfn_Get_System_times == NULL)
739 return FALSE;
740 return (s_pfn_Get_System_times (lpIdleTime, lpKernelTime, lpUserTime));
743 /* Equivalent of strerror for W32 error codes. */
744 char *
745 w32_strerror (int error_no)
747 static char buf[500];
749 if (error_no == 0)
750 error_no = GetLastError ();
752 buf[0] = '\0';
753 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
754 error_no,
755 0, /* choose most suitable language */
756 buf, sizeof (buf), NULL))
757 sprintf (buf, "w32 error %u", error_no);
758 return buf;
761 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
762 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
764 This is called from alloc.c:valid_pointer_p. */
766 w32_valid_pointer_p (void *p, int size)
768 SIZE_T done;
769 HANDLE h = OpenProcess (PROCESS_VM_READ, FALSE, GetCurrentProcessId ());
771 if (h)
773 unsigned char *buf = alloca (size);
774 int retval = ReadProcessMemory (h, p, buf, size, &done);
776 CloseHandle (h);
777 return retval;
779 else
780 return -1;
783 static char startup_dir[MAXPATHLEN];
785 /* Get the current working directory. */
786 char *
787 getwd (char *dir)
789 #if 0
790 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
791 return dir;
792 return NULL;
793 #else
794 /* Emacs doesn't actually change directory itself, and we want to
795 force our real wd to be where emacs.exe is to avoid unnecessary
796 conflicts when trying to rename or delete directories. */
797 strcpy (dir, startup_dir);
798 return dir;
799 #endif
802 /* Emulate getloadavg. */
804 struct load_sample {
805 time_t sample_time;
806 ULONGLONG idle;
807 ULONGLONG kernel;
808 ULONGLONG user;
811 /* Number of processors on this machine. */
812 static unsigned num_of_processors;
814 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
815 static struct load_sample samples[16*60];
816 static int first_idx = -1, last_idx = -1;
817 static int max_idx = sizeof (samples) / sizeof (samples[0]);
819 static int
820 buf_next (int from)
822 int next_idx = from + 1;
824 if (next_idx >= max_idx)
825 next_idx = 0;
827 return next_idx;
830 static int
831 buf_prev (int from)
833 int prev_idx = from - 1;
835 if (prev_idx < 0)
836 prev_idx = max_idx - 1;
838 return prev_idx;
841 static void
842 sample_system_load (ULONGLONG *idle, ULONGLONG *kernel, ULONGLONG *user)
844 SYSTEM_INFO sysinfo;
845 FILETIME ft_idle, ft_user, ft_kernel;
847 /* Initialize the number of processors on this machine. */
848 if (num_of_processors <= 0)
850 get_native_system_info (&sysinfo);
851 num_of_processors = sysinfo.dwNumberOfProcessors;
852 if (num_of_processors <= 0)
854 GetSystemInfo (&sysinfo);
855 num_of_processors = sysinfo.dwNumberOfProcessors;
857 if (num_of_processors <= 0)
858 num_of_processors = 1;
861 /* TODO: Take into account threads that are ready to run, by
862 sampling the "\System\Processor Queue Length" performance
863 counter. The code below accounts only for threads that are
864 actually running. */
866 if (get_system_times (&ft_idle, &ft_kernel, &ft_user))
868 ULARGE_INTEGER uidle, ukernel, uuser;
870 memcpy (&uidle, &ft_idle, sizeof (ft_idle));
871 memcpy (&ukernel, &ft_kernel, sizeof (ft_kernel));
872 memcpy (&uuser, &ft_user, sizeof (ft_user));
873 *idle = uidle.QuadPart;
874 *kernel = ukernel.QuadPart;
875 *user = uuser.QuadPart;
877 else
879 *idle = 0;
880 *kernel = 0;
881 *user = 0;
885 /* Produce the load average for a given time interval, using the
886 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
887 1-minute, 5-minute, or 15-minute average, respectively. */
888 static double
889 getavg (int which)
891 double retval = -1.0;
892 double tdiff;
893 int idx;
894 double span = (which == 0 ? 1.0 : (which == 1 ? 5.0 : 15.0)) * 60;
895 time_t now = samples[last_idx].sample_time;
897 if (first_idx != last_idx)
899 for (idx = buf_prev (last_idx); ; idx = buf_prev (idx))
901 tdiff = difftime (now, samples[idx].sample_time);
902 if (tdiff >= span - 2*DBL_EPSILON*now)
904 long double sys =
905 samples[last_idx].kernel + samples[last_idx].user
906 - (samples[idx].kernel + samples[idx].user);
907 long double idl = samples[last_idx].idle - samples[idx].idle;
909 retval = (1.0 - idl / sys) * num_of_processors;
910 break;
912 if (idx == first_idx)
913 break;
917 return retval;
921 getloadavg (double loadavg[], int nelem)
923 int elem;
924 ULONGLONG idle, kernel, user;
925 time_t now = time (NULL);
927 /* Store another sample. We ignore samples that are less than 1 sec
928 apart. */
929 if (difftime (now, samples[last_idx].sample_time) >= 1.0 - 2*DBL_EPSILON*now)
931 sample_system_load (&idle, &kernel, &user);
932 last_idx = buf_next (last_idx);
933 samples[last_idx].sample_time = now;
934 samples[last_idx].idle = idle;
935 samples[last_idx].kernel = kernel;
936 samples[last_idx].user = user;
937 /* If the buffer has more that 15 min worth of samples, discard
938 the old ones. */
939 if (first_idx == -1)
940 first_idx = last_idx;
941 while (first_idx != last_idx
942 && (difftime (now, samples[first_idx].sample_time)
943 >= 15.0*60 + 2*DBL_EPSILON*now))
944 first_idx = buf_next (first_idx);
947 for (elem = 0; elem < nelem; elem++)
949 double avg = getavg (elem);
951 if (avg < 0)
952 break;
953 loadavg[elem] = avg;
956 return elem;
959 /* Emulate getpwuid, getpwnam and others. */
961 #define PASSWD_FIELD_SIZE 256
963 static char dflt_passwd_name[PASSWD_FIELD_SIZE];
964 static char dflt_passwd_passwd[PASSWD_FIELD_SIZE];
965 static char dflt_passwd_gecos[PASSWD_FIELD_SIZE];
966 static char dflt_passwd_dir[PASSWD_FIELD_SIZE];
967 static char dflt_passwd_shell[PASSWD_FIELD_SIZE];
969 static struct passwd dflt_passwd =
971 dflt_passwd_name,
972 dflt_passwd_passwd,
976 dflt_passwd_gecos,
977 dflt_passwd_dir,
978 dflt_passwd_shell,
981 static char dflt_group_name[GNLEN+1];
983 static struct group dflt_group =
985 /* When group information is not available, we return this as the
986 group for all files. */
987 dflt_group_name,
991 unsigned
992 getuid (void)
994 return dflt_passwd.pw_uid;
997 unsigned
998 geteuid (void)
1000 /* I could imagine arguing for checking to see whether the user is
1001 in the Administrators group and returning a UID of 0 for that
1002 case, but I don't know how wise that would be in the long run. */
1003 return getuid ();
1006 unsigned
1007 getgid (void)
1009 return dflt_passwd.pw_gid;
1012 unsigned
1013 getegid (void)
1015 return getgid ();
1018 struct passwd *
1019 getpwuid (unsigned uid)
1021 if (uid == dflt_passwd.pw_uid)
1022 return &dflt_passwd;
1023 return NULL;
1026 struct group *
1027 getgrgid (gid_t gid)
1029 return &dflt_group;
1032 struct passwd *
1033 getpwnam (char *name)
1035 struct passwd *pw;
1037 pw = getpwuid (getuid ());
1038 if (!pw)
1039 return pw;
1041 if (xstrcasecmp (name, pw->pw_name))
1042 return NULL;
1044 return pw;
1047 static void
1048 init_user_info (void)
1050 /* Find the user's real name by opening the process token and
1051 looking up the name associated with the user-sid in that token.
1053 Use the relative portion of the identifier authority value from
1054 the user-sid as the user id value (same for group id using the
1055 primary group sid from the process token). */
1057 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
1058 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
1059 DWORD glength = sizeof (gname);
1060 HANDLE token = NULL;
1061 SID_NAME_USE user_type;
1062 unsigned char *buf = NULL;
1063 DWORD blen = 0;
1064 TOKEN_USER user_token;
1065 TOKEN_PRIMARY_GROUP group_token;
1066 BOOL result;
1068 result = open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token);
1069 if (result)
1071 result = get_token_information (token, TokenUser, NULL, 0, &blen);
1072 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1074 buf = xmalloc (blen);
1075 result = get_token_information (token, TokenUser,
1076 (LPVOID)buf, blen, &needed);
1077 if (result)
1079 memcpy (&user_token, buf, sizeof (user_token));
1080 result = lookup_account_sid (NULL, user_token.User.Sid,
1081 uname, &ulength,
1082 domain, &dlength, &user_type);
1085 else
1086 result = FALSE;
1088 if (result)
1090 strcpy (dflt_passwd.pw_name, uname);
1091 /* Determine a reasonable uid value. */
1092 if (xstrcasecmp ("administrator", uname) == 0)
1094 dflt_passwd.pw_uid = 500; /* well-known Administrator uid */
1095 dflt_passwd.pw_gid = 513; /* well-known None gid */
1097 else
1099 /* Use the last sub-authority value of the RID, the relative
1100 portion of the SID, as user/group ID. */
1101 dflt_passwd.pw_uid = get_rid (user_token.User.Sid);
1103 /* Get group id and name. */
1104 result = get_token_information (token, TokenPrimaryGroup,
1105 (LPVOID)buf, blen, &needed);
1106 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1108 buf = xrealloc (buf, blen = needed);
1109 result = get_token_information (token, TokenPrimaryGroup,
1110 (LPVOID)buf, blen, &needed);
1112 if (result)
1114 memcpy (&group_token, buf, sizeof (group_token));
1115 dflt_passwd.pw_gid = get_rid (group_token.PrimaryGroup);
1116 dlength = sizeof (domain);
1117 /* If we can get at the real Primary Group name, use that.
1118 Otherwise, the default group name was already set to
1119 "None" in globals_of_w32. */
1120 if (lookup_account_sid (NULL, group_token.PrimaryGroup,
1121 gname, &glength, NULL, &dlength,
1122 &user_type))
1123 strcpy (dflt_group_name, gname);
1125 else
1126 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
1129 /* If security calls are not supported (presumably because we
1130 are running under Windows 9X), fallback to this: */
1131 else if (GetUserName (uname, &ulength))
1133 strcpy (dflt_passwd.pw_name, uname);
1134 if (xstrcasecmp ("administrator", uname) == 0)
1135 dflt_passwd.pw_uid = 0;
1136 else
1137 dflt_passwd.pw_uid = 123;
1138 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
1140 else
1142 strcpy (dflt_passwd.pw_name, "unknown");
1143 dflt_passwd.pw_uid = 123;
1144 dflt_passwd.pw_gid = 123;
1146 dflt_group.gr_gid = dflt_passwd.pw_gid;
1148 /* Ensure HOME and SHELL are defined. */
1149 if (getenv ("HOME") == NULL)
1150 abort ();
1151 if (getenv ("SHELL") == NULL)
1152 abort ();
1154 /* Set dir and shell from environment variables. */
1155 strcpy (dflt_passwd.pw_dir, getenv ("HOME"));
1156 strcpy (dflt_passwd.pw_shell, getenv ("SHELL"));
1158 xfree (buf);
1159 if (token)
1160 CloseHandle (token);
1164 random (void)
1166 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1167 return ((rand () << 15) | rand ());
1170 void
1171 srandom (int seed)
1173 srand (seed);
1177 /* Normalize filename by converting all path separators to
1178 the specified separator. Also conditionally convert upper
1179 case path name components to lower case. */
1181 static void
1182 normalize_filename (register char *fp, char path_sep)
1184 char sep;
1185 char *elem;
1187 /* Always lower-case drive letters a-z, even if the filesystem
1188 preserves case in filenames.
1189 This is so filenames can be compared by string comparison
1190 functions that are case-sensitive. Even case-preserving filesystems
1191 do not distinguish case in drive letters. */
1192 if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
1194 *fp += 'a' - 'A';
1195 fp += 2;
1198 if (NILP (Vw32_downcase_file_names))
1200 while (*fp)
1202 if (*fp == '/' || *fp == '\\')
1203 *fp = path_sep;
1204 fp++;
1206 return;
1209 sep = path_sep; /* convert to this path separator */
1210 elem = fp; /* start of current path element */
1212 do {
1213 if (*fp >= 'a' && *fp <= 'z')
1214 elem = 0; /* don't convert this element */
1216 if (*fp == 0 || *fp == ':')
1218 sep = *fp; /* restore current separator (or 0) */
1219 *fp = '/'; /* after conversion of this element */
1222 if (*fp == '/' || *fp == '\\')
1224 if (elem && elem != fp)
1226 *fp = 0; /* temporary end of string */
1227 _strlwr (elem); /* while we convert to lower case */
1229 *fp = sep; /* convert (or restore) path separator */
1230 elem = fp + 1; /* next element starts after separator */
1231 sep = path_sep;
1233 } while (*fp++);
1236 /* Destructively turn backslashes into slashes. */
1237 void
1238 dostounix_filename (register char *p)
1240 normalize_filename (p, '/');
1243 /* Destructively turn slashes into backslashes. */
1244 void
1245 unixtodos_filename (register char *p)
1247 normalize_filename (p, '\\');
1250 /* Remove all CR's that are followed by a LF.
1251 (From msdos.c...probably should figure out a way to share it,
1252 although this code isn't going to ever change.) */
1253 static int
1254 crlf_to_lf (register int n, register unsigned char *buf)
1256 unsigned char *np = buf;
1257 unsigned char *startp = buf;
1258 unsigned char *endp = buf + n;
1260 if (n == 0)
1261 return n;
1262 while (buf < endp - 1)
1264 if (*buf == 0x0d)
1266 if (*(++buf) != 0x0a)
1267 *np++ = 0x0d;
1269 else
1270 *np++ = *buf++;
1272 if (buf < endp)
1273 *np++ = *buf++;
1274 return np - startp;
1277 /* Parse the root part of file name, if present. Return length and
1278 optionally store pointer to char after root. */
1279 static int
1280 parse_root (char * name, char ** pPath)
1282 char * start = name;
1284 if (name == NULL)
1285 return 0;
1287 /* find the root name of the volume if given */
1288 if (isalpha (name[0]) && name[1] == ':')
1290 /* skip past drive specifier */
1291 name += 2;
1292 if (IS_DIRECTORY_SEP (name[0]))
1293 name++;
1295 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1297 int slashes = 2;
1298 name += 2;
1301 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1302 break;
1303 name++;
1305 while ( *name );
1306 if (IS_DIRECTORY_SEP (name[0]))
1307 name++;
1310 if (pPath)
1311 *pPath = name;
1313 return name - start;
1316 /* Get long base name for name; name is assumed to be absolute. */
1317 static int
1318 get_long_basename (char * name, char * buf, int size)
1320 WIN32_FIND_DATA find_data;
1321 HANDLE dir_handle;
1322 int len = 0;
1324 /* must be valid filename, no wild cards or other invalid characters */
1325 if (_mbspbrk (name, "*?|<>\""))
1326 return 0;
1328 dir_handle = FindFirstFile (name, &find_data);
1329 if (dir_handle != INVALID_HANDLE_VALUE)
1331 if ((len = strlen (find_data.cFileName)) < size)
1332 memcpy (buf, find_data.cFileName, len + 1);
1333 else
1334 len = 0;
1335 FindClose (dir_handle);
1337 return len;
1340 /* Get long name for file, if possible (assumed to be absolute). */
1341 BOOL
1342 w32_get_long_filename (char * name, char * buf, int size)
1344 char * o = buf;
1345 char * p;
1346 char * q;
1347 char full[ MAX_PATH ];
1348 int len;
1350 len = strlen (name);
1351 if (len >= MAX_PATH)
1352 return FALSE;
1354 /* Use local copy for destructive modification. */
1355 memcpy (full, name, len+1);
1356 unixtodos_filename (full);
1358 /* Copy root part verbatim. */
1359 len = parse_root (full, &p);
1360 memcpy (o, full, len);
1361 o += len;
1362 *o = '\0';
1363 size -= len;
1365 while (p != NULL && *p)
1367 q = p;
1368 p = strchr (q, '\\');
1369 if (p) *p = '\0';
1370 len = get_long_basename (full, o, size);
1371 if (len > 0)
1373 o += len;
1374 size -= len;
1375 if (p != NULL)
1377 *p++ = '\\';
1378 if (size < 2)
1379 return FALSE;
1380 *o++ = '\\';
1381 size--;
1382 *o = '\0';
1385 else
1386 return FALSE;
1389 return TRUE;
1392 static int
1393 is_unc_volume (const char *filename)
1395 const char *ptr = filename;
1397 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
1398 return 0;
1400 if (_mbspbrk (ptr + 2, "*?|<>\"\\/"))
1401 return 0;
1403 return 1;
1406 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
1409 sigsetmask (int signal_mask)
1411 return 0;
1415 sigmask (int sig)
1417 return 0;
1421 sigblock (int sig)
1423 return 0;
1427 sigunblock (int sig)
1429 return 0;
1433 sigemptyset (sigset_t *set)
1435 return 0;
1439 sigaddset (sigset_t *set, int signo)
1441 return 0;
1445 sigfillset (sigset_t *set)
1447 return 0;
1451 sigprocmask (int how, const sigset_t *set, sigset_t *oset)
1453 return 0;
1457 pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
1459 if (sigprocmask (how, set, oset) == -1)
1460 return EINVAL;
1461 return 0;
1465 setpgrp (int pid, int gid)
1467 return 0;
1471 alarm (int seconds)
1473 return 0;
1476 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1478 LPBYTE
1479 w32_get_resource (char *key, LPDWORD lpdwtype)
1481 LPBYTE lpvalue;
1482 HKEY hrootkey = NULL;
1483 DWORD cbData;
1485 /* Check both the current user and the local machine to see if
1486 we have any resources. */
1488 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1490 lpvalue = NULL;
1492 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1493 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
1494 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1496 RegCloseKey (hrootkey);
1497 return (lpvalue);
1500 xfree (lpvalue);
1502 RegCloseKey (hrootkey);
1505 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1507 lpvalue = NULL;
1509 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1510 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
1511 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1513 RegCloseKey (hrootkey);
1514 return (lpvalue);
1517 xfree (lpvalue);
1519 RegCloseKey (hrootkey);
1522 return (NULL);
1525 char *get_emacs_configuration (void);
1527 void
1528 init_environment (char ** argv)
1530 static const char * const tempdirs[] = {
1531 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1534 int i;
1536 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
1538 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1539 temporary files and assume "/tmp" if $TMPDIR is unset, which
1540 will break on DOS/Windows. Refuse to work if we cannot find
1541 a directory, not even "c:/", usable for that purpose. */
1542 for (i = 0; i < imax ; i++)
1544 const char *tmp = tempdirs[i];
1546 if (*tmp == '$')
1547 tmp = getenv (tmp + 1);
1548 /* Note that `access' can lie to us if the directory resides on a
1549 read-only filesystem, like CD-ROM or a write-protected floppy.
1550 The only way to be really sure is to actually create a file and
1551 see if it succeeds. But I think that's too much to ask. */
1552 #ifdef _MSC_VER
1553 /* MSVC's _access crashes with D_OK. */
1554 if (tmp && sys_access (tmp, D_OK) == 0)
1555 #else
1556 if (tmp && _access (tmp, D_OK) == 0)
1557 #endif
1559 char * var = alloca (strlen (tmp) + 8);
1560 sprintf (var, "TMPDIR=%s", tmp);
1561 _putenv (strdup (var));
1562 break;
1565 if (i >= imax)
1566 cmd_error_internal
1567 (Fcons (Qerror,
1568 Fcons (build_string ("no usable temporary directories found!!"),
1569 Qnil)),
1570 "While setting TMPDIR: ");
1572 /* Check for environment variables and use registry settings if they
1573 don't exist. Fallback on default values where applicable. */
1575 int i;
1576 LPBYTE lpval;
1577 DWORD dwType;
1578 char locale_name[32];
1579 struct stat ignored;
1580 char default_home[MAX_PATH];
1581 int appdata = 0;
1583 static const struct env_entry
1585 char * name;
1586 char * def_value;
1587 } dflt_envvars[] =
1589 {"HOME", "C:/"},
1590 {"PRELOAD_WINSOCK", NULL},
1591 {"emacs_dir", "C:/emacs"},
1592 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1593 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1594 {"EMACSDATA", "%emacs_dir%/etc"},
1595 {"EMACSPATH", "%emacs_dir%/bin"},
1596 /* We no longer set INFOPATH because Info-default-directory-list
1597 is then ignored. */
1598 /* {"INFOPATH", "%emacs_dir%/info"}, */
1599 {"EMACSDOC", "%emacs_dir%/etc"},
1600 {"TERM", "cmd"},
1601 {"LANG", NULL},
1604 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1606 /* We need to copy dflt_envvars[] and work on the copy because we
1607 don't want the dumped Emacs to inherit the values of
1608 environment variables we saw during dumping (which could be on
1609 a different system). The defaults above must be left intact. */
1610 struct env_entry env_vars[N_ENV_VARS];
1612 for (i = 0; i < N_ENV_VARS; i++)
1613 env_vars[i] = dflt_envvars[i];
1615 /* For backwards compatibility, check if a .emacs file exists in C:/
1616 If not, then we can try to default to the appdata directory under the
1617 user's profile, which is more likely to be writable. */
1618 if (stat ("C:/.emacs", &ignored) < 0)
1620 HRESULT profile_result;
1621 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1622 of Windows 95 and NT4 that have not been updated to include
1623 MSIE 5. */
1624 ShGetFolderPath_fn get_folder_path;
1625 get_folder_path = (ShGetFolderPath_fn)
1626 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1628 if (get_folder_path != NULL)
1630 profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
1631 0, default_home);
1633 /* If we can't get the appdata dir, revert to old behavior. */
1634 if (profile_result == S_OK)
1636 env_vars[0].def_value = default_home;
1637 appdata = 1;
1642 /* Get default locale info and use it for LANG. */
1643 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
1644 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1645 locale_name, sizeof (locale_name)))
1647 for (i = 0; i < N_ENV_VARS; i++)
1649 if (strcmp (env_vars[i].name, "LANG") == 0)
1651 env_vars[i].def_value = locale_name;
1652 break;
1657 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1659 /* Treat emacs_dir specially: set it unconditionally based on our
1660 location, if it appears that we are running from the bin subdir
1661 of a standard installation. */
1663 char *p;
1664 char modname[MAX_PATH];
1666 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1667 abort ();
1668 if ((p = strrchr (modname, '\\')) == NULL)
1669 abort ();
1670 *p = 0;
1672 if ((p = strrchr (modname, '\\')) && xstrcasecmp (p, "\\bin") == 0)
1674 char buf[SET_ENV_BUF_SIZE];
1676 *p = 0;
1677 for (p = modname; *p; p++)
1678 if (*p == '\\') *p = '/';
1680 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
1681 _putenv (strdup (buf));
1683 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1685 /* FIXME: should use substring of get_emacs_configuration ().
1686 But I don't think the Windows build supports alpha, mips etc
1687 anymore, so have taken the easy option for now. */
1688 else if (p && xstrcasecmp (p, "\\i386") == 0)
1690 *p = 0;
1691 p = strrchr (modname, '\\');
1692 if (p != NULL)
1694 *p = 0;
1695 p = strrchr (modname, '\\');
1696 if (p && xstrcasecmp (p, "\\src") == 0)
1698 char buf[SET_ENV_BUF_SIZE];
1700 *p = 0;
1701 for (p = modname; *p; p++)
1702 if (*p == '\\') *p = '/';
1704 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
1705 _putenv (strdup (buf));
1711 for (i = 0; i < N_ENV_VARS; i++)
1713 if (!getenv (env_vars[i].name))
1715 int dont_free = 0;
1717 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL
1718 /* Also ignore empty environment variables. */
1719 || *lpval == 0)
1721 xfree (lpval);
1722 lpval = env_vars[i].def_value;
1723 dwType = REG_EXPAND_SZ;
1724 dont_free = 1;
1725 if (!strcmp (env_vars[i].name, "HOME") && !appdata)
1727 Lisp_Object warning[2];
1728 warning[0] = intern ("initialization");
1729 warning[1] = build_string ("Setting HOME to C:\\ by default is deprecated");
1730 Vdelayed_warnings_list = Fcons (Flist (2, warning),
1731 Vdelayed_warnings_list);
1735 if (lpval)
1737 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
1739 if (dwType == REG_EXPAND_SZ)
1740 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof (buf1));
1741 else if (dwType == REG_SZ)
1742 strcpy (buf1, lpval);
1743 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
1745 _snprintf (buf2, sizeof (buf2)-1, "%s=%s", env_vars[i].name,
1746 buf1);
1747 _putenv (strdup (buf2));
1750 if (!dont_free)
1751 xfree (lpval);
1757 /* Rebuild system configuration to reflect invoking system. */
1758 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1760 /* Another special case: on NT, the PATH variable is actually named
1761 "Path" although cmd.exe (perhaps NT itself) arranges for
1762 environment variable lookup and setting to be case insensitive.
1763 However, Emacs assumes a fully case sensitive environment, so we
1764 need to change "Path" to "PATH" to match the expectations of
1765 various elisp packages. We do this by the sneaky method of
1766 modifying the string in the C runtime environ entry.
1768 The same applies to COMSPEC. */
1770 char ** envp;
1772 for (envp = environ; *envp; envp++)
1773 if (_strnicmp (*envp, "PATH=", 5) == 0)
1774 memcpy (*envp, "PATH=", 5);
1775 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
1776 memcpy (*envp, "COMSPEC=", 8);
1779 /* Remember the initial working directory for getwd, then make the
1780 real wd be the location of emacs.exe to avoid conflicts when
1781 renaming or deleting directories. (We also don't call chdir when
1782 running subprocesses for the same reason.) */
1783 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
1784 abort ();
1787 char *p;
1788 static char modname[MAX_PATH];
1790 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1791 abort ();
1792 if ((p = strrchr (modname, '\\')) == NULL)
1793 abort ();
1794 *p = 0;
1796 SetCurrentDirectory (modname);
1798 /* Ensure argv[0] has the full path to Emacs. */
1799 *p = '\\';
1800 argv[0] = modname;
1803 /* Determine if there is a middle mouse button, to allow parse_button
1804 to decide whether right mouse events should be mouse-2 or
1805 mouse-3. */
1806 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
1808 init_user_info ();
1811 char *
1812 emacs_root_dir (void)
1814 static char root_dir[FILENAME_MAX];
1815 const char *p;
1817 p = getenv ("emacs_dir");
1818 if (p == NULL)
1819 abort ();
1820 strcpy (root_dir, p);
1821 root_dir[parse_root (root_dir, NULL)] = '\0';
1822 dostounix_filename (root_dir);
1823 return root_dir;
1826 /* We don't have scripts to automatically determine the system configuration
1827 for Emacs before it's compiled, and we don't want to have to make the
1828 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1829 routine. */
1831 char *
1832 get_emacs_configuration (void)
1834 char *arch, *oem, *os;
1835 int build_num;
1836 static char configuration_buffer[32];
1838 /* Determine the processor type. */
1839 switch (get_processor_type ())
1842 #ifdef PROCESSOR_INTEL_386
1843 case PROCESSOR_INTEL_386:
1844 case PROCESSOR_INTEL_486:
1845 case PROCESSOR_INTEL_PENTIUM:
1846 arch = "i386";
1847 break;
1848 #endif
1850 #ifdef PROCESSOR_MIPS_R2000
1851 case PROCESSOR_MIPS_R2000:
1852 case PROCESSOR_MIPS_R3000:
1853 case PROCESSOR_MIPS_R4000:
1854 arch = "mips";
1855 break;
1856 #endif
1858 #ifdef PROCESSOR_ALPHA_21064
1859 case PROCESSOR_ALPHA_21064:
1860 arch = "alpha";
1861 break;
1862 #endif
1864 default:
1865 arch = "unknown";
1866 break;
1869 /* Use the OEM field to reflect the compiler/library combination. */
1870 #ifdef _MSC_VER
1871 #define COMPILER_NAME "msvc"
1872 #else
1873 #ifdef __GNUC__
1874 #define COMPILER_NAME "mingw"
1875 #else
1876 #define COMPILER_NAME "unknown"
1877 #endif
1878 #endif
1879 oem = COMPILER_NAME;
1881 switch (osinfo_cache.dwPlatformId) {
1882 case VER_PLATFORM_WIN32_NT:
1883 os = "nt";
1884 build_num = osinfo_cache.dwBuildNumber;
1885 break;
1886 case VER_PLATFORM_WIN32_WINDOWS:
1887 if (osinfo_cache.dwMinorVersion == 0) {
1888 os = "windows95";
1889 } else {
1890 os = "windows98";
1892 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1893 break;
1894 case VER_PLATFORM_WIN32s:
1895 /* Not supported, should not happen. */
1896 os = "windows32s";
1897 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1898 break;
1899 default:
1900 os = "unknown";
1901 build_num = 0;
1902 break;
1905 if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1906 sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
1907 get_w32_major_version (), get_w32_minor_version (), build_num);
1908 } else {
1909 sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
1912 return configuration_buffer;
1915 char *
1916 get_emacs_configuration_options (void)
1918 static char *options_buffer;
1919 char cv[32]; /* Enough for COMPILER_VERSION. */
1920 char *options[] = {
1921 cv, /* To be filled later. */
1922 #ifdef EMACSDEBUG
1923 " --no-opt",
1924 #endif
1925 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1926 with a starting space to save work here. */
1927 #ifdef USER_CFLAGS
1928 " --cflags", USER_CFLAGS,
1929 #endif
1930 #ifdef USER_LDFLAGS
1931 " --ldflags", USER_LDFLAGS,
1932 #endif
1933 NULL
1935 size_t size = 0;
1936 int i;
1938 /* Work out the effective configure options for this build. */
1939 #ifdef _MSC_VER
1940 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1941 #else
1942 #ifdef __GNUC__
1943 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1944 #else
1945 #define COMPILER_VERSION ""
1946 #endif
1947 #endif
1949 if (_snprintf (cv, sizeof (cv) - 1, COMPILER_VERSION) < 0)
1950 return "Error: not enough space for compiler version";
1951 cv[sizeof (cv) - 1] = '\0';
1953 for (i = 0; options[i]; i++)
1954 size += strlen (options[i]);
1956 options_buffer = xmalloc (size + 1);
1957 options_buffer[0] = '\0';
1959 for (i = 0; options[i]; i++)
1960 strcat (options_buffer, options[i]);
1962 return options_buffer;
1966 #include <sys/timeb.h>
1968 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1969 void
1970 gettimeofday (struct timeval *tv, struct timezone *tz)
1972 struct _timeb tb;
1973 _ftime (&tb);
1975 tv->tv_sec = tb.time;
1976 tv->tv_usec = tb.millitm * 1000L;
1977 /* Implementation note: _ftime sometimes doesn't update the dstflag
1978 according to the new timezone when the system timezone is
1979 changed. We could fix that by using GetSystemTime and
1980 GetTimeZoneInformation, but that doesn't seem necessary, since
1981 Emacs always calls gettimeofday with the 2nd argument NULL (see
1982 EMACS_GET_TIME). */
1983 if (tz)
1985 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
1986 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
1990 /* ------------------------------------------------------------------------- */
1991 /* IO support and wrapper functions for W32 API. */
1992 /* ------------------------------------------------------------------------- */
1994 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1995 on network directories, so we handle that case here.
1996 (Ulrich Leodolter, 1/11/95). */
1997 char *
1998 sys_ctime (const time_t *t)
2000 char *str = (char *) ctime (t);
2001 return (str ? str : "Sun Jan 01 00:00:00 1970");
2004 /* Emulate sleep...we could have done this with a define, but that
2005 would necessitate including windows.h in the files that used it.
2006 This is much easier. */
2007 void
2008 sys_sleep (int seconds)
2010 Sleep (seconds * 1000);
2013 /* Internal MSVC functions for low-level descriptor munging */
2014 extern int __cdecl _set_osfhnd (int fd, long h);
2015 extern int __cdecl _free_osfhnd (int fd);
2017 /* parallel array of private info on file handles */
2018 filedesc fd_info [ MAXDESC ];
2020 typedef struct volume_info_data {
2021 struct volume_info_data * next;
2023 /* time when info was obtained */
2024 DWORD timestamp;
2026 /* actual volume info */
2027 char * root_dir;
2028 DWORD serialnum;
2029 DWORD maxcomp;
2030 DWORD flags;
2031 char * name;
2032 char * type;
2033 } volume_info_data;
2035 /* Global referenced by various functions. */
2036 static volume_info_data volume_info;
2038 /* Vector to indicate which drives are local and fixed (for which cached
2039 data never expires). */
2040 static BOOL fixed_drives[26];
2042 /* Consider cached volume information to be stale if older than 10s,
2043 at least for non-local drives. Info for fixed drives is never stale. */
2044 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2045 #define VOLINFO_STILL_VALID( root_dir, info ) \
2046 ( ( isalpha (root_dir[0]) && \
2047 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2048 || GetTickCount () - info->timestamp < 10000 )
2050 /* Cache support functions. */
2052 /* Simple linked list with linear search is sufficient. */
2053 static volume_info_data *volume_cache = NULL;
2055 static volume_info_data *
2056 lookup_volume_info (char * root_dir)
2058 volume_info_data * info;
2060 for (info = volume_cache; info; info = info->next)
2061 if (xstrcasecmp (info->root_dir, root_dir) == 0)
2062 break;
2063 return info;
2066 static void
2067 add_volume_info (char * root_dir, volume_info_data * info)
2069 info->root_dir = xstrdup (root_dir);
2070 info->next = volume_cache;
2071 volume_cache = info;
2075 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2076 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2077 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2078 static volume_info_data *
2079 GetCachedVolumeInformation (char * root_dir)
2081 volume_info_data * info;
2082 char default_root[ MAX_PATH ];
2084 /* NULL for root_dir means use root from current directory. */
2085 if (root_dir == NULL)
2087 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
2088 return NULL;
2089 parse_root (default_root, &root_dir);
2090 *root_dir = 0;
2091 root_dir = default_root;
2094 /* Local fixed drives can be cached permanently. Removable drives
2095 cannot be cached permanently, since the volume name and serial
2096 number (if nothing else) can change. Remote drives should be
2097 treated as if they are removable, since there is no sure way to
2098 tell whether they are or not. Also, the UNC association of drive
2099 letters mapped to remote volumes can be changed at any time (even
2100 by other processes) without notice.
2102 As a compromise, so we can benefit from caching info for remote
2103 volumes, we use a simple expiry mechanism to invalidate cache
2104 entries that are more than ten seconds old. */
2106 #if 0
2107 /* No point doing this, because WNetGetConnection is even slower than
2108 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2109 GetDriveType is about the only call of this type which does not
2110 involve network access, and so is extremely quick). */
2112 /* Map drive letter to UNC if remote. */
2113 if (isalpha (root_dir[0]) && !fixed[DRIVE_INDEX (root_dir[0])])
2115 char remote_name[ 256 ];
2116 char drive[3] = { root_dir[0], ':' };
2118 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
2119 == NO_ERROR)
2120 /* do something */ ;
2122 #endif
2124 info = lookup_volume_info (root_dir);
2126 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
2128 char name[ 256 ];
2129 DWORD serialnum;
2130 DWORD maxcomp;
2131 DWORD flags;
2132 char type[ 256 ];
2134 /* Info is not cached, or is stale. */
2135 if (!GetVolumeInformation (root_dir,
2136 name, sizeof (name),
2137 &serialnum,
2138 &maxcomp,
2139 &flags,
2140 type, sizeof (type)))
2141 return NULL;
2143 /* Cache the volume information for future use, overwriting existing
2144 entry if present. */
2145 if (info == NULL)
2147 info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
2148 add_volume_info (root_dir, info);
2150 else
2152 xfree (info->name);
2153 xfree (info->type);
2156 info->name = xstrdup (name);
2157 info->serialnum = serialnum;
2158 info->maxcomp = maxcomp;
2159 info->flags = flags;
2160 info->type = xstrdup (type);
2161 info->timestamp = GetTickCount ();
2164 return info;
2167 /* Get information on the volume where name is held; set path pointer to
2168 start of pathname in name (past UNC header\volume header if present). */
2169 static int
2170 get_volume_info (const char * name, const char ** pPath)
2172 char temp[MAX_PATH];
2173 char *rootname = NULL; /* default to current volume */
2174 volume_info_data * info;
2176 if (name == NULL)
2177 return FALSE;
2179 /* find the root name of the volume if given */
2180 if (isalpha (name[0]) && name[1] == ':')
2182 rootname = temp;
2183 temp[0] = *name++;
2184 temp[1] = *name++;
2185 temp[2] = '\\';
2186 temp[3] = 0;
2188 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
2190 char *str = temp;
2191 int slashes = 4;
2192 rootname = temp;
2195 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
2196 break;
2197 *str++ = *name++;
2199 while ( *name );
2201 *str++ = '\\';
2202 *str = 0;
2205 if (pPath)
2206 *pPath = name;
2208 info = GetCachedVolumeInformation (rootname);
2209 if (info != NULL)
2211 /* Set global referenced by other functions. */
2212 volume_info = *info;
2213 return TRUE;
2215 return FALSE;
2218 /* Determine if volume is FAT format (ie. only supports short 8.3
2219 names); also set path pointer to start of pathname in name. */
2220 static int
2221 is_fat_volume (const char * name, const char ** pPath)
2223 if (get_volume_info (name, pPath))
2224 return (volume_info.maxcomp == 12);
2225 return FALSE;
2228 /* Map filename to a valid 8.3 name if necessary. */
2229 const char *
2230 map_w32_filename (const char * name, const char ** pPath)
2232 static char shortname[MAX_PATH];
2233 char * str = shortname;
2234 char c;
2235 char * path;
2236 const char * save_name = name;
2238 if (strlen (name) >= MAX_PATH)
2240 /* Return a filename which will cause callers to fail. */
2241 strcpy (shortname, "?");
2242 return shortname;
2245 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
2247 register int left = 8; /* maximum number of chars in part */
2248 register int extn = 0; /* extension added? */
2249 register int dots = 2; /* maximum number of dots allowed */
2251 while (name < path)
2252 *str++ = *name++; /* skip past UNC header */
2254 while ((c = *name++))
2256 switch ( c )
2258 case '\\':
2259 case '/':
2260 *str++ = '\\';
2261 extn = 0; /* reset extension flags */
2262 dots = 2; /* max 2 dots */
2263 left = 8; /* max length 8 for main part */
2264 break;
2265 case ':':
2266 *str++ = ':';
2267 extn = 0; /* reset extension flags */
2268 dots = 2; /* max 2 dots */
2269 left = 8; /* max length 8 for main part */
2270 break;
2271 case '.':
2272 if ( dots )
2274 /* Convert path components of the form .xxx to _xxx,
2275 but leave . and .. as they are. This allows .emacs
2276 to be read as _emacs, for example. */
2278 if (! *name ||
2279 *name == '.' ||
2280 IS_DIRECTORY_SEP (*name))
2282 *str++ = '.';
2283 dots--;
2285 else
2287 *str++ = '_';
2288 left--;
2289 dots = 0;
2292 else if ( !extn )
2294 *str++ = '.';
2295 extn = 1; /* we've got an extension */
2296 left = 3; /* 3 chars in extension */
2298 else
2300 /* any embedded dots after the first are converted to _ */
2301 *str++ = '_';
2303 break;
2304 case '~':
2305 case '#': /* don't lose these, they're important */
2306 if ( ! left )
2307 str[-1] = c; /* replace last character of part */
2308 /* FALLTHRU */
2309 default:
2310 if ( left )
2312 *str++ = tolower (c); /* map to lower case (looks nicer) */
2313 left--;
2314 dots = 0; /* started a path component */
2316 break;
2319 *str = '\0';
2321 else
2323 strcpy (shortname, name);
2324 unixtodos_filename (shortname);
2327 if (pPath)
2328 *pPath = shortname + (path - save_name);
2330 return shortname;
2333 static int
2334 is_exec (const char * name)
2336 char * p = strrchr (name, '.');
2337 return
2338 (p != NULL
2339 && (xstrcasecmp (p, ".exe") == 0 ||
2340 xstrcasecmp (p, ".com") == 0 ||
2341 xstrcasecmp (p, ".bat") == 0 ||
2342 xstrcasecmp (p, ".cmd") == 0));
2345 /* Emulate the Unix directory procedures opendir, closedir,
2346 and readdir. We can't use the procedures supplied in sysdep.c,
2347 so we provide them here. */
2349 struct direct dir_static; /* simulated directory contents */
2350 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
2351 static int dir_is_fat;
2352 static char dir_pathname[MAXPATHLEN+1];
2353 static WIN32_FIND_DATA dir_find_data;
2355 /* Support shares on a network resource as subdirectories of a read-only
2356 root directory. */
2357 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
2358 static HANDLE open_unc_volume (const char *);
2359 static char *read_unc_volume (HANDLE, char *, int);
2360 static void close_unc_volume (HANDLE);
2362 DIR *
2363 opendir (char *filename)
2365 DIR *dirp;
2367 /* Opening is done by FindFirstFile. However, a read is inherent to
2368 this operation, so we defer the open until read time. */
2370 if (dir_find_handle != INVALID_HANDLE_VALUE)
2371 return NULL;
2372 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2373 return NULL;
2375 if (is_unc_volume (filename))
2377 wnet_enum_handle = open_unc_volume (filename);
2378 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
2379 return NULL;
2382 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
2383 return NULL;
2385 dirp->dd_fd = 0;
2386 dirp->dd_loc = 0;
2387 dirp->dd_size = 0;
2389 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
2390 dir_pathname[MAXPATHLEN] = '\0';
2391 dir_is_fat = is_fat_volume (filename, NULL);
2393 return dirp;
2396 void
2397 closedir (DIR *dirp)
2399 /* If we have a find-handle open, close it. */
2400 if (dir_find_handle != INVALID_HANDLE_VALUE)
2402 FindClose (dir_find_handle);
2403 dir_find_handle = INVALID_HANDLE_VALUE;
2405 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2407 close_unc_volume (wnet_enum_handle);
2408 wnet_enum_handle = INVALID_HANDLE_VALUE;
2410 xfree ((char *) dirp);
2413 struct direct *
2414 readdir (DIR *dirp)
2416 int downcase = !NILP (Vw32_downcase_file_names);
2418 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2420 if (!read_unc_volume (wnet_enum_handle,
2421 dir_find_data.cFileName,
2422 MAX_PATH))
2423 return NULL;
2425 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2426 else if (dir_find_handle == INVALID_HANDLE_VALUE)
2428 char filename[MAXNAMLEN + 3];
2429 int ln;
2431 strcpy (filename, dir_pathname);
2432 ln = strlen (filename) - 1;
2433 if (!IS_DIRECTORY_SEP (filename[ln]))
2434 strcat (filename, "\\");
2435 strcat (filename, "*");
2437 dir_find_handle = FindFirstFile (filename, &dir_find_data);
2439 if (dir_find_handle == INVALID_HANDLE_VALUE)
2440 return NULL;
2442 else
2444 if (!FindNextFile (dir_find_handle, &dir_find_data))
2445 return NULL;
2448 /* Emacs never uses this value, so don't bother making it match
2449 value returned by stat(). */
2450 dir_static.d_ino = 1;
2452 strcpy (dir_static.d_name, dir_find_data.cFileName);
2454 /* If the file name in cFileName[] includes `?' characters, it means
2455 the original file name used characters that cannot be represented
2456 by the current ANSI codepage. To avoid total lossage, retrieve
2457 the short 8+3 alias of the long file name. */
2458 if (_mbspbrk (dir_static.d_name, "?"))
2460 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2461 downcase = 1; /* 8+3 aliases are returned in all caps */
2463 dir_static.d_namlen = strlen (dir_static.d_name);
2464 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
2465 dir_static.d_namlen - dir_static.d_namlen % 4;
2467 /* If the file name in cFileName[] includes `?' characters, it means
2468 the original file name used characters that cannot be represented
2469 by the current ANSI codepage. To avoid total lossage, retrieve
2470 the short 8+3 alias of the long file name. */
2471 if (_mbspbrk (dir_find_data.cFileName, "?"))
2473 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2474 /* 8+3 aliases are returned in all caps, which could break
2475 various alists that look at filenames' extensions. */
2476 downcase = 1;
2478 else
2479 strcpy (dir_static.d_name, dir_find_data.cFileName);
2480 dir_static.d_namlen = strlen (dir_static.d_name);
2481 if (dir_is_fat)
2482 _strlwr (dir_static.d_name);
2483 else if (downcase)
2485 register char *p;
2486 for (p = dir_static.d_name; *p; p++)
2487 if (*p >= 'a' && *p <= 'z')
2488 break;
2489 if (!*p)
2490 _strlwr (dir_static.d_name);
2493 return &dir_static;
2496 static HANDLE
2497 open_unc_volume (const char *path)
2499 NETRESOURCE nr;
2500 HANDLE henum;
2501 int result;
2503 nr.dwScope = RESOURCE_GLOBALNET;
2504 nr.dwType = RESOURCETYPE_DISK;
2505 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
2506 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
2507 nr.lpLocalName = NULL;
2508 nr.lpRemoteName = (LPSTR)map_w32_filename (path, NULL);
2509 nr.lpComment = NULL;
2510 nr.lpProvider = NULL;
2512 result = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
2513 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
2515 if (result == NO_ERROR)
2516 return henum;
2517 else
2518 return INVALID_HANDLE_VALUE;
2521 static char *
2522 read_unc_volume (HANDLE henum, char *readbuf, int size)
2524 DWORD count;
2525 int result;
2526 DWORD bufsize = 512;
2527 char *buffer;
2528 char *ptr;
2530 count = 1;
2531 buffer = alloca (bufsize);
2532 result = WNetEnumResource (henum, &count, buffer, &bufsize);
2533 if (result != NO_ERROR)
2534 return NULL;
2536 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2537 ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
2538 ptr += 2;
2539 while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
2540 ptr++;
2542 strncpy (readbuf, ptr, size);
2543 return readbuf;
2546 static void
2547 close_unc_volume (HANDLE henum)
2549 if (henum != INVALID_HANDLE_VALUE)
2550 WNetCloseEnum (henum);
2553 static DWORD
2554 unc_volume_file_attributes (const char *path)
2556 HANDLE henum;
2557 DWORD attrs;
2559 henum = open_unc_volume (path);
2560 if (henum == INVALID_HANDLE_VALUE)
2561 return -1;
2563 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
2565 close_unc_volume (henum);
2567 return attrs;
2570 /* Ensure a network connection is authenticated. */
2571 static void
2572 logon_network_drive (const char *path)
2574 NETRESOURCE resource;
2575 char share[MAX_PATH];
2576 int i, n_slashes;
2577 char drive[4];
2578 UINT drvtype;
2580 if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
2581 drvtype = DRIVE_REMOTE;
2582 else if (path[0] == '\0' || path[1] != ':')
2583 drvtype = GetDriveType (NULL);
2584 else
2586 drive[0] = path[0];
2587 drive[1] = ':';
2588 drive[2] = '\\';
2589 drive[3] = '\0';
2590 drvtype = GetDriveType (drive);
2593 /* Only logon to networked drives. */
2594 if (drvtype != DRIVE_REMOTE)
2595 return;
2597 n_slashes = 2;
2598 strncpy (share, path, MAX_PATH);
2599 /* Truncate to just server and share name. */
2600 for (i = 2; i < MAX_PATH; i++)
2602 if (IS_DIRECTORY_SEP (share[i]) && ++n_slashes > 3)
2604 share[i] = '\0';
2605 break;
2609 resource.dwType = RESOURCETYPE_DISK;
2610 resource.lpLocalName = NULL;
2611 resource.lpRemoteName = share;
2612 resource.lpProvider = NULL;
2614 WNetAddConnection2 (&resource, NULL, NULL, CONNECT_INTERACTIVE);
2617 /* Shadow some MSVC runtime functions to map requests for long filenames
2618 to reasonable short names if necessary. This was originally added to
2619 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2620 long file names. */
2623 sys_access (const char * path, int mode)
2625 DWORD attributes;
2627 /* MSVC implementation doesn't recognize D_OK. */
2628 path = map_w32_filename (path, NULL);
2629 if (is_unc_volume (path))
2631 attributes = unc_volume_file_attributes (path);
2632 if (attributes == -1) {
2633 errno = EACCES;
2634 return -1;
2637 else if ((attributes = GetFileAttributes (path)) == -1)
2639 /* Should try mapping GetLastError to errno; for now just indicate
2640 that path doesn't exist. */
2641 errno = EACCES;
2642 return -1;
2644 if ((mode & X_OK) != 0 && !is_exec (path))
2646 errno = EACCES;
2647 return -1;
2649 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
2651 errno = EACCES;
2652 return -1;
2654 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
2656 errno = EACCES;
2657 return -1;
2659 return 0;
2663 sys_chdir (const char * path)
2665 return _chdir (map_w32_filename (path, NULL));
2669 sys_chmod (const char * path, int mode)
2671 return _chmod (map_w32_filename (path, NULL), mode);
2675 sys_chown (const char *path, uid_t owner, gid_t group)
2677 if (sys_chmod (path, S_IREAD) == -1) /* check if file exists */
2678 return -1;
2679 return 0;
2683 sys_creat (const char * path, int mode)
2685 return _creat (map_w32_filename (path, NULL), mode);
2688 FILE *
2689 sys_fopen (const char * path, const char * mode)
2691 int fd;
2692 int oflag;
2693 const char * mode_save = mode;
2695 /* Force all file handles to be non-inheritable. This is necessary to
2696 ensure child processes don't unwittingly inherit handles that might
2697 prevent future file access. */
2699 if (mode[0] == 'r')
2700 oflag = O_RDONLY;
2701 else if (mode[0] == 'w' || mode[0] == 'a')
2702 oflag = O_WRONLY | O_CREAT | O_TRUNC;
2703 else
2704 return NULL;
2706 /* Only do simplistic option parsing. */
2707 while (*++mode)
2708 if (mode[0] == '+')
2710 oflag &= ~(O_RDONLY | O_WRONLY);
2711 oflag |= O_RDWR;
2713 else if (mode[0] == 'b')
2715 oflag &= ~O_TEXT;
2716 oflag |= O_BINARY;
2718 else if (mode[0] == 't')
2720 oflag &= ~O_BINARY;
2721 oflag |= O_TEXT;
2723 else break;
2725 fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
2726 if (fd < 0)
2727 return NULL;
2729 return _fdopen (fd, mode_save);
2732 /* This only works on NTFS volumes, but is useful to have. */
2734 sys_link (const char * old, const char * new)
2736 HANDLE fileh;
2737 int result = -1;
2738 char oldname[MAX_PATH], newname[MAX_PATH];
2740 if (old == NULL || new == NULL)
2742 errno = ENOENT;
2743 return -1;
2746 strcpy (oldname, map_w32_filename (old, NULL));
2747 strcpy (newname, map_w32_filename (new, NULL));
2749 fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
2750 FILE_FLAG_BACKUP_SEMANTICS, NULL);
2751 if (fileh != INVALID_HANDLE_VALUE)
2753 int wlen;
2755 /* Confusingly, the "alternate" stream name field does not apply
2756 when restoring a hard link, and instead contains the actual
2757 stream data for the link (ie. the name of the link to create).
2758 The WIN32_STREAM_ID structure before the cStreamName field is
2759 the stream header, which is then immediately followed by the
2760 stream data. */
2762 struct {
2763 WIN32_STREAM_ID wid;
2764 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
2765 } data;
2767 wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
2768 data.wid.cStreamName, MAX_PATH);
2769 if (wlen > 0)
2771 LPVOID context = NULL;
2772 DWORD wbytes = 0;
2774 data.wid.dwStreamId = BACKUP_LINK;
2775 data.wid.dwStreamAttributes = 0;
2776 data.wid.Size.LowPart = wlen * sizeof (WCHAR);
2777 data.wid.Size.HighPart = 0;
2778 data.wid.dwStreamNameSize = 0;
2780 if (BackupWrite (fileh, (LPBYTE)&data,
2781 offsetof (WIN32_STREAM_ID, cStreamName)
2782 + data.wid.Size.LowPart,
2783 &wbytes, FALSE, FALSE, &context)
2784 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
2786 /* succeeded */
2787 result = 0;
2789 else
2791 /* Should try mapping GetLastError to errno; for now just
2792 indicate a general error (eg. links not supported). */
2793 errno = EINVAL; // perhaps EMLINK?
2797 CloseHandle (fileh);
2799 else
2800 errno = ENOENT;
2802 return result;
2806 sys_mkdir (const char * path)
2808 return _mkdir (map_w32_filename (path, NULL));
2811 /* Because of long name mapping issues, we need to implement this
2812 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2813 a unique name, instead of setting the input template to an empty
2814 string.
2816 Standard algorithm seems to be use pid or tid with a letter on the
2817 front (in place of the 6 X's) and cycle through the letters to find a
2818 unique name. We extend that to allow any reasonable character as the
2819 first of the 6 X's. */
2820 char *
2821 sys_mktemp (char * template)
2823 char * p;
2824 int i;
2825 unsigned uid = GetCurrentThreadId ();
2826 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2828 if (template == NULL)
2829 return NULL;
2830 p = template + strlen (template);
2831 i = 5;
2832 /* replace up to the last 5 X's with uid in decimal */
2833 while (--p >= template && p[0] == 'X' && --i >= 0)
2835 p[0] = '0' + uid % 10;
2836 uid /= 10;
2839 if (i < 0 && p[0] == 'X')
2841 i = 0;
2844 int save_errno = errno;
2845 p[0] = first_char[i];
2846 if (sys_access (template, 0) < 0)
2848 errno = save_errno;
2849 return template;
2852 while (++i < sizeof (first_char));
2855 /* Template is badly formed or else we can't generate a unique name,
2856 so return empty string */
2857 template[0] = 0;
2858 return template;
2862 sys_open (const char * path, int oflag, int mode)
2864 const char* mpath = map_w32_filename (path, NULL);
2865 /* Try to open file without _O_CREAT, to be able to write to hidden
2866 and system files. Force all file handles to be
2867 non-inheritable. */
2868 int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
2869 if (res >= 0)
2870 return res;
2871 return _open (mpath, oflag | _O_NOINHERIT, mode);
2875 sys_rename (const char * oldname, const char * newname)
2877 BOOL result;
2878 char temp[MAX_PATH];
2880 /* MoveFile on Windows 95 doesn't correctly change the short file name
2881 alias in a number of circumstances (it is not easy to predict when
2882 just by looking at oldname and newname, unfortunately). In these
2883 cases, renaming through a temporary name avoids the problem.
2885 A second problem on Windows 95 is that renaming through a temp name when
2886 newname is uppercase fails (the final long name ends up in
2887 lowercase, although the short alias might be uppercase) UNLESS the
2888 long temp name is not 8.3.
2890 So, on Windows 95 we always rename through a temp name, and we make sure
2891 the temp name has a long extension to ensure correct renaming. */
2893 strcpy (temp, map_w32_filename (oldname, NULL));
2895 if (os_subtype == OS_WIN95)
2897 char * o;
2898 char * p;
2899 int i = 0;
2901 oldname = map_w32_filename (oldname, NULL);
2902 if ((o = strrchr (oldname, '\\')))
2903 o++;
2904 else
2905 o = (char *) oldname;
2907 if ((p = strrchr (temp, '\\')))
2908 p++;
2909 else
2910 p = temp;
2914 /* Force temp name to require a manufactured 8.3 alias - this
2915 seems to make the second rename work properly. */
2916 sprintf (p, "_.%s.%u", o, i);
2917 i++;
2918 result = rename (oldname, temp);
2920 /* This loop must surely terminate! */
2921 while (result < 0 && errno == EEXIST);
2922 if (result < 0)
2923 return -1;
2926 /* Emulate Unix behavior - newname is deleted if it already exists
2927 (at least if it is a file; don't do this for directories).
2929 Since we mustn't do this if we are just changing the case of the
2930 file name (we would end up deleting the file we are trying to
2931 rename!), we let rename detect if the destination file already
2932 exists - that way we avoid the possible pitfalls of trying to
2933 determine ourselves whether two names really refer to the same
2934 file, which is not always possible in the general case. (Consider
2935 all the permutations of shared or subst'd drives, etc.) */
2937 newname = map_w32_filename (newname, NULL);
2938 result = rename (temp, newname);
2940 if (result < 0
2941 && errno == EEXIST
2942 && _chmod (newname, 0666) == 0
2943 && _unlink (newname) == 0)
2944 result = rename (temp, newname);
2946 return result;
2950 sys_rmdir (const char * path)
2952 return _rmdir (map_w32_filename (path, NULL));
2956 sys_unlink (const char * path)
2958 path = map_w32_filename (path, NULL);
2960 /* On Unix, unlink works without write permission. */
2961 _chmod (path, 0666);
2962 return _unlink (path);
2965 static FILETIME utc_base_ft;
2966 static ULONGLONG utc_base; /* In 100ns units */
2967 static int init = 0;
2969 #define FILETIME_TO_U64(result, ft) \
2970 do { \
2971 ULARGE_INTEGER uiTemp; \
2972 uiTemp.LowPart = (ft).dwLowDateTime; \
2973 uiTemp.HighPart = (ft).dwHighDateTime; \
2974 result = uiTemp.QuadPart; \
2975 } while (0)
2977 static void
2978 initialize_utc_base (void)
2980 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2981 SYSTEMTIME st;
2983 st.wYear = 1970;
2984 st.wMonth = 1;
2985 st.wDay = 1;
2986 st.wHour = 0;
2987 st.wMinute = 0;
2988 st.wSecond = 0;
2989 st.wMilliseconds = 0;
2991 SystemTimeToFileTime (&st, &utc_base_ft);
2992 FILETIME_TO_U64 (utc_base, utc_base_ft);
2995 static time_t
2996 convert_time (FILETIME ft)
2998 ULONGLONG tmp;
3000 if (!init)
3002 initialize_utc_base ();
3003 init = 1;
3006 if (CompareFileTime (&ft, &utc_base_ft) < 0)
3007 return 0;
3009 FILETIME_TO_U64 (tmp, ft);
3010 return (time_t) ((tmp - utc_base) / 10000000L);
3013 static void
3014 convert_from_time_t (time_t time, FILETIME * pft)
3016 ULARGE_INTEGER tmp;
3018 if (!init)
3020 initialize_utc_base ();
3021 init = 1;
3024 /* time in 100ns units since 1-Jan-1601 */
3025 tmp.QuadPart = (ULONGLONG) time * 10000000L + utc_base;
3026 pft->dwHighDateTime = tmp.HighPart;
3027 pft->dwLowDateTime = tmp.LowPart;
3030 #if 0
3031 /* No reason to keep this; faking inode values either by hashing or even
3032 using the file index from GetInformationByHandle, is not perfect and
3033 so by default Emacs doesn't use the inode values on Windows.
3034 Instead, we now determine file-truename correctly (except for
3035 possible drive aliasing etc). */
3037 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3038 static unsigned
3039 hashval (const unsigned char * str)
3041 unsigned h = 0;
3042 while (*str)
3044 h = (h << 4) + *str++;
3045 h ^= (h >> 28);
3047 return h;
3050 /* Return the hash value of the canonical pathname, excluding the
3051 drive/UNC header, to get a hopefully unique inode number. */
3052 static DWORD
3053 generate_inode_val (const char * name)
3055 char fullname[ MAX_PATH ];
3056 char * p;
3057 unsigned hash;
3059 /* Get the truly canonical filename, if it exists. (Note: this
3060 doesn't resolve aliasing due to subst commands, or recognise hard
3061 links. */
3062 if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
3063 abort ();
3065 parse_root (fullname, &p);
3066 /* Normal W32 filesystems are still case insensitive. */
3067 _strlwr (p);
3068 return hashval (p);
3071 #endif
3073 static PSECURITY_DESCRIPTOR
3074 get_file_security_desc (const char *fname)
3076 PSECURITY_DESCRIPTOR psd = NULL;
3077 DWORD sd_len, err;
3078 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3079 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
3081 if (!get_file_security (fname, si, psd, 0, &sd_len))
3083 err = GetLastError ();
3084 if (err != ERROR_INSUFFICIENT_BUFFER)
3085 return NULL;
3088 psd = xmalloc (sd_len);
3089 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
3091 xfree (psd);
3092 return NULL;
3095 return psd;
3098 static DWORD
3099 get_rid (PSID sid)
3101 unsigned n_subauthorities;
3103 /* Use the last sub-authority value of the RID, the relative
3104 portion of the SID, as user/group ID. */
3105 n_subauthorities = *get_sid_sub_authority_count (sid);
3106 if (n_subauthorities < 1)
3107 return 0; /* the "World" RID */
3108 return *get_sid_sub_authority (sid, n_subauthorities - 1);
3111 /* Caching SID and account values for faster lokup. */
3113 #ifdef __GNUC__
3114 # define FLEXIBLE_ARRAY_MEMBER
3115 #else
3116 # define FLEXIBLE_ARRAY_MEMBER 1
3117 #endif
3119 struct w32_id {
3120 unsigned rid;
3121 struct w32_id *next;
3122 char name[GNLEN+1];
3123 unsigned char sid[FLEXIBLE_ARRAY_MEMBER];
3126 static struct w32_id *w32_idlist;
3128 static int
3129 w32_cached_id (PSID sid, unsigned *id, char *name)
3131 struct w32_id *tail, *found;
3133 for (found = NULL, tail = w32_idlist; tail; tail = tail->next)
3135 if (equal_sid ((PSID)tail->sid, sid))
3137 found = tail;
3138 break;
3141 if (found)
3143 *id = found->rid;
3144 strcpy (name, found->name);
3145 return 1;
3147 else
3148 return 0;
3151 static void
3152 w32_add_to_cache (PSID sid, unsigned id, char *name)
3154 DWORD sid_len;
3155 struct w32_id *new_entry;
3157 /* We don't want to leave behind stale cache from when Emacs was
3158 dumped. */
3159 if (initialized)
3161 sid_len = get_length_sid (sid);
3162 new_entry = xmalloc (offsetof (struct w32_id, sid) + sid_len);
3163 if (new_entry)
3165 new_entry->rid = id;
3166 strcpy (new_entry->name, name);
3167 copy_sid (sid_len, (PSID)new_entry->sid, sid);
3168 new_entry->next = w32_idlist;
3169 w32_idlist = new_entry;
3174 #define UID 1
3175 #define GID 2
3177 static int
3178 get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
3179 unsigned *id, char *nm, int what)
3181 PSID sid = NULL;
3182 char machine[MAX_COMPUTERNAME_LENGTH+1];
3183 BOOL dflt;
3184 SID_NAME_USE ignore;
3185 char name[UNLEN+1];
3186 DWORD name_len = sizeof (name);
3187 char domain[1024];
3188 DWORD domain_len = sizeof (domain);
3189 char *mp = NULL;
3190 int use_dflt = 0;
3191 int result;
3193 if (what == UID)
3194 result = get_security_descriptor_owner (psd, &sid, &dflt);
3195 else if (what == GID)
3196 result = get_security_descriptor_group (psd, &sid, &dflt);
3197 else
3198 result = 0;
3200 if (!result || !is_valid_sid (sid))
3201 use_dflt = 1;
3202 else if (!w32_cached_id (sid, id, nm))
3204 /* If FNAME is a UNC, we need to lookup account on the
3205 specified machine. */
3206 if (IS_DIRECTORY_SEP (fname[0]) && IS_DIRECTORY_SEP (fname[1])
3207 && fname[2] != '\0')
3209 const char *s;
3210 char *p;
3212 for (s = fname + 2, p = machine;
3213 *s && !IS_DIRECTORY_SEP (*s); s++, p++)
3214 *p = *s;
3215 *p = '\0';
3216 mp = machine;
3219 if (!lookup_account_sid (mp, sid, name, &name_len,
3220 domain, &domain_len, &ignore)
3221 || name_len > UNLEN+1)
3222 use_dflt = 1;
3223 else
3225 *id = get_rid (sid);
3226 strcpy (nm, name);
3227 w32_add_to_cache (sid, *id, name);
3230 return use_dflt;
3233 static void
3234 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd,
3235 const char *fname,
3236 struct stat *st)
3238 int dflt_usr = 0, dflt_grp = 0;
3240 if (!psd)
3242 dflt_usr = 1;
3243 dflt_grp = 1;
3245 else
3247 if (get_name_and_id (psd, fname, &st->st_uid, st->st_uname, UID))
3248 dflt_usr = 1;
3249 if (get_name_and_id (psd, fname, &st->st_gid, st->st_gname, GID))
3250 dflt_grp = 1;
3252 /* Consider files to belong to current user/group, if we cannot get
3253 more accurate information. */
3254 if (dflt_usr)
3256 st->st_uid = dflt_passwd.pw_uid;
3257 strcpy (st->st_uname, dflt_passwd.pw_name);
3259 if (dflt_grp)
3261 st->st_gid = dflt_passwd.pw_gid;
3262 strcpy (st->st_gname, dflt_group.gr_name);
3266 /* Return non-zero if NAME is a potentially slow filesystem. */
3268 is_slow_fs (const char *name)
3270 char drive_root[4];
3271 UINT devtype;
3273 if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
3274 devtype = DRIVE_REMOTE; /* assume UNC name is remote */
3275 else if (!(strlen (name) >= 2 && IS_DEVICE_SEP (name[1])))
3276 devtype = GetDriveType (NULL); /* use root of current drive */
3277 else
3279 /* GetDriveType needs the root directory of the drive. */
3280 strncpy (drive_root, name, 2);
3281 drive_root[2] = '\\';
3282 drive_root[3] = '\0';
3283 devtype = GetDriveType (drive_root);
3285 return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
3288 /* MSVC stat function can't cope with UNC names and has other bugs, so
3289 replace it with our own. This also allows us to calculate consistent
3290 inode values without hacks in the main Emacs code. */
3292 stat (const char * path, struct stat * buf)
3294 char *name, *r;
3295 WIN32_FIND_DATA wfd;
3296 HANDLE fh;
3297 unsigned __int64 fake_inode;
3298 int permission;
3299 int len;
3300 int rootdir = FALSE;
3301 PSECURITY_DESCRIPTOR psd = NULL;
3303 if (path == NULL || buf == NULL)
3305 errno = EFAULT;
3306 return -1;
3309 name = (char *) map_w32_filename (path, &path);
3310 /* Must be valid filename, no wild cards or other invalid
3311 characters. We use _mbspbrk to support multibyte strings that
3312 might look to strpbrk as if they included literal *, ?, and other
3313 characters mentioned below that are disallowed by Windows
3314 filesystems. */
3315 if (_mbspbrk (name, "*?|<>\""))
3317 errno = ENOENT;
3318 return -1;
3321 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3322 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
3323 if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
3325 r[1] = r[2] = '\0';
3328 /* Remove trailing directory separator, unless name is the root
3329 directory of a drive or UNC volume in which case ensure there
3330 is a trailing separator. */
3331 len = strlen (name);
3332 rootdir = (path >= name + len - 1
3333 && (IS_DIRECTORY_SEP (*path) || *path == 0));
3334 name = strcpy (alloca (len + 2), name);
3336 if (is_unc_volume (name))
3338 DWORD attrs = unc_volume_file_attributes (name);
3340 if (attrs == -1)
3341 return -1;
3343 memset (&wfd, 0, sizeof (wfd));
3344 wfd.dwFileAttributes = attrs;
3345 wfd.ftCreationTime = utc_base_ft;
3346 wfd.ftLastAccessTime = utc_base_ft;
3347 wfd.ftLastWriteTime = utc_base_ft;
3348 strcpy (wfd.cFileName, name);
3350 else if (rootdir)
3352 if (!IS_DIRECTORY_SEP (name[len-1]))
3353 strcat (name, "\\");
3354 if (GetDriveType (name) < 2)
3356 errno = ENOENT;
3357 return -1;
3359 memset (&wfd, 0, sizeof (wfd));
3360 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
3361 wfd.ftCreationTime = utc_base_ft;
3362 wfd.ftLastAccessTime = utc_base_ft;
3363 wfd.ftLastWriteTime = utc_base_ft;
3364 strcpy (wfd.cFileName, name);
3366 else
3368 if (IS_DIRECTORY_SEP (name[len-1]))
3369 name[len - 1] = 0;
3371 /* (This is hacky, but helps when doing file completions on
3372 network drives.) Optimize by using information available from
3373 active readdir if possible. */
3374 len = strlen (dir_pathname);
3375 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
3376 len--;
3377 if (dir_find_handle != INVALID_HANDLE_VALUE
3378 && strnicmp (name, dir_pathname, len) == 0
3379 && IS_DIRECTORY_SEP (name[len])
3380 && xstrcasecmp (name + len + 1, dir_static.d_name) == 0)
3382 /* This was the last entry returned by readdir. */
3383 wfd = dir_find_data;
3385 else
3387 logon_network_drive (name);
3389 fh = FindFirstFile (name, &wfd);
3390 if (fh == INVALID_HANDLE_VALUE)
3392 errno = ENOENT;
3393 return -1;
3395 FindClose (fh);
3399 if (!(NILP (Vw32_get_true_file_attributes)
3400 || (EQ (Vw32_get_true_file_attributes, Qlocal) && is_slow_fs (name)))
3401 /* No access rights required to get info. */
3402 && (fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
3403 FILE_FLAG_BACKUP_SEMANTICS, NULL))
3404 != INVALID_HANDLE_VALUE)
3406 /* This is more accurate in terms of gettting the correct number
3407 of links, but is quite slow (it is noticeable when Emacs is
3408 making a list of file name completions). */
3409 BY_HANDLE_FILE_INFORMATION info;
3411 if (GetFileInformationByHandle (fh, &info))
3413 buf->st_nlink = info.nNumberOfLinks;
3414 /* Might as well use file index to fake inode values, but this
3415 is not guaranteed to be unique unless we keep a handle open
3416 all the time (even then there are situations where it is
3417 not unique). Reputedly, there are at most 48 bits of info
3418 (on NTFS, presumably less on FAT). */
3419 fake_inode = info.nFileIndexHigh;
3420 fake_inode <<= 32;
3421 fake_inode += info.nFileIndexLow;
3423 else
3425 buf->st_nlink = 1;
3426 fake_inode = 0;
3429 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3431 buf->st_mode = S_IFDIR;
3433 else
3435 switch (GetFileType (fh))
3437 case FILE_TYPE_DISK:
3438 buf->st_mode = S_IFREG;
3439 break;
3440 case FILE_TYPE_PIPE:
3441 buf->st_mode = S_IFIFO;
3442 break;
3443 case FILE_TYPE_CHAR:
3444 case FILE_TYPE_UNKNOWN:
3445 default:
3446 buf->st_mode = S_IFCHR;
3449 CloseHandle (fh);
3450 psd = get_file_security_desc (name);
3451 get_file_owner_and_group (psd, name, buf);
3453 else
3455 /* Don't bother to make this information more accurate. */
3456 buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
3457 S_IFDIR : S_IFREG;
3458 buf->st_nlink = 1;
3459 fake_inode = 0;
3461 get_file_owner_and_group (NULL, name, buf);
3463 xfree (psd);
3465 #if 0
3466 /* Not sure if there is any point in this. */
3467 if (!NILP (Vw32_generate_fake_inodes))
3468 fake_inode = generate_inode_val (name);
3469 else if (fake_inode == 0)
3471 /* For want of something better, try to make everything unique. */
3472 static DWORD gen_num = 0;
3473 fake_inode = ++gen_num;
3475 #endif
3477 /* MSVC defines _ino_t to be short; other libc's might not. */
3478 if (sizeof (buf->st_ino) == 2)
3479 buf->st_ino = fake_inode ^ (fake_inode >> 16);
3480 else
3481 buf->st_ino = fake_inode;
3483 /* volume_info is set indirectly by map_w32_filename */
3484 buf->st_dev = volume_info.serialnum;
3485 buf->st_rdev = volume_info.serialnum;
3487 buf->st_size = wfd.nFileSizeHigh;
3488 buf->st_size <<= 32;
3489 buf->st_size += wfd.nFileSizeLow;
3491 /* Convert timestamps to Unix format. */
3492 buf->st_mtime = convert_time (wfd.ftLastWriteTime);
3493 buf->st_atime = convert_time (wfd.ftLastAccessTime);
3494 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
3495 buf->st_ctime = convert_time (wfd.ftCreationTime);
3496 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
3498 /* determine rwx permissions */
3499 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
3500 permission = S_IREAD;
3501 else
3502 permission = S_IREAD | S_IWRITE;
3504 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3505 permission |= S_IEXEC;
3506 else if (is_exec (name))
3507 permission |= S_IEXEC;
3509 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
3511 return 0;
3514 /* Provide fstat and utime as well as stat for consistent handling of
3515 file timestamps. */
3517 fstat (int desc, struct stat * buf)
3519 HANDLE fh = (HANDLE) _get_osfhandle (desc);
3520 BY_HANDLE_FILE_INFORMATION info;
3521 unsigned __int64 fake_inode;
3522 int permission;
3524 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
3526 case FILE_TYPE_DISK:
3527 buf->st_mode = S_IFREG;
3528 if (!GetFileInformationByHandle (fh, &info))
3530 errno = EACCES;
3531 return -1;
3533 break;
3534 case FILE_TYPE_PIPE:
3535 buf->st_mode = S_IFIFO;
3536 goto non_disk;
3537 case FILE_TYPE_CHAR:
3538 case FILE_TYPE_UNKNOWN:
3539 default:
3540 buf->st_mode = S_IFCHR;
3541 non_disk:
3542 memset (&info, 0, sizeof (info));
3543 info.dwFileAttributes = 0;
3544 info.ftCreationTime = utc_base_ft;
3545 info.ftLastAccessTime = utc_base_ft;
3546 info.ftLastWriteTime = utc_base_ft;
3549 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3550 buf->st_mode = S_IFDIR;
3552 buf->st_nlink = info.nNumberOfLinks;
3553 /* Might as well use file index to fake inode values, but this
3554 is not guaranteed to be unique unless we keep a handle open
3555 all the time (even then there are situations where it is
3556 not unique). Reputedly, there are at most 48 bits of info
3557 (on NTFS, presumably less on FAT). */
3558 fake_inode = info.nFileIndexHigh;
3559 fake_inode <<= 32;
3560 fake_inode += info.nFileIndexLow;
3562 /* MSVC defines _ino_t to be short; other libc's might not. */
3563 if (sizeof (buf->st_ino) == 2)
3564 buf->st_ino = fake_inode ^ (fake_inode >> 16);
3565 else
3566 buf->st_ino = fake_inode;
3568 /* Consider files to belong to current user.
3569 FIXME: this should use GetSecurityInfo API, but it is only
3570 available for _WIN32_WINNT >= 0x501. */
3571 buf->st_uid = dflt_passwd.pw_uid;
3572 buf->st_gid = dflt_passwd.pw_gid;
3573 strcpy (buf->st_uname, dflt_passwd.pw_name);
3574 strcpy (buf->st_gname, dflt_group.gr_name);
3576 buf->st_dev = info.dwVolumeSerialNumber;
3577 buf->st_rdev = info.dwVolumeSerialNumber;
3579 buf->st_size = info.nFileSizeHigh;
3580 buf->st_size <<= 32;
3581 buf->st_size += info.nFileSizeLow;
3583 /* Convert timestamps to Unix format. */
3584 buf->st_mtime = convert_time (info.ftLastWriteTime);
3585 buf->st_atime = convert_time (info.ftLastAccessTime);
3586 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
3587 buf->st_ctime = convert_time (info.ftCreationTime);
3588 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
3590 /* determine rwx permissions */
3591 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
3592 permission = S_IREAD;
3593 else
3594 permission = S_IREAD | S_IWRITE;
3596 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3597 permission |= S_IEXEC;
3598 else
3600 #if 0 /* no way of knowing the filename */
3601 char * p = strrchr (name, '.');
3602 if (p != NULL &&
3603 (xstrcasecmp (p, ".exe") == 0 ||
3604 xstrcasecmp (p, ".com") == 0 ||
3605 xstrcasecmp (p, ".bat") == 0 ||
3606 xstrcasecmp (p, ".cmd") == 0))
3607 permission |= S_IEXEC;
3608 #endif
3611 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
3613 return 0;
3617 utime (const char *name, struct utimbuf *times)
3619 struct utimbuf deftime;
3620 HANDLE fh;
3621 FILETIME mtime;
3622 FILETIME atime;
3624 if (times == NULL)
3626 deftime.modtime = deftime.actime = time (NULL);
3627 times = &deftime;
3630 /* Need write access to set times. */
3631 fh = CreateFile (name, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
3632 0, OPEN_EXISTING, 0, NULL);
3633 if (fh)
3635 convert_from_time_t (times->actime, &atime);
3636 convert_from_time_t (times->modtime, &mtime);
3637 if (!SetFileTime (fh, NULL, &atime, &mtime))
3639 CloseHandle (fh);
3640 errno = EACCES;
3641 return -1;
3643 CloseHandle (fh);
3645 else
3647 errno = EINVAL;
3648 return -1;
3650 return 0;
3654 /* Symlink-related functions that always fail. Used in fileio.c and in
3655 sysdep.c to avoid #ifdef's. */
3657 symlink (char const *dummy1, char const *dummy2)
3659 errno = ENOSYS;
3660 return -1;
3663 ssize_t
3664 readlink (const char *name, char *dummy1, size_t dummy2)
3666 /* `access' is much faster than `stat' on MS-Windows. */
3667 if (sys_access (name, 0) == 0)
3668 errno = EINVAL;
3669 return -1;
3672 char *
3673 careadlinkat (int fd, char const *filename,
3674 char *buffer, size_t buffer_size,
3675 struct allocator const *alloc,
3676 ssize_t (*preadlinkat) (int, char const *, char *, size_t))
3678 errno = ENOSYS;
3679 return NULL;
3682 ssize_t
3683 careadlinkatcwd (int fd, char const *filename, char *buffer,
3684 size_t buffer_size)
3686 (void) fd;
3687 return readlink (filename, buffer, buffer_size);
3691 /* Support for browsing other processes and their attributes. See
3692 process.c for the Lisp bindings. */
3694 /* Helper wrapper functions. */
3696 static HANDLE WINAPI
3697 create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
3699 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
3701 if (g_b_init_create_toolhelp32_snapshot == 0)
3703 g_b_init_create_toolhelp32_snapshot = 1;
3704 s_pfn_Create_Toolhelp32_Snapshot = (CreateToolhelp32Snapshot_Proc)
3705 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3706 "CreateToolhelp32Snapshot");
3708 if (s_pfn_Create_Toolhelp32_Snapshot == NULL)
3710 return INVALID_HANDLE_VALUE;
3712 return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
3715 static BOOL WINAPI
3716 process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
3718 static Process32First_Proc s_pfn_Process32_First = NULL;
3720 if (g_b_init_process32_first == 0)
3722 g_b_init_process32_first = 1;
3723 s_pfn_Process32_First = (Process32First_Proc)
3724 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3725 "Process32First");
3727 if (s_pfn_Process32_First == NULL)
3729 return FALSE;
3731 return (s_pfn_Process32_First (hSnapshot, lppe));
3734 static BOOL WINAPI
3735 process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
3737 static Process32Next_Proc s_pfn_Process32_Next = NULL;
3739 if (g_b_init_process32_next == 0)
3741 g_b_init_process32_next = 1;
3742 s_pfn_Process32_Next = (Process32Next_Proc)
3743 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3744 "Process32Next");
3746 if (s_pfn_Process32_Next == NULL)
3748 return FALSE;
3750 return (s_pfn_Process32_Next (hSnapshot, lppe));
3753 static BOOL WINAPI
3754 open_thread_token (HANDLE ThreadHandle,
3755 DWORD DesiredAccess,
3756 BOOL OpenAsSelf,
3757 PHANDLE TokenHandle)
3759 static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
3760 HMODULE hm_advapi32 = NULL;
3761 if (is_windows_9x () == TRUE)
3763 SetLastError (ERROR_NOT_SUPPORTED);
3764 return FALSE;
3766 if (g_b_init_open_thread_token == 0)
3768 g_b_init_open_thread_token = 1;
3769 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3770 s_pfn_Open_Thread_Token =
3771 (OpenThreadToken_Proc) GetProcAddress (hm_advapi32, "OpenThreadToken");
3773 if (s_pfn_Open_Thread_Token == NULL)
3775 SetLastError (ERROR_NOT_SUPPORTED);
3776 return FALSE;
3778 return (
3779 s_pfn_Open_Thread_Token (
3780 ThreadHandle,
3781 DesiredAccess,
3782 OpenAsSelf,
3783 TokenHandle)
3787 static BOOL WINAPI
3788 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
3790 static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
3791 HMODULE hm_advapi32 = NULL;
3792 if (is_windows_9x () == TRUE)
3794 return FALSE;
3796 if (g_b_init_impersonate_self == 0)
3798 g_b_init_impersonate_self = 1;
3799 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3800 s_pfn_Impersonate_Self =
3801 (ImpersonateSelf_Proc) GetProcAddress (hm_advapi32, "ImpersonateSelf");
3803 if (s_pfn_Impersonate_Self == NULL)
3805 return FALSE;
3807 return s_pfn_Impersonate_Self (ImpersonationLevel);
3810 static BOOL WINAPI
3811 revert_to_self (void)
3813 static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
3814 HMODULE hm_advapi32 = NULL;
3815 if (is_windows_9x () == TRUE)
3817 return FALSE;
3819 if (g_b_init_revert_to_self == 0)
3821 g_b_init_revert_to_self = 1;
3822 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3823 s_pfn_Revert_To_Self =
3824 (RevertToSelf_Proc) GetProcAddress (hm_advapi32, "RevertToSelf");
3826 if (s_pfn_Revert_To_Self == NULL)
3828 return FALSE;
3830 return s_pfn_Revert_To_Self ();
3833 static BOOL WINAPI
3834 get_process_memory_info (HANDLE h_proc,
3835 PPROCESS_MEMORY_COUNTERS mem_counters,
3836 DWORD bufsize)
3838 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
3839 HMODULE hm_psapi = NULL;
3840 if (is_windows_9x () == TRUE)
3842 return FALSE;
3844 if (g_b_init_get_process_memory_info == 0)
3846 g_b_init_get_process_memory_info = 1;
3847 hm_psapi = LoadLibrary ("Psapi.dll");
3848 if (hm_psapi)
3849 s_pfn_Get_Process_Memory_Info = (GetProcessMemoryInfo_Proc)
3850 GetProcAddress (hm_psapi, "GetProcessMemoryInfo");
3852 if (s_pfn_Get_Process_Memory_Info == NULL)
3854 return FALSE;
3856 return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
3859 static BOOL WINAPI
3860 get_process_working_set_size (HANDLE h_proc,
3861 DWORD *minrss,
3862 DWORD *maxrss)
3864 static GetProcessWorkingSetSize_Proc
3865 s_pfn_Get_Process_Working_Set_Size = NULL;
3867 if (is_windows_9x () == TRUE)
3869 return FALSE;
3871 if (g_b_init_get_process_working_set_size == 0)
3873 g_b_init_get_process_working_set_size = 1;
3874 s_pfn_Get_Process_Working_Set_Size = (GetProcessWorkingSetSize_Proc)
3875 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3876 "GetProcessWorkingSetSize");
3878 if (s_pfn_Get_Process_Working_Set_Size == NULL)
3880 return FALSE;
3882 return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
3885 static BOOL WINAPI
3886 global_memory_status (MEMORYSTATUS *buf)
3888 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
3890 if (is_windows_9x () == TRUE)
3892 return FALSE;
3894 if (g_b_init_global_memory_status == 0)
3896 g_b_init_global_memory_status = 1;
3897 s_pfn_Global_Memory_Status = (GlobalMemoryStatus_Proc)
3898 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3899 "GlobalMemoryStatus");
3901 if (s_pfn_Global_Memory_Status == NULL)
3903 return FALSE;
3905 return s_pfn_Global_Memory_Status (buf);
3908 static BOOL WINAPI
3909 global_memory_status_ex (MEMORY_STATUS_EX *buf)
3911 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
3913 if (is_windows_9x () == TRUE)
3915 return FALSE;
3917 if (g_b_init_global_memory_status_ex == 0)
3919 g_b_init_global_memory_status_ex = 1;
3920 s_pfn_Global_Memory_Status_Ex = (GlobalMemoryStatusEx_Proc)
3921 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3922 "GlobalMemoryStatusEx");
3924 if (s_pfn_Global_Memory_Status_Ex == NULL)
3926 return FALSE;
3928 return s_pfn_Global_Memory_Status_Ex (buf);
3931 Lisp_Object
3932 list_system_processes (void)
3934 struct gcpro gcpro1;
3935 Lisp_Object proclist = Qnil;
3936 HANDLE h_snapshot;
3938 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
3940 if (h_snapshot != INVALID_HANDLE_VALUE)
3942 PROCESSENTRY32 proc_entry;
3943 DWORD proc_id;
3944 BOOL res;
3946 GCPRO1 (proclist);
3948 proc_entry.dwSize = sizeof (PROCESSENTRY32);
3949 for (res = process32_first (h_snapshot, &proc_entry); res;
3950 res = process32_next (h_snapshot, &proc_entry))
3952 proc_id = proc_entry.th32ProcessID;
3953 proclist = Fcons (make_fixnum_or_float (proc_id), proclist);
3956 CloseHandle (h_snapshot);
3957 UNGCPRO;
3958 proclist = Fnreverse (proclist);
3961 return proclist;
3964 static int
3965 enable_privilege (LPCTSTR priv_name, BOOL enable_p, TOKEN_PRIVILEGES *old_priv)
3967 TOKEN_PRIVILEGES priv;
3968 DWORD priv_size = sizeof (priv);
3969 DWORD opriv_size = sizeof (*old_priv);
3970 HANDLE h_token = NULL;
3971 HANDLE h_thread = GetCurrentThread ();
3972 int ret_val = 0;
3973 BOOL res;
3975 res = open_thread_token (h_thread,
3976 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3977 FALSE, &h_token);
3978 if (!res && GetLastError () == ERROR_NO_TOKEN)
3980 if (impersonate_self (SecurityImpersonation))
3981 res = open_thread_token (h_thread,
3982 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3983 FALSE, &h_token);
3985 if (res)
3987 priv.PrivilegeCount = 1;
3988 priv.Privileges[0].Attributes = enable_p ? SE_PRIVILEGE_ENABLED : 0;
3989 LookupPrivilegeValue (NULL, priv_name, &priv.Privileges[0].Luid);
3990 if (AdjustTokenPrivileges (h_token, FALSE, &priv, priv_size,
3991 old_priv, &opriv_size)
3992 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
3993 ret_val = 1;
3995 if (h_token)
3996 CloseHandle (h_token);
3998 return ret_val;
4001 static int
4002 restore_privilege (TOKEN_PRIVILEGES *priv)
4004 DWORD priv_size = sizeof (*priv);
4005 HANDLE h_token = NULL;
4006 int ret_val = 0;
4008 if (open_thread_token (GetCurrentThread (),
4009 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
4010 FALSE, &h_token))
4012 if (AdjustTokenPrivileges (h_token, FALSE, priv, priv_size, NULL, NULL)
4013 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
4014 ret_val = 1;
4016 if (h_token)
4017 CloseHandle (h_token);
4019 return ret_val;
4022 static Lisp_Object
4023 ltime (long time_sec, long time_usec)
4025 return list3 (make_number ((time_sec >> 16) & 0xffff),
4026 make_number (time_sec & 0xffff),
4027 make_number (time_usec));
4030 #define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
4032 static int
4033 process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
4034 Lisp_Object *stime, Lisp_Object *utime, Lisp_Object *ttime,
4035 double *pcpu)
4037 FILETIME ft_creation, ft_exit, ft_kernel, ft_user, ft_current;
4038 ULONGLONG tem1, tem2, tem3, tem;
4040 if (!h_proc
4041 || !get_process_times_fn
4042 || !(*get_process_times_fn) (h_proc, &ft_creation, &ft_exit,
4043 &ft_kernel, &ft_user))
4044 return 0;
4046 GetSystemTimeAsFileTime (&ft_current);
4048 FILETIME_TO_U64 (tem1, ft_kernel);
4049 tem1 /= 10L;
4050 *stime = U64_TO_LISP_TIME (tem1);
4052 FILETIME_TO_U64 (tem2, ft_user);
4053 tem2 /= 10L;
4054 *utime = U64_TO_LISP_TIME (tem2);
4056 tem3 = tem1 + tem2;
4057 *ttime = U64_TO_LISP_TIME (tem3);
4059 FILETIME_TO_U64 (tem, ft_creation);
4060 /* Process no 4 (System) returns zero creation time. */
4061 if (tem)
4062 tem = (tem - utc_base) / 10L;
4063 *ctime = U64_TO_LISP_TIME (tem);
4065 if (tem)
4067 FILETIME_TO_U64 (tem3, ft_current);
4068 tem = (tem3 - utc_base) / 10L - tem;
4070 *etime = U64_TO_LISP_TIME (tem);
4072 if (tem)
4074 *pcpu = 100.0 * (tem1 + tem2) / tem;
4075 if (*pcpu > 100)
4076 *pcpu = 100.0;
4078 else
4079 *pcpu = 0;
4081 return 1;
4084 Lisp_Object
4085 system_process_attributes (Lisp_Object pid)
4087 struct gcpro gcpro1, gcpro2, gcpro3;
4088 Lisp_Object attrs = Qnil;
4089 Lisp_Object cmd_str, decoded_cmd, tem;
4090 HANDLE h_snapshot, h_proc;
4091 DWORD proc_id;
4092 int found_proc = 0;
4093 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
4094 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
4095 DWORD glength = sizeof (gname);
4096 HANDLE token = NULL;
4097 SID_NAME_USE user_type;
4098 unsigned char *buf = NULL;
4099 DWORD blen = 0;
4100 TOKEN_USER user_token;
4101 TOKEN_PRIMARY_GROUP group_token;
4102 unsigned euid;
4103 unsigned egid;
4104 PROCESS_MEMORY_COUNTERS mem;
4105 PROCESS_MEMORY_COUNTERS_EX mem_ex;
4106 DWORD minrss, maxrss;
4107 MEMORYSTATUS memst;
4108 MEMORY_STATUS_EX memstex;
4109 double totphys = 0.0;
4110 Lisp_Object ctime, stime, utime, etime, ttime;
4111 double pcpu;
4112 BOOL result = FALSE;
4114 CHECK_NUMBER_OR_FLOAT (pid);
4115 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
4117 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
4119 GCPRO3 (attrs, decoded_cmd, tem);
4121 if (h_snapshot != INVALID_HANDLE_VALUE)
4123 PROCESSENTRY32 pe;
4124 BOOL res;
4126 pe.dwSize = sizeof (PROCESSENTRY32);
4127 for (res = process32_first (h_snapshot, &pe); res;
4128 res = process32_next (h_snapshot, &pe))
4130 if (proc_id == pe.th32ProcessID)
4132 if (proc_id == 0)
4133 decoded_cmd = build_string ("Idle");
4134 else
4136 /* Decode the command name from locale-specific
4137 encoding. */
4138 cmd_str = make_unibyte_string (pe.szExeFile,
4139 strlen (pe.szExeFile));
4140 decoded_cmd =
4141 code_convert_string_norecord (cmd_str,
4142 Vlocale_coding_system, 0);
4144 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
4145 attrs = Fcons (Fcons (Qppid,
4146 make_fixnum_or_float (pe.th32ParentProcessID)),
4147 attrs);
4148 attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
4149 attrs);
4150 attrs = Fcons (Fcons (Qthcount,
4151 make_fixnum_or_float (pe.cntThreads)),
4152 attrs);
4153 found_proc = 1;
4154 break;
4158 CloseHandle (h_snapshot);
4161 if (!found_proc)
4163 UNGCPRO;
4164 return Qnil;
4167 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4168 FALSE, proc_id);
4169 /* If we were denied a handle to the process, try again after
4170 enabling the SeDebugPrivilege in our process. */
4171 if (!h_proc)
4173 TOKEN_PRIVILEGES priv_current;
4175 if (enable_privilege (SE_DEBUG_NAME, TRUE, &priv_current))
4177 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4178 FALSE, proc_id);
4179 restore_privilege (&priv_current);
4180 revert_to_self ();
4183 if (h_proc)
4185 result = open_process_token (h_proc, TOKEN_QUERY, &token);
4186 if (result)
4188 result = get_token_information (token, TokenUser, NULL, 0, &blen);
4189 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
4191 buf = xmalloc (blen);
4192 result = get_token_information (token, TokenUser,
4193 (LPVOID)buf, blen, &needed);
4194 if (result)
4196 memcpy (&user_token, buf, sizeof (user_token));
4197 if (!w32_cached_id (user_token.User.Sid, &euid, uname))
4199 euid = get_rid (user_token.User.Sid);
4200 result = lookup_account_sid (NULL, user_token.User.Sid,
4201 uname, &ulength,
4202 domain, &dlength,
4203 &user_type);
4204 if (result)
4205 w32_add_to_cache (user_token.User.Sid, euid, uname);
4206 else
4208 strcpy (uname, "unknown");
4209 result = TRUE;
4212 ulength = strlen (uname);
4216 if (result)
4218 /* Determine a reasonable euid and gid values. */
4219 if (xstrcasecmp ("administrator", uname) == 0)
4221 euid = 500; /* well-known Administrator uid */
4222 egid = 513; /* well-known None gid */
4224 else
4226 /* Get group id and name. */
4227 result = get_token_information (token, TokenPrimaryGroup,
4228 (LPVOID)buf, blen, &needed);
4229 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
4231 buf = xrealloc (buf, blen = needed);
4232 result = get_token_information (token, TokenPrimaryGroup,
4233 (LPVOID)buf, blen, &needed);
4235 if (result)
4237 memcpy (&group_token, buf, sizeof (group_token));
4238 if (!w32_cached_id (group_token.PrimaryGroup, &egid, gname))
4240 egid = get_rid (group_token.PrimaryGroup);
4241 dlength = sizeof (domain);
4242 result =
4243 lookup_account_sid (NULL, group_token.PrimaryGroup,
4244 gname, &glength, NULL, &dlength,
4245 &user_type);
4246 if (result)
4247 w32_add_to_cache (group_token.PrimaryGroup,
4248 egid, gname);
4249 else
4251 strcpy (gname, "None");
4252 result = TRUE;
4255 glength = strlen (gname);
4259 xfree (buf);
4261 if (!result)
4263 if (!is_windows_9x ())
4265 /* We couldn't open the process token, presumably because of
4266 insufficient access rights. Assume this process is run
4267 by the system. */
4268 strcpy (uname, "SYSTEM");
4269 strcpy (gname, "None");
4270 euid = 18; /* SYSTEM */
4271 egid = 513; /* None */
4272 glength = strlen (gname);
4273 ulength = strlen (uname);
4275 /* If we are running under Windows 9X, where security calls are
4276 not supported, we assume all processes are run by the current
4277 user. */
4278 else if (GetUserName (uname, &ulength))
4280 if (xstrcasecmp ("administrator", uname) == 0)
4281 euid = 0;
4282 else
4283 euid = 123;
4284 egid = euid;
4285 strcpy (gname, "None");
4286 glength = strlen (gname);
4287 ulength = strlen (uname);
4289 else
4291 euid = 123;
4292 egid = 123;
4293 strcpy (uname, "administrator");
4294 ulength = strlen (uname);
4295 strcpy (gname, "None");
4296 glength = strlen (gname);
4298 if (token)
4299 CloseHandle (token);
4302 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (euid)), attrs);
4303 tem = make_unibyte_string (uname, ulength);
4304 attrs = Fcons (Fcons (Quser,
4305 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
4306 attrs);
4307 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (egid)), attrs);
4308 tem = make_unibyte_string (gname, glength);
4309 attrs = Fcons (Fcons (Qgroup,
4310 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
4311 attrs);
4313 if (global_memory_status_ex (&memstex))
4314 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
4315 totphys = memstex.ullTotalPhys / 1024.0;
4316 #else
4317 /* Visual Studio 6 cannot convert an unsigned __int64 type to
4318 double, so we need to do this for it... */
4320 DWORD tot_hi = memstex.ullTotalPhys >> 32;
4321 DWORD tot_md = (memstex.ullTotalPhys & 0x00000000ffffffff) >> 10;
4322 DWORD tot_lo = memstex.ullTotalPhys % 1024;
4324 totphys = tot_hi * 4194304.0 + tot_md + tot_lo / 1024.0;
4326 #endif /* __GNUC__ || _MSC_VER >= 1300 */
4327 else if (global_memory_status (&memst))
4328 totphys = memst.dwTotalPhys / 1024.0;
4330 if (h_proc
4331 && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
4332 sizeof (mem_ex)))
4334 DWORD rss = mem_ex.WorkingSetSize / 1024;
4336 attrs = Fcons (Fcons (Qmajflt,
4337 make_fixnum_or_float (mem_ex.PageFaultCount)),
4338 attrs);
4339 attrs = Fcons (Fcons (Qvsize,
4340 make_fixnum_or_float (mem_ex.PrivateUsage / 1024)),
4341 attrs);
4342 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
4343 if (totphys)
4344 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4346 else if (h_proc
4347 && get_process_memory_info (h_proc, &mem, sizeof (mem)))
4349 DWORD rss = mem_ex.WorkingSetSize / 1024;
4351 attrs = Fcons (Fcons (Qmajflt,
4352 make_fixnum_or_float (mem.PageFaultCount)),
4353 attrs);
4354 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
4355 if (totphys)
4356 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4358 else if (h_proc
4359 && get_process_working_set_size (h_proc, &minrss, &maxrss))
4361 DWORD rss = maxrss / 1024;
4363 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (maxrss / 1024)), attrs);
4364 if (totphys)
4365 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4368 if (process_times (h_proc, &ctime, &etime, &stime, &utime, &ttime, &pcpu))
4370 attrs = Fcons (Fcons (Qutime, utime), attrs);
4371 attrs = Fcons (Fcons (Qstime, stime), attrs);
4372 attrs = Fcons (Fcons (Qtime, ttime), attrs);
4373 attrs = Fcons (Fcons (Qstart, ctime), attrs);
4374 attrs = Fcons (Fcons (Qetime, etime), attrs);
4375 attrs = Fcons (Fcons (Qpcpu, make_float (pcpu)), attrs);
4378 /* FIXME: Retrieve command line by walking the PEB of the process. */
4380 if (h_proc)
4381 CloseHandle (h_proc);
4382 UNGCPRO;
4383 return attrs;
4387 /* Wrappers for winsock functions to map between our file descriptors
4388 and winsock's handles; also set h_errno for convenience.
4390 To allow Emacs to run on systems which don't have winsock support
4391 installed, we dynamically link to winsock on startup if present, and
4392 otherwise provide the minimum necessary functionality
4393 (eg. gethostname). */
4395 /* function pointers for relevant socket functions */
4396 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
4397 void (PASCAL *pfn_WSASetLastError) (int iError);
4398 int (PASCAL *pfn_WSAGetLastError) (void);
4399 int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
4400 HANDLE (PASCAL *pfn_WSACreateEvent) (void);
4401 int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
4402 int (PASCAL *pfn_socket) (int af, int type, int protocol);
4403 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
4404 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
4405 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
4406 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
4407 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
4408 int (PASCAL *pfn_closesocket) (SOCKET s);
4409 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
4410 int (PASCAL *pfn_WSACleanup) (void);
4412 u_short (PASCAL *pfn_htons) (u_short hostshort);
4413 u_short (PASCAL *pfn_ntohs) (u_short netshort);
4414 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
4415 int (PASCAL *pfn_gethostname) (char * name, int namelen);
4416 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
4417 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
4418 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
4419 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
4420 const char * optval, int optlen);
4421 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
4422 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
4423 int * namelen);
4424 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
4425 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
4426 struct sockaddr * from, int * fromlen);
4427 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
4428 const struct sockaddr * to, int tolen);
4430 /* SetHandleInformation is only needed to make sockets non-inheritable. */
4431 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
4432 #ifndef HANDLE_FLAG_INHERIT
4433 #define HANDLE_FLAG_INHERIT 1
4434 #endif
4436 HANDLE winsock_lib;
4437 static int winsock_inuse;
4439 BOOL
4440 term_winsock (void)
4442 if (winsock_lib != NULL && winsock_inuse == 0)
4444 /* Not sure what would cause WSAENETDOWN, or even if it can happen
4445 after WSAStartup returns successfully, but it seems reasonable
4446 to allow unloading winsock anyway in that case. */
4447 if (pfn_WSACleanup () == 0 ||
4448 pfn_WSAGetLastError () == WSAENETDOWN)
4450 if (FreeLibrary (winsock_lib))
4451 winsock_lib = NULL;
4452 return TRUE;
4455 return FALSE;
4458 BOOL
4459 init_winsock (int load_now)
4461 WSADATA winsockData;
4463 if (winsock_lib != NULL)
4464 return TRUE;
4466 pfn_SetHandleInformation
4467 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
4468 "SetHandleInformation");
4470 winsock_lib = LoadLibrary ("Ws2_32.dll");
4472 if (winsock_lib != NULL)
4474 /* dynamically link to socket functions */
4476 #define LOAD_PROC(fn) \
4477 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
4478 goto fail;
4480 LOAD_PROC (WSAStartup);
4481 LOAD_PROC (WSASetLastError);
4482 LOAD_PROC (WSAGetLastError);
4483 LOAD_PROC (WSAEventSelect);
4484 LOAD_PROC (WSACreateEvent);
4485 LOAD_PROC (WSACloseEvent);
4486 LOAD_PROC (socket);
4487 LOAD_PROC (bind);
4488 LOAD_PROC (connect);
4489 LOAD_PROC (ioctlsocket);
4490 LOAD_PROC (recv);
4491 LOAD_PROC (send);
4492 LOAD_PROC (closesocket);
4493 LOAD_PROC (shutdown);
4494 LOAD_PROC (htons);
4495 LOAD_PROC (ntohs);
4496 LOAD_PROC (inet_addr);
4497 LOAD_PROC (gethostname);
4498 LOAD_PROC (gethostbyname);
4499 LOAD_PROC (getservbyname);
4500 LOAD_PROC (getpeername);
4501 LOAD_PROC (WSACleanup);
4502 LOAD_PROC (setsockopt);
4503 LOAD_PROC (listen);
4504 LOAD_PROC (getsockname);
4505 LOAD_PROC (accept);
4506 LOAD_PROC (recvfrom);
4507 LOAD_PROC (sendto);
4508 #undef LOAD_PROC
4510 /* specify version 1.1 of winsock */
4511 if (pfn_WSAStartup (0x101, &winsockData) == 0)
4513 if (winsockData.wVersion != 0x101)
4514 goto fail;
4516 if (!load_now)
4518 /* Report that winsock exists and is usable, but leave
4519 socket functions disabled. I am assuming that calling
4520 WSAStartup does not require any network interaction,
4521 and in particular does not cause or require a dial-up
4522 connection to be established. */
4524 pfn_WSACleanup ();
4525 FreeLibrary (winsock_lib);
4526 winsock_lib = NULL;
4528 winsock_inuse = 0;
4529 return TRUE;
4532 fail:
4533 FreeLibrary (winsock_lib);
4534 winsock_lib = NULL;
4537 return FALSE;
4541 int h_errno = 0;
4543 /* function to set h_errno for compatibility; map winsock error codes to
4544 normal system codes where they overlap (non-overlapping definitions
4545 are already in <sys/socket.h> */
4546 static void
4547 set_errno (void)
4549 if (winsock_lib == NULL)
4550 h_errno = EINVAL;
4551 else
4552 h_errno = pfn_WSAGetLastError ();
4554 switch (h_errno)
4556 case WSAEACCES: h_errno = EACCES; break;
4557 case WSAEBADF: h_errno = EBADF; break;
4558 case WSAEFAULT: h_errno = EFAULT; break;
4559 case WSAEINTR: h_errno = EINTR; break;
4560 case WSAEINVAL: h_errno = EINVAL; break;
4561 case WSAEMFILE: h_errno = EMFILE; break;
4562 case WSAENAMETOOLONG: h_errno = ENAMETOOLONG; break;
4563 case WSAENOTEMPTY: h_errno = ENOTEMPTY; break;
4565 errno = h_errno;
4568 static void
4569 check_errno (void)
4571 if (h_errno == 0 && winsock_lib != NULL)
4572 pfn_WSASetLastError (0);
4575 /* Extend strerror to handle the winsock-specific error codes. */
4576 struct {
4577 int errnum;
4578 char * msg;
4579 } _wsa_errlist[] = {
4580 {WSAEINTR , "Interrupted function call"},
4581 {WSAEBADF , "Bad file descriptor"},
4582 {WSAEACCES , "Permission denied"},
4583 {WSAEFAULT , "Bad address"},
4584 {WSAEINVAL , "Invalid argument"},
4585 {WSAEMFILE , "Too many open files"},
4587 {WSAEWOULDBLOCK , "Resource temporarily unavailable"},
4588 {WSAEINPROGRESS , "Operation now in progress"},
4589 {WSAEALREADY , "Operation already in progress"},
4590 {WSAENOTSOCK , "Socket operation on non-socket"},
4591 {WSAEDESTADDRREQ , "Destination address required"},
4592 {WSAEMSGSIZE , "Message too long"},
4593 {WSAEPROTOTYPE , "Protocol wrong type for socket"},
4594 {WSAENOPROTOOPT , "Bad protocol option"},
4595 {WSAEPROTONOSUPPORT , "Protocol not supported"},
4596 {WSAESOCKTNOSUPPORT , "Socket type not supported"},
4597 {WSAEOPNOTSUPP , "Operation not supported"},
4598 {WSAEPFNOSUPPORT , "Protocol family not supported"},
4599 {WSAEAFNOSUPPORT , "Address family not supported by protocol family"},
4600 {WSAEADDRINUSE , "Address already in use"},
4601 {WSAEADDRNOTAVAIL , "Cannot assign requested address"},
4602 {WSAENETDOWN , "Network is down"},
4603 {WSAENETUNREACH , "Network is unreachable"},
4604 {WSAENETRESET , "Network dropped connection on reset"},
4605 {WSAECONNABORTED , "Software caused connection abort"},
4606 {WSAECONNRESET , "Connection reset by peer"},
4607 {WSAENOBUFS , "No buffer space available"},
4608 {WSAEISCONN , "Socket is already connected"},
4609 {WSAENOTCONN , "Socket is not connected"},
4610 {WSAESHUTDOWN , "Cannot send after socket shutdown"},
4611 {WSAETOOMANYREFS , "Too many references"}, /* not sure */
4612 {WSAETIMEDOUT , "Connection timed out"},
4613 {WSAECONNREFUSED , "Connection refused"},
4614 {WSAELOOP , "Network loop"}, /* not sure */
4615 {WSAENAMETOOLONG , "Name is too long"},
4616 {WSAEHOSTDOWN , "Host is down"},
4617 {WSAEHOSTUNREACH , "No route to host"},
4618 {WSAENOTEMPTY , "Buffer not empty"}, /* not sure */
4619 {WSAEPROCLIM , "Too many processes"},
4620 {WSAEUSERS , "Too many users"}, /* not sure */
4621 {WSAEDQUOT , "Double quote in host name"}, /* really not sure */
4622 {WSAESTALE , "Data is stale"}, /* not sure */
4623 {WSAEREMOTE , "Remote error"}, /* not sure */
4625 {WSASYSNOTREADY , "Network subsystem is unavailable"},
4626 {WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range"},
4627 {WSANOTINITIALISED , "Winsock not initialized successfully"},
4628 {WSAEDISCON , "Graceful shutdown in progress"},
4629 #ifdef WSAENOMORE
4630 {WSAENOMORE , "No more operations allowed"}, /* not sure */
4631 {WSAECANCELLED , "Operation cancelled"}, /* not sure */
4632 {WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider"},
4633 {WSAEINVALIDPROVIDER , "Invalid service provider version number"},
4634 {WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider"},
4635 {WSASYSCALLFAILURE , "System call failure"},
4636 {WSASERVICE_NOT_FOUND , "Service not found"}, /* not sure */
4637 {WSATYPE_NOT_FOUND , "Class type not found"},
4638 {WSA_E_NO_MORE , "No more resources available"}, /* really not sure */
4639 {WSA_E_CANCELLED , "Operation already cancelled"}, /* really not sure */
4640 {WSAEREFUSED , "Operation refused"}, /* not sure */
4641 #endif
4643 {WSAHOST_NOT_FOUND , "Host not found"},
4644 {WSATRY_AGAIN , "Authoritative host not found during name lookup"},
4645 {WSANO_RECOVERY , "Non-recoverable error during name lookup"},
4646 {WSANO_DATA , "Valid name, no data record of requested type"},
4648 {-1, NULL}
4651 char *
4652 sys_strerror (int error_no)
4654 int i;
4655 static char unknown_msg[40];
4657 if (error_no >= 0 && error_no < sys_nerr)
4658 return sys_errlist[error_no];
4660 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
4661 if (_wsa_errlist[i].errnum == error_no)
4662 return _wsa_errlist[i].msg;
4664 sprintf (unknown_msg, "Unidentified error: %d", error_no);
4665 return unknown_msg;
4668 /* [andrewi 3-May-96] I've had conflicting results using both methods,
4669 but I believe the method of keeping the socket handle separate (and
4670 insuring it is not inheritable) is the correct one. */
4672 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
4674 static int socket_to_fd (SOCKET s);
4677 sys_socket (int af, int type, int protocol)
4679 SOCKET s;
4681 if (winsock_lib == NULL)
4683 h_errno = ENETDOWN;
4684 return INVALID_SOCKET;
4687 check_errno ();
4689 /* call the real socket function */
4690 s = pfn_socket (af, type, protocol);
4692 if (s != INVALID_SOCKET)
4693 return socket_to_fd (s);
4695 set_errno ();
4696 return -1;
4699 /* Convert a SOCKET to a file descriptor. */
4700 static int
4701 socket_to_fd (SOCKET s)
4703 int fd;
4704 child_process * cp;
4706 /* Although under NT 3.5 _open_osfhandle will accept a socket
4707 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
4708 that does not work under NT 3.1. However, we can get the same
4709 effect by using a backdoor function to replace an existing
4710 descriptor handle with the one we want. */
4712 /* allocate a file descriptor (with appropriate flags) */
4713 fd = _open ("NUL:", _O_RDWR);
4714 if (fd >= 0)
4716 /* Make a non-inheritable copy of the socket handle. Note
4717 that it is possible that sockets aren't actually kernel
4718 handles, which appears to be the case on Windows 9x when
4719 the MS Proxy winsock client is installed. */
4721 /* Apparently there is a bug in NT 3.51 with some service
4722 packs, which prevents using DuplicateHandle to make a
4723 socket handle non-inheritable (causes WSACleanup to
4724 hang). The work-around is to use SetHandleInformation
4725 instead if it is available and implemented. */
4726 if (pfn_SetHandleInformation)
4728 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
4730 else
4732 HANDLE parent = GetCurrentProcess ();
4733 HANDLE new_s = INVALID_HANDLE_VALUE;
4735 if (DuplicateHandle (parent,
4736 (HANDLE) s,
4737 parent,
4738 &new_s,
4740 FALSE,
4741 DUPLICATE_SAME_ACCESS))
4743 /* It is possible that DuplicateHandle succeeds even
4744 though the socket wasn't really a kernel handle,
4745 because a real handle has the same value. So
4746 test whether the new handle really is a socket. */
4747 long nonblocking = 0;
4748 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
4750 pfn_closesocket (s);
4751 s = (SOCKET) new_s;
4753 else
4755 CloseHandle (new_s);
4760 fd_info[fd].hnd = (HANDLE) s;
4762 /* set our own internal flags */
4763 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
4765 cp = new_child ();
4766 if (cp)
4768 cp->fd = fd;
4769 cp->status = STATUS_READ_ACKNOWLEDGED;
4771 /* attach child_process to fd_info */
4772 if (fd_info[ fd ].cp != NULL)
4774 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
4775 abort ();
4778 fd_info[ fd ].cp = cp;
4780 /* success! */
4781 winsock_inuse++; /* count open sockets */
4782 return fd;
4785 /* clean up */
4786 _close (fd);
4788 pfn_closesocket (s);
4789 h_errno = EMFILE;
4790 return -1;
4794 sys_bind (int s, const struct sockaddr * addr, int namelen)
4796 if (winsock_lib == NULL)
4798 h_errno = ENOTSOCK;
4799 return SOCKET_ERROR;
4802 check_errno ();
4803 if (fd_info[s].flags & FILE_SOCKET)
4805 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
4806 if (rc == SOCKET_ERROR)
4807 set_errno ();
4808 return rc;
4810 h_errno = ENOTSOCK;
4811 return SOCKET_ERROR;
4815 sys_connect (int s, const struct sockaddr * name, int namelen)
4817 if (winsock_lib == NULL)
4819 h_errno = ENOTSOCK;
4820 return SOCKET_ERROR;
4823 check_errno ();
4824 if (fd_info[s].flags & FILE_SOCKET)
4826 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
4827 if (rc == SOCKET_ERROR)
4828 set_errno ();
4829 return rc;
4831 h_errno = ENOTSOCK;
4832 return SOCKET_ERROR;
4835 u_short
4836 sys_htons (u_short hostshort)
4838 return (winsock_lib != NULL) ?
4839 pfn_htons (hostshort) : hostshort;
4842 u_short
4843 sys_ntohs (u_short netshort)
4845 return (winsock_lib != NULL) ?
4846 pfn_ntohs (netshort) : netshort;
4849 unsigned long
4850 sys_inet_addr (const char * cp)
4852 return (winsock_lib != NULL) ?
4853 pfn_inet_addr (cp) : INADDR_NONE;
4857 sys_gethostname (char * name, int namelen)
4859 if (winsock_lib != NULL)
4860 return pfn_gethostname (name, namelen);
4862 if (namelen > MAX_COMPUTERNAME_LENGTH)
4863 return !GetComputerName (name, (DWORD *)&namelen);
4865 h_errno = EFAULT;
4866 return SOCKET_ERROR;
4869 struct hostent *
4870 sys_gethostbyname (const char * name)
4872 struct hostent * host;
4874 if (winsock_lib == NULL)
4876 h_errno = ENETDOWN;
4877 return NULL;
4880 check_errno ();
4881 host = pfn_gethostbyname (name);
4882 if (!host)
4883 set_errno ();
4884 return host;
4887 struct servent *
4888 sys_getservbyname (const char * name, const char * proto)
4890 struct servent * serv;
4892 if (winsock_lib == NULL)
4894 h_errno = ENETDOWN;
4895 return NULL;
4898 check_errno ();
4899 serv = pfn_getservbyname (name, proto);
4900 if (!serv)
4901 set_errno ();
4902 return serv;
4906 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
4908 if (winsock_lib == NULL)
4910 h_errno = ENETDOWN;
4911 return SOCKET_ERROR;
4914 check_errno ();
4915 if (fd_info[s].flags & FILE_SOCKET)
4917 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
4918 if (rc == SOCKET_ERROR)
4919 set_errno ();
4920 return rc;
4922 h_errno = ENOTSOCK;
4923 return SOCKET_ERROR;
4927 sys_shutdown (int s, int how)
4929 if (winsock_lib == NULL)
4931 h_errno = ENETDOWN;
4932 return SOCKET_ERROR;
4935 check_errno ();
4936 if (fd_info[s].flags & FILE_SOCKET)
4938 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
4939 if (rc == SOCKET_ERROR)
4940 set_errno ();
4941 return rc;
4943 h_errno = ENOTSOCK;
4944 return SOCKET_ERROR;
4948 sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
4950 if (winsock_lib == NULL)
4952 h_errno = ENETDOWN;
4953 return SOCKET_ERROR;
4956 check_errno ();
4957 if (fd_info[s].flags & FILE_SOCKET)
4959 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
4960 (const char *)optval, optlen);
4961 if (rc == SOCKET_ERROR)
4962 set_errno ();
4963 return rc;
4965 h_errno = ENOTSOCK;
4966 return SOCKET_ERROR;
4970 sys_listen (int s, int backlog)
4972 if (winsock_lib == NULL)
4974 h_errno = ENETDOWN;
4975 return SOCKET_ERROR;
4978 check_errno ();
4979 if (fd_info[s].flags & FILE_SOCKET)
4981 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
4982 if (rc == SOCKET_ERROR)
4983 set_errno ();
4984 else
4985 fd_info[s].flags |= FILE_LISTEN;
4986 return rc;
4988 h_errno = ENOTSOCK;
4989 return SOCKET_ERROR;
4993 sys_getsockname (int s, struct sockaddr * name, int * namelen)
4995 if (winsock_lib == NULL)
4997 h_errno = ENETDOWN;
4998 return SOCKET_ERROR;
5001 check_errno ();
5002 if (fd_info[s].flags & FILE_SOCKET)
5004 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
5005 if (rc == SOCKET_ERROR)
5006 set_errno ();
5007 return rc;
5009 h_errno = ENOTSOCK;
5010 return SOCKET_ERROR;
5014 sys_accept (int s, struct sockaddr * addr, int * addrlen)
5016 if (winsock_lib == NULL)
5018 h_errno = ENETDOWN;
5019 return -1;
5022 check_errno ();
5023 if (fd_info[s].flags & FILE_LISTEN)
5025 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
5026 int fd = -1;
5027 if (t == INVALID_SOCKET)
5028 set_errno ();
5029 else
5030 fd = socket_to_fd (t);
5032 fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
5033 ResetEvent (fd_info[s].cp->char_avail);
5034 return fd;
5036 h_errno = ENOTSOCK;
5037 return -1;
5041 sys_recvfrom (int s, char * buf, int len, int flags,
5042 struct sockaddr * from, int * fromlen)
5044 if (winsock_lib == NULL)
5046 h_errno = ENETDOWN;
5047 return SOCKET_ERROR;
5050 check_errno ();
5051 if (fd_info[s].flags & FILE_SOCKET)
5053 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
5054 if (rc == SOCKET_ERROR)
5055 set_errno ();
5056 return rc;
5058 h_errno = ENOTSOCK;
5059 return SOCKET_ERROR;
5063 sys_sendto (int s, const char * buf, int len, int flags,
5064 const struct sockaddr * to, int tolen)
5066 if (winsock_lib == NULL)
5068 h_errno = ENETDOWN;
5069 return SOCKET_ERROR;
5072 check_errno ();
5073 if (fd_info[s].flags & FILE_SOCKET)
5075 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
5076 if (rc == SOCKET_ERROR)
5077 set_errno ();
5078 return rc;
5080 h_errno = ENOTSOCK;
5081 return SOCKET_ERROR;
5084 /* Windows does not have an fcntl function. Provide an implementation
5085 solely for making sockets non-blocking. */
5087 fcntl (int s, int cmd, int options)
5089 if (winsock_lib == NULL)
5091 h_errno = ENETDOWN;
5092 return -1;
5095 check_errno ();
5096 if (fd_info[s].flags & FILE_SOCKET)
5098 if (cmd == F_SETFL && options == O_NDELAY)
5100 unsigned long nblock = 1;
5101 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
5102 if (rc == SOCKET_ERROR)
5103 set_errno ();
5104 /* Keep track of the fact that we set this to non-blocking. */
5105 fd_info[s].flags |= FILE_NDELAY;
5106 return rc;
5108 else
5110 h_errno = EINVAL;
5111 return SOCKET_ERROR;
5114 h_errno = ENOTSOCK;
5115 return SOCKET_ERROR;
5119 /* Shadow main io functions: we need to handle pipes and sockets more
5120 intelligently, and implement non-blocking mode as well. */
5123 sys_close (int fd)
5125 int rc;
5127 if (fd < 0)
5129 errno = EBADF;
5130 return -1;
5133 if (fd < MAXDESC && fd_info[fd].cp)
5135 child_process * cp = fd_info[fd].cp;
5137 fd_info[fd].cp = NULL;
5139 if (CHILD_ACTIVE (cp))
5141 /* if last descriptor to active child_process then cleanup */
5142 int i;
5143 for (i = 0; i < MAXDESC; i++)
5145 if (i == fd)
5146 continue;
5147 if (fd_info[i].cp == cp)
5148 break;
5150 if (i == MAXDESC)
5152 if (fd_info[fd].flags & FILE_SOCKET)
5154 if (winsock_lib == NULL) abort ();
5156 pfn_shutdown (SOCK_HANDLE (fd), 2);
5157 rc = pfn_closesocket (SOCK_HANDLE (fd));
5159 winsock_inuse--; /* count open sockets */
5161 delete_child (cp);
5166 /* Note that sockets do not need special treatment here (at least on
5167 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5168 closesocket is equivalent to CloseHandle, which is to be expected
5169 because socket handles are fully fledged kernel handles. */
5170 rc = _close (fd);
5172 if (rc == 0 && fd < MAXDESC)
5173 fd_info[fd].flags = 0;
5175 return rc;
5179 sys_dup (int fd)
5181 int new_fd;
5183 new_fd = _dup (fd);
5184 if (new_fd >= 0 && new_fd < MAXDESC)
5186 /* duplicate our internal info as well */
5187 fd_info[new_fd] = fd_info[fd];
5189 return new_fd;
5193 sys_dup2 (int src, int dst)
5195 int rc;
5197 if (dst < 0 || dst >= MAXDESC)
5199 errno = EBADF;
5200 return -1;
5203 /* make sure we close the destination first if it's a pipe or socket */
5204 if (src != dst && fd_info[dst].flags != 0)
5205 sys_close (dst);
5207 rc = _dup2 (src, dst);
5208 if (rc == 0)
5210 /* duplicate our internal info as well */
5211 fd_info[dst] = fd_info[src];
5213 return rc;
5216 /* Unix pipe() has only one arg */
5218 sys_pipe (int * phandles)
5220 int rc;
5221 unsigned flags;
5223 /* make pipe handles non-inheritable; when we spawn a child, we
5224 replace the relevant handle with an inheritable one. Also put
5225 pipes into binary mode; we will do text mode translation ourselves
5226 if required. */
5227 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
5229 if (rc == 0)
5231 /* Protect against overflow, since Windows can open more handles than
5232 our fd_info array has room for. */
5233 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
5235 _close (phandles[0]);
5236 _close (phandles[1]);
5237 rc = -1;
5239 else
5241 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
5242 fd_info[phandles[0]].flags = flags;
5244 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
5245 fd_info[phandles[1]].flags = flags;
5249 return rc;
5252 /* Function to do blocking read of one byte, needed to implement
5253 select. It is only allowed on sockets and pipes. */
5255 _sys_read_ahead (int fd)
5257 child_process * cp;
5258 int rc;
5260 if (fd < 0 || fd >= MAXDESC)
5261 return STATUS_READ_ERROR;
5263 cp = fd_info[fd].cp;
5265 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
5266 return STATUS_READ_ERROR;
5268 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SERIAL | FILE_SOCKET)) == 0
5269 || (fd_info[fd].flags & FILE_READ) == 0)
5271 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd));
5272 abort ();
5275 cp->status = STATUS_READ_IN_PROGRESS;
5277 if (fd_info[fd].flags & FILE_PIPE)
5279 rc = _read (fd, &cp->chr, sizeof (char));
5281 /* Give subprocess time to buffer some more output for us before
5282 reporting that input is available; we need this because Windows 95
5283 connects DOS programs to pipes by making the pipe appear to be
5284 the normal console stdout - as a result most DOS programs will
5285 write to stdout without buffering, ie. one character at a
5286 time. Even some W32 programs do this - "dir" in a command
5287 shell on NT is very slow if we don't do this. */
5288 if (rc > 0)
5290 int wait = w32_pipe_read_delay;
5292 if (wait > 0)
5293 Sleep (wait);
5294 else if (wait < 0)
5295 while (++wait <= 0)
5296 /* Yield remainder of our time slice, effectively giving a
5297 temporary priority boost to the child process. */
5298 Sleep (0);
5301 else if (fd_info[fd].flags & FILE_SERIAL)
5303 HANDLE hnd = fd_info[fd].hnd;
5304 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
5305 COMMTIMEOUTS ct;
5307 /* Configure timeouts for blocking read. */
5308 if (!GetCommTimeouts (hnd, &ct))
5309 return STATUS_READ_ERROR;
5310 ct.ReadIntervalTimeout = 0;
5311 ct.ReadTotalTimeoutMultiplier = 0;
5312 ct.ReadTotalTimeoutConstant = 0;
5313 if (!SetCommTimeouts (hnd, &ct))
5314 return STATUS_READ_ERROR;
5316 if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
5318 if (GetLastError () != ERROR_IO_PENDING)
5319 return STATUS_READ_ERROR;
5320 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
5321 return STATUS_READ_ERROR;
5324 else if (fd_info[fd].flags & FILE_SOCKET)
5326 unsigned long nblock = 0;
5327 /* We always want this to block, so temporarily disable NDELAY. */
5328 if (fd_info[fd].flags & FILE_NDELAY)
5329 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5331 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
5333 if (fd_info[fd].flags & FILE_NDELAY)
5335 nblock = 1;
5336 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5340 if (rc == sizeof (char))
5341 cp->status = STATUS_READ_SUCCEEDED;
5342 else
5343 cp->status = STATUS_READ_FAILED;
5345 return cp->status;
5349 _sys_wait_accept (int fd)
5351 HANDLE hEv;
5352 child_process * cp;
5353 int rc;
5355 if (fd < 0 || fd >= MAXDESC)
5356 return STATUS_READ_ERROR;
5358 cp = fd_info[fd].cp;
5360 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
5361 return STATUS_READ_ERROR;
5363 cp->status = STATUS_READ_FAILED;
5365 hEv = pfn_WSACreateEvent ();
5366 rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
5367 if (rc != SOCKET_ERROR)
5369 rc = WaitForSingleObject (hEv, INFINITE);
5370 pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
5371 if (rc == WAIT_OBJECT_0)
5372 cp->status = STATUS_READ_SUCCEEDED;
5374 pfn_WSACloseEvent (hEv);
5376 return cp->status;
5380 sys_read (int fd, char * buffer, unsigned int count)
5382 int nchars;
5383 int to_read;
5384 DWORD waiting;
5385 char * orig_buffer = buffer;
5387 if (fd < 0)
5389 errno = EBADF;
5390 return -1;
5393 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
5395 child_process *cp = fd_info[fd].cp;
5397 if ((fd_info[fd].flags & FILE_READ) == 0)
5399 errno = EBADF;
5400 return -1;
5403 nchars = 0;
5405 /* re-read CR carried over from last read */
5406 if (fd_info[fd].flags & FILE_LAST_CR)
5408 if (fd_info[fd].flags & FILE_BINARY) abort ();
5409 *buffer++ = 0x0d;
5410 count--;
5411 nchars++;
5412 fd_info[fd].flags &= ~FILE_LAST_CR;
5415 /* presence of a child_process structure means we are operating in
5416 non-blocking mode - otherwise we just call _read directly.
5417 Note that the child_process structure might be missing because
5418 reap_subprocess has been called; in this case the pipe is
5419 already broken, so calling _read on it is okay. */
5420 if (cp)
5422 int current_status = cp->status;
5424 switch (current_status)
5426 case STATUS_READ_FAILED:
5427 case STATUS_READ_ERROR:
5428 /* report normal EOF if nothing in buffer */
5429 if (nchars <= 0)
5430 fd_info[fd].flags |= FILE_AT_EOF;
5431 return nchars;
5433 case STATUS_READ_READY:
5434 case STATUS_READ_IN_PROGRESS:
5435 DebPrint (("sys_read called when read is in progress\n"));
5436 errno = EWOULDBLOCK;
5437 return -1;
5439 case STATUS_READ_SUCCEEDED:
5440 /* consume read-ahead char */
5441 *buffer++ = cp->chr;
5442 count--;
5443 nchars++;
5444 cp->status = STATUS_READ_ACKNOWLEDGED;
5445 ResetEvent (cp->char_avail);
5447 case STATUS_READ_ACKNOWLEDGED:
5448 break;
5450 default:
5451 DebPrint (("sys_read: bad status %d\n", current_status));
5452 errno = EBADF;
5453 return -1;
5456 if (fd_info[fd].flags & FILE_PIPE)
5458 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
5459 to_read = min (waiting, (DWORD) count);
5461 if (to_read > 0)
5462 nchars += _read (fd, buffer, to_read);
5464 else if (fd_info[fd].flags & FILE_SERIAL)
5466 HANDLE hnd = fd_info[fd].hnd;
5467 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
5468 int rc = 0;
5469 COMMTIMEOUTS ct;
5471 if (count > 0)
5473 /* Configure timeouts for non-blocking read. */
5474 if (!GetCommTimeouts (hnd, &ct))
5476 errno = EIO;
5477 return -1;
5479 ct.ReadIntervalTimeout = MAXDWORD;
5480 ct.ReadTotalTimeoutMultiplier = 0;
5481 ct.ReadTotalTimeoutConstant = 0;
5482 if (!SetCommTimeouts (hnd, &ct))
5484 errno = EIO;
5485 return -1;
5488 if (!ResetEvent (ovl->hEvent))
5490 errno = EIO;
5491 return -1;
5493 if (!ReadFile (hnd, buffer, count, (DWORD*) &rc, ovl))
5495 if (GetLastError () != ERROR_IO_PENDING)
5497 errno = EIO;
5498 return -1;
5500 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
5502 errno = EIO;
5503 return -1;
5506 nchars += rc;
5509 else /* FILE_SOCKET */
5511 if (winsock_lib == NULL) abort ();
5513 /* do the equivalent of a non-blocking read */
5514 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
5515 if (waiting == 0 && nchars == 0)
5517 h_errno = errno = EWOULDBLOCK;
5518 return -1;
5521 if (waiting)
5523 /* always use binary mode for sockets */
5524 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
5525 if (res == SOCKET_ERROR)
5527 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
5528 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
5529 set_errno ();
5530 return -1;
5532 nchars += res;
5536 else
5538 int nread = _read (fd, buffer, count);
5539 if (nread >= 0)
5540 nchars += nread;
5541 else if (nchars == 0)
5542 nchars = nread;
5545 if (nchars <= 0)
5546 fd_info[fd].flags |= FILE_AT_EOF;
5547 /* Perform text mode translation if required. */
5548 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
5550 nchars = crlf_to_lf (nchars, orig_buffer);
5551 /* If buffer contains only CR, return that. To be absolutely
5552 sure we should attempt to read the next char, but in
5553 practice a CR to be followed by LF would not appear by
5554 itself in the buffer. */
5555 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
5557 fd_info[fd].flags |= FILE_LAST_CR;
5558 nchars--;
5562 else
5563 nchars = _read (fd, buffer, count);
5565 return nchars;
5568 /* From w32xfns.c */
5569 extern HANDLE interrupt_handle;
5571 /* For now, don't bother with a non-blocking mode */
5573 sys_write (int fd, const void * buffer, unsigned int count)
5575 int nchars;
5577 if (fd < 0)
5579 errno = EBADF;
5580 return -1;
5583 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
5585 if ((fd_info[fd].flags & FILE_WRITE) == 0)
5587 errno = EBADF;
5588 return -1;
5591 /* Perform text mode translation if required. */
5592 if ((fd_info[fd].flags & FILE_BINARY) == 0)
5594 char * tmpbuf = alloca (count * 2);
5595 unsigned char * src = (void *)buffer;
5596 unsigned char * dst = tmpbuf;
5597 int nbytes = count;
5599 while (1)
5601 unsigned char *next;
5602 /* copy next line or remaining bytes */
5603 next = _memccpy (dst, src, '\n', nbytes);
5604 if (next)
5606 /* copied one line ending with '\n' */
5607 int copied = next - dst;
5608 nbytes -= copied;
5609 src += copied;
5610 /* insert '\r' before '\n' */
5611 next[-1] = '\r';
5612 next[0] = '\n';
5613 dst = next + 1;
5614 count++;
5616 else
5617 /* copied remaining partial line -> now finished */
5618 break;
5620 buffer = tmpbuf;
5624 if (fd < MAXDESC && fd_info[fd].flags & FILE_SERIAL)
5626 HANDLE hnd = (HANDLE) _get_osfhandle (fd);
5627 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_write;
5628 HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
5629 DWORD active = 0;
5631 if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
5633 if (GetLastError () != ERROR_IO_PENDING)
5635 errno = EIO;
5636 return -1;
5638 if (detect_input_pending ())
5639 active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
5640 QS_ALLINPUT);
5641 else
5642 active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
5643 if (active == WAIT_OBJECT_0)
5644 { /* User pressed C-g, cancel write, then leave. Don't bother
5645 cleaning up as we may only get stuck in buggy drivers. */
5646 PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
5647 CancelIo (hnd);
5648 errno = EIO;
5649 return -1;
5651 if (active == WAIT_OBJECT_0 + 1
5652 && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
5654 errno = EIO;
5655 return -1;
5659 else if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
5661 unsigned long nblock = 0;
5662 if (winsock_lib == NULL) abort ();
5664 /* TODO: implement select() properly so non-blocking I/O works. */
5665 /* For now, make sure the write blocks. */
5666 if (fd_info[fd].flags & FILE_NDELAY)
5667 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5669 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
5671 /* Set the socket back to non-blocking if it was before,
5672 for other operations that support it. */
5673 if (fd_info[fd].flags & FILE_NDELAY)
5675 nblock = 1;
5676 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5679 if (nchars == SOCKET_ERROR)
5681 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
5682 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
5683 set_errno ();
5686 else
5688 /* Some networked filesystems don't like too large writes, so
5689 break them into smaller chunks. See the Comments section of
5690 the MSDN documentation of WriteFile for details behind the
5691 choice of the value of CHUNK below. See also the thread
5692 http://thread.gmane.org/gmane.comp.version-control.git/145294
5693 in the git mailing list. */
5694 const unsigned char *p = buffer;
5695 const unsigned chunk = 30 * 1024 * 1024;
5697 nchars = 0;
5698 while (count > 0)
5700 unsigned this_chunk = count < chunk ? count : chunk;
5701 int n = _write (fd, p, this_chunk);
5703 nchars += n;
5704 if (n < 0)
5706 nchars = n;
5707 break;
5709 else if (n < this_chunk)
5710 break;
5711 count -= n;
5712 p += n;
5716 return nchars;
5719 /* The Windows CRT functions are "optimized for speed", so they don't
5720 check for timezone and DST changes if they were last called less
5721 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
5722 all Emacs features that repeatedly call time functions (e.g.,
5723 display-time) are in real danger of missing timezone and DST
5724 changes. Calling tzset before each localtime call fixes that. */
5725 struct tm *
5726 sys_localtime (const time_t *t)
5728 tzset ();
5729 return localtime (t);
5734 /* Delayed loading of libraries. */
5736 Lisp_Object Vlibrary_cache;
5738 /* The argument LIBRARIES is an alist that associates a symbol
5739 LIBRARY_ID, identifying an external DLL library known to Emacs, to
5740 a list of filenames under which the library is usually found. In
5741 most cases, the argument passed as LIBRARIES is the variable
5742 `dynamic-library-alist', which is initialized to a list of common
5743 library names. If the function loads the library successfully, it
5744 returns the handle of the DLL, and records the filename in the
5745 property :loaded-from of LIBRARY_ID; it returns NULL if the library
5746 could not be found, or when it was already loaded (because the
5747 handle is not recorded anywhere, and so is lost after use). It
5748 would be trivial to save the handle too in :loaded-from, but
5749 currently there's no use case for it. */
5750 HMODULE
5751 w32_delayed_load (Lisp_Object libraries, Lisp_Object library_id)
5753 HMODULE library_dll = NULL;
5755 CHECK_SYMBOL (library_id);
5757 if (CONSP (libraries) && NILP (Fassq (library_id, Vlibrary_cache)))
5759 Lisp_Object found = Qnil;
5760 Lisp_Object dlls = Fassq (library_id, libraries);
5762 if (CONSP (dlls))
5763 for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
5765 CHECK_STRING_CAR (dlls);
5766 if ((library_dll = LoadLibrary (SDATA (XCAR (dlls)))))
5768 found = XCAR (dlls);
5769 break;
5773 Fput (library_id, QCloaded_from, found);
5776 return library_dll;
5780 static void
5781 check_windows_init_file (void)
5783 /* A common indication that Emacs is not installed properly is when
5784 it cannot find the Windows installation file. If this file does
5785 not exist in the expected place, tell the user. */
5787 if (!noninteractive && !inhibit_window_system
5788 /* Vload_path is not yet initialized when we are loading
5789 loadup.el. */
5790 && NILP (Vpurify_flag))
5792 Lisp_Object objs[2];
5793 Lisp_Object full_load_path;
5794 Lisp_Object init_file;
5795 int fd;
5797 objs[0] = Vload_path;
5798 objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
5799 full_load_path = Fappend (2, objs);
5800 init_file = build_string ("term/w32-win");
5801 fd = openp (full_load_path, init_file, Fget_load_suffixes (), NULL, Qnil);
5802 if (fd < 0)
5804 Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
5805 char *init_file_name = SDATA (init_file);
5806 char *load_path = SDATA (load_path_print);
5807 char *buffer = alloca (1024
5808 + strlen (init_file_name)
5809 + strlen (load_path));
5811 sprintf (buffer,
5812 "The Emacs Windows initialization file \"%s.el\" "
5813 "could not be found in your Emacs installation. "
5814 "Emacs checked the following directories for this file:\n"
5815 "\n%s\n\n"
5816 "When Emacs cannot find this file, it usually means that it "
5817 "was not installed properly, or its distribution file was "
5818 "not unpacked properly.\nSee the README.W32 file in the "
5819 "top-level Emacs directory for more information.",
5820 init_file_name, load_path);
5821 MessageBox (NULL,
5822 buffer,
5823 "Emacs Abort Dialog",
5824 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
5825 /* Use the low-level Emacs abort. */
5826 #undef abort
5827 abort ();
5829 else
5831 _close (fd);
5836 void
5837 term_ntproc (void)
5839 /* shutdown the socket interface if necessary */
5840 term_winsock ();
5842 term_w32select ();
5845 void
5846 init_ntproc (void)
5848 /* Initialise the socket interface now if available and requested by
5849 the user by defining PRELOAD_WINSOCK; otherwise loading will be
5850 delayed until open-network-stream is called (w32-has-winsock can
5851 also be used to dynamically load or reload winsock).
5853 Conveniently, init_environment is called before us, so
5854 PRELOAD_WINSOCK can be set in the registry. */
5856 /* Always initialize this correctly. */
5857 winsock_lib = NULL;
5859 if (getenv ("PRELOAD_WINSOCK") != NULL)
5860 init_winsock (TRUE);
5862 /* Initial preparation for subprocess support: replace our standard
5863 handles with non-inheritable versions. */
5865 HANDLE parent;
5866 HANDLE stdin_save = INVALID_HANDLE_VALUE;
5867 HANDLE stdout_save = INVALID_HANDLE_VALUE;
5868 HANDLE stderr_save = INVALID_HANDLE_VALUE;
5870 parent = GetCurrentProcess ();
5872 /* ignore errors when duplicating and closing; typically the
5873 handles will be invalid when running as a gui program. */
5874 DuplicateHandle (parent,
5875 GetStdHandle (STD_INPUT_HANDLE),
5876 parent,
5877 &stdin_save,
5879 FALSE,
5880 DUPLICATE_SAME_ACCESS);
5882 DuplicateHandle (parent,
5883 GetStdHandle (STD_OUTPUT_HANDLE),
5884 parent,
5885 &stdout_save,
5887 FALSE,
5888 DUPLICATE_SAME_ACCESS);
5890 DuplicateHandle (parent,
5891 GetStdHandle (STD_ERROR_HANDLE),
5892 parent,
5893 &stderr_save,
5895 FALSE,
5896 DUPLICATE_SAME_ACCESS);
5898 fclose (stdin);
5899 fclose (stdout);
5900 fclose (stderr);
5902 if (stdin_save != INVALID_HANDLE_VALUE)
5903 _open_osfhandle ((long) stdin_save, O_TEXT);
5904 else
5905 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
5906 _fdopen (0, "r");
5908 if (stdout_save != INVALID_HANDLE_VALUE)
5909 _open_osfhandle ((long) stdout_save, O_TEXT);
5910 else
5911 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
5912 _fdopen (1, "w");
5914 if (stderr_save != INVALID_HANDLE_VALUE)
5915 _open_osfhandle ((long) stderr_save, O_TEXT);
5916 else
5917 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
5918 _fdopen (2, "w");
5921 /* unfortunately, atexit depends on implementation of malloc */
5922 /* atexit (term_ntproc); */
5923 signal (SIGABRT, term_ntproc);
5925 /* determine which drives are fixed, for GetCachedVolumeInformation */
5927 /* GetDriveType must have trailing backslash. */
5928 char drive[] = "A:\\";
5930 /* Loop over all possible drive letters */
5931 while (*drive <= 'Z')
5933 /* Record if this drive letter refers to a fixed drive. */
5934 fixed_drives[DRIVE_INDEX (*drive)] =
5935 (GetDriveType (drive) == DRIVE_FIXED);
5937 (*drive)++;
5940 /* Reset the volume info cache. */
5941 volume_cache = NULL;
5944 /* Check to see if Emacs has been installed correctly. */
5945 check_windows_init_file ();
5949 shutdown_handler ensures that buffers' autosave files are
5950 up to date when the user logs off, or the system shuts down.
5952 static BOOL WINAPI
5953 shutdown_handler (DWORD type)
5955 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
5956 if (type == CTRL_CLOSE_EVENT /* User closes console window. */
5957 || type == CTRL_LOGOFF_EVENT /* User logs off. */
5958 || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown. */
5960 /* Shut down cleanly, making sure autosave files are up to date. */
5961 shut_down_emacs (0, 0, Qnil);
5964 /* Allow other handlers to handle this signal. */
5965 return FALSE;
5969 globals_of_w32 is used to initialize those global variables that
5970 must always be initialized on startup even when the global variable
5971 initialized is non zero (see the function main in emacs.c).
5973 void
5974 globals_of_w32 (void)
5976 HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
5978 get_process_times_fn = (GetProcessTimes_Proc)
5979 GetProcAddress (kernel32, "GetProcessTimes");
5981 DEFSYM (QCloaded_from, ":loaded-from");
5983 Vlibrary_cache = Qnil;
5984 staticpro (&Vlibrary_cache);
5986 g_b_init_is_windows_9x = 0;
5987 g_b_init_open_process_token = 0;
5988 g_b_init_get_token_information = 0;
5989 g_b_init_lookup_account_sid = 0;
5990 g_b_init_get_sid_sub_authority = 0;
5991 g_b_init_get_sid_sub_authority_count = 0;
5992 g_b_init_get_file_security = 0;
5993 g_b_init_get_security_descriptor_owner = 0;
5994 g_b_init_get_security_descriptor_group = 0;
5995 g_b_init_is_valid_sid = 0;
5996 g_b_init_create_toolhelp32_snapshot = 0;
5997 g_b_init_process32_first = 0;
5998 g_b_init_process32_next = 0;
5999 g_b_init_open_thread_token = 0;
6000 g_b_init_impersonate_self = 0;
6001 g_b_init_revert_to_self = 0;
6002 g_b_init_get_process_memory_info = 0;
6003 g_b_init_get_process_working_set_size = 0;
6004 g_b_init_global_memory_status = 0;
6005 g_b_init_global_memory_status_ex = 0;
6006 g_b_init_equal_sid = 0;
6007 g_b_init_copy_sid = 0;
6008 g_b_init_get_length_sid = 0;
6009 g_b_init_get_native_system_info = 0;
6010 g_b_init_get_system_times = 0;
6011 num_of_processors = 0;
6012 /* The following sets a handler for shutdown notifications for
6013 console apps. This actually applies to Emacs in both console and
6014 GUI modes, since we had to fool windows into thinking emacs is a
6015 console application to get console mode to work. */
6016 SetConsoleCtrlHandler (shutdown_handler, TRUE);
6018 /* "None" is the default group name on standalone workstations. */
6019 strcpy (dflt_group_name, "None");
6022 /* For make-serial-process */
6024 serial_open (char *port)
6026 HANDLE hnd;
6027 child_process *cp;
6028 int fd = -1;
6030 hnd = CreateFile (port, GENERIC_READ | GENERIC_WRITE, 0, 0,
6031 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
6032 if (hnd == INVALID_HANDLE_VALUE)
6033 error ("Could not open %s", port);
6034 fd = (int) _open_osfhandle ((int) hnd, 0);
6035 if (fd == -1)
6036 error ("Could not open %s", port);
6038 cp = new_child ();
6039 if (!cp)
6040 error ("Could not create child process");
6041 cp->fd = fd;
6042 cp->status = STATUS_READ_ACKNOWLEDGED;
6043 fd_info[ fd ].hnd = hnd;
6044 fd_info[ fd ].flags |=
6045 FILE_READ | FILE_WRITE | FILE_BINARY | FILE_SERIAL;
6046 if (fd_info[ fd ].cp != NULL)
6048 error ("fd_info[fd = %d] is already in use", fd);
6050 fd_info[ fd ].cp = cp;
6051 cp->ovl_read.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
6052 if (cp->ovl_read.hEvent == NULL)
6053 error ("Could not create read event");
6054 cp->ovl_write.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
6055 if (cp->ovl_write.hEvent == NULL)
6056 error ("Could not create write event");
6058 return fd;
6061 /* For serial-process-configure */
6062 void
6063 serial_configure (struct Lisp_Process *p, Lisp_Object contact)
6065 Lisp_Object childp2 = Qnil;
6066 Lisp_Object tem = Qnil;
6067 HANDLE hnd;
6068 DCB dcb;
6069 COMMTIMEOUTS ct;
6070 char summary[4] = "???"; /* This usually becomes "8N1". */
6072 if ((fd_info[ p->outfd ].flags & FILE_SERIAL) == 0)
6073 error ("Not a serial process");
6074 hnd = fd_info[ p->outfd ].hnd;
6076 childp2 = Fcopy_sequence (p->childp);
6078 /* Initialize timeouts for blocking read and blocking write. */
6079 if (!GetCommTimeouts (hnd, &ct))
6080 error ("GetCommTimeouts() failed");
6081 ct.ReadIntervalTimeout = 0;
6082 ct.ReadTotalTimeoutMultiplier = 0;
6083 ct.ReadTotalTimeoutConstant = 0;
6084 ct.WriteTotalTimeoutMultiplier = 0;
6085 ct.WriteTotalTimeoutConstant = 0;
6086 if (!SetCommTimeouts (hnd, &ct))
6087 error ("SetCommTimeouts() failed");
6088 /* Read port attributes and prepare default configuration. */
6089 memset (&dcb, 0, sizeof (dcb));
6090 dcb.DCBlength = sizeof (DCB);
6091 if (!GetCommState (hnd, &dcb))
6092 error ("GetCommState() failed");
6093 dcb.fBinary = TRUE;
6094 dcb.fNull = FALSE;
6095 dcb.fAbortOnError = FALSE;
6096 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
6097 dcb.ErrorChar = 0;
6098 dcb.EofChar = 0;
6099 dcb.EvtChar = 0;
6101 /* Configure speed. */
6102 if (!NILP (Fplist_member (contact, QCspeed)))
6103 tem = Fplist_get (contact, QCspeed);
6104 else
6105 tem = Fplist_get (p->childp, QCspeed);
6106 CHECK_NUMBER (tem);
6107 dcb.BaudRate = XINT (tem);
6108 childp2 = Fplist_put (childp2, QCspeed, tem);
6110 /* Configure bytesize. */
6111 if (!NILP (Fplist_member (contact, QCbytesize)))
6112 tem = Fplist_get (contact, QCbytesize);
6113 else
6114 tem = Fplist_get (p->childp, QCbytesize);
6115 if (NILP (tem))
6116 tem = make_number (8);
6117 CHECK_NUMBER (tem);
6118 if (XINT (tem) != 7 && XINT (tem) != 8)
6119 error (":bytesize must be nil (8), 7, or 8");
6120 dcb.ByteSize = XINT (tem);
6121 summary[0] = XINT (tem) + '0';
6122 childp2 = Fplist_put (childp2, QCbytesize, tem);
6124 /* Configure parity. */
6125 if (!NILP (Fplist_member (contact, QCparity)))
6126 tem = Fplist_get (contact, QCparity);
6127 else
6128 tem = Fplist_get (p->childp, QCparity);
6129 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
6130 error (":parity must be nil (no parity), `even', or `odd'");
6131 dcb.fParity = FALSE;
6132 dcb.Parity = NOPARITY;
6133 dcb.fErrorChar = FALSE;
6134 if (NILP (tem))
6136 summary[1] = 'N';
6138 else if (EQ (tem, Qeven))
6140 summary[1] = 'E';
6141 dcb.fParity = TRUE;
6142 dcb.Parity = EVENPARITY;
6143 dcb.fErrorChar = TRUE;
6145 else if (EQ (tem, Qodd))
6147 summary[1] = 'O';
6148 dcb.fParity = TRUE;
6149 dcb.Parity = ODDPARITY;
6150 dcb.fErrorChar = TRUE;
6152 childp2 = Fplist_put (childp2, QCparity, tem);
6154 /* Configure stopbits. */
6155 if (!NILP (Fplist_member (contact, QCstopbits)))
6156 tem = Fplist_get (contact, QCstopbits);
6157 else
6158 tem = Fplist_get (p->childp, QCstopbits);
6159 if (NILP (tem))
6160 tem = make_number (1);
6161 CHECK_NUMBER (tem);
6162 if (XINT (tem) != 1 && XINT (tem) != 2)
6163 error (":stopbits must be nil (1 stopbit), 1, or 2");
6164 summary[2] = XINT (tem) + '0';
6165 if (XINT (tem) == 1)
6166 dcb.StopBits = ONESTOPBIT;
6167 else if (XINT (tem) == 2)
6168 dcb.StopBits = TWOSTOPBITS;
6169 childp2 = Fplist_put (childp2, QCstopbits, tem);
6171 /* Configure flowcontrol. */
6172 if (!NILP (Fplist_member (contact, QCflowcontrol)))
6173 tem = Fplist_get (contact, QCflowcontrol);
6174 else
6175 tem = Fplist_get (p->childp, QCflowcontrol);
6176 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
6177 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6178 dcb.fOutxCtsFlow = FALSE;
6179 dcb.fOutxDsrFlow = FALSE;
6180 dcb.fDtrControl = DTR_CONTROL_DISABLE;
6181 dcb.fDsrSensitivity = FALSE;
6182 dcb.fTXContinueOnXoff = FALSE;
6183 dcb.fOutX = FALSE;
6184 dcb.fInX = FALSE;
6185 dcb.fRtsControl = RTS_CONTROL_DISABLE;
6186 dcb.XonChar = 17; /* Control-Q */
6187 dcb.XoffChar = 19; /* Control-S */
6188 if (NILP (tem))
6190 /* Already configured. */
6192 else if (EQ (tem, Qhw))
6194 dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
6195 dcb.fOutxCtsFlow = TRUE;
6197 else if (EQ (tem, Qsw))
6199 dcb.fOutX = TRUE;
6200 dcb.fInX = TRUE;
6202 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
6204 /* Activate configuration. */
6205 if (!SetCommState (hnd, &dcb))
6206 error ("SetCommState() failed");
6208 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
6209 p->childp = childp2;
6212 #ifdef HAVE_GNUTLS
6214 ssize_t
6215 emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
6217 int n, sc, err;
6218 SELECT_TYPE fdset;
6219 EMACS_TIME timeout;
6220 struct Lisp_Process *process = (struct Lisp_Process *)p;
6221 int fd = process->infd;
6223 for (;;)
6225 n = sys_read (fd, (char*)buf, sz);
6227 if (n >= 0)
6228 return n;
6230 err = errno;
6232 if (err == EWOULDBLOCK)
6234 /* Set a small timeout. */
6235 EMACS_SET_SECS_USECS (timeout, 1, 0);
6236 FD_ZERO (&fdset);
6237 FD_SET ((int)fd, &fdset);
6239 /* Use select with the timeout to poll the selector. */
6240 sc = select (fd + 1, &fdset, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
6241 &timeout);
6243 if (sc > 0)
6244 continue; /* Try again. */
6246 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
6247 Also accept select return 0 as an indicator to EAGAIN. */
6248 if (sc == 0 || errno == EWOULDBLOCK)
6249 err = EAGAIN;
6250 else
6251 err = errno; /* Other errors are just passed on. */
6254 emacs_gnutls_transport_set_errno (process->gnutls_state, err);
6256 return -1;
6260 ssize_t
6261 emacs_gnutls_push (gnutls_transport_ptr_t p, const void* buf, size_t sz)
6263 struct Lisp_Process *process = (struct Lisp_Process *)p;
6264 int fd = process->outfd;
6265 ssize_t n = sys_write (fd, buf, sz);
6267 /* 0 or more bytes written means everything went fine. */
6268 if (n >= 0)
6269 return n;
6271 /* Negative bytes written means we got an error in errno.
6272 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
6273 emacs_gnutls_transport_set_errno (process->gnutls_state,
6274 errno == EWOULDBLOCK ? EAGAIN : errno);
6276 return -1;
6278 #endif /* HAVE_GNUTLS */
6280 /* end of w32.c */