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 */
25 #include <float.h> /* for DBL_EPSILON */
33 #include <sys/utime.h>
34 #include <mbstring.h> /* for _mbspbrk */
38 /* must include CRT headers *before* config.h */
71 #define _ANONYMOUS_UNION
72 #define _ANONYMOUS_STRUCT
75 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
76 use a different name to avoid compilation problems. */
77 typedef struct _MEMORY_STATUS_EX
{
80 DWORDLONG ullTotalPhys
;
81 DWORDLONG ullAvailPhys
;
82 DWORDLONG ullTotalPageFile
;
83 DWORDLONG ullAvailPageFile
;
84 DWORDLONG ullTotalVirtual
;
85 DWORDLONG ullAvailVirtual
;
86 DWORDLONG ullAvailExtendedVirtual
;
87 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
95 #if !defined(__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
96 /* This either is not in psapi.h or guarded by higher value of
97 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
98 defines it in psapi.h */
99 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
101 DWORD PageFaultCount
;
102 DWORD PeakWorkingSetSize
;
103 DWORD WorkingSetSize
;
104 DWORD QuotaPeakPagedPoolUsage
;
105 DWORD QuotaPagedPoolUsage
;
106 DWORD QuotaPeakNonPagedPoolUsage
;
107 DWORD QuotaNonPagedPoolUsage
;
109 DWORD PeakPagefileUsage
;
111 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
114 /* TCP connection support. */
115 #include <sys/socket.h>
138 #include "dispextern.h" /* for xstrcasecmp */
139 #include "coding.h" /* for Vlocale_coding_system */
141 /* For serial_configure and serial_open. */
144 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
145 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
147 void globals_of_w32 (void);
148 static DWORD
get_rid (PSID
);
151 /* Initialization states.
153 WARNING: If you add any more such variables for additional APIs,
154 you MUST add initialization for them to globals_of_w32
155 below. This is because these variables might get set
156 to non-NULL values during dumping, but the dumped Emacs
157 cannot reuse those values, because it could be run on a
158 different version of the OS, where API addresses are
160 static BOOL g_b_init_is_windows_9x
;
161 static BOOL g_b_init_open_process_token
;
162 static BOOL g_b_init_get_token_information
;
163 static BOOL g_b_init_lookup_account_sid
;
164 static BOOL g_b_init_get_sid_sub_authority
;
165 static BOOL g_b_init_get_sid_sub_authority_count
;
166 static BOOL g_b_init_get_file_security
;
167 static BOOL g_b_init_get_security_descriptor_owner
;
168 static BOOL g_b_init_get_security_descriptor_group
;
169 static BOOL g_b_init_is_valid_sid
;
170 static BOOL g_b_init_create_toolhelp32_snapshot
;
171 static BOOL g_b_init_process32_first
;
172 static BOOL g_b_init_process32_next
;
173 static BOOL g_b_init_open_thread_token
;
174 static BOOL g_b_init_impersonate_self
;
175 static BOOL g_b_init_revert_to_self
;
176 static BOOL g_b_init_get_process_memory_info
;
177 static BOOL g_b_init_get_process_working_set_size
;
178 static BOOL g_b_init_global_memory_status
;
179 static BOOL g_b_init_global_memory_status_ex
;
180 static BOOL g_b_init_get_length_sid
;
181 static BOOL g_b_init_equal_sid
;
182 static BOOL g_b_init_copy_sid
;
183 static BOOL g_b_init_get_native_system_info
;
184 static BOOL g_b_init_get_system_times
;
187 BEGIN: Wrapper functions around OpenProcessToken
188 and other functions in advapi32.dll that are only
189 supported in Windows NT / 2k / XP
191 /* ** Function pointer typedefs ** */
192 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
193 HANDLE ProcessHandle
,
195 PHANDLE TokenHandle
);
196 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
198 TOKEN_INFORMATION_CLASS TokenInformationClass
,
199 LPVOID TokenInformation
,
200 DWORD TokenInformationLength
,
201 PDWORD ReturnLength
);
202 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
203 HANDLE process_handle
,
204 LPFILETIME creation_time
,
205 LPFILETIME exit_time
,
206 LPFILETIME kernel_time
,
207 LPFILETIME user_time
);
209 GetProcessTimes_Proc get_process_times_fn
= NULL
;
212 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
213 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
215 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
216 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
218 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
219 LPCTSTR lpSystemName
,
224 LPDWORD cbDomainName
,
225 PSID_NAME_USE peUse
);
226 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
229 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
231 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
233 SECURITY_INFORMATION RequestedInformation
,
234 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
236 LPDWORD lpnLengthNeeded
);
237 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
238 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
240 LPBOOL lpbOwnerDefaulted
);
241 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
242 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
244 LPBOOL lpbGroupDefaulted
);
245 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
247 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
249 DWORD th32ProcessID
);
250 typedef BOOL (WINAPI
* Process32First_Proc
) (
252 LPPROCESSENTRY32 lppe
);
253 typedef BOOL (WINAPI
* Process32Next_Proc
) (
255 LPPROCESSENTRY32 lppe
);
256 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
260 PHANDLE TokenHandle
);
261 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
262 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
263 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
264 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
266 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
268 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
270 DWORD
* lpMinimumWorkingSetSize
,
271 DWORD
* lpMaximumWorkingSetSize
);
272 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
273 LPMEMORYSTATUS lpBuffer
);
274 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
275 LPMEMORY_STATUS_EX lpBuffer
);
276 typedef BOOL (WINAPI
* CopySid_Proc
) (
277 DWORD nDestinationSidLength
,
278 PSID pDestinationSid
,
280 typedef BOOL (WINAPI
* EqualSid_Proc
) (
283 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
285 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
286 LPSYSTEM_INFO lpSystemInfo
);
287 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
288 LPFILETIME lpIdleTime
,
289 LPFILETIME lpKernelTime
,
290 LPFILETIME lpUserTime
);
292 /* ** A utility function ** */
296 static BOOL s_b_ret
= 0;
297 OSVERSIONINFO os_ver
;
298 if (g_b_init_is_windows_9x
== 0)
300 g_b_init_is_windows_9x
= 1;
301 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
302 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
303 if (GetVersionEx (&os_ver
))
305 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
311 /* Get total user and system times for get-internal-run-time.
312 Returns a list of three integers if the times are provided by the OS
313 (NT derivatives), otherwise it returns the result of current-time. */
315 w32_get_internal_run_time (void)
317 if (get_process_times_fn
)
319 FILETIME create
, exit
, kernel
, user
;
320 HANDLE proc
= GetCurrentProcess ();
321 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
323 LARGE_INTEGER user_int
, kernel_int
, total
;
325 user_int
.LowPart
= user
.dwLowDateTime
;
326 user_int
.HighPart
= user
.dwHighDateTime
;
327 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
328 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
329 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
330 /* FILETIME is 100 nanosecond increments, Emacs only wants
331 microsecond resolution. */
332 total
.QuadPart
/= 10;
333 microseconds
= total
.QuadPart
% 1000000;
334 total
.QuadPart
/= 1000000;
336 /* Sanity check to make sure we can represent the result. */
337 if (total
.HighPart
== 0)
339 int secs
= total
.LowPart
;
341 return list3 (make_number ((secs
>> 16) & 0xffff),
342 make_number (secs
& 0xffff),
343 make_number (microseconds
));
348 return Fcurrent_time ();
351 /* ** The wrapper functions ** */
354 open_process_token (HANDLE ProcessHandle
,
358 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
359 HMODULE hm_advapi32
= NULL
;
360 if (is_windows_9x () == TRUE
)
364 if (g_b_init_open_process_token
== 0)
366 g_b_init_open_process_token
= 1;
367 hm_advapi32
= LoadLibrary ("Advapi32.dll");
368 s_pfn_Open_Process_Token
=
369 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
371 if (s_pfn_Open_Process_Token
== NULL
)
376 s_pfn_Open_Process_Token (
384 get_token_information (HANDLE TokenHandle
,
385 TOKEN_INFORMATION_CLASS TokenInformationClass
,
386 LPVOID TokenInformation
,
387 DWORD TokenInformationLength
,
390 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
391 HMODULE hm_advapi32
= NULL
;
392 if (is_windows_9x () == TRUE
)
396 if (g_b_init_get_token_information
== 0)
398 g_b_init_get_token_information
= 1;
399 hm_advapi32
= LoadLibrary ("Advapi32.dll");
400 s_pfn_Get_Token_Information
=
401 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
403 if (s_pfn_Get_Token_Information
== NULL
)
408 s_pfn_Get_Token_Information (
410 TokenInformationClass
,
412 TokenInformationLength
,
418 lookup_account_sid (LPCTSTR lpSystemName
,
423 LPDWORD cbDomainName
,
426 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
427 HMODULE hm_advapi32
= NULL
;
428 if (is_windows_9x () == TRUE
)
432 if (g_b_init_lookup_account_sid
== 0)
434 g_b_init_lookup_account_sid
= 1;
435 hm_advapi32
= LoadLibrary ("Advapi32.dll");
436 s_pfn_Lookup_Account_Sid
=
437 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
439 if (s_pfn_Lookup_Account_Sid
== NULL
)
444 s_pfn_Lookup_Account_Sid (
456 get_sid_sub_authority (PSID pSid
, DWORD n
)
458 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
459 static DWORD zero
= 0U;
460 HMODULE hm_advapi32
= NULL
;
461 if (is_windows_9x () == TRUE
)
465 if (g_b_init_get_sid_sub_authority
== 0)
467 g_b_init_get_sid_sub_authority
= 1;
468 hm_advapi32
= LoadLibrary ("Advapi32.dll");
469 s_pfn_Get_Sid_Sub_Authority
=
470 (GetSidSubAuthority_Proc
) GetProcAddress (
471 hm_advapi32
, "GetSidSubAuthority");
473 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
477 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
481 get_sid_sub_authority_count (PSID pSid
)
483 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
484 static UCHAR zero
= 0U;
485 HMODULE hm_advapi32
= NULL
;
486 if (is_windows_9x () == TRUE
)
490 if (g_b_init_get_sid_sub_authority_count
== 0)
492 g_b_init_get_sid_sub_authority_count
= 1;
493 hm_advapi32
= LoadLibrary ("Advapi32.dll");
494 s_pfn_Get_Sid_Sub_Authority_Count
=
495 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
496 hm_advapi32
, "GetSidSubAuthorityCount");
498 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
502 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
506 get_file_security (LPCTSTR lpFileName
,
507 SECURITY_INFORMATION RequestedInformation
,
508 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
510 LPDWORD lpnLengthNeeded
)
512 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
513 HMODULE hm_advapi32
= NULL
;
514 if (is_windows_9x () == TRUE
)
518 if (g_b_init_get_file_security
== 0)
520 g_b_init_get_file_security
= 1;
521 hm_advapi32
= LoadLibrary ("Advapi32.dll");
522 s_pfn_Get_File_Security
=
523 (GetFileSecurity_Proc
) GetProcAddress (
524 hm_advapi32
, GetFileSecurity_Name
);
526 if (s_pfn_Get_File_Security
== NULL
)
530 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
531 pSecurityDescriptor
, nLength
,
536 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
538 LPBOOL lpbOwnerDefaulted
)
540 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
541 HMODULE hm_advapi32
= NULL
;
542 if (is_windows_9x () == TRUE
)
546 if (g_b_init_get_security_descriptor_owner
== 0)
548 g_b_init_get_security_descriptor_owner
= 1;
549 hm_advapi32
= LoadLibrary ("Advapi32.dll");
550 s_pfn_Get_Security_Descriptor_Owner
=
551 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
552 hm_advapi32
, "GetSecurityDescriptorOwner");
554 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
558 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
563 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
565 LPBOOL lpbGroupDefaulted
)
567 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
568 HMODULE hm_advapi32
= NULL
;
569 if (is_windows_9x () == TRUE
)
573 if (g_b_init_get_security_descriptor_group
== 0)
575 g_b_init_get_security_descriptor_group
= 1;
576 hm_advapi32
= LoadLibrary ("Advapi32.dll");
577 s_pfn_Get_Security_Descriptor_Group
=
578 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
579 hm_advapi32
, "GetSecurityDescriptorGroup");
581 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
585 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
590 is_valid_sid (PSID sid
)
592 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
593 HMODULE hm_advapi32
= NULL
;
594 if (is_windows_9x () == TRUE
)
598 if (g_b_init_is_valid_sid
== 0)
600 g_b_init_is_valid_sid
= 1;
601 hm_advapi32
= LoadLibrary ("Advapi32.dll");
603 (IsValidSid_Proc
) GetProcAddress (
604 hm_advapi32
, "IsValidSid");
606 if (s_pfn_Is_Valid_Sid
== NULL
)
610 return (s_pfn_Is_Valid_Sid (sid
));
614 equal_sid (PSID sid1
, PSID sid2
)
616 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
617 HMODULE hm_advapi32
= NULL
;
618 if (is_windows_9x () == TRUE
)
622 if (g_b_init_equal_sid
== 0)
624 g_b_init_equal_sid
= 1;
625 hm_advapi32
= LoadLibrary ("Advapi32.dll");
627 (EqualSid_Proc
) GetProcAddress (
628 hm_advapi32
, "EqualSid");
630 if (s_pfn_Equal_Sid
== NULL
)
634 return (s_pfn_Equal_Sid (sid1
, sid2
));
638 get_length_sid (PSID sid
)
640 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
641 HMODULE hm_advapi32
= NULL
;
642 if (is_windows_9x () == TRUE
)
646 if (g_b_init_get_length_sid
== 0)
648 g_b_init_get_length_sid
= 1;
649 hm_advapi32
= LoadLibrary ("Advapi32.dll");
650 s_pfn_Get_Length_Sid
=
651 (GetLengthSid_Proc
) GetProcAddress (
652 hm_advapi32
, "GetLengthSid");
654 if (s_pfn_Get_Length_Sid
== NULL
)
658 return (s_pfn_Get_Length_Sid (sid
));
662 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
664 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
665 HMODULE hm_advapi32
= NULL
;
666 if (is_windows_9x () == TRUE
)
670 if (g_b_init_copy_sid
== 0)
672 g_b_init_copy_sid
= 1;
673 hm_advapi32
= LoadLibrary ("Advapi32.dll");
675 (CopySid_Proc
) GetProcAddress (
676 hm_advapi32
, "CopySid");
678 if (s_pfn_Copy_Sid
== NULL
)
682 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
686 END: Wrapper functions around OpenProcessToken
687 and other functions in advapi32.dll that are only
688 supported in Windows NT / 2k / XP
692 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
694 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
695 if (is_windows_9x () != TRUE
)
697 if (g_b_init_get_native_system_info
== 0)
699 g_b_init_get_native_system_info
= 1;
700 s_pfn_Get_Native_System_Info
=
701 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
702 "GetNativeSystemInfo");
704 if (s_pfn_Get_Native_System_Info
!= NULL
)
705 s_pfn_Get_Native_System_Info (lpSystemInfo
);
708 lpSystemInfo
->dwNumberOfProcessors
= -1;
712 get_system_times (LPFILETIME lpIdleTime
,
713 LPFILETIME lpKernelTime
,
714 LPFILETIME lpUserTime
)
716 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
717 if (is_windows_9x () == TRUE
)
721 if (g_b_init_get_system_times
== 0)
723 g_b_init_get_system_times
= 1;
724 s_pfn_Get_System_times
=
725 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
728 if (s_pfn_Get_System_times
== NULL
)
730 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
733 /* Equivalent of strerror for W32 error codes. */
735 w32_strerror (int error_no
)
737 static char buf
[500];
740 error_no
= GetLastError ();
743 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
745 0, /* choose most suitable language */
746 buf
, sizeof (buf
), NULL
))
747 sprintf (buf
, "w32 error %u", error_no
);
751 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
752 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
754 This is called from alloc.c:valid_pointer_p. */
756 w32_valid_pointer_p (void *p
, int size
)
759 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
763 unsigned char *buf
= alloca (size
);
764 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
773 static char startup_dir
[MAXPATHLEN
];
775 /* Get the current working directory. */
780 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
784 /* Emacs doesn't actually change directory itself, and we want to
785 force our real wd to be where emacs.exe is to avoid unnecessary
786 conflicts when trying to rename or delete directories. */
787 strcpy (dir
, startup_dir
);
792 /* Emulate getloadavg. */
801 /* Number of processors on this machine. */
802 static unsigned num_of_processors
;
804 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
805 static struct load_sample samples
[16*60];
806 static int first_idx
= -1, last_idx
= -1;
807 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
812 int next_idx
= from
+ 1;
814 if (next_idx
>= max_idx
)
823 int prev_idx
= from
- 1;
826 prev_idx
= max_idx
- 1;
832 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
835 FILETIME ft_idle
, ft_user
, ft_kernel
;
837 /* Initialize the number of processors on this machine. */
838 if (num_of_processors
<= 0)
840 get_native_system_info (&sysinfo
);
841 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
842 if (num_of_processors
<= 0)
844 GetSystemInfo (&sysinfo
);
845 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
847 if (num_of_processors
<= 0)
848 num_of_processors
= 1;
851 /* TODO: Take into account threads that are ready to run, by
852 sampling the "\System\Processor Queue Length" performance
853 counter. The code below accounts only for threads that are
856 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
858 ULARGE_INTEGER uidle
, ukernel
, uuser
;
860 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
861 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
862 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
863 *idle
= uidle
.QuadPart
;
864 *kernel
= ukernel
.QuadPart
;
865 *user
= uuser
.QuadPart
;
875 /* Produce the load average for a given time interval, using the
876 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
877 1-minute, 5-minute, or 15-minute average, respectively. */
881 double retval
= -1.0;
884 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
885 time_t now
= samples
[last_idx
].sample_time
;
887 if (first_idx
!= last_idx
)
889 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
891 tdiff
= difftime (now
, samples
[idx
].sample_time
);
892 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
895 samples
[last_idx
].kernel
+ samples
[last_idx
].user
896 - (samples
[idx
].kernel
+ samples
[idx
].user
);
897 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
899 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
902 if (idx
== first_idx
)
911 getloadavg (double loadavg
[], int nelem
)
914 ULONGLONG idle
, kernel
, user
;
915 time_t now
= time (NULL
);
917 /* Store another sample. We ignore samples that are less than 1 sec
919 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
921 sample_system_load (&idle
, &kernel
, &user
);
922 last_idx
= buf_next (last_idx
);
923 samples
[last_idx
].sample_time
= now
;
924 samples
[last_idx
].idle
= idle
;
925 samples
[last_idx
].kernel
= kernel
;
926 samples
[last_idx
].user
= user
;
927 /* If the buffer has more that 15 min worth of samples, discard
930 first_idx
= last_idx
;
931 while (first_idx
!= last_idx
932 && (difftime (now
, samples
[first_idx
].sample_time
)
933 >= 15.0*60 + 2*DBL_EPSILON
*now
))
934 first_idx
= buf_next (first_idx
);
937 for (elem
= 0; elem
< nelem
; elem
++)
939 double avg
= getavg (elem
);
949 /* Emulate getpwuid, getpwnam and others. */
951 #define PASSWD_FIELD_SIZE 256
953 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
954 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
955 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
956 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
957 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
959 static struct passwd dflt_passwd
=
971 static char dflt_group_name
[GNLEN
+1];
973 static struct group dflt_group
=
975 /* When group information is not available, we return this as the
976 group for all files. */
984 return dflt_passwd
.pw_uid
;
990 /* I could imagine arguing for checking to see whether the user is
991 in the Administrators group and returning a UID of 0 for that
992 case, but I don't know how wise that would be in the long run. */
999 return dflt_passwd
.pw_gid
;
1009 getpwuid (unsigned uid
)
1011 if (uid
== dflt_passwd
.pw_uid
)
1012 return &dflt_passwd
;
1017 getgrgid (gid_t gid
)
1023 getpwnam (char *name
)
1027 pw
= getpwuid (getuid ());
1031 if (xstrcasecmp (name
, pw
->pw_name
))
1038 init_user_info (void)
1040 /* Find the user's real name by opening the process token and
1041 looking up the name associated with the user-sid in that token.
1043 Use the relative portion of the identifier authority value from
1044 the user-sid as the user id value (same for group id using the
1045 primary group sid from the process token). */
1047 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1048 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1049 DWORD glength
= sizeof (gname
);
1050 HANDLE token
= NULL
;
1051 SID_NAME_USE user_type
;
1052 unsigned char *buf
= NULL
;
1054 TOKEN_USER user_token
;
1055 TOKEN_PRIMARY_GROUP group_token
;
1058 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1061 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1062 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1064 buf
= xmalloc (blen
);
1065 result
= get_token_information (token
, TokenUser
,
1066 (LPVOID
)buf
, blen
, &needed
);
1069 memcpy (&user_token
, buf
, sizeof (user_token
));
1070 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1072 domain
, &dlength
, &user_type
);
1080 strcpy (dflt_passwd
.pw_name
, uname
);
1081 /* Determine a reasonable uid value. */
1082 if (xstrcasecmp ("administrator", uname
) == 0)
1084 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1085 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1089 /* Use the last sub-authority value of the RID, the relative
1090 portion of the SID, as user/group ID. */
1091 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1093 /* Get group id and name. */
1094 result
= get_token_information (token
, TokenPrimaryGroup
,
1095 (LPVOID
)buf
, blen
, &needed
);
1096 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1098 buf
= xrealloc (buf
, blen
= needed
);
1099 result
= get_token_information (token
, TokenPrimaryGroup
,
1100 (LPVOID
)buf
, blen
, &needed
);
1104 memcpy (&group_token
, buf
, sizeof (group_token
));
1105 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1106 dlength
= sizeof (domain
);
1107 /* If we can get at the real Primary Group name, use that.
1108 Otherwise, the default group name was already set to
1109 "None" in globals_of_w32. */
1110 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1111 gname
, &glength
, NULL
, &dlength
,
1113 strcpy (dflt_group_name
, gname
);
1116 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1119 /* If security calls are not supported (presumably because we
1120 are running under Windows 9X), fallback to this: */
1121 else if (GetUserName (uname
, &ulength
))
1123 strcpy (dflt_passwd
.pw_name
, uname
);
1124 if (xstrcasecmp ("administrator", uname
) == 0)
1125 dflt_passwd
.pw_uid
= 0;
1127 dflt_passwd
.pw_uid
= 123;
1128 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1132 strcpy (dflt_passwd
.pw_name
, "unknown");
1133 dflt_passwd
.pw_uid
= 123;
1134 dflt_passwd
.pw_gid
= 123;
1136 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1138 /* Ensure HOME and SHELL are defined. */
1139 if (getenv ("HOME") == NULL
)
1141 if (getenv ("SHELL") == NULL
)
1144 /* Set dir and shell from environment variables. */
1145 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1146 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1150 CloseHandle (token
);
1156 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1157 return ((rand () << 15) | rand ());
1167 /* Normalize filename by converting all path separators to
1168 the specified separator. Also conditionally convert upper
1169 case path name components to lower case. */
1172 normalize_filename (register char *fp
, char path_sep
)
1177 /* Always lower-case drive letters a-z, even if the filesystem
1178 preserves case in filenames.
1179 This is so filenames can be compared by string comparison
1180 functions that are case-sensitive. Even case-preserving filesystems
1181 do not distinguish case in drive letters. */
1182 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
1188 if (NILP (Vw32_downcase_file_names
))
1192 if (*fp
== '/' || *fp
== '\\')
1199 sep
= path_sep
; /* convert to this path separator */
1200 elem
= fp
; /* start of current path element */
1203 if (*fp
>= 'a' && *fp
<= 'z')
1204 elem
= 0; /* don't convert this element */
1206 if (*fp
== 0 || *fp
== ':')
1208 sep
= *fp
; /* restore current separator (or 0) */
1209 *fp
= '/'; /* after conversion of this element */
1212 if (*fp
== '/' || *fp
== '\\')
1214 if (elem
&& elem
!= fp
)
1216 *fp
= 0; /* temporary end of string */
1217 _strlwr (elem
); /* while we convert to lower case */
1219 *fp
= sep
; /* convert (or restore) path separator */
1220 elem
= fp
+ 1; /* next element starts after separator */
1226 /* Destructively turn backslashes into slashes. */
1228 dostounix_filename (register char *p
)
1230 normalize_filename (p
, '/');
1233 /* Destructively turn slashes into backslashes. */
1235 unixtodos_filename (register char *p
)
1237 normalize_filename (p
, '\\');
1240 /* Remove all CR's that are followed by a LF.
1241 (From msdos.c...probably should figure out a way to share it,
1242 although this code isn't going to ever change.) */
1244 crlf_to_lf (register int n
, register unsigned char *buf
)
1246 unsigned char *np
= buf
;
1247 unsigned char *startp
= buf
;
1248 unsigned char *endp
= buf
+ n
;
1252 while (buf
< endp
- 1)
1256 if (*(++buf
) != 0x0a)
1267 /* Parse the root part of file name, if present. Return length and
1268 optionally store pointer to char after root. */
1270 parse_root (char * name
, char ** pPath
)
1272 char * start
= name
;
1277 /* find the root name of the volume if given */
1278 if (isalpha (name
[0]) && name
[1] == ':')
1280 /* skip past drive specifier */
1282 if (IS_DIRECTORY_SEP (name
[0]))
1285 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1291 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1296 if (IS_DIRECTORY_SEP (name
[0]))
1303 return name
- start
;
1306 /* Get long base name for name; name is assumed to be absolute. */
1308 get_long_basename (char * name
, char * buf
, int size
)
1310 WIN32_FIND_DATA find_data
;
1314 /* must be valid filename, no wild cards or other invalid characters */
1315 if (_mbspbrk (name
, "*?|<>\""))
1318 dir_handle
= FindFirstFile (name
, &find_data
);
1319 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1321 if ((len
= strlen (find_data
.cFileName
)) < size
)
1322 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1325 FindClose (dir_handle
);
1330 /* Get long name for file, if possible (assumed to be absolute). */
1332 w32_get_long_filename (char * name
, char * buf
, int size
)
1337 char full
[ MAX_PATH
];
1340 len
= strlen (name
);
1341 if (len
>= MAX_PATH
)
1344 /* Use local copy for destructive modification. */
1345 memcpy (full
, name
, len
+1);
1346 unixtodos_filename (full
);
1348 /* Copy root part verbatim. */
1349 len
= parse_root (full
, &p
);
1350 memcpy (o
, full
, len
);
1355 while (p
!= NULL
&& *p
)
1358 p
= strchr (q
, '\\');
1360 len
= get_long_basename (full
, o
, size
);
1383 is_unc_volume (const char *filename
)
1385 const char *ptr
= filename
;
1387 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1390 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1396 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
1399 sigsetmask (int signal_mask
)
1417 sigunblock (int sig
)
1423 sigemptyset (sigset_t
*set
)
1429 sigaddset (sigset_t
*set
, int signo
)
1435 sigfillset (sigset_t
*set
)
1441 sigprocmask (int how
, const sigset_t
*set
, sigset_t
*oset
)
1447 setpgrp (int pid
, int gid
)
1458 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1461 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1464 HKEY hrootkey
= NULL
;
1467 /* Check both the current user and the local machine to see if
1468 we have any resources. */
1470 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1474 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1475 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1476 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1478 RegCloseKey (hrootkey
);
1484 RegCloseKey (hrootkey
);
1487 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1491 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1492 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1493 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1495 RegCloseKey (hrootkey
);
1501 RegCloseKey (hrootkey
);
1507 char *get_emacs_configuration (void);
1509 init_environment (char ** argv
)
1511 static const char * const tempdirs
[] = {
1512 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1517 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1519 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1520 temporary files and assume "/tmp" if $TMPDIR is unset, which
1521 will break on DOS/Windows. Refuse to work if we cannot find
1522 a directory, not even "c:/", usable for that purpose. */
1523 for (i
= 0; i
< imax
; i
++)
1525 const char *tmp
= tempdirs
[i
];
1528 tmp
= getenv (tmp
+ 1);
1529 /* Note that `access' can lie to us if the directory resides on a
1530 read-only filesystem, like CD-ROM or a write-protected floppy.
1531 The only way to be really sure is to actually create a file and
1532 see if it succeeds. But I think that's too much to ask. */
1533 if (tmp
&& _access (tmp
, D_OK
) == 0)
1535 char * var
= alloca (strlen (tmp
) + 8);
1536 sprintf (var
, "TMPDIR=%s", tmp
);
1537 _putenv (strdup (var
));
1544 Fcons (build_string ("no usable temporary directories found!!"),
1546 "While setting TMPDIR: ");
1548 /* Check for environment variables and use registry settings if they
1549 don't exist. Fallback on default values where applicable. */
1554 char locale_name
[32];
1555 struct stat ignored
;
1556 char default_home
[MAX_PATH
];
1558 static const struct env_entry
1565 {"PRELOAD_WINSOCK", NULL
},
1566 {"emacs_dir", "C:/emacs"},
1567 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1568 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1569 {"EMACSDATA", "%emacs_dir%/etc"},
1570 {"EMACSPATH", "%emacs_dir%/bin"},
1571 /* We no longer set INFOPATH because Info-default-directory-list
1573 /* {"INFOPATH", "%emacs_dir%/info"}, */
1574 {"EMACSDOC", "%emacs_dir%/etc"},
1579 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1581 /* We need to copy dflt_envvars[] and work on the copy because we
1582 don't want the dumped Emacs to inherit the values of
1583 environment variables we saw during dumping (which could be on
1584 a different system). The defaults above must be left intact. */
1585 struct env_entry env_vars
[N_ENV_VARS
];
1587 for (i
= 0; i
< N_ENV_VARS
; i
++)
1588 env_vars
[i
] = dflt_envvars
[i
];
1590 /* For backwards compatibility, check if a .emacs file exists in C:/
1591 If not, then we can try to default to the appdata directory under the
1592 user's profile, which is more likely to be writable. */
1593 if (stat ("C:/.emacs", &ignored
) < 0)
1595 HRESULT profile_result
;
1596 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1597 of Windows 95 and NT4 that have not been updated to include
1599 ShGetFolderPath_fn get_folder_path
;
1600 get_folder_path
= (ShGetFolderPath_fn
)
1601 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1603 if (get_folder_path
!= NULL
)
1605 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1608 /* If we can't get the appdata dir, revert to old behavior. */
1609 if (profile_result
== S_OK
)
1610 env_vars
[0].def_value
= default_home
;
1614 /* Get default locale info and use it for LANG. */
1615 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1616 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1617 locale_name
, sizeof (locale_name
)))
1619 for (i
= 0; i
< N_ENV_VARS
; i
++)
1621 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1623 env_vars
[i
].def_value
= locale_name
;
1629 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1631 /* Treat emacs_dir specially: set it unconditionally based on our
1632 location, if it appears that we are running from the bin subdir
1633 of a standard installation. */
1636 char modname
[MAX_PATH
];
1638 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1640 if ((p
= strrchr (modname
, '\\')) == NULL
)
1644 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1646 char buf
[SET_ENV_BUF_SIZE
];
1649 for (p
= modname
; *p
; p
++)
1650 if (*p
== '\\') *p
= '/';
1652 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1653 _putenv (strdup (buf
));
1655 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1657 /* FIXME: should use substring of get_emacs_configuration ().
1658 But I don't think the Windows build supports alpha, mips etc
1659 anymore, so have taken the easy option for now. */
1660 else if (p
&& xstrcasecmp (p
, "\\i386") == 0)
1663 p
= strrchr (modname
, '\\');
1667 p
= strrchr (modname
, '\\');
1668 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1670 char buf
[SET_ENV_BUF_SIZE
];
1673 for (p
= modname
; *p
; p
++)
1674 if (*p
== '\\') *p
= '/';
1676 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1677 _putenv (strdup (buf
));
1683 for (i
= 0; i
< N_ENV_VARS
; i
++)
1685 if (!getenv (env_vars
[i
].name
))
1689 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1690 /* Also ignore empty environment variables. */
1694 lpval
= env_vars
[i
].def_value
;
1695 dwType
= REG_EXPAND_SZ
;
1701 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1703 if (dwType
== REG_EXPAND_SZ
)
1704 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1705 else if (dwType
== REG_SZ
)
1706 strcpy (buf1
, lpval
);
1707 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1709 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1711 _putenv (strdup (buf2
));
1721 /* Rebuild system configuration to reflect invoking system. */
1722 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1724 /* Another special case: on NT, the PATH variable is actually named
1725 "Path" although cmd.exe (perhaps NT itself) arranges for
1726 environment variable lookup and setting to be case insensitive.
1727 However, Emacs assumes a fully case sensitive environment, so we
1728 need to change "Path" to "PATH" to match the expectations of
1729 various elisp packages. We do this by the sneaky method of
1730 modifying the string in the C runtime environ entry.
1732 The same applies to COMSPEC. */
1736 for (envp
= environ
; *envp
; envp
++)
1737 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1738 memcpy (*envp
, "PATH=", 5);
1739 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1740 memcpy (*envp
, "COMSPEC=", 8);
1743 /* Remember the initial working directory for getwd, then make the
1744 real wd be the location of emacs.exe to avoid conflicts when
1745 renaming or deleting directories. (We also don't call chdir when
1746 running subprocesses for the same reason.) */
1747 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1752 static char modname
[MAX_PATH
];
1754 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1756 if ((p
= strrchr (modname
, '\\')) == NULL
)
1760 SetCurrentDirectory (modname
);
1762 /* Ensure argv[0] has the full path to Emacs. */
1767 /* Determine if there is a middle mouse button, to allow parse_button
1768 to decide whether right mouse events should be mouse-2 or
1770 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1776 emacs_root_dir (void)
1778 static char root_dir
[FILENAME_MAX
];
1781 p
= getenv ("emacs_dir");
1784 strcpy (root_dir
, p
);
1785 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1786 dostounix_filename (root_dir
);
1790 /* We don't have scripts to automatically determine the system configuration
1791 for Emacs before it's compiled, and we don't want to have to make the
1792 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1796 get_emacs_configuration (void)
1798 char *arch
, *oem
, *os
;
1800 static char configuration_buffer
[32];
1802 /* Determine the processor type. */
1803 switch (get_processor_type ())
1806 #ifdef PROCESSOR_INTEL_386
1807 case PROCESSOR_INTEL_386
:
1808 case PROCESSOR_INTEL_486
:
1809 case PROCESSOR_INTEL_PENTIUM
:
1814 #ifdef PROCESSOR_MIPS_R2000
1815 case PROCESSOR_MIPS_R2000
:
1816 case PROCESSOR_MIPS_R3000
:
1817 case PROCESSOR_MIPS_R4000
:
1822 #ifdef PROCESSOR_ALPHA_21064
1823 case PROCESSOR_ALPHA_21064
:
1833 /* Use the OEM field to reflect the compiler/library combination. */
1835 #define COMPILER_NAME "msvc"
1838 #define COMPILER_NAME "mingw"
1840 #define COMPILER_NAME "unknown"
1843 oem
= COMPILER_NAME
;
1845 switch (osinfo_cache
.dwPlatformId
) {
1846 case VER_PLATFORM_WIN32_NT
:
1848 build_num
= osinfo_cache
.dwBuildNumber
;
1850 case VER_PLATFORM_WIN32_WINDOWS
:
1851 if (osinfo_cache
.dwMinorVersion
== 0) {
1856 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1858 case VER_PLATFORM_WIN32s
:
1859 /* Not supported, should not happen. */
1861 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1869 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1870 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1871 get_w32_major_version (), get_w32_minor_version (), build_num
);
1873 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1876 return configuration_buffer
;
1880 get_emacs_configuration_options (void)
1882 static char *options_buffer
;
1883 char cv
[32]; /* Enough for COMPILER_VERSION. */
1885 cv
, /* To be filled later. */
1889 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1890 with a starting space to save work here. */
1892 " --cflags", USER_CFLAGS
,
1895 " --ldflags", USER_LDFLAGS
,
1902 /* Work out the effective configure options for this build. */
1904 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1907 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1909 #define COMPILER_VERSION ""
1913 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
1914 return "Error: not enough space for compiler version";
1915 cv
[sizeof (cv
) - 1] = '\0';
1917 for (i
= 0; options
[i
]; i
++)
1918 size
+= strlen (options
[i
]);
1920 options_buffer
= xmalloc (size
+ 1);
1921 options_buffer
[0] = '\0';
1923 for (i
= 0; options
[i
]; i
++)
1924 strcat (options_buffer
, options
[i
]);
1926 return options_buffer
;
1930 #include <sys/timeb.h>
1932 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1934 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1939 tv
->tv_sec
= tb
.time
;
1940 tv
->tv_usec
= tb
.millitm
* 1000L;
1943 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1944 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1948 /* ------------------------------------------------------------------------- */
1949 /* IO support and wrapper functions for W32 API. */
1950 /* ------------------------------------------------------------------------- */
1952 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1953 on network directories, so we handle that case here.
1954 (Ulrich Leodolter, 1/11/95). */
1956 sys_ctime (const time_t *t
)
1958 char *str
= (char *) ctime (t
);
1959 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1962 /* Emulate sleep...we could have done this with a define, but that
1963 would necessitate including windows.h in the files that used it.
1964 This is much easier. */
1966 sys_sleep (int seconds
)
1968 Sleep (seconds
* 1000);
1971 /* Internal MSVC functions for low-level descriptor munging */
1972 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1973 extern int __cdecl
_free_osfhnd (int fd
);
1975 /* parallel array of private info on file handles */
1976 filedesc fd_info
[ MAXDESC
];
1978 typedef struct volume_info_data
{
1979 struct volume_info_data
* next
;
1981 /* time when info was obtained */
1984 /* actual volume info */
1993 /* Global referenced by various functions. */
1994 static volume_info_data volume_info
;
1996 /* Vector to indicate which drives are local and fixed (for which cached
1997 data never expires). */
1998 static BOOL fixed_drives
[26];
2000 /* Consider cached volume information to be stale if older than 10s,
2001 at least for non-local drives. Info for fixed drives is never stale. */
2002 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2003 #define VOLINFO_STILL_VALID( root_dir, info ) \
2004 ( ( isalpha (root_dir[0]) && \
2005 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2006 || GetTickCount () - info->timestamp < 10000 )
2008 /* Cache support functions. */
2010 /* Simple linked list with linear search is sufficient. */
2011 static volume_info_data
*volume_cache
= NULL
;
2013 static volume_info_data
*
2014 lookup_volume_info (char * root_dir
)
2016 volume_info_data
* info
;
2018 for (info
= volume_cache
; info
; info
= info
->next
)
2019 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2025 add_volume_info (char * root_dir
, volume_info_data
* info
)
2027 info
->root_dir
= xstrdup (root_dir
);
2028 info
->next
= volume_cache
;
2029 volume_cache
= info
;
2033 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2034 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2035 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2036 static volume_info_data
*
2037 GetCachedVolumeInformation (char * root_dir
)
2039 volume_info_data
* info
;
2040 char default_root
[ MAX_PATH
];
2042 /* NULL for root_dir means use root from current directory. */
2043 if (root_dir
== NULL
)
2045 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2047 parse_root (default_root
, &root_dir
);
2049 root_dir
= default_root
;
2052 /* Local fixed drives can be cached permanently. Removable drives
2053 cannot be cached permanently, since the volume name and serial
2054 number (if nothing else) can change. Remote drives should be
2055 treated as if they are removable, since there is no sure way to
2056 tell whether they are or not. Also, the UNC association of drive
2057 letters mapped to remote volumes can be changed at any time (even
2058 by other processes) without notice.
2060 As a compromise, so we can benefit from caching info for remote
2061 volumes, we use a simple expiry mechanism to invalidate cache
2062 entries that are more than ten seconds old. */
2065 /* No point doing this, because WNetGetConnection is even slower than
2066 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2067 GetDriveType is about the only call of this type which does not
2068 involve network access, and so is extremely quick). */
2070 /* Map drive letter to UNC if remote. */
2071 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2073 char remote_name
[ 256 ];
2074 char drive
[3] = { root_dir
[0], ':' };
2076 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2078 /* do something */ ;
2082 info
= lookup_volume_info (root_dir
);
2084 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2092 /* Info is not cached, or is stale. */
2093 if (!GetVolumeInformation (root_dir
,
2094 name
, sizeof (name
),
2098 type
, sizeof (type
)))
2101 /* Cache the volume information for future use, overwriting existing
2102 entry if present. */
2105 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
2106 add_volume_info (root_dir
, info
);
2114 info
->name
= xstrdup (name
);
2115 info
->serialnum
= serialnum
;
2116 info
->maxcomp
= maxcomp
;
2117 info
->flags
= flags
;
2118 info
->type
= xstrdup (type
);
2119 info
->timestamp
= GetTickCount ();
2125 /* Get information on the volume where name is held; set path pointer to
2126 start of pathname in name (past UNC header\volume header if present). */
2128 get_volume_info (const char * name
, const char ** pPath
)
2130 char temp
[MAX_PATH
];
2131 char *rootname
= NULL
; /* default to current volume */
2132 volume_info_data
* info
;
2137 /* find the root name of the volume if given */
2138 if (isalpha (name
[0]) && name
[1] == ':')
2146 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2153 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2166 info
= GetCachedVolumeInformation (rootname
);
2169 /* Set global referenced by other functions. */
2170 volume_info
= *info
;
2176 /* Determine if volume is FAT format (ie. only supports short 8.3
2177 names); also set path pointer to start of pathname in name. */
2179 is_fat_volume (const char * name
, const char ** pPath
)
2181 if (get_volume_info (name
, pPath
))
2182 return (volume_info
.maxcomp
== 12);
2186 /* Map filename to a valid 8.3 name if necessary. */
2188 map_w32_filename (const char * name
, const char ** pPath
)
2190 static char shortname
[MAX_PATH
];
2191 char * str
= shortname
;
2194 const char * save_name
= name
;
2196 if (strlen (name
) >= MAX_PATH
)
2198 /* Return a filename which will cause callers to fail. */
2199 strcpy (shortname
, "?");
2203 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2205 register int left
= 8; /* maximum number of chars in part */
2206 register int extn
= 0; /* extension added? */
2207 register int dots
= 2; /* maximum number of dots allowed */
2210 *str
++ = *name
++; /* skip past UNC header */
2212 while ((c
= *name
++))
2219 extn
= 0; /* reset extension flags */
2220 dots
= 2; /* max 2 dots */
2221 left
= 8; /* max length 8 for main part */
2225 extn
= 0; /* reset extension flags */
2226 dots
= 2; /* max 2 dots */
2227 left
= 8; /* max length 8 for main part */
2232 /* Convert path components of the form .xxx to _xxx,
2233 but leave . and .. as they are. This allows .emacs
2234 to be read as _emacs, for example. */
2238 IS_DIRECTORY_SEP (*name
))
2253 extn
= 1; /* we've got an extension */
2254 left
= 3; /* 3 chars in extension */
2258 /* any embedded dots after the first are converted to _ */
2263 case '#': /* don't lose these, they're important */
2265 str
[-1] = c
; /* replace last character of part */
2270 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2272 dots
= 0; /* started a path component */
2281 strcpy (shortname
, name
);
2282 unixtodos_filename (shortname
);
2286 *pPath
= shortname
+ (path
- save_name
);
2292 is_exec (const char * name
)
2294 char * p
= strrchr (name
, '.');
2297 && (xstrcasecmp (p
, ".exe") == 0 ||
2298 xstrcasecmp (p
, ".com") == 0 ||
2299 xstrcasecmp (p
, ".bat") == 0 ||
2300 xstrcasecmp (p
, ".cmd") == 0));
2303 /* Emulate the Unix directory procedures opendir, closedir,
2304 and readdir. We can't use the procedures supplied in sysdep.c,
2305 so we provide them here. */
2307 struct direct dir_static
; /* simulated directory contents */
2308 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2309 static int dir_is_fat
;
2310 static char dir_pathname
[MAXPATHLEN
+1];
2311 static WIN32_FIND_DATA dir_find_data
;
2313 /* Support shares on a network resource as subdirectories of a read-only
2315 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2316 static HANDLE
open_unc_volume (const char *);
2317 static char *read_unc_volume (HANDLE
, char *, int);
2318 static void close_unc_volume (HANDLE
);
2321 opendir (char *filename
)
2325 /* Opening is done by FindFirstFile. However, a read is inherent to
2326 this operation, so we defer the open until read time. */
2328 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2330 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2333 if (is_unc_volume (filename
))
2335 wnet_enum_handle
= open_unc_volume (filename
);
2336 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2340 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2347 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2348 dir_pathname
[MAXPATHLEN
] = '\0';
2349 dir_is_fat
= is_fat_volume (filename
, NULL
);
2355 closedir (DIR *dirp
)
2357 /* If we have a find-handle open, close it. */
2358 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2360 FindClose (dir_find_handle
);
2361 dir_find_handle
= INVALID_HANDLE_VALUE
;
2363 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2365 close_unc_volume (wnet_enum_handle
);
2366 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2368 xfree ((char *) dirp
);
2374 int downcase
= !NILP (Vw32_downcase_file_names
);
2376 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2378 if (!read_unc_volume (wnet_enum_handle
,
2379 dir_find_data
.cFileName
,
2383 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2384 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2386 char filename
[MAXNAMLEN
+ 3];
2389 strcpy (filename
, dir_pathname
);
2390 ln
= strlen (filename
) - 1;
2391 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2392 strcat (filename
, "\\");
2393 strcat (filename
, "*");
2395 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2397 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2402 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2406 /* Emacs never uses this value, so don't bother making it match
2407 value returned by stat(). */
2408 dir_static
.d_ino
= 1;
2410 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2412 /* If the file name in cFileName[] includes `?' characters, it means
2413 the original file name used characters that cannot be represented
2414 by the current ANSI codepage. To avoid total lossage, retrieve
2415 the short 8+3 alias of the long file name. */
2416 if (_mbspbrk (dir_static
.d_name
, "?"))
2418 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2419 downcase
= 1; /* 8+3 aliases are returned in all caps */
2421 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2422 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2423 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2425 /* If the file name in cFileName[] includes `?' characters, it means
2426 the original file name used characters that cannot be represented
2427 by the current ANSI codepage. To avoid total lossage, retrieve
2428 the short 8+3 alias of the long file name. */
2429 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2431 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2432 /* 8+3 aliases are returned in all caps, which could break
2433 various alists that look at filenames' extensions. */
2437 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2438 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2440 _strlwr (dir_static
.d_name
);
2444 for (p
= dir_static
.d_name
; *p
; p
++)
2445 if (*p
>= 'a' && *p
<= 'z')
2448 _strlwr (dir_static
.d_name
);
2455 open_unc_volume (const char *path
)
2461 nr
.dwScope
= RESOURCE_GLOBALNET
;
2462 nr
.dwType
= RESOURCETYPE_DISK
;
2463 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2464 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2465 nr
.lpLocalName
= NULL
;
2466 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2467 nr
.lpComment
= NULL
;
2468 nr
.lpProvider
= NULL
;
2470 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2471 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2473 if (result
== NO_ERROR
)
2476 return INVALID_HANDLE_VALUE
;
2480 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2484 DWORD bufsize
= 512;
2489 buffer
= alloca (bufsize
);
2490 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
2491 if (result
!= NO_ERROR
)
2494 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2495 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2497 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2500 strncpy (readbuf
, ptr
, size
);
2505 close_unc_volume (HANDLE henum
)
2507 if (henum
!= INVALID_HANDLE_VALUE
)
2508 WNetCloseEnum (henum
);
2512 unc_volume_file_attributes (const char *path
)
2517 henum
= open_unc_volume (path
);
2518 if (henum
== INVALID_HANDLE_VALUE
)
2521 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2523 close_unc_volume (henum
);
2528 /* Ensure a network connection is authenticated. */
2530 logon_network_drive (const char *path
)
2532 NETRESOURCE resource
;
2533 char share
[MAX_PATH
];
2538 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2539 drvtype
= DRIVE_REMOTE
;
2540 else if (path
[0] == '\0' || path
[1] != ':')
2541 drvtype
= GetDriveType (NULL
);
2548 drvtype
= GetDriveType (drive
);
2551 /* Only logon to networked drives. */
2552 if (drvtype
!= DRIVE_REMOTE
)
2556 strncpy (share
, path
, MAX_PATH
);
2557 /* Truncate to just server and share name. */
2558 for (i
= 2; i
< MAX_PATH
; i
++)
2560 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2567 resource
.dwType
= RESOURCETYPE_DISK
;
2568 resource
.lpLocalName
= NULL
;
2569 resource
.lpRemoteName
= share
;
2570 resource
.lpProvider
= NULL
;
2572 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2575 /* Shadow some MSVC runtime functions to map requests for long filenames
2576 to reasonable short names if necessary. This was originally added to
2577 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2581 sys_access (const char * path
, int mode
)
2585 /* MSVC implementation doesn't recognize D_OK. */
2586 path
= map_w32_filename (path
, NULL
);
2587 if (is_unc_volume (path
))
2589 attributes
= unc_volume_file_attributes (path
);
2590 if (attributes
== -1) {
2595 else if ((attributes
= GetFileAttributes (path
)) == -1)
2597 /* Should try mapping GetLastError to errno; for now just indicate
2598 that path doesn't exist. */
2602 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2607 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2612 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2621 sys_chdir (const char * path
)
2623 return _chdir (map_w32_filename (path
, NULL
));
2627 sys_chmod (const char * path
, int mode
)
2629 return _chmod (map_w32_filename (path
, NULL
), mode
);
2633 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2635 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2641 sys_creat (const char * path
, int mode
)
2643 return _creat (map_w32_filename (path
, NULL
), mode
);
2647 sys_fopen (const char * path
, const char * mode
)
2651 const char * mode_save
= mode
;
2653 /* Force all file handles to be non-inheritable. This is necessary to
2654 ensure child processes don't unwittingly inherit handles that might
2655 prevent future file access. */
2659 else if (mode
[0] == 'w' || mode
[0] == 'a')
2660 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2664 /* Only do simplistic option parsing. */
2668 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2671 else if (mode
[0] == 'b')
2676 else if (mode
[0] == 't')
2683 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2687 return _fdopen (fd
, mode_save
);
2690 /* This only works on NTFS volumes, but is useful to have. */
2692 sys_link (const char * old
, const char * new)
2696 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2698 if (old
== NULL
|| new == NULL
)
2704 strcpy (oldname
, map_w32_filename (old
, NULL
));
2705 strcpy (newname
, map_w32_filename (new, NULL
));
2707 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2708 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2709 if (fileh
!= INVALID_HANDLE_VALUE
)
2713 /* Confusingly, the "alternate" stream name field does not apply
2714 when restoring a hard link, and instead contains the actual
2715 stream data for the link (ie. the name of the link to create).
2716 The WIN32_STREAM_ID structure before the cStreamName field is
2717 the stream header, which is then immediately followed by the
2721 WIN32_STREAM_ID wid
;
2722 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2725 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2726 data
.wid
.cStreamName
, MAX_PATH
);
2729 LPVOID context
= NULL
;
2732 data
.wid
.dwStreamId
= BACKUP_LINK
;
2733 data
.wid
.dwStreamAttributes
= 0;
2734 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2735 data
.wid
.Size
.HighPart
= 0;
2736 data
.wid
.dwStreamNameSize
= 0;
2738 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2739 offsetof (WIN32_STREAM_ID
, cStreamName
)
2740 + data
.wid
.Size
.LowPart
,
2741 &wbytes
, FALSE
, FALSE
, &context
)
2742 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2749 /* Should try mapping GetLastError to errno; for now just
2750 indicate a general error (eg. links not supported). */
2751 errno
= EINVAL
; // perhaps EMLINK?
2755 CloseHandle (fileh
);
2764 sys_mkdir (const char * path
)
2766 return _mkdir (map_w32_filename (path
, NULL
));
2769 /* Because of long name mapping issues, we need to implement this
2770 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2771 a unique name, instead of setting the input template to an empty
2774 Standard algorithm seems to be use pid or tid with a letter on the
2775 front (in place of the 6 X's) and cycle through the letters to find a
2776 unique name. We extend that to allow any reasonable character as the
2777 first of the 6 X's. */
2779 sys_mktemp (char * template)
2783 unsigned uid
= GetCurrentThreadId ();
2784 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2786 if (template == NULL
)
2788 p
= template + strlen (template);
2790 /* replace up to the last 5 X's with uid in decimal */
2791 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2793 p
[0] = '0' + uid
% 10;
2797 if (i
< 0 && p
[0] == 'X')
2802 int save_errno
= errno
;
2803 p
[0] = first_char
[i
];
2804 if (sys_access (template, 0) < 0)
2810 while (++i
< sizeof (first_char
));
2813 /* Template is badly formed or else we can't generate a unique name,
2814 so return empty string */
2820 sys_open (const char * path
, int oflag
, int mode
)
2822 const char* mpath
= map_w32_filename (path
, NULL
);
2823 /* Try to open file without _O_CREAT, to be able to write to hidden
2824 and system files. Force all file handles to be
2826 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2829 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2833 sys_rename (const char * oldname
, const char * newname
)
2836 char temp
[MAX_PATH
];
2838 /* MoveFile on Windows 95 doesn't correctly change the short file name
2839 alias in a number of circumstances (it is not easy to predict when
2840 just by looking at oldname and newname, unfortunately). In these
2841 cases, renaming through a temporary name avoids the problem.
2843 A second problem on Windows 95 is that renaming through a temp name when
2844 newname is uppercase fails (the final long name ends up in
2845 lowercase, although the short alias might be uppercase) UNLESS the
2846 long temp name is not 8.3.
2848 So, on Windows 95 we always rename through a temp name, and we make sure
2849 the temp name has a long extension to ensure correct renaming. */
2851 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2853 if (os_subtype
== OS_WIN95
)
2859 oldname
= map_w32_filename (oldname
, NULL
);
2860 if (o
= strrchr (oldname
, '\\'))
2863 o
= (char *) oldname
;
2865 if (p
= strrchr (temp
, '\\'))
2872 /* Force temp name to require a manufactured 8.3 alias - this
2873 seems to make the second rename work properly. */
2874 sprintf (p
, "_.%s.%u", o
, i
);
2876 result
= rename (oldname
, temp
);
2878 /* This loop must surely terminate! */
2879 while (result
< 0 && errno
== EEXIST
);
2884 /* Emulate Unix behavior - newname is deleted if it already exists
2885 (at least if it is a file; don't do this for directories).
2887 Since we mustn't do this if we are just changing the case of the
2888 file name (we would end up deleting the file we are trying to
2889 rename!), we let rename detect if the destination file already
2890 exists - that way we avoid the possible pitfalls of trying to
2891 determine ourselves whether two names really refer to the same
2892 file, which is not always possible in the general case. (Consider
2893 all the permutations of shared or subst'd drives, etc.) */
2895 newname
= map_w32_filename (newname
, NULL
);
2896 result
= rename (temp
, newname
);
2900 && _chmod (newname
, 0666) == 0
2901 && _unlink (newname
) == 0)
2902 result
= rename (temp
, newname
);
2908 sys_rmdir (const char * path
)
2910 return _rmdir (map_w32_filename (path
, NULL
));
2914 sys_unlink (const char * path
)
2916 path
= map_w32_filename (path
, NULL
);
2918 /* On Unix, unlink works without write permission. */
2919 _chmod (path
, 0666);
2920 return _unlink (path
);
2923 static FILETIME utc_base_ft
;
2924 static ULONGLONG utc_base
; /* In 100ns units */
2925 static int init
= 0;
2927 #define FILETIME_TO_U64(result, ft) \
2929 ULARGE_INTEGER uiTemp; \
2930 uiTemp.LowPart = (ft).dwLowDateTime; \
2931 uiTemp.HighPart = (ft).dwHighDateTime; \
2932 result = uiTemp.QuadPart; \
2936 initialize_utc_base (void)
2938 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2947 st
.wMilliseconds
= 0;
2949 SystemTimeToFileTime (&st
, &utc_base_ft
);
2950 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
2954 convert_time (FILETIME ft
)
2960 initialize_utc_base ();
2964 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2967 FILETIME_TO_U64 (tmp
, ft
);
2968 return (time_t) ((tmp
- utc_base
) / 10000000L);
2972 convert_from_time_t (time_t time
, FILETIME
* pft
)
2978 initialize_utc_base ();
2982 /* time in 100ns units since 1-Jan-1601 */
2983 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
2984 pft
->dwHighDateTime
= tmp
.HighPart
;
2985 pft
->dwLowDateTime
= tmp
.LowPart
;
2989 /* No reason to keep this; faking inode values either by hashing or even
2990 using the file index from GetInformationByHandle, is not perfect and
2991 so by default Emacs doesn't use the inode values on Windows.
2992 Instead, we now determine file-truename correctly (except for
2993 possible drive aliasing etc). */
2995 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2997 hashval (const unsigned char * str
)
3002 h
= (h
<< 4) + *str
++;
3008 /* Return the hash value of the canonical pathname, excluding the
3009 drive/UNC header, to get a hopefully unique inode number. */
3011 generate_inode_val (const char * name
)
3013 char fullname
[ MAX_PATH
];
3017 /* Get the truly canonical filename, if it exists. (Note: this
3018 doesn't resolve aliasing due to subst commands, or recognise hard
3020 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3023 parse_root (fullname
, &p
);
3024 /* Normal W32 filesystems are still case insensitive. */
3031 static PSECURITY_DESCRIPTOR
3032 get_file_security_desc (const char *fname
)
3034 PSECURITY_DESCRIPTOR psd
= NULL
;
3036 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3037 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3039 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3041 err
= GetLastError ();
3042 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3046 psd
= xmalloc (sd_len
);
3047 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3059 unsigned n_subauthorities
;
3061 /* Use the last sub-authority value of the RID, the relative
3062 portion of the SID, as user/group ID. */
3063 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3064 if (n_subauthorities
< 1)
3065 return 0; /* the "World" RID */
3066 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3069 /* Caching SID and account values for faster lokup. */
3072 # define FLEXIBLE_ARRAY_MEMBER
3074 # define FLEXIBLE_ARRAY_MEMBER 1
3079 struct w32_id
*next
;
3081 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3084 static struct w32_id
*w32_idlist
;
3087 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3089 struct w32_id
*tail
, *found
;
3091 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3093 if (equal_sid ((PSID
)tail
->sid
, sid
))
3102 strcpy (name
, found
->name
);
3110 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3113 struct w32_id
*new_entry
;
3115 /* We don't want to leave behind stale cache from when Emacs was
3119 sid_len
= get_length_sid (sid
);
3120 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3123 new_entry
->rid
= id
;
3124 strcpy (new_entry
->name
, name
);
3125 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3126 new_entry
->next
= w32_idlist
;
3127 w32_idlist
= new_entry
;
3136 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3137 unsigned *id
, char *nm
, int what
)
3140 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3142 SID_NAME_USE ignore
;
3144 DWORD name_len
= sizeof (name
);
3146 DWORD domain_len
= sizeof (domain
);
3152 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3153 else if (what
== GID
)
3154 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3158 if (!result
|| !is_valid_sid (sid
))
3160 else if (!w32_cached_id (sid
, id
, nm
))
3162 /* If FNAME is a UNC, we need to lookup account on the
3163 specified machine. */
3164 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3165 && fname
[2] != '\0')
3170 for (s
= fname
+ 2, p
= machine
;
3171 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3177 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3178 domain
, &domain_len
, &ignore
)
3179 || name_len
> UNLEN
+1)
3183 *id
= get_rid (sid
);
3185 w32_add_to_cache (sid
, *id
, name
);
3192 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3196 int dflt_usr
= 0, dflt_grp
= 0;
3205 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3207 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3210 /* Consider files to belong to current user/group, if we cannot get
3211 more accurate information. */
3214 st
->st_uid
= dflt_passwd
.pw_uid
;
3215 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3219 st
->st_gid
= dflt_passwd
.pw_gid
;
3220 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3224 /* Return non-zero if NAME is a potentially slow filesystem. */
3226 is_slow_fs (const char *name
)
3231 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3232 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3233 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3234 devtype
= GetDriveType (NULL
); /* use root of current drive */
3237 /* GetDriveType needs the root directory of the drive. */
3238 strncpy (drive_root
, name
, 2);
3239 drive_root
[2] = '\\';
3240 drive_root
[3] = '\0';
3241 devtype
= GetDriveType (drive_root
);
3243 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3246 /* MSVC stat function can't cope with UNC names and has other bugs, so
3247 replace it with our own. This also allows us to calculate consistent
3248 inode values without hacks in the main Emacs code. */
3250 stat (const char * path
, struct stat
* buf
)
3255 WIN32_FIND_DATA wfd
;
3257 unsigned __int64 fake_inode
;
3260 int rootdir
= FALSE
;
3261 PSECURITY_DESCRIPTOR psd
= NULL
;
3263 if (path
== NULL
|| buf
== NULL
)
3269 name
= (char *) map_w32_filename (path
, &path
);
3270 /* Must be valid filename, no wild cards or other invalid
3271 characters. We use _mbspbrk to support multibyte strings that
3272 might look to strpbrk as if they included literal *, ?, and other
3273 characters mentioned below that are disallowed by Windows
3275 if (_mbspbrk (name
, "*?|<>\""))
3281 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3282 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3283 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3288 /* Remove trailing directory separator, unless name is the root
3289 directory of a drive or UNC volume in which case ensure there
3290 is a trailing separator. */
3291 len
= strlen (name
);
3292 rootdir
= (path
>= name
+ len
- 1
3293 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3294 name
= strcpy (alloca (len
+ 2), name
);
3296 if (is_unc_volume (name
))
3298 DWORD attrs
= unc_volume_file_attributes (name
);
3303 memset (&wfd
, 0, sizeof (wfd
));
3304 wfd
.dwFileAttributes
= attrs
;
3305 wfd
.ftCreationTime
= utc_base_ft
;
3306 wfd
.ftLastAccessTime
= utc_base_ft
;
3307 wfd
.ftLastWriteTime
= utc_base_ft
;
3308 strcpy (wfd
.cFileName
, name
);
3312 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3313 strcat (name
, "\\");
3314 if (GetDriveType (name
) < 2)
3319 memset (&wfd
, 0, sizeof (wfd
));
3320 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
3321 wfd
.ftCreationTime
= utc_base_ft
;
3322 wfd
.ftLastAccessTime
= utc_base_ft
;
3323 wfd
.ftLastWriteTime
= utc_base_ft
;
3324 strcpy (wfd
.cFileName
, name
);
3328 if (IS_DIRECTORY_SEP (name
[len
-1]))
3331 /* (This is hacky, but helps when doing file completions on
3332 network drives.) Optimize by using information available from
3333 active readdir if possible. */
3334 len
= strlen (dir_pathname
);
3335 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3337 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3338 && strnicmp (name
, dir_pathname
, len
) == 0
3339 && IS_DIRECTORY_SEP (name
[len
])
3340 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3342 /* This was the last entry returned by readdir. */
3343 wfd
= dir_find_data
;
3347 logon_network_drive (name
);
3349 fh
= FindFirstFile (name
, &wfd
);
3350 if (fh
== INVALID_HANDLE_VALUE
)
3359 if (!(NILP (Vw32_get_true_file_attributes
)
3360 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3361 /* No access rights required to get info. */
3362 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3363 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
3364 != INVALID_HANDLE_VALUE
)
3366 /* This is more accurate in terms of gettting the correct number
3367 of links, but is quite slow (it is noticeable when Emacs is
3368 making a list of file name completions). */
3369 BY_HANDLE_FILE_INFORMATION info
;
3371 if (GetFileInformationByHandle (fh
, &info
))
3373 buf
->st_nlink
= info
.nNumberOfLinks
;
3374 /* Might as well use file index to fake inode values, but this
3375 is not guaranteed to be unique unless we keep a handle open
3376 all the time (even then there are situations where it is
3377 not unique). Reputedly, there are at most 48 bits of info
3378 (on NTFS, presumably less on FAT). */
3379 fake_inode
= info
.nFileIndexHigh
;
3381 fake_inode
+= info
.nFileIndexLow
;
3389 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3391 buf
->st_mode
= S_IFDIR
;
3395 switch (GetFileType (fh
))
3397 case FILE_TYPE_DISK
:
3398 buf
->st_mode
= S_IFREG
;
3400 case FILE_TYPE_PIPE
:
3401 buf
->st_mode
= S_IFIFO
;
3403 case FILE_TYPE_CHAR
:
3404 case FILE_TYPE_UNKNOWN
:
3406 buf
->st_mode
= S_IFCHR
;
3410 psd
= get_file_security_desc (name
);
3411 get_file_owner_and_group (psd
, name
, buf
);
3415 /* Don't bother to make this information more accurate. */
3416 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
3421 get_file_owner_and_group (NULL
, name
, buf
);
3426 /* Not sure if there is any point in this. */
3427 if (!NILP (Vw32_generate_fake_inodes
))
3428 fake_inode
= generate_inode_val (name
);
3429 else if (fake_inode
== 0)
3431 /* For want of something better, try to make everything unique. */
3432 static DWORD gen_num
= 0;
3433 fake_inode
= ++gen_num
;
3437 /* MSVC defines _ino_t to be short; other libc's might not. */
3438 if (sizeof (buf
->st_ino
) == 2)
3439 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3441 buf
->st_ino
= fake_inode
;
3443 /* volume_info is set indirectly by map_w32_filename */
3444 buf
->st_dev
= volume_info
.serialnum
;
3445 buf
->st_rdev
= volume_info
.serialnum
;
3447 buf
->st_size
= wfd
.nFileSizeHigh
;
3448 buf
->st_size
<<= 32;
3449 buf
->st_size
+= wfd
.nFileSizeLow
;
3451 /* Convert timestamps to Unix format. */
3452 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
3453 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
3454 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3455 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
3456 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3458 /* determine rwx permissions */
3459 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3460 permission
= S_IREAD
;
3462 permission
= S_IREAD
| S_IWRITE
;
3464 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3465 permission
|= S_IEXEC
;
3466 else if (is_exec (name
))
3467 permission
|= S_IEXEC
;
3469 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3474 /* Provide fstat and utime as well as stat for consistent handling of
3477 fstat (int desc
, struct stat
* buf
)
3479 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3480 BY_HANDLE_FILE_INFORMATION info
;
3481 unsigned __int64 fake_inode
;
3484 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3486 case FILE_TYPE_DISK
:
3487 buf
->st_mode
= S_IFREG
;
3488 if (!GetFileInformationByHandle (fh
, &info
))
3494 case FILE_TYPE_PIPE
:
3495 buf
->st_mode
= S_IFIFO
;
3497 case FILE_TYPE_CHAR
:
3498 case FILE_TYPE_UNKNOWN
:
3500 buf
->st_mode
= S_IFCHR
;
3502 memset (&info
, 0, sizeof (info
));
3503 info
.dwFileAttributes
= 0;
3504 info
.ftCreationTime
= utc_base_ft
;
3505 info
.ftLastAccessTime
= utc_base_ft
;
3506 info
.ftLastWriteTime
= utc_base_ft
;
3509 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3510 buf
->st_mode
= S_IFDIR
;
3512 buf
->st_nlink
= info
.nNumberOfLinks
;
3513 /* Might as well use file index to fake inode values, but this
3514 is not guaranteed to be unique unless we keep a handle open
3515 all the time (even then there are situations where it is
3516 not unique). Reputedly, there are at most 48 bits of info
3517 (on NTFS, presumably less on FAT). */
3518 fake_inode
= info
.nFileIndexHigh
;
3520 fake_inode
+= info
.nFileIndexLow
;
3522 /* MSVC defines _ino_t to be short; other libc's might not. */
3523 if (sizeof (buf
->st_ino
) == 2)
3524 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3526 buf
->st_ino
= fake_inode
;
3528 /* Consider files to belong to current user.
3529 FIXME: this should use GetSecurityInfo API, but it is only
3530 available for _WIN32_WINNT >= 0x501. */
3531 buf
->st_uid
= dflt_passwd
.pw_uid
;
3532 buf
->st_gid
= dflt_passwd
.pw_gid
;
3533 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3534 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3536 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3537 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3539 buf
->st_size
= info
.nFileSizeHigh
;
3540 buf
->st_size
<<= 32;
3541 buf
->st_size
+= info
.nFileSizeLow
;
3543 /* Convert timestamps to Unix format. */
3544 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3545 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3546 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3547 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3548 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3550 /* determine rwx permissions */
3551 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3552 permission
= S_IREAD
;
3554 permission
= S_IREAD
| S_IWRITE
;
3556 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3557 permission
|= S_IEXEC
;
3560 #if 0 /* no way of knowing the filename */
3561 char * p
= strrchr (name
, '.');
3563 (xstrcasecmp (p
, ".exe") == 0 ||
3564 xstrcasecmp (p
, ".com") == 0 ||
3565 xstrcasecmp (p
, ".bat") == 0 ||
3566 xstrcasecmp (p
, ".cmd") == 0))
3567 permission
|= S_IEXEC
;
3571 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3577 utime (const char *name
, struct utimbuf
*times
)
3579 struct utimbuf deftime
;
3586 deftime
.modtime
= deftime
.actime
= time (NULL
);
3590 /* Need write access to set times. */
3591 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3592 0, OPEN_EXISTING
, 0, NULL
);
3595 convert_from_time_t (times
->actime
, &atime
);
3596 convert_from_time_t (times
->modtime
, &mtime
);
3597 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3614 /* Symlink-related functions that always fail. Used in fileio.c to
3617 symlink (char const *dummy1
, char const *dummy2
)
3624 readlink (const char *name
, char *dummy1
, size_t dummy2
)
3626 /* `access' is much faster than `stat' on MS-Windows. */
3627 if (sys_access (name
, 0) == 0)
3633 /* Support for browsing other processes and their attributes. See
3634 process.c for the Lisp bindings. */
3636 /* Helper wrapper functions. */
3638 static HANDLE WINAPI
3639 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
3641 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
3643 if (g_b_init_create_toolhelp32_snapshot
== 0)
3645 g_b_init_create_toolhelp32_snapshot
= 1;
3646 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
3647 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3648 "CreateToolhelp32Snapshot");
3650 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
3652 return INVALID_HANDLE_VALUE
;
3654 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
3658 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
3660 static Process32First_Proc s_pfn_Process32_First
= NULL
;
3662 if (g_b_init_process32_first
== 0)
3664 g_b_init_process32_first
= 1;
3665 s_pfn_Process32_First
= (Process32First_Proc
)
3666 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3669 if (s_pfn_Process32_First
== NULL
)
3673 return (s_pfn_Process32_First (hSnapshot
, lppe
));
3677 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
3679 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
3681 if (g_b_init_process32_next
== 0)
3683 g_b_init_process32_next
= 1;
3684 s_pfn_Process32_Next
= (Process32Next_Proc
)
3685 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3688 if (s_pfn_Process32_Next
== NULL
)
3692 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
3696 open_thread_token (HANDLE ThreadHandle
,
3697 DWORD DesiredAccess
,
3699 PHANDLE TokenHandle
)
3701 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
3702 HMODULE hm_advapi32
= NULL
;
3703 if (is_windows_9x () == TRUE
)
3705 SetLastError (ERROR_NOT_SUPPORTED
);
3708 if (g_b_init_open_thread_token
== 0)
3710 g_b_init_open_thread_token
= 1;
3711 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3712 s_pfn_Open_Thread_Token
=
3713 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
3715 if (s_pfn_Open_Thread_Token
== NULL
)
3717 SetLastError (ERROR_NOT_SUPPORTED
);
3721 s_pfn_Open_Thread_Token (
3730 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
3732 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
3733 HMODULE hm_advapi32
= NULL
;
3734 if (is_windows_9x () == TRUE
)
3738 if (g_b_init_impersonate_self
== 0)
3740 g_b_init_impersonate_self
= 1;
3741 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3742 s_pfn_Impersonate_Self
=
3743 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
3745 if (s_pfn_Impersonate_Self
== NULL
)
3749 return s_pfn_Impersonate_Self (ImpersonationLevel
);
3753 revert_to_self (void)
3755 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
3756 HMODULE hm_advapi32
= NULL
;
3757 if (is_windows_9x () == TRUE
)
3761 if (g_b_init_revert_to_self
== 0)
3763 g_b_init_revert_to_self
= 1;
3764 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3765 s_pfn_Revert_To_Self
=
3766 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
3768 if (s_pfn_Revert_To_Self
== NULL
)
3772 return s_pfn_Revert_To_Self ();
3776 get_process_memory_info (HANDLE h_proc
,
3777 PPROCESS_MEMORY_COUNTERS mem_counters
,
3780 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
3781 HMODULE hm_psapi
= NULL
;
3782 if (is_windows_9x () == TRUE
)
3786 if (g_b_init_get_process_memory_info
== 0)
3788 g_b_init_get_process_memory_info
= 1;
3789 hm_psapi
= LoadLibrary ("Psapi.dll");
3791 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
3792 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
3794 if (s_pfn_Get_Process_Memory_Info
== NULL
)
3798 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
3802 get_process_working_set_size (HANDLE h_proc
,
3806 static GetProcessWorkingSetSize_Proc
3807 s_pfn_Get_Process_Working_Set_Size
= NULL
;
3809 if (is_windows_9x () == TRUE
)
3813 if (g_b_init_get_process_working_set_size
== 0)
3815 g_b_init_get_process_working_set_size
= 1;
3816 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
3817 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3818 "GetProcessWorkingSetSize");
3820 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
3824 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
3828 global_memory_status (MEMORYSTATUS
*buf
)
3830 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
3832 if (is_windows_9x () == TRUE
)
3836 if (g_b_init_global_memory_status
== 0)
3838 g_b_init_global_memory_status
= 1;
3839 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
3840 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3841 "GlobalMemoryStatus");
3843 if (s_pfn_Global_Memory_Status
== NULL
)
3847 return s_pfn_Global_Memory_Status (buf
);
3851 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
3853 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
3855 if (is_windows_9x () == TRUE
)
3859 if (g_b_init_global_memory_status_ex
== 0)
3861 g_b_init_global_memory_status_ex
= 1;
3862 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
3863 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3864 "GlobalMemoryStatusEx");
3866 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
3870 return s_pfn_Global_Memory_Status_Ex (buf
);
3874 list_system_processes (void)
3876 struct gcpro gcpro1
;
3877 Lisp_Object proclist
= Qnil
;
3880 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
3882 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
3884 PROCESSENTRY32 proc_entry
;
3890 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
3891 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
3892 res
= process32_next (h_snapshot
, &proc_entry
))
3894 proc_id
= proc_entry
.th32ProcessID
;
3895 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
3898 CloseHandle (h_snapshot
);
3900 proclist
= Fnreverse (proclist
);
3907 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
3909 TOKEN_PRIVILEGES priv
;
3910 DWORD priv_size
= sizeof (priv
);
3911 DWORD opriv_size
= sizeof (*old_priv
);
3912 HANDLE h_token
= NULL
;
3913 HANDLE h_thread
= GetCurrentThread ();
3917 res
= open_thread_token (h_thread
,
3918 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3920 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
3922 if (impersonate_self (SecurityImpersonation
))
3923 res
= open_thread_token (h_thread
,
3924 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3929 priv
.PrivilegeCount
= 1;
3930 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
3931 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
3932 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
3933 old_priv
, &opriv_size
)
3934 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
3938 CloseHandle (h_token
);
3944 restore_privilege (TOKEN_PRIVILEGES
*priv
)
3946 DWORD priv_size
= sizeof (*priv
);
3947 HANDLE h_token
= NULL
;
3950 if (open_thread_token (GetCurrentThread (),
3951 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3954 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
3955 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
3959 CloseHandle (h_token
);
3965 ltime (long time_sec
, long time_usec
)
3967 return list3 (make_number ((time_sec
>> 16) & 0xffff),
3968 make_number (time_sec
& 0xffff),
3969 make_number (time_usec
));
3972 #define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
3975 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
3976 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
3979 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
3980 ULONGLONG tem1
, tem2
, tem3
, tem
;
3983 || !get_process_times_fn
3984 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
3985 &ft_kernel
, &ft_user
))
3988 GetSystemTimeAsFileTime (&ft_current
);
3990 FILETIME_TO_U64 (tem1
, ft_kernel
);
3992 *stime
= U64_TO_LISP_TIME (tem1
);
3994 FILETIME_TO_U64 (tem2
, ft_user
);
3996 *utime
= U64_TO_LISP_TIME (tem2
);
3999 *ttime
= U64_TO_LISP_TIME (tem3
);
4001 FILETIME_TO_U64 (tem
, ft_creation
);
4002 /* Process no 4 (System) returns zero creation time. */
4004 tem
= (tem
- utc_base
) / 10L;
4005 *ctime
= U64_TO_LISP_TIME (tem
);
4009 FILETIME_TO_U64 (tem3
, ft_current
);
4010 tem
= (tem3
- utc_base
) / 10L - tem
;
4012 *etime
= U64_TO_LISP_TIME (tem
);
4016 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4027 system_process_attributes (Lisp_Object pid
)
4029 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4030 Lisp_Object attrs
= Qnil
;
4031 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4032 HANDLE h_snapshot
, h_proc
;
4035 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4036 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4037 DWORD glength
= sizeof (gname
);
4038 HANDLE token
= NULL
;
4039 SID_NAME_USE user_type
;
4040 unsigned char *buf
= NULL
;
4042 TOKEN_USER user_token
;
4043 TOKEN_PRIMARY_GROUP group_token
;
4047 PROCESS_MEMORY_COUNTERS mem
;
4048 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4049 DWORD minrss
, maxrss
;
4051 MEMORY_STATUS_EX memstex
;
4052 double totphys
= 0.0;
4053 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4055 BOOL result
= FALSE
;
4057 CHECK_NUMBER_OR_FLOAT (pid
);
4058 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4060 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4062 GCPRO3 (attrs
, decoded_cmd
, tem
);
4064 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4069 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4070 for (res
= process32_first (h_snapshot
, &pe
); res
;
4071 res
= process32_next (h_snapshot
, &pe
))
4073 if (proc_id
== pe
.th32ProcessID
)
4076 decoded_cmd
= build_string ("Idle");
4079 /* Decode the command name from locale-specific
4081 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4082 strlen (pe
.szExeFile
));
4084 code_convert_string_norecord (cmd_str
,
4085 Vlocale_coding_system
, 0);
4087 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4088 attrs
= Fcons (Fcons (Qppid
,
4089 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4091 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4093 attrs
= Fcons (Fcons (Qthcount
,
4094 make_fixnum_or_float (pe
.cntThreads
)),
4101 CloseHandle (h_snapshot
);
4110 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4112 /* If we were denied a handle to the process, try again after
4113 enabling the SeDebugPrivilege in our process. */
4116 TOKEN_PRIVILEGES priv_current
;
4118 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4120 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4122 restore_privilege (&priv_current
);
4128 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4131 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4132 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4134 buf
= xmalloc (blen
);
4135 result
= get_token_information (token
, TokenUser
,
4136 (LPVOID
)buf
, blen
, &needed
);
4139 memcpy (&user_token
, buf
, sizeof (user_token
));
4140 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4142 euid
= get_rid (user_token
.User
.Sid
);
4143 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4148 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4151 strcpy (uname
, "unknown");
4155 ulength
= strlen (uname
);
4161 /* Determine a reasonable euid and gid values. */
4162 if (xstrcasecmp ("administrator", uname
) == 0)
4164 euid
= 500; /* well-known Administrator uid */
4165 egid
= 513; /* well-known None gid */
4169 /* Get group id and name. */
4170 result
= get_token_information (token
, TokenPrimaryGroup
,
4171 (LPVOID
)buf
, blen
, &needed
);
4172 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4174 buf
= xrealloc (buf
, blen
= needed
);
4175 result
= get_token_information (token
, TokenPrimaryGroup
,
4176 (LPVOID
)buf
, blen
, &needed
);
4180 memcpy (&group_token
, buf
, sizeof (group_token
));
4181 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
4183 egid
= get_rid (group_token
.PrimaryGroup
);
4184 dlength
= sizeof (domain
);
4186 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
4187 gname
, &glength
, NULL
, &dlength
,
4190 w32_add_to_cache (group_token
.PrimaryGroup
,
4194 strcpy (gname
, "None");
4198 glength
= strlen (gname
);
4206 if (!is_windows_9x ())
4208 /* We couldn't open the process token, presumably because of
4209 insufficient access rights. Assume this process is run
4211 strcpy (uname
, "SYSTEM");
4212 strcpy (gname
, "None");
4213 euid
= 18; /* SYSTEM */
4214 egid
= 513; /* None */
4215 glength
= strlen (gname
);
4216 ulength
= strlen (uname
);
4218 /* If we are running under Windows 9X, where security calls are
4219 not supported, we assume all processes are run by the current
4221 else if (GetUserName (uname
, &ulength
))
4223 if (xstrcasecmp ("administrator", uname
) == 0)
4228 strcpy (gname
, "None");
4229 glength
= strlen (gname
);
4230 ulength
= strlen (uname
);
4236 strcpy (uname
, "administrator");
4237 ulength
= strlen (uname
);
4238 strcpy (gname
, "None");
4239 glength
= strlen (gname
);
4242 CloseHandle (token
);
4245 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
4246 tem
= make_unibyte_string (uname
, ulength
);
4247 attrs
= Fcons (Fcons (Quser
,
4248 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
4250 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
4251 tem
= make_unibyte_string (gname
, glength
);
4252 attrs
= Fcons (Fcons (Qgroup
,
4253 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
4256 if (global_memory_status_ex (&memstex
))
4257 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
4258 totphys
= memstex
.ullTotalPhys
/ 1024.0;
4260 /* Visual Studio 6 cannot convert an unsigned __int64 type to
4261 double, so we need to do this for it... */
4263 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
4264 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
4265 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
4267 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
4269 #endif /* __GNUC__ || _MSC_VER >= 1300 */
4270 else if (global_memory_status (&memst
))
4271 totphys
= memst
.dwTotalPhys
/ 1024.0;
4274 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
4277 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
4279 attrs
= Fcons (Fcons (Qmajflt
,
4280 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
4282 attrs
= Fcons (Fcons (Qvsize
,
4283 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
4285 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
4287 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4290 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
4292 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
4294 attrs
= Fcons (Fcons (Qmajflt
,
4295 make_fixnum_or_float (mem
.PageFaultCount
)),
4297 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
4299 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4302 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
4304 DWORD rss
= maxrss
/ 1024;
4306 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
4308 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4311 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
4313 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
4314 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
4315 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
4316 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
4317 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
4318 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
4321 /* FIXME: Retrieve command line by walking the PEB of the process. */
4324 CloseHandle (h_proc
);
4330 /* Wrappers for winsock functions to map between our file descriptors
4331 and winsock's handles; also set h_errno for convenience.
4333 To allow Emacs to run on systems which don't have winsock support
4334 installed, we dynamically link to winsock on startup if present, and
4335 otherwise provide the minimum necessary functionality
4336 (eg. gethostname). */
4338 /* function pointers for relevant socket functions */
4339 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
4340 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
4341 int (PASCAL
*pfn_WSAGetLastError
) (void);
4342 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
4343 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
4344 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
4345 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
4346 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
4347 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
4348 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
4349 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
4350 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
4351 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
4352 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
4353 int (PASCAL
*pfn_WSACleanup
) (void);
4355 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
4356 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
4357 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
4358 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
4359 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
4360 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
4361 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
4362 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
4363 const char * optval
, int optlen
);
4364 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
4365 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
4367 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
4368 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
4369 struct sockaddr
* from
, int * fromlen
);
4370 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
4371 const struct sockaddr
* to
, int tolen
);
4373 /* SetHandleInformation is only needed to make sockets non-inheritable. */
4374 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
4375 #ifndef HANDLE_FLAG_INHERIT
4376 #define HANDLE_FLAG_INHERIT 1
4380 static int winsock_inuse
;
4385 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
4387 /* Not sure what would cause WSAENETDOWN, or even if it can happen
4388 after WSAStartup returns successfully, but it seems reasonable
4389 to allow unloading winsock anyway in that case. */
4390 if (pfn_WSACleanup () == 0 ||
4391 pfn_WSAGetLastError () == WSAENETDOWN
)
4393 if (FreeLibrary (winsock_lib
))
4402 init_winsock (int load_now
)
4404 WSADATA winsockData
;
4406 if (winsock_lib
!= NULL
)
4409 pfn_SetHandleInformation
4410 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
4411 "SetHandleInformation");
4413 winsock_lib
= LoadLibrary ("Ws2_32.dll");
4415 if (winsock_lib
!= NULL
)
4417 /* dynamically link to socket functions */
4419 #define LOAD_PROC(fn) \
4420 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
4423 LOAD_PROC (WSAStartup
);
4424 LOAD_PROC (WSASetLastError
);
4425 LOAD_PROC (WSAGetLastError
);
4426 LOAD_PROC (WSAEventSelect
);
4427 LOAD_PROC (WSACreateEvent
);
4428 LOAD_PROC (WSACloseEvent
);
4431 LOAD_PROC (connect
);
4432 LOAD_PROC (ioctlsocket
);
4435 LOAD_PROC (closesocket
);
4436 LOAD_PROC (shutdown
);
4439 LOAD_PROC (inet_addr
);
4440 LOAD_PROC (gethostname
);
4441 LOAD_PROC (gethostbyname
);
4442 LOAD_PROC (getservbyname
);
4443 LOAD_PROC (getpeername
);
4444 LOAD_PROC (WSACleanup
);
4445 LOAD_PROC (setsockopt
);
4447 LOAD_PROC (getsockname
);
4449 LOAD_PROC (recvfrom
);
4453 /* specify version 1.1 of winsock */
4454 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
4456 if (winsockData
.wVersion
!= 0x101)
4461 /* Report that winsock exists and is usable, but leave
4462 socket functions disabled. I am assuming that calling
4463 WSAStartup does not require any network interaction,
4464 and in particular does not cause or require a dial-up
4465 connection to be established. */
4468 FreeLibrary (winsock_lib
);
4476 FreeLibrary (winsock_lib
);
4486 /* function to set h_errno for compatibility; map winsock error codes to
4487 normal system codes where they overlap (non-overlapping definitions
4488 are already in <sys/socket.h> */
4492 if (winsock_lib
== NULL
)
4495 h_errno
= pfn_WSAGetLastError ();
4499 case WSAEACCES
: h_errno
= EACCES
; break;
4500 case WSAEBADF
: h_errno
= EBADF
; break;
4501 case WSAEFAULT
: h_errno
= EFAULT
; break;
4502 case WSAEINTR
: h_errno
= EINTR
; break;
4503 case WSAEINVAL
: h_errno
= EINVAL
; break;
4504 case WSAEMFILE
: h_errno
= EMFILE
; break;
4505 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
4506 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
4514 if (h_errno
== 0 && winsock_lib
!= NULL
)
4515 pfn_WSASetLastError (0);
4518 /* Extend strerror to handle the winsock-specific error codes. */
4522 } _wsa_errlist
[] = {
4523 WSAEINTR
, "Interrupted function call",
4524 WSAEBADF
, "Bad file descriptor",
4525 WSAEACCES
, "Permission denied",
4526 WSAEFAULT
, "Bad address",
4527 WSAEINVAL
, "Invalid argument",
4528 WSAEMFILE
, "Too many open files",
4530 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
4531 WSAEINPROGRESS
, "Operation now in progress",
4532 WSAEALREADY
, "Operation already in progress",
4533 WSAENOTSOCK
, "Socket operation on non-socket",
4534 WSAEDESTADDRREQ
, "Destination address required",
4535 WSAEMSGSIZE
, "Message too long",
4536 WSAEPROTOTYPE
, "Protocol wrong type for socket",
4537 WSAENOPROTOOPT
, "Bad protocol option",
4538 WSAEPROTONOSUPPORT
, "Protocol not supported",
4539 WSAESOCKTNOSUPPORT
, "Socket type not supported",
4540 WSAEOPNOTSUPP
, "Operation not supported",
4541 WSAEPFNOSUPPORT
, "Protocol family not supported",
4542 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
4543 WSAEADDRINUSE
, "Address already in use",
4544 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
4545 WSAENETDOWN
, "Network is down",
4546 WSAENETUNREACH
, "Network is unreachable",
4547 WSAENETRESET
, "Network dropped connection on reset",
4548 WSAECONNABORTED
, "Software caused connection abort",
4549 WSAECONNRESET
, "Connection reset by peer",
4550 WSAENOBUFS
, "No buffer space available",
4551 WSAEISCONN
, "Socket is already connected",
4552 WSAENOTCONN
, "Socket is not connected",
4553 WSAESHUTDOWN
, "Cannot send after socket shutdown",
4554 WSAETOOMANYREFS
, "Too many references", /* not sure */
4555 WSAETIMEDOUT
, "Connection timed out",
4556 WSAECONNREFUSED
, "Connection refused",
4557 WSAELOOP
, "Network loop", /* not sure */
4558 WSAENAMETOOLONG
, "Name is too long",
4559 WSAEHOSTDOWN
, "Host is down",
4560 WSAEHOSTUNREACH
, "No route to host",
4561 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
4562 WSAEPROCLIM
, "Too many processes",
4563 WSAEUSERS
, "Too many users", /* not sure */
4564 WSAEDQUOT
, "Double quote in host name", /* really not sure */
4565 WSAESTALE
, "Data is stale", /* not sure */
4566 WSAEREMOTE
, "Remote error", /* not sure */
4568 WSASYSNOTREADY
, "Network subsystem is unavailable",
4569 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
4570 WSANOTINITIALISED
, "Winsock not initialized successfully",
4571 WSAEDISCON
, "Graceful shutdown in progress",
4573 WSAENOMORE
, "No more operations allowed", /* not sure */
4574 WSAECANCELLED
, "Operation cancelled", /* not sure */
4575 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
4576 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
4577 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
4578 WSASYSCALLFAILURE
, "System call failure",
4579 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
4580 WSATYPE_NOT_FOUND
, "Class type not found",
4581 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
4582 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
4583 WSAEREFUSED
, "Operation refused", /* not sure */
4586 WSAHOST_NOT_FOUND
, "Host not found",
4587 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
4588 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
4589 WSANO_DATA
, "Valid name, no data record of requested type",
4595 sys_strerror (int error_no
)
4598 static char unknown_msg
[40];
4600 if (error_no
>= 0 && error_no
< sys_nerr
)
4601 return sys_errlist
[error_no
];
4603 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
4604 if (_wsa_errlist
[i
].errnum
== error_no
)
4605 return _wsa_errlist
[i
].msg
;
4607 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
4611 /* [andrewi 3-May-96] I've had conflicting results using both methods,
4612 but I believe the method of keeping the socket handle separate (and
4613 insuring it is not inheritable) is the correct one. */
4615 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
4617 static int socket_to_fd (SOCKET s
);
4620 sys_socket (int af
, int type
, int protocol
)
4624 if (winsock_lib
== NULL
)
4627 return INVALID_SOCKET
;
4632 /* call the real socket function */
4633 s
= pfn_socket (af
, type
, protocol
);
4635 if (s
!= INVALID_SOCKET
)
4636 return socket_to_fd (s
);
4642 /* Convert a SOCKET to a file descriptor. */
4644 socket_to_fd (SOCKET s
)
4649 /* Although under NT 3.5 _open_osfhandle will accept a socket
4650 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
4651 that does not work under NT 3.1. However, we can get the same
4652 effect by using a backdoor function to replace an existing
4653 descriptor handle with the one we want. */
4655 /* allocate a file descriptor (with appropriate flags) */
4656 fd
= _open ("NUL:", _O_RDWR
);
4659 /* Make a non-inheritable copy of the socket handle. Note
4660 that it is possible that sockets aren't actually kernel
4661 handles, which appears to be the case on Windows 9x when
4662 the MS Proxy winsock client is installed. */
4664 /* Apparently there is a bug in NT 3.51 with some service
4665 packs, which prevents using DuplicateHandle to make a
4666 socket handle non-inheritable (causes WSACleanup to
4667 hang). The work-around is to use SetHandleInformation
4668 instead if it is available and implemented. */
4669 if (pfn_SetHandleInformation
)
4671 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
4675 HANDLE parent
= GetCurrentProcess ();
4676 HANDLE new_s
= INVALID_HANDLE_VALUE
;
4678 if (DuplicateHandle (parent
,
4684 DUPLICATE_SAME_ACCESS
))
4686 /* It is possible that DuplicateHandle succeeds even
4687 though the socket wasn't really a kernel handle,
4688 because a real handle has the same value. So
4689 test whether the new handle really is a socket. */
4690 long nonblocking
= 0;
4691 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
4693 pfn_closesocket (s
);
4698 CloseHandle (new_s
);
4703 fd_info
[fd
].hnd
= (HANDLE
) s
;
4705 /* set our own internal flags */
4706 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
4712 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
4714 /* attach child_process to fd_info */
4715 if (fd_info
[ fd
].cp
!= NULL
)
4717 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
4721 fd_info
[ fd
].cp
= cp
;
4724 winsock_inuse
++; /* count open sockets */
4731 pfn_closesocket (s
);
4737 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
4739 if (winsock_lib
== NULL
)
4742 return SOCKET_ERROR
;
4746 if (fd_info
[s
].flags
& FILE_SOCKET
)
4748 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
4749 if (rc
== SOCKET_ERROR
)
4754 return SOCKET_ERROR
;
4758 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
4760 if (winsock_lib
== NULL
)
4763 return SOCKET_ERROR
;
4767 if (fd_info
[s
].flags
& FILE_SOCKET
)
4769 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
4770 if (rc
== SOCKET_ERROR
)
4775 return SOCKET_ERROR
;
4779 sys_htons (u_short hostshort
)
4781 return (winsock_lib
!= NULL
) ?
4782 pfn_htons (hostshort
) : hostshort
;
4786 sys_ntohs (u_short netshort
)
4788 return (winsock_lib
!= NULL
) ?
4789 pfn_ntohs (netshort
) : netshort
;
4793 sys_inet_addr (const char * cp
)
4795 return (winsock_lib
!= NULL
) ?
4796 pfn_inet_addr (cp
) : INADDR_NONE
;
4800 sys_gethostname (char * name
, int namelen
)
4802 if (winsock_lib
!= NULL
)
4803 return pfn_gethostname (name
, namelen
);
4805 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
4806 return !GetComputerName (name
, (DWORD
*)&namelen
);
4809 return SOCKET_ERROR
;
4813 sys_gethostbyname (const char * name
)
4815 struct hostent
* host
;
4817 if (winsock_lib
== NULL
)
4824 host
= pfn_gethostbyname (name
);
4831 sys_getservbyname (const char * name
, const char * proto
)
4833 struct servent
* serv
;
4835 if (winsock_lib
== NULL
)
4842 serv
= pfn_getservbyname (name
, proto
);
4849 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
4851 if (winsock_lib
== NULL
)
4854 return SOCKET_ERROR
;
4858 if (fd_info
[s
].flags
& FILE_SOCKET
)
4860 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
4861 if (rc
== SOCKET_ERROR
)
4866 return SOCKET_ERROR
;
4870 sys_shutdown (int s
, int how
)
4872 if (winsock_lib
== NULL
)
4875 return SOCKET_ERROR
;
4879 if (fd_info
[s
].flags
& FILE_SOCKET
)
4881 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
4882 if (rc
== SOCKET_ERROR
)
4887 return SOCKET_ERROR
;
4891 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
4893 if (winsock_lib
== NULL
)
4896 return SOCKET_ERROR
;
4900 if (fd_info
[s
].flags
& FILE_SOCKET
)
4902 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
4903 (const char *)optval
, optlen
);
4904 if (rc
== SOCKET_ERROR
)
4909 return SOCKET_ERROR
;
4913 sys_listen (int s
, int backlog
)
4915 if (winsock_lib
== NULL
)
4918 return SOCKET_ERROR
;
4922 if (fd_info
[s
].flags
& FILE_SOCKET
)
4924 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
4925 if (rc
== SOCKET_ERROR
)
4928 fd_info
[s
].flags
|= FILE_LISTEN
;
4932 return SOCKET_ERROR
;
4936 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
4938 if (winsock_lib
== NULL
)
4941 return SOCKET_ERROR
;
4945 if (fd_info
[s
].flags
& FILE_SOCKET
)
4947 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
4948 if (rc
== SOCKET_ERROR
)
4953 return SOCKET_ERROR
;
4957 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
4959 if (winsock_lib
== NULL
)
4966 if (fd_info
[s
].flags
& FILE_LISTEN
)
4968 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
4970 if (t
== INVALID_SOCKET
)
4973 fd
= socket_to_fd (t
);
4975 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
4976 ResetEvent (fd_info
[s
].cp
->char_avail
);
4984 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
4985 struct sockaddr
* from
, int * fromlen
)
4987 if (winsock_lib
== NULL
)
4990 return SOCKET_ERROR
;
4994 if (fd_info
[s
].flags
& FILE_SOCKET
)
4996 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
4997 if (rc
== SOCKET_ERROR
)
5002 return SOCKET_ERROR
;
5006 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5007 const struct sockaddr
* to
, int tolen
)
5009 if (winsock_lib
== NULL
)
5012 return SOCKET_ERROR
;
5016 if (fd_info
[s
].flags
& FILE_SOCKET
)
5018 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5019 if (rc
== SOCKET_ERROR
)
5024 return SOCKET_ERROR
;
5027 /* Windows does not have an fcntl function. Provide an implementation
5028 solely for making sockets non-blocking. */
5030 fcntl (int s
, int cmd
, int options
)
5032 if (winsock_lib
== NULL
)
5039 if (fd_info
[s
].flags
& FILE_SOCKET
)
5041 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
5043 unsigned long nblock
= 1;
5044 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5045 if (rc
== SOCKET_ERROR
)
5047 /* Keep track of the fact that we set this to non-blocking. */
5048 fd_info
[s
].flags
|= FILE_NDELAY
;
5054 return SOCKET_ERROR
;
5058 return SOCKET_ERROR
;
5062 /* Shadow main io functions: we need to handle pipes and sockets more
5063 intelligently, and implement non-blocking mode as well. */
5076 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5078 child_process
* cp
= fd_info
[fd
].cp
;
5080 fd_info
[fd
].cp
= NULL
;
5082 if (CHILD_ACTIVE (cp
))
5084 /* if last descriptor to active child_process then cleanup */
5086 for (i
= 0; i
< MAXDESC
; i
++)
5090 if (fd_info
[i
].cp
== cp
)
5095 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5097 if (winsock_lib
== NULL
) abort ();
5099 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5100 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5102 winsock_inuse
--; /* count open sockets */
5109 /* Note that sockets do not need special treatment here (at least on
5110 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5111 closesocket is equivalent to CloseHandle, which is to be expected
5112 because socket handles are fully fledged kernel handles. */
5115 if (rc
== 0 && fd
< MAXDESC
)
5116 fd_info
[fd
].flags
= 0;
5127 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5129 /* duplicate our internal info as well */
5130 fd_info
[new_fd
] = fd_info
[fd
];
5136 sys_dup2 (int src
, int dst
)
5140 if (dst
< 0 || dst
>= MAXDESC
)
5146 /* make sure we close the destination first if it's a pipe or socket */
5147 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5150 rc
= _dup2 (src
, dst
);
5153 /* duplicate our internal info as well */
5154 fd_info
[dst
] = fd_info
[src
];
5159 /* Unix pipe() has only one arg */
5161 sys_pipe (int * phandles
)
5166 /* make pipe handles non-inheritable; when we spawn a child, we
5167 replace the relevant handle with an inheritable one. Also put
5168 pipes into binary mode; we will do text mode translation ourselves
5170 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5174 /* Protect against overflow, since Windows can open more handles than
5175 our fd_info array has room for. */
5176 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5178 _close (phandles
[0]);
5179 _close (phandles
[1]);
5184 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
5185 fd_info
[phandles
[0]].flags
= flags
;
5187 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
5188 fd_info
[phandles
[1]].flags
= flags
;
5195 /* Function to do blocking read of one byte, needed to implement
5196 select. It is only allowed on sockets and pipes. */
5198 _sys_read_ahead (int fd
)
5203 if (fd
< 0 || fd
>= MAXDESC
)
5204 return STATUS_READ_ERROR
;
5206 cp
= fd_info
[fd
].cp
;
5208 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
5209 return STATUS_READ_ERROR
;
5211 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
5212 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
5214 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
5218 cp
->status
= STATUS_READ_IN_PROGRESS
;
5220 if (fd_info
[fd
].flags
& FILE_PIPE
)
5222 rc
= _read (fd
, &cp
->chr
, sizeof (char));
5224 /* Give subprocess time to buffer some more output for us before
5225 reporting that input is available; we need this because Windows 95
5226 connects DOS programs to pipes by making the pipe appear to be
5227 the normal console stdout - as a result most DOS programs will
5228 write to stdout without buffering, ie. one character at a
5229 time. Even some W32 programs do this - "dir" in a command
5230 shell on NT is very slow if we don't do this. */
5233 int wait
= w32_pipe_read_delay
;
5239 /* Yield remainder of our time slice, effectively giving a
5240 temporary priority boost to the child process. */
5244 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
5246 HANDLE hnd
= fd_info
[fd
].hnd
;
5247 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
5250 /* Configure timeouts for blocking read. */
5251 if (!GetCommTimeouts (hnd
, &ct
))
5252 return STATUS_READ_ERROR
;
5253 ct
.ReadIntervalTimeout
= 0;
5254 ct
.ReadTotalTimeoutMultiplier
= 0;
5255 ct
.ReadTotalTimeoutConstant
= 0;
5256 if (!SetCommTimeouts (hnd
, &ct
))
5257 return STATUS_READ_ERROR
;
5259 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
5261 if (GetLastError () != ERROR_IO_PENDING
)
5262 return STATUS_READ_ERROR
;
5263 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
5264 return STATUS_READ_ERROR
;
5267 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
5269 unsigned long nblock
= 0;
5270 /* We always want this to block, so temporarily disable NDELAY. */
5271 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5272 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5274 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
5276 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5279 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5283 if (rc
== sizeof (char))
5284 cp
->status
= STATUS_READ_SUCCEEDED
;
5286 cp
->status
= STATUS_READ_FAILED
;
5292 _sys_wait_accept (int fd
)
5298 if (fd
< 0 || fd
>= MAXDESC
)
5299 return STATUS_READ_ERROR
;
5301 cp
= fd_info
[fd
].cp
;
5303 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
5304 return STATUS_READ_ERROR
;
5306 cp
->status
= STATUS_READ_FAILED
;
5308 hEv
= pfn_WSACreateEvent ();
5309 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
5310 if (rc
!= SOCKET_ERROR
)
5312 rc
= WaitForSingleObject (hEv
, INFINITE
);
5313 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
5314 if (rc
== WAIT_OBJECT_0
)
5315 cp
->status
= STATUS_READ_SUCCEEDED
;
5317 pfn_WSACloseEvent (hEv
);
5323 sys_read (int fd
, char * buffer
, unsigned int count
)
5328 char * orig_buffer
= buffer
;
5336 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
5338 child_process
*cp
= fd_info
[fd
].cp
;
5340 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
5348 /* re-read CR carried over from last read */
5349 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
5351 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
5355 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
5358 /* presence of a child_process structure means we are operating in
5359 non-blocking mode - otherwise we just call _read directly.
5360 Note that the child_process structure might be missing because
5361 reap_subprocess has been called; in this case the pipe is
5362 already broken, so calling _read on it is okay. */
5365 int current_status
= cp
->status
;
5367 switch (current_status
)
5369 case STATUS_READ_FAILED
:
5370 case STATUS_READ_ERROR
:
5371 /* report normal EOF if nothing in buffer */
5373 fd_info
[fd
].flags
|= FILE_AT_EOF
;
5376 case STATUS_READ_READY
:
5377 case STATUS_READ_IN_PROGRESS
:
5378 DebPrint (("sys_read called when read is in progress\n"));
5379 errno
= EWOULDBLOCK
;
5382 case STATUS_READ_SUCCEEDED
:
5383 /* consume read-ahead char */
5384 *buffer
++ = cp
->chr
;
5387 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5388 ResetEvent (cp
->char_avail
);
5390 case STATUS_READ_ACKNOWLEDGED
:
5394 DebPrint (("sys_read: bad status %d\n", current_status
));
5399 if (fd_info
[fd
].flags
& FILE_PIPE
)
5401 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
5402 to_read
= min (waiting
, (DWORD
) count
);
5405 nchars
+= _read (fd
, buffer
, to_read
);
5407 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
5409 HANDLE hnd
= fd_info
[fd
].hnd
;
5410 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
5417 /* Configure timeouts for non-blocking read. */
5418 if (!GetCommTimeouts (hnd
, &ct
))
5423 ct
.ReadIntervalTimeout
= MAXDWORD
;
5424 ct
.ReadTotalTimeoutMultiplier
= 0;
5425 ct
.ReadTotalTimeoutConstant
= 0;
5426 if (!SetCommTimeouts (hnd
, &ct
))
5432 if (!ResetEvent (ovl
->hEvent
))
5437 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
5439 if (GetLastError () != ERROR_IO_PENDING
)
5444 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
5453 else /* FILE_SOCKET */
5455 if (winsock_lib
== NULL
) abort ();
5457 /* do the equivalent of a non-blocking read */
5458 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
5459 if (waiting
== 0 && nchars
== 0)
5461 h_errno
= errno
= EWOULDBLOCK
;
5467 /* always use binary mode for sockets */
5468 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
5469 if (res
== SOCKET_ERROR
)
5471 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
5472 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
5482 int nread
= _read (fd
, buffer
, count
);
5485 else if (nchars
== 0)
5490 fd_info
[fd
].flags
|= FILE_AT_EOF
;
5491 /* Perform text mode translation if required. */
5492 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
5494 nchars
= crlf_to_lf (nchars
, orig_buffer
);
5495 /* If buffer contains only CR, return that. To be absolutely
5496 sure we should attempt to read the next char, but in
5497 practice a CR to be followed by LF would not appear by
5498 itself in the buffer. */
5499 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
5501 fd_info
[fd
].flags
|= FILE_LAST_CR
;
5507 nchars
= _read (fd
, buffer
, count
);
5512 /* From w32xfns.c */
5513 extern HANDLE interrupt_handle
;
5515 /* For now, don't bother with a non-blocking mode */
5517 sys_write (int fd
, const void * buffer
, unsigned int count
)
5527 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
5529 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
5535 /* Perform text mode translation if required. */
5536 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
5538 char * tmpbuf
= alloca (count
* 2);
5539 unsigned char * src
= (void *)buffer
;
5540 unsigned char * dst
= tmpbuf
;
5545 unsigned char *next
;
5546 /* copy next line or remaining bytes */
5547 next
= _memccpy (dst
, src
, '\n', nbytes
);
5550 /* copied one line ending with '\n' */
5551 int copied
= next
- dst
;
5554 /* insert '\r' before '\n' */
5561 /* copied remaining partial line -> now finished */
5568 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
5570 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
5571 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
5572 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
5575 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
5577 if (GetLastError () != ERROR_IO_PENDING
)
5582 if (detect_input_pending ())
5583 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
5586 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
5587 if (active
== WAIT_OBJECT_0
)
5588 { /* User pressed C-g, cancel write, then leave. Don't bother
5589 cleaning up as we may only get stuck in buggy drivers. */
5590 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
5595 if (active
== WAIT_OBJECT_0
+ 1
5596 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
5603 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
5605 unsigned long nblock
= 0;
5606 if (winsock_lib
== NULL
) abort ();
5608 /* TODO: implement select() properly so non-blocking I/O works. */
5609 /* For now, make sure the write blocks. */
5610 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5611 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5613 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
5615 /* Set the socket back to non-blocking if it was before,
5616 for other operations that support it. */
5617 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5620 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5623 if (nchars
== SOCKET_ERROR
)
5625 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
5626 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
5632 /* Some networked filesystems don't like too large writes, so
5633 break them into smaller chunks. See the Comments section of
5634 the MSDN documentation of WriteFile for details behind the
5635 choice of the value of CHUNK below. See also the thread
5636 http://thread.gmane.org/gmane.comp.version-control.git/145294
5637 in the git mailing list. */
5638 const unsigned char *p
= buffer
;
5639 const unsigned chunk
= 30 * 1024 * 1024;
5644 unsigned this_chunk
= count
< chunk
? count
: chunk
;
5645 int n
= _write (fd
, p
, this_chunk
);
5653 else if (n
< this_chunk
)
5664 check_windows_init_file (void)
5666 /* A common indication that Emacs is not installed properly is when
5667 it cannot find the Windows installation file. If this file does
5668 not exist in the expected place, tell the user. */
5670 if (!noninteractive
&& !inhibit_window_system
)
5672 Lisp_Object objs
[2];
5673 Lisp_Object full_load_path
;
5674 Lisp_Object init_file
;
5677 objs
[0] = Vload_path
;
5678 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
5679 full_load_path
= Fappend (2, objs
);
5680 init_file
= build_string ("term/w32-win");
5681 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
5684 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
5685 char *init_file_name
= SDATA (init_file
);
5686 char *load_path
= SDATA (load_path_print
);
5687 char *buffer
= alloca (1024
5688 + strlen (init_file_name
)
5689 + strlen (load_path
));
5692 "The Emacs Windows initialization file \"%s.el\" "
5693 "could not be found in your Emacs installation. "
5694 "Emacs checked the following directories for this file:\n"
5696 "When Emacs cannot find this file, it usually means that it "
5697 "was not installed properly, or its distribution file was "
5698 "not unpacked properly.\nSee the README.W32 file in the "
5699 "top-level Emacs directory for more information.",
5700 init_file_name
, load_path
);
5703 "Emacs Abort Dialog",
5704 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
5705 /* Use the low-level Emacs abort. */
5719 /* shutdown the socket interface if necessary */
5728 /* Initialise the socket interface now if available and requested by
5729 the user by defining PRELOAD_WINSOCK; otherwise loading will be
5730 delayed until open-network-stream is called (w32-has-winsock can
5731 also be used to dynamically load or reload winsock).
5733 Conveniently, init_environment is called before us, so
5734 PRELOAD_WINSOCK can be set in the registry. */
5736 /* Always initialize this correctly. */
5739 if (getenv ("PRELOAD_WINSOCK") != NULL
)
5740 init_winsock (TRUE
);
5742 /* Initial preparation for subprocess support: replace our standard
5743 handles with non-inheritable versions. */
5746 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
5747 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
5748 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
5750 parent
= GetCurrentProcess ();
5752 /* ignore errors when duplicating and closing; typically the
5753 handles will be invalid when running as a gui program. */
5754 DuplicateHandle (parent
,
5755 GetStdHandle (STD_INPUT_HANDLE
),
5760 DUPLICATE_SAME_ACCESS
);
5762 DuplicateHandle (parent
,
5763 GetStdHandle (STD_OUTPUT_HANDLE
),
5768 DUPLICATE_SAME_ACCESS
);
5770 DuplicateHandle (parent
,
5771 GetStdHandle (STD_ERROR_HANDLE
),
5776 DUPLICATE_SAME_ACCESS
);
5782 if (stdin_save
!= INVALID_HANDLE_VALUE
)
5783 _open_osfhandle ((long) stdin_save
, O_TEXT
);
5785 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
5788 if (stdout_save
!= INVALID_HANDLE_VALUE
)
5789 _open_osfhandle ((long) stdout_save
, O_TEXT
);
5791 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
5794 if (stderr_save
!= INVALID_HANDLE_VALUE
)
5795 _open_osfhandle ((long) stderr_save
, O_TEXT
);
5797 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
5801 /* unfortunately, atexit depends on implementation of malloc */
5802 /* atexit (term_ntproc); */
5803 signal (SIGABRT
, term_ntproc
);
5805 /* determine which drives are fixed, for GetCachedVolumeInformation */
5807 /* GetDriveType must have trailing backslash. */
5808 char drive
[] = "A:\\";
5810 /* Loop over all possible drive letters */
5811 while (*drive
<= 'Z')
5813 /* Record if this drive letter refers to a fixed drive. */
5814 fixed_drives
[DRIVE_INDEX (*drive
)] =
5815 (GetDriveType (drive
) == DRIVE_FIXED
);
5820 /* Reset the volume info cache. */
5821 volume_cache
= NULL
;
5824 /* Check to see if Emacs has been installed correctly. */
5825 check_windows_init_file ();
5829 shutdown_handler ensures that buffers' autosave files are
5830 up to date when the user logs off, or the system shuts down.
5833 shutdown_handler (DWORD type
)
5835 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
5836 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
5837 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
5838 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
5840 /* Shut down cleanly, making sure autosave files are up to date. */
5841 shut_down_emacs (0, 0, Qnil
);
5844 /* Allow other handlers to handle this signal. */
5849 globals_of_w32 is used to initialize those global variables that
5850 must always be initialized on startup even when the global variable
5851 initialized is non zero (see the function main in emacs.c).
5854 globals_of_w32 (void)
5856 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
5858 get_process_times_fn
= (GetProcessTimes_Proc
)
5859 GetProcAddress (kernel32
, "GetProcessTimes");
5861 g_b_init_is_windows_9x
= 0;
5862 g_b_init_open_process_token
= 0;
5863 g_b_init_get_token_information
= 0;
5864 g_b_init_lookup_account_sid
= 0;
5865 g_b_init_get_sid_sub_authority
= 0;
5866 g_b_init_get_sid_sub_authority_count
= 0;
5867 g_b_init_get_file_security
= 0;
5868 g_b_init_get_security_descriptor_owner
= 0;
5869 g_b_init_get_security_descriptor_group
= 0;
5870 g_b_init_is_valid_sid
= 0;
5871 g_b_init_create_toolhelp32_snapshot
= 0;
5872 g_b_init_process32_first
= 0;
5873 g_b_init_process32_next
= 0;
5874 g_b_init_open_thread_token
= 0;
5875 g_b_init_impersonate_self
= 0;
5876 g_b_init_revert_to_self
= 0;
5877 g_b_init_get_process_memory_info
= 0;
5878 g_b_init_get_process_working_set_size
= 0;
5879 g_b_init_global_memory_status
= 0;
5880 g_b_init_global_memory_status_ex
= 0;
5881 g_b_init_equal_sid
= 0;
5882 g_b_init_copy_sid
= 0;
5883 g_b_init_get_length_sid
= 0;
5884 g_b_init_get_native_system_info
= 0;
5885 g_b_init_get_system_times
= 0;
5886 num_of_processors
= 0;
5887 /* The following sets a handler for shutdown notifications for
5888 console apps. This actually applies to Emacs in both console and
5889 GUI modes, since we had to fool windows into thinking emacs is a
5890 console application to get console mode to work. */
5891 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
5893 /* "None" is the default group name on standalone workstations. */
5894 strcpy (dflt_group_name
, "None");
5897 /* For make-serial-process */
5899 serial_open (char *port
)
5905 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
5906 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
5907 if (hnd
== INVALID_HANDLE_VALUE
)
5908 error ("Could not open %s", port
);
5909 fd
= (int) _open_osfhandle ((int) hnd
, 0);
5911 error ("Could not open %s", port
);
5915 error ("Could not create child process");
5917 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5918 fd_info
[ fd
].hnd
= hnd
;
5919 fd_info
[ fd
].flags
|=
5920 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
5921 if (fd_info
[ fd
].cp
!= NULL
)
5923 error ("fd_info[fd = %d] is already in use", fd
);
5925 fd_info
[ fd
].cp
= cp
;
5926 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
5927 if (cp
->ovl_read
.hEvent
== NULL
)
5928 error ("Could not create read event");
5929 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
5930 if (cp
->ovl_write
.hEvent
== NULL
)
5931 error ("Could not create write event");
5936 /* For serial-process-configure */
5938 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
5940 Lisp_Object childp2
= Qnil
;
5941 Lisp_Object tem
= Qnil
;
5945 char summary
[4] = "???"; /* This usually becomes "8N1". */
5947 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
5948 error ("Not a serial process");
5949 hnd
= fd_info
[ p
->outfd
].hnd
;
5951 childp2
= Fcopy_sequence (p
->childp
);
5953 /* Initialize timeouts for blocking read and blocking write. */
5954 if (!GetCommTimeouts (hnd
, &ct
))
5955 error ("GetCommTimeouts() failed");
5956 ct
.ReadIntervalTimeout
= 0;
5957 ct
.ReadTotalTimeoutMultiplier
= 0;
5958 ct
.ReadTotalTimeoutConstant
= 0;
5959 ct
.WriteTotalTimeoutMultiplier
= 0;
5960 ct
.WriteTotalTimeoutConstant
= 0;
5961 if (!SetCommTimeouts (hnd
, &ct
))
5962 error ("SetCommTimeouts() failed");
5963 /* Read port attributes and prepare default configuration. */
5964 memset (&dcb
, 0, sizeof (dcb
));
5965 dcb
.DCBlength
= sizeof (DCB
);
5966 if (!GetCommState (hnd
, &dcb
))
5967 error ("GetCommState() failed");
5970 dcb
.fAbortOnError
= FALSE
;
5971 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
5976 /* Configure speed. */
5977 if (!NILP (Fplist_member (contact
, QCspeed
)))
5978 tem
= Fplist_get (contact
, QCspeed
);
5980 tem
= Fplist_get (p
->childp
, QCspeed
);
5982 dcb
.BaudRate
= XINT (tem
);
5983 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
5985 /* Configure bytesize. */
5986 if (!NILP (Fplist_member (contact
, QCbytesize
)))
5987 tem
= Fplist_get (contact
, QCbytesize
);
5989 tem
= Fplist_get (p
->childp
, QCbytesize
);
5991 tem
= make_number (8);
5993 if (XINT (tem
) != 7 && XINT (tem
) != 8)
5994 error (":bytesize must be nil (8), 7, or 8");
5995 dcb
.ByteSize
= XINT (tem
);
5996 summary
[0] = XINT (tem
) + '0';
5997 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
5999 /* Configure parity. */
6000 if (!NILP (Fplist_member (contact
, QCparity
)))
6001 tem
= Fplist_get (contact
, QCparity
);
6003 tem
= Fplist_get (p
->childp
, QCparity
);
6004 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6005 error (":parity must be nil (no parity), `even', or `odd'");
6006 dcb
.fParity
= FALSE
;
6007 dcb
.Parity
= NOPARITY
;
6008 dcb
.fErrorChar
= FALSE
;
6013 else if (EQ (tem
, Qeven
))
6017 dcb
.Parity
= EVENPARITY
;
6018 dcb
.fErrorChar
= TRUE
;
6020 else if (EQ (tem
, Qodd
))
6024 dcb
.Parity
= ODDPARITY
;
6025 dcb
.fErrorChar
= TRUE
;
6027 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6029 /* Configure stopbits. */
6030 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6031 tem
= Fplist_get (contact
, QCstopbits
);
6033 tem
= Fplist_get (p
->childp
, QCstopbits
);
6035 tem
= make_number (1);
6037 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6038 error (":stopbits must be nil (1 stopbit), 1, or 2");
6039 summary
[2] = XINT (tem
) + '0';
6040 if (XINT (tem
) == 1)
6041 dcb
.StopBits
= ONESTOPBIT
;
6042 else if (XINT (tem
) == 2)
6043 dcb
.StopBits
= TWOSTOPBITS
;
6044 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6046 /* Configure flowcontrol. */
6047 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6048 tem
= Fplist_get (contact
, QCflowcontrol
);
6050 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6051 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6052 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6053 dcb
.fOutxCtsFlow
= FALSE
;
6054 dcb
.fOutxDsrFlow
= FALSE
;
6055 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6056 dcb
.fDsrSensitivity
= FALSE
;
6057 dcb
.fTXContinueOnXoff
= FALSE
;
6060 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6061 dcb
.XonChar
= 17; /* Control-Q */
6062 dcb
.XoffChar
= 19; /* Control-S */
6065 /* Already configured. */
6067 else if (EQ (tem
, Qhw
))
6069 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6070 dcb
.fOutxCtsFlow
= TRUE
;
6072 else if (EQ (tem
, Qsw
))
6077 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6079 /* Activate configuration. */
6080 if (!SetCommState (hnd
, &dcb
))
6081 error ("SetCommState() failed");
6083 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6084 p
->childp
= childp2
;