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
)
3253 WIN32_FIND_DATA wfd
;
3255 unsigned __int64 fake_inode
;
3258 int rootdir
= FALSE
;
3259 PSECURITY_DESCRIPTOR psd
= NULL
;
3261 if (path
== NULL
|| buf
== NULL
)
3267 name
= (char *) map_w32_filename (path
, &path
);
3268 /* Must be valid filename, no wild cards or other invalid
3269 characters. We use _mbspbrk to support multibyte strings that
3270 might look to strpbrk as if they included literal *, ?, and other
3271 characters mentioned below that are disallowed by Windows
3273 if (_mbspbrk (name
, "*?|<>\""))
3279 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3280 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3281 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3286 /* Remove trailing directory separator, unless name is the root
3287 directory of a drive or UNC volume in which case ensure there
3288 is a trailing separator. */
3289 len
= strlen (name
);
3290 rootdir
= (path
>= name
+ len
- 1
3291 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3292 name
= strcpy (alloca (len
+ 2), name
);
3294 if (is_unc_volume (name
))
3296 DWORD attrs
= unc_volume_file_attributes (name
);
3301 memset (&wfd
, 0, sizeof (wfd
));
3302 wfd
.dwFileAttributes
= attrs
;
3303 wfd
.ftCreationTime
= utc_base_ft
;
3304 wfd
.ftLastAccessTime
= utc_base_ft
;
3305 wfd
.ftLastWriteTime
= utc_base_ft
;
3306 strcpy (wfd
.cFileName
, name
);
3310 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3311 strcat (name
, "\\");
3312 if (GetDriveType (name
) < 2)
3317 memset (&wfd
, 0, sizeof (wfd
));
3318 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
3319 wfd
.ftCreationTime
= utc_base_ft
;
3320 wfd
.ftLastAccessTime
= utc_base_ft
;
3321 wfd
.ftLastWriteTime
= utc_base_ft
;
3322 strcpy (wfd
.cFileName
, name
);
3326 if (IS_DIRECTORY_SEP (name
[len
-1]))
3329 /* (This is hacky, but helps when doing file completions on
3330 network drives.) Optimize by using information available from
3331 active readdir if possible. */
3332 len
= strlen (dir_pathname
);
3333 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3335 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3336 && strnicmp (name
, dir_pathname
, len
) == 0
3337 && IS_DIRECTORY_SEP (name
[len
])
3338 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3340 /* This was the last entry returned by readdir. */
3341 wfd
= dir_find_data
;
3345 logon_network_drive (name
);
3347 fh
= FindFirstFile (name
, &wfd
);
3348 if (fh
== INVALID_HANDLE_VALUE
)
3357 if (!(NILP (Vw32_get_true_file_attributes
)
3358 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3359 /* No access rights required to get info. */
3360 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3361 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
3362 != INVALID_HANDLE_VALUE
)
3364 /* This is more accurate in terms of gettting the correct number
3365 of links, but is quite slow (it is noticeable when Emacs is
3366 making a list of file name completions). */
3367 BY_HANDLE_FILE_INFORMATION info
;
3369 if (GetFileInformationByHandle (fh
, &info
))
3371 buf
->st_nlink
= info
.nNumberOfLinks
;
3372 /* Might as well use file index to fake inode values, but this
3373 is not guaranteed to be unique unless we keep a handle open
3374 all the time (even then there are situations where it is
3375 not unique). Reputedly, there are at most 48 bits of info
3376 (on NTFS, presumably less on FAT). */
3377 fake_inode
= info
.nFileIndexHigh
;
3379 fake_inode
+= info
.nFileIndexLow
;
3387 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3389 buf
->st_mode
= S_IFDIR
;
3393 switch (GetFileType (fh
))
3395 case FILE_TYPE_DISK
:
3396 buf
->st_mode
= S_IFREG
;
3398 case FILE_TYPE_PIPE
:
3399 buf
->st_mode
= S_IFIFO
;
3401 case FILE_TYPE_CHAR
:
3402 case FILE_TYPE_UNKNOWN
:
3404 buf
->st_mode
= S_IFCHR
;
3408 psd
= get_file_security_desc (name
);
3409 get_file_owner_and_group (psd
, name
, buf
);
3413 /* Don't bother to make this information more accurate. */
3414 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
3419 get_file_owner_and_group (NULL
, name
, buf
);
3424 /* Not sure if there is any point in this. */
3425 if (!NILP (Vw32_generate_fake_inodes
))
3426 fake_inode
= generate_inode_val (name
);
3427 else if (fake_inode
== 0)
3429 /* For want of something better, try to make everything unique. */
3430 static DWORD gen_num
= 0;
3431 fake_inode
= ++gen_num
;
3435 /* MSVC defines _ino_t to be short; other libc's might not. */
3436 if (sizeof (buf
->st_ino
) == 2)
3437 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3439 buf
->st_ino
= fake_inode
;
3441 /* volume_info is set indirectly by map_w32_filename */
3442 buf
->st_dev
= volume_info
.serialnum
;
3443 buf
->st_rdev
= volume_info
.serialnum
;
3445 buf
->st_size
= wfd
.nFileSizeHigh
;
3446 buf
->st_size
<<= 32;
3447 buf
->st_size
+= wfd
.nFileSizeLow
;
3449 /* Convert timestamps to Unix format. */
3450 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
3451 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
3452 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3453 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
3454 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3456 /* determine rwx permissions */
3457 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3458 permission
= S_IREAD
;
3460 permission
= S_IREAD
| S_IWRITE
;
3462 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3463 permission
|= S_IEXEC
;
3464 else if (is_exec (name
))
3465 permission
|= S_IEXEC
;
3467 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3472 /* Provide fstat and utime as well as stat for consistent handling of
3475 fstat (int desc
, struct stat
* buf
)
3477 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3478 BY_HANDLE_FILE_INFORMATION info
;
3479 unsigned __int64 fake_inode
;
3482 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3484 case FILE_TYPE_DISK
:
3485 buf
->st_mode
= S_IFREG
;
3486 if (!GetFileInformationByHandle (fh
, &info
))
3492 case FILE_TYPE_PIPE
:
3493 buf
->st_mode
= S_IFIFO
;
3495 case FILE_TYPE_CHAR
:
3496 case FILE_TYPE_UNKNOWN
:
3498 buf
->st_mode
= S_IFCHR
;
3500 memset (&info
, 0, sizeof (info
));
3501 info
.dwFileAttributes
= 0;
3502 info
.ftCreationTime
= utc_base_ft
;
3503 info
.ftLastAccessTime
= utc_base_ft
;
3504 info
.ftLastWriteTime
= utc_base_ft
;
3507 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3508 buf
->st_mode
= S_IFDIR
;
3510 buf
->st_nlink
= info
.nNumberOfLinks
;
3511 /* Might as well use file index to fake inode values, but this
3512 is not guaranteed to be unique unless we keep a handle open
3513 all the time (even then there are situations where it is
3514 not unique). Reputedly, there are at most 48 bits of info
3515 (on NTFS, presumably less on FAT). */
3516 fake_inode
= info
.nFileIndexHigh
;
3518 fake_inode
+= info
.nFileIndexLow
;
3520 /* MSVC defines _ino_t to be short; other libc's might not. */
3521 if (sizeof (buf
->st_ino
) == 2)
3522 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3524 buf
->st_ino
= fake_inode
;
3526 /* Consider files to belong to current user.
3527 FIXME: this should use GetSecurityInfo API, but it is only
3528 available for _WIN32_WINNT >= 0x501. */
3529 buf
->st_uid
= dflt_passwd
.pw_uid
;
3530 buf
->st_gid
= dflt_passwd
.pw_gid
;
3531 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3532 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3534 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3535 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3537 buf
->st_size
= info
.nFileSizeHigh
;
3538 buf
->st_size
<<= 32;
3539 buf
->st_size
+= info
.nFileSizeLow
;
3541 /* Convert timestamps to Unix format. */
3542 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3543 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3544 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3545 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3546 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3548 /* determine rwx permissions */
3549 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3550 permission
= S_IREAD
;
3552 permission
= S_IREAD
| S_IWRITE
;
3554 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3555 permission
|= S_IEXEC
;
3558 #if 0 /* no way of knowing the filename */
3559 char * p
= strrchr (name
, '.');
3561 (xstrcasecmp (p
, ".exe") == 0 ||
3562 xstrcasecmp (p
, ".com") == 0 ||
3563 xstrcasecmp (p
, ".bat") == 0 ||
3564 xstrcasecmp (p
, ".cmd") == 0))
3565 permission
|= S_IEXEC
;
3569 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3575 utime (const char *name
, struct utimbuf
*times
)
3577 struct utimbuf deftime
;
3584 deftime
.modtime
= deftime
.actime
= time (NULL
);
3588 /* Need write access to set times. */
3589 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3590 0, OPEN_EXISTING
, 0, NULL
);
3593 convert_from_time_t (times
->actime
, &atime
);
3594 convert_from_time_t (times
->modtime
, &mtime
);
3595 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3612 /* Symlink-related functions that always fail. Used in fileio.c to
3615 symlink (char const *dummy1
, char const *dummy2
)
3622 readlink (const char *name
, char *dummy1
, size_t dummy2
)
3624 /* `access' is much faster than `stat' on MS-Windows. */
3625 if (sys_access (name
, 0) == 0)
3631 /* Support for browsing other processes and their attributes. See
3632 process.c for the Lisp bindings. */
3634 /* Helper wrapper functions. */
3636 static HANDLE WINAPI
3637 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
3639 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
3641 if (g_b_init_create_toolhelp32_snapshot
== 0)
3643 g_b_init_create_toolhelp32_snapshot
= 1;
3644 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
3645 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3646 "CreateToolhelp32Snapshot");
3648 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
3650 return INVALID_HANDLE_VALUE
;
3652 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
3656 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
3658 static Process32First_Proc s_pfn_Process32_First
= NULL
;
3660 if (g_b_init_process32_first
== 0)
3662 g_b_init_process32_first
= 1;
3663 s_pfn_Process32_First
= (Process32First_Proc
)
3664 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3667 if (s_pfn_Process32_First
== NULL
)
3671 return (s_pfn_Process32_First (hSnapshot
, lppe
));
3675 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
3677 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
3679 if (g_b_init_process32_next
== 0)
3681 g_b_init_process32_next
= 1;
3682 s_pfn_Process32_Next
= (Process32Next_Proc
)
3683 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3686 if (s_pfn_Process32_Next
== NULL
)
3690 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
3694 open_thread_token (HANDLE ThreadHandle
,
3695 DWORD DesiredAccess
,
3697 PHANDLE TokenHandle
)
3699 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
3700 HMODULE hm_advapi32
= NULL
;
3701 if (is_windows_9x () == TRUE
)
3703 SetLastError (ERROR_NOT_SUPPORTED
);
3706 if (g_b_init_open_thread_token
== 0)
3708 g_b_init_open_thread_token
= 1;
3709 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3710 s_pfn_Open_Thread_Token
=
3711 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
3713 if (s_pfn_Open_Thread_Token
== NULL
)
3715 SetLastError (ERROR_NOT_SUPPORTED
);
3719 s_pfn_Open_Thread_Token (
3728 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
3730 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
3731 HMODULE hm_advapi32
= NULL
;
3732 if (is_windows_9x () == TRUE
)
3736 if (g_b_init_impersonate_self
== 0)
3738 g_b_init_impersonate_self
= 1;
3739 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3740 s_pfn_Impersonate_Self
=
3741 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
3743 if (s_pfn_Impersonate_Self
== NULL
)
3747 return s_pfn_Impersonate_Self (ImpersonationLevel
);
3751 revert_to_self (void)
3753 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
3754 HMODULE hm_advapi32
= NULL
;
3755 if (is_windows_9x () == TRUE
)
3759 if (g_b_init_revert_to_self
== 0)
3761 g_b_init_revert_to_self
= 1;
3762 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3763 s_pfn_Revert_To_Self
=
3764 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
3766 if (s_pfn_Revert_To_Self
== NULL
)
3770 return s_pfn_Revert_To_Self ();
3774 get_process_memory_info (HANDLE h_proc
,
3775 PPROCESS_MEMORY_COUNTERS mem_counters
,
3778 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
3779 HMODULE hm_psapi
= NULL
;
3780 if (is_windows_9x () == TRUE
)
3784 if (g_b_init_get_process_memory_info
== 0)
3786 g_b_init_get_process_memory_info
= 1;
3787 hm_psapi
= LoadLibrary ("Psapi.dll");
3789 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
3790 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
3792 if (s_pfn_Get_Process_Memory_Info
== NULL
)
3796 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
3800 get_process_working_set_size (HANDLE h_proc
,
3804 static GetProcessWorkingSetSize_Proc
3805 s_pfn_Get_Process_Working_Set_Size
= NULL
;
3807 if (is_windows_9x () == TRUE
)
3811 if (g_b_init_get_process_working_set_size
== 0)
3813 g_b_init_get_process_working_set_size
= 1;
3814 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
3815 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3816 "GetProcessWorkingSetSize");
3818 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
3822 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
3826 global_memory_status (MEMORYSTATUS
*buf
)
3828 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
3830 if (is_windows_9x () == TRUE
)
3834 if (g_b_init_global_memory_status
== 0)
3836 g_b_init_global_memory_status
= 1;
3837 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
3838 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3839 "GlobalMemoryStatus");
3841 if (s_pfn_Global_Memory_Status
== NULL
)
3845 return s_pfn_Global_Memory_Status (buf
);
3849 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
3851 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
3853 if (is_windows_9x () == TRUE
)
3857 if (g_b_init_global_memory_status_ex
== 0)
3859 g_b_init_global_memory_status_ex
= 1;
3860 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
3861 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3862 "GlobalMemoryStatusEx");
3864 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
3868 return s_pfn_Global_Memory_Status_Ex (buf
);
3872 list_system_processes (void)
3874 struct gcpro gcpro1
;
3875 Lisp_Object proclist
= Qnil
;
3878 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
3880 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
3882 PROCESSENTRY32 proc_entry
;
3888 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
3889 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
3890 res
= process32_next (h_snapshot
, &proc_entry
))
3892 proc_id
= proc_entry
.th32ProcessID
;
3893 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
3896 CloseHandle (h_snapshot
);
3898 proclist
= Fnreverse (proclist
);
3905 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
3907 TOKEN_PRIVILEGES priv
;
3908 DWORD priv_size
= sizeof (priv
);
3909 DWORD opriv_size
= sizeof (*old_priv
);
3910 HANDLE h_token
= NULL
;
3911 HANDLE h_thread
= GetCurrentThread ();
3915 res
= open_thread_token (h_thread
,
3916 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3918 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
3920 if (impersonate_self (SecurityImpersonation
))
3921 res
= open_thread_token (h_thread
,
3922 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3927 priv
.PrivilegeCount
= 1;
3928 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
3929 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
3930 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
3931 old_priv
, &opriv_size
)
3932 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
3936 CloseHandle (h_token
);
3942 restore_privilege (TOKEN_PRIVILEGES
*priv
)
3944 DWORD priv_size
= sizeof (*priv
);
3945 HANDLE h_token
= NULL
;
3948 if (open_thread_token (GetCurrentThread (),
3949 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3952 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
3953 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
3957 CloseHandle (h_token
);
3963 ltime (long time_sec
, long time_usec
)
3965 return list3 (make_number ((time_sec
>> 16) & 0xffff),
3966 make_number (time_sec
& 0xffff),
3967 make_number (time_usec
));
3970 #define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
3973 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
3974 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
3977 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
3978 ULONGLONG tem1
, tem2
, tem3
, tem
;
3981 || !get_process_times_fn
3982 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
3983 &ft_kernel
, &ft_user
))
3986 GetSystemTimeAsFileTime (&ft_current
);
3988 FILETIME_TO_U64 (tem1
, ft_kernel
);
3990 *stime
= U64_TO_LISP_TIME (tem1
);
3992 FILETIME_TO_U64 (tem2
, ft_user
);
3994 *utime
= U64_TO_LISP_TIME (tem2
);
3997 *ttime
= U64_TO_LISP_TIME (tem3
);
3999 FILETIME_TO_U64 (tem
, ft_creation
);
4000 /* Process no 4 (System) returns zero creation time. */
4002 tem
= (tem
- utc_base
) / 10L;
4003 *ctime
= U64_TO_LISP_TIME (tem
);
4007 FILETIME_TO_U64 (tem3
, ft_current
);
4008 tem
= (tem3
- utc_base
) / 10L - tem
;
4010 *etime
= U64_TO_LISP_TIME (tem
);
4014 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4025 system_process_attributes (Lisp_Object pid
)
4027 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4028 Lisp_Object attrs
= Qnil
;
4029 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4030 HANDLE h_snapshot
, h_proc
;
4033 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4034 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4035 DWORD glength
= sizeof (gname
);
4036 HANDLE token
= NULL
;
4037 SID_NAME_USE user_type
;
4038 unsigned char *buf
= NULL
;
4040 TOKEN_USER user_token
;
4041 TOKEN_PRIMARY_GROUP group_token
;
4044 PROCESS_MEMORY_COUNTERS mem
;
4045 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4046 DWORD minrss
, maxrss
;
4048 MEMORY_STATUS_EX memstex
;
4049 double totphys
= 0.0;
4050 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4052 BOOL result
= FALSE
;
4054 CHECK_NUMBER_OR_FLOAT (pid
);
4055 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4057 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4059 GCPRO3 (attrs
, decoded_cmd
, tem
);
4061 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4066 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4067 for (res
= process32_first (h_snapshot
, &pe
); res
;
4068 res
= process32_next (h_snapshot
, &pe
))
4070 if (proc_id
== pe
.th32ProcessID
)
4073 decoded_cmd
= build_string ("Idle");
4076 /* Decode the command name from locale-specific
4078 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4079 strlen (pe
.szExeFile
));
4081 code_convert_string_norecord (cmd_str
,
4082 Vlocale_coding_system
, 0);
4084 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4085 attrs
= Fcons (Fcons (Qppid
,
4086 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4088 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4090 attrs
= Fcons (Fcons (Qthcount
,
4091 make_fixnum_or_float (pe
.cntThreads
)),
4098 CloseHandle (h_snapshot
);
4107 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4109 /* If we were denied a handle to the process, try again after
4110 enabling the SeDebugPrivilege in our process. */
4113 TOKEN_PRIVILEGES priv_current
;
4115 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4117 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4119 restore_privilege (&priv_current
);
4125 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4128 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4129 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4131 buf
= xmalloc (blen
);
4132 result
= get_token_information (token
, TokenUser
,
4133 (LPVOID
)buf
, blen
, &needed
);
4136 memcpy (&user_token
, buf
, sizeof (user_token
));
4137 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4139 euid
= get_rid (user_token
.User
.Sid
);
4140 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4145 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4148 strcpy (uname
, "unknown");
4152 ulength
= strlen (uname
);
4158 /* Determine a reasonable euid and gid values. */
4159 if (xstrcasecmp ("administrator", uname
) == 0)
4161 euid
= 500; /* well-known Administrator uid */
4162 egid
= 513; /* well-known None gid */
4166 /* Get group id and name. */
4167 result
= get_token_information (token
, TokenPrimaryGroup
,
4168 (LPVOID
)buf
, blen
, &needed
);
4169 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4171 buf
= xrealloc (buf
, blen
= needed
);
4172 result
= get_token_information (token
, TokenPrimaryGroup
,
4173 (LPVOID
)buf
, blen
, &needed
);
4177 memcpy (&group_token
, buf
, sizeof (group_token
));
4178 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
4180 egid
= get_rid (group_token
.PrimaryGroup
);
4181 dlength
= sizeof (domain
);
4183 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
4184 gname
, &glength
, NULL
, &dlength
,
4187 w32_add_to_cache (group_token
.PrimaryGroup
,
4191 strcpy (gname
, "None");
4195 glength
= strlen (gname
);
4203 if (!is_windows_9x ())
4205 /* We couldn't open the process token, presumably because of
4206 insufficient access rights. Assume this process is run
4208 strcpy (uname
, "SYSTEM");
4209 strcpy (gname
, "None");
4210 euid
= 18; /* SYSTEM */
4211 egid
= 513; /* None */
4212 glength
= strlen (gname
);
4213 ulength
= strlen (uname
);
4215 /* If we are running under Windows 9X, where security calls are
4216 not supported, we assume all processes are run by the current
4218 else if (GetUserName (uname
, &ulength
))
4220 if (xstrcasecmp ("administrator", uname
) == 0)
4225 strcpy (gname
, "None");
4226 glength
= strlen (gname
);
4227 ulength
= strlen (uname
);
4233 strcpy (uname
, "administrator");
4234 ulength
= strlen (uname
);
4235 strcpy (gname
, "None");
4236 glength
= strlen (gname
);
4239 CloseHandle (token
);
4242 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
4243 tem
= make_unibyte_string (uname
, ulength
);
4244 attrs
= Fcons (Fcons (Quser
,
4245 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
4247 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
4248 tem
= make_unibyte_string (gname
, glength
);
4249 attrs
= Fcons (Fcons (Qgroup
,
4250 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
4253 if (global_memory_status_ex (&memstex
))
4254 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
4255 totphys
= memstex
.ullTotalPhys
/ 1024.0;
4257 /* Visual Studio 6 cannot convert an unsigned __int64 type to
4258 double, so we need to do this for it... */
4260 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
4261 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
4262 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
4264 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
4266 #endif /* __GNUC__ || _MSC_VER >= 1300 */
4267 else if (global_memory_status (&memst
))
4268 totphys
= memst
.dwTotalPhys
/ 1024.0;
4271 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
4274 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
4276 attrs
= Fcons (Fcons (Qmajflt
,
4277 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
4279 attrs
= Fcons (Fcons (Qvsize
,
4280 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
4282 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
4284 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4287 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
4289 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
4291 attrs
= Fcons (Fcons (Qmajflt
,
4292 make_fixnum_or_float (mem
.PageFaultCount
)),
4294 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
4296 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4299 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
4301 DWORD rss
= maxrss
/ 1024;
4303 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
4305 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4308 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
4310 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
4311 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
4312 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
4313 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
4314 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
4315 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
4318 /* FIXME: Retrieve command line by walking the PEB of the process. */
4321 CloseHandle (h_proc
);
4327 /* Wrappers for winsock functions to map between our file descriptors
4328 and winsock's handles; also set h_errno for convenience.
4330 To allow Emacs to run on systems which don't have winsock support
4331 installed, we dynamically link to winsock on startup if present, and
4332 otherwise provide the minimum necessary functionality
4333 (eg. gethostname). */
4335 /* function pointers for relevant socket functions */
4336 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
4337 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
4338 int (PASCAL
*pfn_WSAGetLastError
) (void);
4339 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
4340 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
4341 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
4342 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
4343 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
4344 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
4345 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
4346 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
4347 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
4348 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
4349 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
4350 int (PASCAL
*pfn_WSACleanup
) (void);
4352 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
4353 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
4354 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
4355 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
4356 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
4357 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
4358 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
4359 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
4360 const char * optval
, int optlen
);
4361 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
4362 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
4364 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
4365 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
4366 struct sockaddr
* from
, int * fromlen
);
4367 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
4368 const struct sockaddr
* to
, int tolen
);
4370 /* SetHandleInformation is only needed to make sockets non-inheritable. */
4371 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
4372 #ifndef HANDLE_FLAG_INHERIT
4373 #define HANDLE_FLAG_INHERIT 1
4377 static int winsock_inuse
;
4382 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
4384 /* Not sure what would cause WSAENETDOWN, or even if it can happen
4385 after WSAStartup returns successfully, but it seems reasonable
4386 to allow unloading winsock anyway in that case. */
4387 if (pfn_WSACleanup () == 0 ||
4388 pfn_WSAGetLastError () == WSAENETDOWN
)
4390 if (FreeLibrary (winsock_lib
))
4399 init_winsock (int load_now
)
4401 WSADATA winsockData
;
4403 if (winsock_lib
!= NULL
)
4406 pfn_SetHandleInformation
4407 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
4408 "SetHandleInformation");
4410 winsock_lib
= LoadLibrary ("Ws2_32.dll");
4412 if (winsock_lib
!= NULL
)
4414 /* dynamically link to socket functions */
4416 #define LOAD_PROC(fn) \
4417 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
4420 LOAD_PROC (WSAStartup
);
4421 LOAD_PROC (WSASetLastError
);
4422 LOAD_PROC (WSAGetLastError
);
4423 LOAD_PROC (WSAEventSelect
);
4424 LOAD_PROC (WSACreateEvent
);
4425 LOAD_PROC (WSACloseEvent
);
4428 LOAD_PROC (connect
);
4429 LOAD_PROC (ioctlsocket
);
4432 LOAD_PROC (closesocket
);
4433 LOAD_PROC (shutdown
);
4436 LOAD_PROC (inet_addr
);
4437 LOAD_PROC (gethostname
);
4438 LOAD_PROC (gethostbyname
);
4439 LOAD_PROC (getservbyname
);
4440 LOAD_PROC (getpeername
);
4441 LOAD_PROC (WSACleanup
);
4442 LOAD_PROC (setsockopt
);
4444 LOAD_PROC (getsockname
);
4446 LOAD_PROC (recvfrom
);
4450 /* specify version 1.1 of winsock */
4451 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
4453 if (winsockData
.wVersion
!= 0x101)
4458 /* Report that winsock exists and is usable, but leave
4459 socket functions disabled. I am assuming that calling
4460 WSAStartup does not require any network interaction,
4461 and in particular does not cause or require a dial-up
4462 connection to be established. */
4465 FreeLibrary (winsock_lib
);
4473 FreeLibrary (winsock_lib
);
4483 /* function to set h_errno for compatibility; map winsock error codes to
4484 normal system codes where they overlap (non-overlapping definitions
4485 are already in <sys/socket.h> */
4489 if (winsock_lib
== NULL
)
4492 h_errno
= pfn_WSAGetLastError ();
4496 case WSAEACCES
: h_errno
= EACCES
; break;
4497 case WSAEBADF
: h_errno
= EBADF
; break;
4498 case WSAEFAULT
: h_errno
= EFAULT
; break;
4499 case WSAEINTR
: h_errno
= EINTR
; break;
4500 case WSAEINVAL
: h_errno
= EINVAL
; break;
4501 case WSAEMFILE
: h_errno
= EMFILE
; break;
4502 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
4503 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
4511 if (h_errno
== 0 && winsock_lib
!= NULL
)
4512 pfn_WSASetLastError (0);
4515 /* Extend strerror to handle the winsock-specific error codes. */
4519 } _wsa_errlist
[] = {
4520 WSAEINTR
, "Interrupted function call",
4521 WSAEBADF
, "Bad file descriptor",
4522 WSAEACCES
, "Permission denied",
4523 WSAEFAULT
, "Bad address",
4524 WSAEINVAL
, "Invalid argument",
4525 WSAEMFILE
, "Too many open files",
4527 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
4528 WSAEINPROGRESS
, "Operation now in progress",
4529 WSAEALREADY
, "Operation already in progress",
4530 WSAENOTSOCK
, "Socket operation on non-socket",
4531 WSAEDESTADDRREQ
, "Destination address required",
4532 WSAEMSGSIZE
, "Message too long",
4533 WSAEPROTOTYPE
, "Protocol wrong type for socket",
4534 WSAENOPROTOOPT
, "Bad protocol option",
4535 WSAEPROTONOSUPPORT
, "Protocol not supported",
4536 WSAESOCKTNOSUPPORT
, "Socket type not supported",
4537 WSAEOPNOTSUPP
, "Operation not supported",
4538 WSAEPFNOSUPPORT
, "Protocol family not supported",
4539 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
4540 WSAEADDRINUSE
, "Address already in use",
4541 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
4542 WSAENETDOWN
, "Network is down",
4543 WSAENETUNREACH
, "Network is unreachable",
4544 WSAENETRESET
, "Network dropped connection on reset",
4545 WSAECONNABORTED
, "Software caused connection abort",
4546 WSAECONNRESET
, "Connection reset by peer",
4547 WSAENOBUFS
, "No buffer space available",
4548 WSAEISCONN
, "Socket is already connected",
4549 WSAENOTCONN
, "Socket is not connected",
4550 WSAESHUTDOWN
, "Cannot send after socket shutdown",
4551 WSAETOOMANYREFS
, "Too many references", /* not sure */
4552 WSAETIMEDOUT
, "Connection timed out",
4553 WSAECONNREFUSED
, "Connection refused",
4554 WSAELOOP
, "Network loop", /* not sure */
4555 WSAENAMETOOLONG
, "Name is too long",
4556 WSAEHOSTDOWN
, "Host is down",
4557 WSAEHOSTUNREACH
, "No route to host",
4558 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
4559 WSAEPROCLIM
, "Too many processes",
4560 WSAEUSERS
, "Too many users", /* not sure */
4561 WSAEDQUOT
, "Double quote in host name", /* really not sure */
4562 WSAESTALE
, "Data is stale", /* not sure */
4563 WSAEREMOTE
, "Remote error", /* not sure */
4565 WSASYSNOTREADY
, "Network subsystem is unavailable",
4566 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
4567 WSANOTINITIALISED
, "Winsock not initialized successfully",
4568 WSAEDISCON
, "Graceful shutdown in progress",
4570 WSAENOMORE
, "No more operations allowed", /* not sure */
4571 WSAECANCELLED
, "Operation cancelled", /* not sure */
4572 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
4573 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
4574 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
4575 WSASYSCALLFAILURE
, "System call failure",
4576 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
4577 WSATYPE_NOT_FOUND
, "Class type not found",
4578 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
4579 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
4580 WSAEREFUSED
, "Operation refused", /* not sure */
4583 WSAHOST_NOT_FOUND
, "Host not found",
4584 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
4585 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
4586 WSANO_DATA
, "Valid name, no data record of requested type",
4592 sys_strerror (int error_no
)
4595 static char unknown_msg
[40];
4597 if (error_no
>= 0 && error_no
< sys_nerr
)
4598 return sys_errlist
[error_no
];
4600 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
4601 if (_wsa_errlist
[i
].errnum
== error_no
)
4602 return _wsa_errlist
[i
].msg
;
4604 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
4608 /* [andrewi 3-May-96] I've had conflicting results using both methods,
4609 but I believe the method of keeping the socket handle separate (and
4610 insuring it is not inheritable) is the correct one. */
4612 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
4614 static int socket_to_fd (SOCKET s
);
4617 sys_socket (int af
, int type
, int protocol
)
4621 if (winsock_lib
== NULL
)
4624 return INVALID_SOCKET
;
4629 /* call the real socket function */
4630 s
= pfn_socket (af
, type
, protocol
);
4632 if (s
!= INVALID_SOCKET
)
4633 return socket_to_fd (s
);
4639 /* Convert a SOCKET to a file descriptor. */
4641 socket_to_fd (SOCKET s
)
4646 /* Although under NT 3.5 _open_osfhandle will accept a socket
4647 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
4648 that does not work under NT 3.1. However, we can get the same
4649 effect by using a backdoor function to replace an existing
4650 descriptor handle with the one we want. */
4652 /* allocate a file descriptor (with appropriate flags) */
4653 fd
= _open ("NUL:", _O_RDWR
);
4656 /* Make a non-inheritable copy of the socket handle. Note
4657 that it is possible that sockets aren't actually kernel
4658 handles, which appears to be the case on Windows 9x when
4659 the MS Proxy winsock client is installed. */
4661 /* Apparently there is a bug in NT 3.51 with some service
4662 packs, which prevents using DuplicateHandle to make a
4663 socket handle non-inheritable (causes WSACleanup to
4664 hang). The work-around is to use SetHandleInformation
4665 instead if it is available and implemented. */
4666 if (pfn_SetHandleInformation
)
4668 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
4672 HANDLE parent
= GetCurrentProcess ();
4673 HANDLE new_s
= INVALID_HANDLE_VALUE
;
4675 if (DuplicateHandle (parent
,
4681 DUPLICATE_SAME_ACCESS
))
4683 /* It is possible that DuplicateHandle succeeds even
4684 though the socket wasn't really a kernel handle,
4685 because a real handle has the same value. So
4686 test whether the new handle really is a socket. */
4687 long nonblocking
= 0;
4688 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
4690 pfn_closesocket (s
);
4695 CloseHandle (new_s
);
4700 fd_info
[fd
].hnd
= (HANDLE
) s
;
4702 /* set our own internal flags */
4703 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
4709 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
4711 /* attach child_process to fd_info */
4712 if (fd_info
[ fd
].cp
!= NULL
)
4714 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
4718 fd_info
[ fd
].cp
= cp
;
4721 winsock_inuse
++; /* count open sockets */
4728 pfn_closesocket (s
);
4734 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
4736 if (winsock_lib
== NULL
)
4739 return SOCKET_ERROR
;
4743 if (fd_info
[s
].flags
& FILE_SOCKET
)
4745 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
4746 if (rc
== SOCKET_ERROR
)
4751 return SOCKET_ERROR
;
4755 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
4757 if (winsock_lib
== NULL
)
4760 return SOCKET_ERROR
;
4764 if (fd_info
[s
].flags
& FILE_SOCKET
)
4766 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
4767 if (rc
== SOCKET_ERROR
)
4772 return SOCKET_ERROR
;
4776 sys_htons (u_short hostshort
)
4778 return (winsock_lib
!= NULL
) ?
4779 pfn_htons (hostshort
) : hostshort
;
4783 sys_ntohs (u_short netshort
)
4785 return (winsock_lib
!= NULL
) ?
4786 pfn_ntohs (netshort
) : netshort
;
4790 sys_inet_addr (const char * cp
)
4792 return (winsock_lib
!= NULL
) ?
4793 pfn_inet_addr (cp
) : INADDR_NONE
;
4797 sys_gethostname (char * name
, int namelen
)
4799 if (winsock_lib
!= NULL
)
4800 return pfn_gethostname (name
, namelen
);
4802 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
4803 return !GetComputerName (name
, (DWORD
*)&namelen
);
4806 return SOCKET_ERROR
;
4810 sys_gethostbyname (const char * name
)
4812 struct hostent
* host
;
4814 if (winsock_lib
== NULL
)
4821 host
= pfn_gethostbyname (name
);
4828 sys_getservbyname (const char * name
, const char * proto
)
4830 struct servent
* serv
;
4832 if (winsock_lib
== NULL
)
4839 serv
= pfn_getservbyname (name
, proto
);
4846 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
4848 if (winsock_lib
== NULL
)
4851 return SOCKET_ERROR
;
4855 if (fd_info
[s
].flags
& FILE_SOCKET
)
4857 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
4858 if (rc
== SOCKET_ERROR
)
4863 return SOCKET_ERROR
;
4867 sys_shutdown (int s
, int how
)
4869 if (winsock_lib
== NULL
)
4872 return SOCKET_ERROR
;
4876 if (fd_info
[s
].flags
& FILE_SOCKET
)
4878 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
4879 if (rc
== SOCKET_ERROR
)
4884 return SOCKET_ERROR
;
4888 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
4890 if (winsock_lib
== NULL
)
4893 return SOCKET_ERROR
;
4897 if (fd_info
[s
].flags
& FILE_SOCKET
)
4899 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
4900 (const char *)optval
, optlen
);
4901 if (rc
== SOCKET_ERROR
)
4906 return SOCKET_ERROR
;
4910 sys_listen (int s
, int backlog
)
4912 if (winsock_lib
== NULL
)
4915 return SOCKET_ERROR
;
4919 if (fd_info
[s
].flags
& FILE_SOCKET
)
4921 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
4922 if (rc
== SOCKET_ERROR
)
4925 fd_info
[s
].flags
|= FILE_LISTEN
;
4929 return SOCKET_ERROR
;
4933 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
4935 if (winsock_lib
== NULL
)
4938 return SOCKET_ERROR
;
4942 if (fd_info
[s
].flags
& FILE_SOCKET
)
4944 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
4945 if (rc
== SOCKET_ERROR
)
4950 return SOCKET_ERROR
;
4954 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
4956 if (winsock_lib
== NULL
)
4963 if (fd_info
[s
].flags
& FILE_LISTEN
)
4965 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
4967 if (t
== INVALID_SOCKET
)
4970 fd
= socket_to_fd (t
);
4972 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
4973 ResetEvent (fd_info
[s
].cp
->char_avail
);
4981 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
4982 struct sockaddr
* from
, int * fromlen
)
4984 if (winsock_lib
== NULL
)
4987 return SOCKET_ERROR
;
4991 if (fd_info
[s
].flags
& FILE_SOCKET
)
4993 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
4994 if (rc
== SOCKET_ERROR
)
4999 return SOCKET_ERROR
;
5003 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5004 const struct sockaddr
* to
, int tolen
)
5006 if (winsock_lib
== NULL
)
5009 return SOCKET_ERROR
;
5013 if (fd_info
[s
].flags
& FILE_SOCKET
)
5015 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5016 if (rc
== SOCKET_ERROR
)
5021 return SOCKET_ERROR
;
5024 /* Windows does not have an fcntl function. Provide an implementation
5025 solely for making sockets non-blocking. */
5027 fcntl (int s
, int cmd
, int options
)
5029 if (winsock_lib
== NULL
)
5036 if (fd_info
[s
].flags
& FILE_SOCKET
)
5038 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
5040 unsigned long nblock
= 1;
5041 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5042 if (rc
== SOCKET_ERROR
)
5044 /* Keep track of the fact that we set this to non-blocking. */
5045 fd_info
[s
].flags
|= FILE_NDELAY
;
5051 return SOCKET_ERROR
;
5055 return SOCKET_ERROR
;
5059 /* Shadow main io functions: we need to handle pipes and sockets more
5060 intelligently, and implement non-blocking mode as well. */
5073 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5075 child_process
* cp
= fd_info
[fd
].cp
;
5077 fd_info
[fd
].cp
= NULL
;
5079 if (CHILD_ACTIVE (cp
))
5081 /* if last descriptor to active child_process then cleanup */
5083 for (i
= 0; i
< MAXDESC
; i
++)
5087 if (fd_info
[i
].cp
== cp
)
5092 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5094 if (winsock_lib
== NULL
) abort ();
5096 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5097 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5099 winsock_inuse
--; /* count open sockets */
5106 /* Note that sockets do not need special treatment here (at least on
5107 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5108 closesocket is equivalent to CloseHandle, which is to be expected
5109 because socket handles are fully fledged kernel handles. */
5112 if (rc
== 0 && fd
< MAXDESC
)
5113 fd_info
[fd
].flags
= 0;
5124 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5126 /* duplicate our internal info as well */
5127 fd_info
[new_fd
] = fd_info
[fd
];
5133 sys_dup2 (int src
, int dst
)
5137 if (dst
< 0 || dst
>= MAXDESC
)
5143 /* make sure we close the destination first if it's a pipe or socket */
5144 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5147 rc
= _dup2 (src
, dst
);
5150 /* duplicate our internal info as well */
5151 fd_info
[dst
] = fd_info
[src
];
5156 /* Unix pipe() has only one arg */
5158 sys_pipe (int * phandles
)
5163 /* make pipe handles non-inheritable; when we spawn a child, we
5164 replace the relevant handle with an inheritable one. Also put
5165 pipes into binary mode; we will do text mode translation ourselves
5167 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5171 /* Protect against overflow, since Windows can open more handles than
5172 our fd_info array has room for. */
5173 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5175 _close (phandles
[0]);
5176 _close (phandles
[1]);
5181 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
5182 fd_info
[phandles
[0]].flags
= flags
;
5184 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
5185 fd_info
[phandles
[1]].flags
= flags
;
5192 /* Function to do blocking read of one byte, needed to implement
5193 select. It is only allowed on sockets and pipes. */
5195 _sys_read_ahead (int fd
)
5200 if (fd
< 0 || fd
>= MAXDESC
)
5201 return STATUS_READ_ERROR
;
5203 cp
= fd_info
[fd
].cp
;
5205 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
5206 return STATUS_READ_ERROR
;
5208 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
5209 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
5211 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
5215 cp
->status
= STATUS_READ_IN_PROGRESS
;
5217 if (fd_info
[fd
].flags
& FILE_PIPE
)
5219 rc
= _read (fd
, &cp
->chr
, sizeof (char));
5221 /* Give subprocess time to buffer some more output for us before
5222 reporting that input is available; we need this because Windows 95
5223 connects DOS programs to pipes by making the pipe appear to be
5224 the normal console stdout - as a result most DOS programs will
5225 write to stdout without buffering, ie. one character at a
5226 time. Even some W32 programs do this - "dir" in a command
5227 shell on NT is very slow if we don't do this. */
5230 int wait
= w32_pipe_read_delay
;
5236 /* Yield remainder of our time slice, effectively giving a
5237 temporary priority boost to the child process. */
5241 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
5243 HANDLE hnd
= fd_info
[fd
].hnd
;
5244 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
5247 /* Configure timeouts for blocking read. */
5248 if (!GetCommTimeouts (hnd
, &ct
))
5249 return STATUS_READ_ERROR
;
5250 ct
.ReadIntervalTimeout
= 0;
5251 ct
.ReadTotalTimeoutMultiplier
= 0;
5252 ct
.ReadTotalTimeoutConstant
= 0;
5253 if (!SetCommTimeouts (hnd
, &ct
))
5254 return STATUS_READ_ERROR
;
5256 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
5258 if (GetLastError () != ERROR_IO_PENDING
)
5259 return STATUS_READ_ERROR
;
5260 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
5261 return STATUS_READ_ERROR
;
5264 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
5266 unsigned long nblock
= 0;
5267 /* We always want this to block, so temporarily disable NDELAY. */
5268 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5269 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5271 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
5273 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5276 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5280 if (rc
== sizeof (char))
5281 cp
->status
= STATUS_READ_SUCCEEDED
;
5283 cp
->status
= STATUS_READ_FAILED
;
5289 _sys_wait_accept (int fd
)
5295 if (fd
< 0 || fd
>= MAXDESC
)
5296 return STATUS_READ_ERROR
;
5298 cp
= fd_info
[fd
].cp
;
5300 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
5301 return STATUS_READ_ERROR
;
5303 cp
->status
= STATUS_READ_FAILED
;
5305 hEv
= pfn_WSACreateEvent ();
5306 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
5307 if (rc
!= SOCKET_ERROR
)
5309 rc
= WaitForSingleObject (hEv
, INFINITE
);
5310 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
5311 if (rc
== WAIT_OBJECT_0
)
5312 cp
->status
= STATUS_READ_SUCCEEDED
;
5314 pfn_WSACloseEvent (hEv
);
5320 sys_read (int fd
, char * buffer
, unsigned int count
)
5325 char * orig_buffer
= buffer
;
5333 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
5335 child_process
*cp
= fd_info
[fd
].cp
;
5337 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
5345 /* re-read CR carried over from last read */
5346 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
5348 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
5352 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
5355 /* presence of a child_process structure means we are operating in
5356 non-blocking mode - otherwise we just call _read directly.
5357 Note that the child_process structure might be missing because
5358 reap_subprocess has been called; in this case the pipe is
5359 already broken, so calling _read on it is okay. */
5362 int current_status
= cp
->status
;
5364 switch (current_status
)
5366 case STATUS_READ_FAILED
:
5367 case STATUS_READ_ERROR
:
5368 /* report normal EOF if nothing in buffer */
5370 fd_info
[fd
].flags
|= FILE_AT_EOF
;
5373 case STATUS_READ_READY
:
5374 case STATUS_READ_IN_PROGRESS
:
5375 DebPrint (("sys_read called when read is in progress\n"));
5376 errno
= EWOULDBLOCK
;
5379 case STATUS_READ_SUCCEEDED
:
5380 /* consume read-ahead char */
5381 *buffer
++ = cp
->chr
;
5384 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5385 ResetEvent (cp
->char_avail
);
5387 case STATUS_READ_ACKNOWLEDGED
:
5391 DebPrint (("sys_read: bad status %d\n", current_status
));
5396 if (fd_info
[fd
].flags
& FILE_PIPE
)
5398 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
5399 to_read
= min (waiting
, (DWORD
) count
);
5402 nchars
+= _read (fd
, buffer
, to_read
);
5404 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
5406 HANDLE hnd
= fd_info
[fd
].hnd
;
5407 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
5413 /* Configure timeouts for non-blocking read. */
5414 if (!GetCommTimeouts (hnd
, &ct
))
5419 ct
.ReadIntervalTimeout
= MAXDWORD
;
5420 ct
.ReadTotalTimeoutMultiplier
= 0;
5421 ct
.ReadTotalTimeoutConstant
= 0;
5422 if (!SetCommTimeouts (hnd
, &ct
))
5428 if (!ResetEvent (ovl
->hEvent
))
5433 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
5435 if (GetLastError () != ERROR_IO_PENDING
)
5440 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
5449 else /* FILE_SOCKET */
5451 if (winsock_lib
== NULL
) abort ();
5453 /* do the equivalent of a non-blocking read */
5454 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
5455 if (waiting
== 0 && nchars
== 0)
5457 h_errno
= errno
= EWOULDBLOCK
;
5463 /* always use binary mode for sockets */
5464 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
5465 if (res
== SOCKET_ERROR
)
5467 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
5468 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
5478 int nread
= _read (fd
, buffer
, count
);
5481 else if (nchars
== 0)
5486 fd_info
[fd
].flags
|= FILE_AT_EOF
;
5487 /* Perform text mode translation if required. */
5488 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
5490 nchars
= crlf_to_lf (nchars
, orig_buffer
);
5491 /* If buffer contains only CR, return that. To be absolutely
5492 sure we should attempt to read the next char, but in
5493 practice a CR to be followed by LF would not appear by
5494 itself in the buffer. */
5495 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
5497 fd_info
[fd
].flags
|= FILE_LAST_CR
;
5503 nchars
= _read (fd
, buffer
, count
);
5508 /* From w32xfns.c */
5509 extern HANDLE interrupt_handle
;
5511 /* For now, don't bother with a non-blocking mode */
5513 sys_write (int fd
, const void * buffer
, unsigned int count
)
5523 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
5525 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
5531 /* Perform text mode translation if required. */
5532 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
5534 char * tmpbuf
= alloca (count
* 2);
5535 unsigned char * src
= (void *)buffer
;
5536 unsigned char * dst
= tmpbuf
;
5541 unsigned char *next
;
5542 /* copy next line or remaining bytes */
5543 next
= _memccpy (dst
, src
, '\n', nbytes
);
5546 /* copied one line ending with '\n' */
5547 int copied
= next
- dst
;
5550 /* insert '\r' before '\n' */
5557 /* copied remaining partial line -> now finished */
5564 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
5566 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
5567 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
5568 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
5571 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
5573 if (GetLastError () != ERROR_IO_PENDING
)
5578 if (detect_input_pending ())
5579 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
5582 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
5583 if (active
== WAIT_OBJECT_0
)
5584 { /* User pressed C-g, cancel write, then leave. Don't bother
5585 cleaning up as we may only get stuck in buggy drivers. */
5586 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
5591 if (active
== WAIT_OBJECT_0
+ 1
5592 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
5599 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
5601 unsigned long nblock
= 0;
5602 if (winsock_lib
== NULL
) abort ();
5604 /* TODO: implement select() properly so non-blocking I/O works. */
5605 /* For now, make sure the write blocks. */
5606 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5607 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5609 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
5611 /* Set the socket back to non-blocking if it was before,
5612 for other operations that support it. */
5613 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5616 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5619 if (nchars
== SOCKET_ERROR
)
5621 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
5622 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
5628 /* Some networked filesystems don't like too large writes, so
5629 break them into smaller chunks. See the Comments section of
5630 the MSDN documentation of WriteFile for details behind the
5631 choice of the value of CHUNK below. See also the thread
5632 http://thread.gmane.org/gmane.comp.version-control.git/145294
5633 in the git mailing list. */
5634 const unsigned char *p
= buffer
;
5635 const unsigned chunk
= 30 * 1024 * 1024;
5640 unsigned this_chunk
= count
< chunk
? count
: chunk
;
5641 int n
= _write (fd
, p
, this_chunk
);
5649 else if (n
< this_chunk
)
5660 check_windows_init_file (void)
5662 /* A common indication that Emacs is not installed properly is when
5663 it cannot find the Windows installation file. If this file does
5664 not exist in the expected place, tell the user. */
5666 if (!noninteractive
&& !inhibit_window_system
)
5668 Lisp_Object objs
[2];
5669 Lisp_Object full_load_path
;
5670 Lisp_Object init_file
;
5673 objs
[0] = Vload_path
;
5674 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
5675 full_load_path
= Fappend (2, objs
);
5676 init_file
= build_string ("term/w32-win");
5677 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
5680 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
5681 char *init_file_name
= SDATA (init_file
);
5682 char *load_path
= SDATA (load_path_print
);
5683 char *buffer
= alloca (1024
5684 + strlen (init_file_name
)
5685 + strlen (load_path
));
5688 "The Emacs Windows initialization file \"%s.el\" "
5689 "could not be found in your Emacs installation. "
5690 "Emacs checked the following directories for this file:\n"
5692 "When Emacs cannot find this file, it usually means that it "
5693 "was not installed properly, or its distribution file was "
5694 "not unpacked properly.\nSee the README.W32 file in the "
5695 "top-level Emacs directory for more information.",
5696 init_file_name
, load_path
);
5699 "Emacs Abort Dialog",
5700 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
5701 /* Use the low-level Emacs abort. */
5715 /* shutdown the socket interface if necessary */
5724 /* Initialise the socket interface now if available and requested by
5725 the user by defining PRELOAD_WINSOCK; otherwise loading will be
5726 delayed until open-network-stream is called (w32-has-winsock can
5727 also be used to dynamically load or reload winsock).
5729 Conveniently, init_environment is called before us, so
5730 PRELOAD_WINSOCK can be set in the registry. */
5732 /* Always initialize this correctly. */
5735 if (getenv ("PRELOAD_WINSOCK") != NULL
)
5736 init_winsock (TRUE
);
5738 /* Initial preparation for subprocess support: replace our standard
5739 handles with non-inheritable versions. */
5742 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
5743 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
5744 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
5746 parent
= GetCurrentProcess ();
5748 /* ignore errors when duplicating and closing; typically the
5749 handles will be invalid when running as a gui program. */
5750 DuplicateHandle (parent
,
5751 GetStdHandle (STD_INPUT_HANDLE
),
5756 DUPLICATE_SAME_ACCESS
);
5758 DuplicateHandle (parent
,
5759 GetStdHandle (STD_OUTPUT_HANDLE
),
5764 DUPLICATE_SAME_ACCESS
);
5766 DuplicateHandle (parent
,
5767 GetStdHandle (STD_ERROR_HANDLE
),
5772 DUPLICATE_SAME_ACCESS
);
5778 if (stdin_save
!= INVALID_HANDLE_VALUE
)
5779 _open_osfhandle ((long) stdin_save
, O_TEXT
);
5781 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
5784 if (stdout_save
!= INVALID_HANDLE_VALUE
)
5785 _open_osfhandle ((long) stdout_save
, O_TEXT
);
5787 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
5790 if (stderr_save
!= INVALID_HANDLE_VALUE
)
5791 _open_osfhandle ((long) stderr_save
, O_TEXT
);
5793 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
5797 /* unfortunately, atexit depends on implementation of malloc */
5798 /* atexit (term_ntproc); */
5799 signal (SIGABRT
, term_ntproc
);
5801 /* determine which drives are fixed, for GetCachedVolumeInformation */
5803 /* GetDriveType must have trailing backslash. */
5804 char drive
[] = "A:\\";
5806 /* Loop over all possible drive letters */
5807 while (*drive
<= 'Z')
5809 /* Record if this drive letter refers to a fixed drive. */
5810 fixed_drives
[DRIVE_INDEX (*drive
)] =
5811 (GetDriveType (drive
) == DRIVE_FIXED
);
5816 /* Reset the volume info cache. */
5817 volume_cache
= NULL
;
5820 /* Check to see if Emacs has been installed correctly. */
5821 check_windows_init_file ();
5825 shutdown_handler ensures that buffers' autosave files are
5826 up to date when the user logs off, or the system shuts down.
5829 shutdown_handler (DWORD type
)
5831 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
5832 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
5833 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
5834 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
5836 /* Shut down cleanly, making sure autosave files are up to date. */
5837 shut_down_emacs (0, 0, Qnil
);
5840 /* Allow other handlers to handle this signal. */
5845 globals_of_w32 is used to initialize those global variables that
5846 must always be initialized on startup even when the global variable
5847 initialized is non zero (see the function main in emacs.c).
5850 globals_of_w32 (void)
5852 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
5854 get_process_times_fn
= (GetProcessTimes_Proc
)
5855 GetProcAddress (kernel32
, "GetProcessTimes");
5857 g_b_init_is_windows_9x
= 0;
5858 g_b_init_open_process_token
= 0;
5859 g_b_init_get_token_information
= 0;
5860 g_b_init_lookup_account_sid
= 0;
5861 g_b_init_get_sid_sub_authority
= 0;
5862 g_b_init_get_sid_sub_authority_count
= 0;
5863 g_b_init_get_file_security
= 0;
5864 g_b_init_get_security_descriptor_owner
= 0;
5865 g_b_init_get_security_descriptor_group
= 0;
5866 g_b_init_is_valid_sid
= 0;
5867 g_b_init_create_toolhelp32_snapshot
= 0;
5868 g_b_init_process32_first
= 0;
5869 g_b_init_process32_next
= 0;
5870 g_b_init_open_thread_token
= 0;
5871 g_b_init_impersonate_self
= 0;
5872 g_b_init_revert_to_self
= 0;
5873 g_b_init_get_process_memory_info
= 0;
5874 g_b_init_get_process_working_set_size
= 0;
5875 g_b_init_global_memory_status
= 0;
5876 g_b_init_global_memory_status_ex
= 0;
5877 g_b_init_equal_sid
= 0;
5878 g_b_init_copy_sid
= 0;
5879 g_b_init_get_length_sid
= 0;
5880 g_b_init_get_native_system_info
= 0;
5881 g_b_init_get_system_times
= 0;
5882 num_of_processors
= 0;
5883 /* The following sets a handler for shutdown notifications for
5884 console apps. This actually applies to Emacs in both console and
5885 GUI modes, since we had to fool windows into thinking emacs is a
5886 console application to get console mode to work. */
5887 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
5889 /* "None" is the default group name on standalone workstations. */
5890 strcpy (dflt_group_name
, "None");
5893 /* For make-serial-process */
5895 serial_open (char *port
)
5901 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
5902 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
5903 if (hnd
== INVALID_HANDLE_VALUE
)
5904 error ("Could not open %s", port
);
5905 fd
= (int) _open_osfhandle ((int) hnd
, 0);
5907 error ("Could not open %s", port
);
5911 error ("Could not create child process");
5913 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5914 fd_info
[ fd
].hnd
= hnd
;
5915 fd_info
[ fd
].flags
|=
5916 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
5917 if (fd_info
[ fd
].cp
!= NULL
)
5919 error ("fd_info[fd = %d] is already in use", fd
);
5921 fd_info
[ fd
].cp
= cp
;
5922 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
5923 if (cp
->ovl_read
.hEvent
== NULL
)
5924 error ("Could not create read event");
5925 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
5926 if (cp
->ovl_write
.hEvent
== NULL
)
5927 error ("Could not create write event");
5932 /* For serial-process-configure */
5934 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
5936 Lisp_Object childp2
= Qnil
;
5937 Lisp_Object tem
= Qnil
;
5941 char summary
[4] = "???"; /* This usually becomes "8N1". */
5943 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
5944 error ("Not a serial process");
5945 hnd
= fd_info
[ p
->outfd
].hnd
;
5947 childp2
= Fcopy_sequence (p
->childp
);
5949 /* Initialize timeouts for blocking read and blocking write. */
5950 if (!GetCommTimeouts (hnd
, &ct
))
5951 error ("GetCommTimeouts() failed");
5952 ct
.ReadIntervalTimeout
= 0;
5953 ct
.ReadTotalTimeoutMultiplier
= 0;
5954 ct
.ReadTotalTimeoutConstant
= 0;
5955 ct
.WriteTotalTimeoutMultiplier
= 0;
5956 ct
.WriteTotalTimeoutConstant
= 0;
5957 if (!SetCommTimeouts (hnd
, &ct
))
5958 error ("SetCommTimeouts() failed");
5959 /* Read port attributes and prepare default configuration. */
5960 memset (&dcb
, 0, sizeof (dcb
));
5961 dcb
.DCBlength
= sizeof (DCB
);
5962 if (!GetCommState (hnd
, &dcb
))
5963 error ("GetCommState() failed");
5966 dcb
.fAbortOnError
= FALSE
;
5967 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
5972 /* Configure speed. */
5973 if (!NILP (Fplist_member (contact
, QCspeed
)))
5974 tem
= Fplist_get (contact
, QCspeed
);
5976 tem
= Fplist_get (p
->childp
, QCspeed
);
5978 dcb
.BaudRate
= XINT (tem
);
5979 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
5981 /* Configure bytesize. */
5982 if (!NILP (Fplist_member (contact
, QCbytesize
)))
5983 tem
= Fplist_get (contact
, QCbytesize
);
5985 tem
= Fplist_get (p
->childp
, QCbytesize
);
5987 tem
= make_number (8);
5989 if (XINT (tem
) != 7 && XINT (tem
) != 8)
5990 error (":bytesize must be nil (8), 7, or 8");
5991 dcb
.ByteSize
= XINT (tem
);
5992 summary
[0] = XINT (tem
) + '0';
5993 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
5995 /* Configure parity. */
5996 if (!NILP (Fplist_member (contact
, QCparity
)))
5997 tem
= Fplist_get (contact
, QCparity
);
5999 tem
= Fplist_get (p
->childp
, QCparity
);
6000 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6001 error (":parity must be nil (no parity), `even', or `odd'");
6002 dcb
.fParity
= FALSE
;
6003 dcb
.Parity
= NOPARITY
;
6004 dcb
.fErrorChar
= FALSE
;
6009 else if (EQ (tem
, Qeven
))
6013 dcb
.Parity
= EVENPARITY
;
6014 dcb
.fErrorChar
= TRUE
;
6016 else if (EQ (tem
, Qodd
))
6020 dcb
.Parity
= ODDPARITY
;
6021 dcb
.fErrorChar
= TRUE
;
6023 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6025 /* Configure stopbits. */
6026 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6027 tem
= Fplist_get (contact
, QCstopbits
);
6029 tem
= Fplist_get (p
->childp
, QCstopbits
);
6031 tem
= make_number (1);
6033 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6034 error (":stopbits must be nil (1 stopbit), 1, or 2");
6035 summary
[2] = XINT (tem
) + '0';
6036 if (XINT (tem
) == 1)
6037 dcb
.StopBits
= ONESTOPBIT
;
6038 else if (XINT (tem
) == 2)
6039 dcb
.StopBits
= TWOSTOPBITS
;
6040 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6042 /* Configure flowcontrol. */
6043 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6044 tem
= Fplist_get (contact
, QCflowcontrol
);
6046 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6047 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6048 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6049 dcb
.fOutxCtsFlow
= FALSE
;
6050 dcb
.fOutxDsrFlow
= FALSE
;
6051 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6052 dcb
.fDsrSensitivity
= FALSE
;
6053 dcb
.fTXContinueOnXoff
= FALSE
;
6056 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6057 dcb
.XonChar
= 17; /* Control-Q */
6058 dcb
.XoffChar
= 19; /* Control-S */
6061 /* Already configured. */
6063 else if (EQ (tem
, Qhw
))
6065 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6066 dcb
.fOutxCtsFlow
= TRUE
;
6068 else if (EQ (tem
, Qsw
))
6073 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6075 /* Activate configuration. */
6076 if (!SetCommState (hnd
, &dcb
))
6077 error ("SetCommState() failed");
6079 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6080 p
->childp
= childp2
;