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);
1510 init_environment (char ** argv
)
1512 static const char * const tempdirs
[] = {
1513 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1518 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1520 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1521 temporary files and assume "/tmp" if $TMPDIR is unset, which
1522 will break on DOS/Windows. Refuse to work if we cannot find
1523 a directory, not even "c:/", usable for that purpose. */
1524 for (i
= 0; i
< imax
; i
++)
1526 const char *tmp
= tempdirs
[i
];
1529 tmp
= getenv (tmp
+ 1);
1530 /* Note that `access' can lie to us if the directory resides on a
1531 read-only filesystem, like CD-ROM or a write-protected floppy.
1532 The only way to be really sure is to actually create a file and
1533 see if it succeeds. But I think that's too much to ask. */
1534 if (tmp
&& _access (tmp
, D_OK
) == 0)
1536 char * var
= alloca (strlen (tmp
) + 8);
1537 sprintf (var
, "TMPDIR=%s", tmp
);
1538 _putenv (strdup (var
));
1545 Fcons (build_string ("no usable temporary directories found!!"),
1547 "While setting TMPDIR: ");
1549 /* Check for environment variables and use registry settings if they
1550 don't exist. Fallback on default values where applicable. */
1555 char locale_name
[32];
1556 struct stat ignored
;
1557 char default_home
[MAX_PATH
];
1559 static const struct env_entry
1566 {"PRELOAD_WINSOCK", NULL
},
1567 {"emacs_dir", "C:/emacs"},
1568 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1569 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1570 {"EMACSDATA", "%emacs_dir%/etc"},
1571 {"EMACSPATH", "%emacs_dir%/bin"},
1572 /* We no longer set INFOPATH because Info-default-directory-list
1574 /* {"INFOPATH", "%emacs_dir%/info"}, */
1575 {"EMACSDOC", "%emacs_dir%/etc"},
1580 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1582 /* We need to copy dflt_envvars[] and work on the copy because we
1583 don't want the dumped Emacs to inherit the values of
1584 environment variables we saw during dumping (which could be on
1585 a different system). The defaults above must be left intact. */
1586 struct env_entry env_vars
[N_ENV_VARS
];
1588 for (i
= 0; i
< N_ENV_VARS
; i
++)
1589 env_vars
[i
] = dflt_envvars
[i
];
1591 /* For backwards compatibility, check if a .emacs file exists in C:/
1592 If not, then we can try to default to the appdata directory under the
1593 user's profile, which is more likely to be writable. */
1594 if (stat ("C:/.emacs", &ignored
) < 0)
1596 HRESULT profile_result
;
1597 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1598 of Windows 95 and NT4 that have not been updated to include
1600 ShGetFolderPath_fn get_folder_path
;
1601 get_folder_path
= (ShGetFolderPath_fn
)
1602 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1604 if (get_folder_path
!= NULL
)
1606 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1609 /* If we can't get the appdata dir, revert to old behavior. */
1610 if (profile_result
== S_OK
)
1611 env_vars
[0].def_value
= default_home
;
1615 /* Get default locale info and use it for LANG. */
1616 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1617 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1618 locale_name
, sizeof (locale_name
)))
1620 for (i
= 0; i
< N_ENV_VARS
; i
++)
1622 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1624 env_vars
[i
].def_value
= locale_name
;
1630 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1632 /* Treat emacs_dir specially: set it unconditionally based on our
1633 location, if it appears that we are running from the bin subdir
1634 of a standard installation. */
1637 char modname
[MAX_PATH
];
1639 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1641 if ((p
= strrchr (modname
, '\\')) == NULL
)
1645 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1647 char buf
[SET_ENV_BUF_SIZE
];
1650 for (p
= modname
; *p
; p
++)
1651 if (*p
== '\\') *p
= '/';
1653 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1654 _putenv (strdup (buf
));
1656 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1658 /* FIXME: should use substring of get_emacs_configuration ().
1659 But I don't think the Windows build supports alpha, mips etc
1660 anymore, so have taken the easy option for now. */
1661 else if (p
&& xstrcasecmp (p
, "\\i386") == 0)
1664 p
= strrchr (modname
, '\\');
1668 p
= strrchr (modname
, '\\');
1669 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1671 char buf
[SET_ENV_BUF_SIZE
];
1674 for (p
= modname
; *p
; p
++)
1675 if (*p
== '\\') *p
= '/';
1677 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1678 _putenv (strdup (buf
));
1684 for (i
= 0; i
< N_ENV_VARS
; i
++)
1686 if (!getenv (env_vars
[i
].name
))
1690 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1691 /* Also ignore empty environment variables. */
1695 lpval
= env_vars
[i
].def_value
;
1696 dwType
= REG_EXPAND_SZ
;
1702 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1704 if (dwType
== REG_EXPAND_SZ
)
1705 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1706 else if (dwType
== REG_SZ
)
1707 strcpy (buf1
, lpval
);
1708 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1710 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1712 _putenv (strdup (buf2
));
1722 /* Rebuild system configuration to reflect invoking system. */
1723 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1725 /* Another special case: on NT, the PATH variable is actually named
1726 "Path" although cmd.exe (perhaps NT itself) arranges for
1727 environment variable lookup and setting to be case insensitive.
1728 However, Emacs assumes a fully case sensitive environment, so we
1729 need to change "Path" to "PATH" to match the expectations of
1730 various elisp packages. We do this by the sneaky method of
1731 modifying the string in the C runtime environ entry.
1733 The same applies to COMSPEC. */
1737 for (envp
= environ
; *envp
; envp
++)
1738 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1739 memcpy (*envp
, "PATH=", 5);
1740 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1741 memcpy (*envp
, "COMSPEC=", 8);
1744 /* Remember the initial working directory for getwd, then make the
1745 real wd be the location of emacs.exe to avoid conflicts when
1746 renaming or deleting directories. (We also don't call chdir when
1747 running subprocesses for the same reason.) */
1748 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1753 static char modname
[MAX_PATH
];
1755 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1757 if ((p
= strrchr (modname
, '\\')) == NULL
)
1761 SetCurrentDirectory (modname
);
1763 /* Ensure argv[0] has the full path to Emacs. */
1768 /* Determine if there is a middle mouse button, to allow parse_button
1769 to decide whether right mouse events should be mouse-2 or
1771 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1777 emacs_root_dir (void)
1779 static char root_dir
[FILENAME_MAX
];
1782 p
= getenv ("emacs_dir");
1785 strcpy (root_dir
, p
);
1786 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1787 dostounix_filename (root_dir
);
1791 /* We don't have scripts to automatically determine the system configuration
1792 for Emacs before it's compiled, and we don't want to have to make the
1793 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1797 get_emacs_configuration (void)
1799 char *arch
, *oem
, *os
;
1801 static char configuration_buffer
[32];
1803 /* Determine the processor type. */
1804 switch (get_processor_type ())
1807 #ifdef PROCESSOR_INTEL_386
1808 case PROCESSOR_INTEL_386
:
1809 case PROCESSOR_INTEL_486
:
1810 case PROCESSOR_INTEL_PENTIUM
:
1815 #ifdef PROCESSOR_MIPS_R2000
1816 case PROCESSOR_MIPS_R2000
:
1817 case PROCESSOR_MIPS_R3000
:
1818 case PROCESSOR_MIPS_R4000
:
1823 #ifdef PROCESSOR_ALPHA_21064
1824 case PROCESSOR_ALPHA_21064
:
1834 /* Use the OEM field to reflect the compiler/library combination. */
1836 #define COMPILER_NAME "msvc"
1839 #define COMPILER_NAME "mingw"
1841 #define COMPILER_NAME "unknown"
1844 oem
= COMPILER_NAME
;
1846 switch (osinfo_cache
.dwPlatformId
) {
1847 case VER_PLATFORM_WIN32_NT
:
1849 build_num
= osinfo_cache
.dwBuildNumber
;
1851 case VER_PLATFORM_WIN32_WINDOWS
:
1852 if (osinfo_cache
.dwMinorVersion
== 0) {
1857 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1859 case VER_PLATFORM_WIN32s
:
1860 /* Not supported, should not happen. */
1862 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1870 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1871 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1872 get_w32_major_version (), get_w32_minor_version (), build_num
);
1874 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1877 return configuration_buffer
;
1881 get_emacs_configuration_options (void)
1883 static char *options_buffer
;
1884 char cv
[32]; /* Enough for COMPILER_VERSION. */
1886 cv
, /* To be filled later. */
1890 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1891 with a starting space to save work here. */
1893 " --cflags", USER_CFLAGS
,
1896 " --ldflags", USER_LDFLAGS
,
1903 /* Work out the effective configure options for this build. */
1905 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1908 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1910 #define COMPILER_VERSION ""
1914 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
1915 return "Error: not enough space for compiler version";
1916 cv
[sizeof (cv
) - 1] = '\0';
1918 for (i
= 0; options
[i
]; i
++)
1919 size
+= strlen (options
[i
]);
1921 options_buffer
= xmalloc (size
+ 1);
1922 options_buffer
[0] = '\0';
1924 for (i
= 0; options
[i
]; i
++)
1925 strcat (options_buffer
, options
[i
]);
1927 return options_buffer
;
1931 #include <sys/timeb.h>
1933 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1935 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1940 tv
->tv_sec
= tb
.time
;
1941 tv
->tv_usec
= tb
.millitm
* 1000L;
1944 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1945 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1949 /* ------------------------------------------------------------------------- */
1950 /* IO support and wrapper functions for W32 API. */
1951 /* ------------------------------------------------------------------------- */
1953 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1954 on network directories, so we handle that case here.
1955 (Ulrich Leodolter, 1/11/95). */
1957 sys_ctime (const time_t *t
)
1959 char *str
= (char *) ctime (t
);
1960 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1963 /* Emulate sleep...we could have done this with a define, but that
1964 would necessitate including windows.h in the files that used it.
1965 This is much easier. */
1967 sys_sleep (int seconds
)
1969 Sleep (seconds
* 1000);
1972 /* Internal MSVC functions for low-level descriptor munging */
1973 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1974 extern int __cdecl
_free_osfhnd (int fd
);
1976 /* parallel array of private info on file handles */
1977 filedesc fd_info
[ MAXDESC
];
1979 typedef struct volume_info_data
{
1980 struct volume_info_data
* next
;
1982 /* time when info was obtained */
1985 /* actual volume info */
1994 /* Global referenced by various functions. */
1995 static volume_info_data volume_info
;
1997 /* Vector to indicate which drives are local and fixed (for which cached
1998 data never expires). */
1999 static BOOL fixed_drives
[26];
2001 /* Consider cached volume information to be stale if older than 10s,
2002 at least for non-local drives. Info for fixed drives is never stale. */
2003 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2004 #define VOLINFO_STILL_VALID( root_dir, info ) \
2005 ( ( isalpha (root_dir[0]) && \
2006 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2007 || GetTickCount () - info->timestamp < 10000 )
2009 /* Cache support functions. */
2011 /* Simple linked list with linear search is sufficient. */
2012 static volume_info_data
*volume_cache
= NULL
;
2014 static volume_info_data
*
2015 lookup_volume_info (char * root_dir
)
2017 volume_info_data
* info
;
2019 for (info
= volume_cache
; info
; info
= info
->next
)
2020 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2026 add_volume_info (char * root_dir
, volume_info_data
* info
)
2028 info
->root_dir
= xstrdup (root_dir
);
2029 info
->next
= volume_cache
;
2030 volume_cache
= info
;
2034 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2035 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2036 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2037 static volume_info_data
*
2038 GetCachedVolumeInformation (char * root_dir
)
2040 volume_info_data
* info
;
2041 char default_root
[ MAX_PATH
];
2043 /* NULL for root_dir means use root from current directory. */
2044 if (root_dir
== NULL
)
2046 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2048 parse_root (default_root
, &root_dir
);
2050 root_dir
= default_root
;
2053 /* Local fixed drives can be cached permanently. Removable drives
2054 cannot be cached permanently, since the volume name and serial
2055 number (if nothing else) can change. Remote drives should be
2056 treated as if they are removable, since there is no sure way to
2057 tell whether they are or not. Also, the UNC association of drive
2058 letters mapped to remote volumes can be changed at any time (even
2059 by other processes) without notice.
2061 As a compromise, so we can benefit from caching info for remote
2062 volumes, we use a simple expiry mechanism to invalidate cache
2063 entries that are more than ten seconds old. */
2066 /* No point doing this, because WNetGetConnection is even slower than
2067 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2068 GetDriveType is about the only call of this type which does not
2069 involve network access, and so is extremely quick). */
2071 /* Map drive letter to UNC if remote. */
2072 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2074 char remote_name
[ 256 ];
2075 char drive
[3] = { root_dir
[0], ':' };
2077 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2079 /* do something */ ;
2083 info
= lookup_volume_info (root_dir
);
2085 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2093 /* Info is not cached, or is stale. */
2094 if (!GetVolumeInformation (root_dir
,
2095 name
, sizeof (name
),
2099 type
, sizeof (type
)))
2102 /* Cache the volume information for future use, overwriting existing
2103 entry if present. */
2106 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
2107 add_volume_info (root_dir
, info
);
2115 info
->name
= xstrdup (name
);
2116 info
->serialnum
= serialnum
;
2117 info
->maxcomp
= maxcomp
;
2118 info
->flags
= flags
;
2119 info
->type
= xstrdup (type
);
2120 info
->timestamp
= GetTickCount ();
2126 /* Get information on the volume where name is held; set path pointer to
2127 start of pathname in name (past UNC header\volume header if present). */
2129 get_volume_info (const char * name
, const char ** pPath
)
2131 char temp
[MAX_PATH
];
2132 char *rootname
= NULL
; /* default to current volume */
2133 volume_info_data
* info
;
2138 /* find the root name of the volume if given */
2139 if (isalpha (name
[0]) && name
[1] == ':')
2147 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2154 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2167 info
= GetCachedVolumeInformation (rootname
);
2170 /* Set global referenced by other functions. */
2171 volume_info
= *info
;
2177 /* Determine if volume is FAT format (ie. only supports short 8.3
2178 names); also set path pointer to start of pathname in name. */
2180 is_fat_volume (const char * name
, const char ** pPath
)
2182 if (get_volume_info (name
, pPath
))
2183 return (volume_info
.maxcomp
== 12);
2187 /* Map filename to a valid 8.3 name if necessary. */
2189 map_w32_filename (const char * name
, const char ** pPath
)
2191 static char shortname
[MAX_PATH
];
2192 char * str
= shortname
;
2195 const char * save_name
= name
;
2197 if (strlen (name
) >= MAX_PATH
)
2199 /* Return a filename which will cause callers to fail. */
2200 strcpy (shortname
, "?");
2204 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2206 register int left
= 8; /* maximum number of chars in part */
2207 register int extn
= 0; /* extension added? */
2208 register int dots
= 2; /* maximum number of dots allowed */
2211 *str
++ = *name
++; /* skip past UNC header */
2213 while ((c
= *name
++))
2220 extn
= 0; /* reset extension flags */
2221 dots
= 2; /* max 2 dots */
2222 left
= 8; /* max length 8 for main part */
2226 extn
= 0; /* reset extension flags */
2227 dots
= 2; /* max 2 dots */
2228 left
= 8; /* max length 8 for main part */
2233 /* Convert path components of the form .xxx to _xxx,
2234 but leave . and .. as they are. This allows .emacs
2235 to be read as _emacs, for example. */
2239 IS_DIRECTORY_SEP (*name
))
2254 extn
= 1; /* we've got an extension */
2255 left
= 3; /* 3 chars in extension */
2259 /* any embedded dots after the first are converted to _ */
2264 case '#': /* don't lose these, they're important */
2266 str
[-1] = c
; /* replace last character of part */
2271 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2273 dots
= 0; /* started a path component */
2282 strcpy (shortname
, name
);
2283 unixtodos_filename (shortname
);
2287 *pPath
= shortname
+ (path
- save_name
);
2293 is_exec (const char * name
)
2295 char * p
= strrchr (name
, '.');
2298 && (xstrcasecmp (p
, ".exe") == 0 ||
2299 xstrcasecmp (p
, ".com") == 0 ||
2300 xstrcasecmp (p
, ".bat") == 0 ||
2301 xstrcasecmp (p
, ".cmd") == 0));
2304 /* Emulate the Unix directory procedures opendir, closedir,
2305 and readdir. We can't use the procedures supplied in sysdep.c,
2306 so we provide them here. */
2308 struct direct dir_static
; /* simulated directory contents */
2309 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2310 static int dir_is_fat
;
2311 static char dir_pathname
[MAXPATHLEN
+1];
2312 static WIN32_FIND_DATA dir_find_data
;
2314 /* Support shares on a network resource as subdirectories of a read-only
2316 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2317 static HANDLE
open_unc_volume (const char *);
2318 static char *read_unc_volume (HANDLE
, char *, int);
2319 static void close_unc_volume (HANDLE
);
2322 opendir (char *filename
)
2326 /* Opening is done by FindFirstFile. However, a read is inherent to
2327 this operation, so we defer the open until read time. */
2329 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2331 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2334 if (is_unc_volume (filename
))
2336 wnet_enum_handle
= open_unc_volume (filename
);
2337 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2341 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2348 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2349 dir_pathname
[MAXPATHLEN
] = '\0';
2350 dir_is_fat
= is_fat_volume (filename
, NULL
);
2356 closedir (DIR *dirp
)
2358 /* If we have a find-handle open, close it. */
2359 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2361 FindClose (dir_find_handle
);
2362 dir_find_handle
= INVALID_HANDLE_VALUE
;
2364 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2366 close_unc_volume (wnet_enum_handle
);
2367 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2369 xfree ((char *) dirp
);
2375 int downcase
= !NILP (Vw32_downcase_file_names
);
2377 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2379 if (!read_unc_volume (wnet_enum_handle
,
2380 dir_find_data
.cFileName
,
2384 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2385 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2387 char filename
[MAXNAMLEN
+ 3];
2390 strcpy (filename
, dir_pathname
);
2391 ln
= strlen (filename
) - 1;
2392 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2393 strcat (filename
, "\\");
2394 strcat (filename
, "*");
2396 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2398 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2403 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2407 /* Emacs never uses this value, so don't bother making it match
2408 value returned by stat(). */
2409 dir_static
.d_ino
= 1;
2411 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2413 /* If the file name in cFileName[] includes `?' characters, it means
2414 the original file name used characters that cannot be represented
2415 by the current ANSI codepage. To avoid total lossage, retrieve
2416 the short 8+3 alias of the long file name. */
2417 if (_mbspbrk (dir_static
.d_name
, "?"))
2419 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2420 downcase
= 1; /* 8+3 aliases are returned in all caps */
2422 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2423 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2424 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2426 /* If the file name in cFileName[] includes `?' characters, it means
2427 the original file name used characters that cannot be represented
2428 by the current ANSI codepage. To avoid total lossage, retrieve
2429 the short 8+3 alias of the long file name. */
2430 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2432 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2433 /* 8+3 aliases are returned in all caps, which could break
2434 various alists that look at filenames' extensions. */
2438 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2439 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2441 _strlwr (dir_static
.d_name
);
2445 for (p
= dir_static
.d_name
; *p
; p
++)
2446 if (*p
>= 'a' && *p
<= 'z')
2449 _strlwr (dir_static
.d_name
);
2456 open_unc_volume (const char *path
)
2462 nr
.dwScope
= RESOURCE_GLOBALNET
;
2463 nr
.dwType
= RESOURCETYPE_DISK
;
2464 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2465 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2466 nr
.lpLocalName
= NULL
;
2467 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2468 nr
.lpComment
= NULL
;
2469 nr
.lpProvider
= NULL
;
2471 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2472 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2474 if (result
== NO_ERROR
)
2477 return INVALID_HANDLE_VALUE
;
2481 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2485 DWORD bufsize
= 512;
2490 buffer
= alloca (bufsize
);
2491 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2492 if (result
!= NO_ERROR
)
2495 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2496 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2498 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2501 strncpy (readbuf
, ptr
, size
);
2506 close_unc_volume (HANDLE henum
)
2508 if (henum
!= INVALID_HANDLE_VALUE
)
2509 WNetCloseEnum (henum
);
2513 unc_volume_file_attributes (const char *path
)
2518 henum
= open_unc_volume (path
);
2519 if (henum
== INVALID_HANDLE_VALUE
)
2522 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2524 close_unc_volume (henum
);
2529 /* Ensure a network connection is authenticated. */
2531 logon_network_drive (const char *path
)
2533 NETRESOURCE resource
;
2534 char share
[MAX_PATH
];
2539 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2540 drvtype
= DRIVE_REMOTE
;
2541 else if (path
[0] == '\0' || path
[1] != ':')
2542 drvtype
= GetDriveType (NULL
);
2549 drvtype
= GetDriveType (drive
);
2552 /* Only logon to networked drives. */
2553 if (drvtype
!= DRIVE_REMOTE
)
2557 strncpy (share
, path
, MAX_PATH
);
2558 /* Truncate to just server and share name. */
2559 for (i
= 2; i
< MAX_PATH
; i
++)
2561 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2568 resource
.dwType
= RESOURCETYPE_DISK
;
2569 resource
.lpLocalName
= NULL
;
2570 resource
.lpRemoteName
= share
;
2571 resource
.lpProvider
= NULL
;
2573 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2576 /* Shadow some MSVC runtime functions to map requests for long filenames
2577 to reasonable short names if necessary. This was originally added to
2578 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2582 sys_access (const char * path
, int mode
)
2586 /* MSVC implementation doesn't recognize D_OK. */
2587 path
= map_w32_filename (path
, NULL
);
2588 if (is_unc_volume (path
))
2590 attributes
= unc_volume_file_attributes (path
);
2591 if (attributes
== -1) {
2596 else if ((attributes
= GetFileAttributes (path
)) == -1)
2598 /* Should try mapping GetLastError to errno; for now just indicate
2599 that path doesn't exist. */
2603 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2608 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2613 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2622 sys_chdir (const char * path
)
2624 return _chdir (map_w32_filename (path
, NULL
));
2628 sys_chmod (const char * path
, int mode
)
2630 return _chmod (map_w32_filename (path
, NULL
), mode
);
2634 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2636 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2642 sys_creat (const char * path
, int mode
)
2644 return _creat (map_w32_filename (path
, NULL
), mode
);
2648 sys_fopen (const char * path
, const char * mode
)
2652 const char * mode_save
= mode
;
2654 /* Force all file handles to be non-inheritable. This is necessary to
2655 ensure child processes don't unwittingly inherit handles that might
2656 prevent future file access. */
2660 else if (mode
[0] == 'w' || mode
[0] == 'a')
2661 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2665 /* Only do simplistic option parsing. */
2669 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2672 else if (mode
[0] == 'b')
2677 else if (mode
[0] == 't')
2684 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2688 return _fdopen (fd
, mode_save
);
2691 /* This only works on NTFS volumes, but is useful to have. */
2693 sys_link (const char * old
, const char * new)
2697 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2699 if (old
== NULL
|| new == NULL
)
2705 strcpy (oldname
, map_w32_filename (old
, NULL
));
2706 strcpy (newname
, map_w32_filename (new, NULL
));
2708 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2709 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2710 if (fileh
!= INVALID_HANDLE_VALUE
)
2714 /* Confusingly, the "alternate" stream name field does not apply
2715 when restoring a hard link, and instead contains the actual
2716 stream data for the link (ie. the name of the link to create).
2717 The WIN32_STREAM_ID structure before the cStreamName field is
2718 the stream header, which is then immediately followed by the
2722 WIN32_STREAM_ID wid
;
2723 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2726 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2727 data
.wid
.cStreamName
, MAX_PATH
);
2730 LPVOID context
= NULL
;
2733 data
.wid
.dwStreamId
= BACKUP_LINK
;
2734 data
.wid
.dwStreamAttributes
= 0;
2735 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2736 data
.wid
.Size
.HighPart
= 0;
2737 data
.wid
.dwStreamNameSize
= 0;
2739 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2740 offsetof (WIN32_STREAM_ID
, cStreamName
)
2741 + data
.wid
.Size
.LowPart
,
2742 &wbytes
, FALSE
, FALSE
, &context
)
2743 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2750 /* Should try mapping GetLastError to errno; for now just
2751 indicate a general error (eg. links not supported). */
2752 errno
= EINVAL
; // perhaps EMLINK?
2756 CloseHandle (fileh
);
2765 sys_mkdir (const char * path
)
2767 return _mkdir (map_w32_filename (path
, NULL
));
2770 /* Because of long name mapping issues, we need to implement this
2771 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2772 a unique name, instead of setting the input template to an empty
2775 Standard algorithm seems to be use pid or tid with a letter on the
2776 front (in place of the 6 X's) and cycle through the letters to find a
2777 unique name. We extend that to allow any reasonable character as the
2778 first of the 6 X's. */
2780 sys_mktemp (char * template)
2784 unsigned uid
= GetCurrentThreadId ();
2785 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2787 if (template == NULL
)
2789 p
= template + strlen (template);
2791 /* replace up to the last 5 X's with uid in decimal */
2792 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2794 p
[0] = '0' + uid
% 10;
2798 if (i
< 0 && p
[0] == 'X')
2803 int save_errno
= errno
;
2804 p
[0] = first_char
[i
];
2805 if (sys_access (template, 0) < 0)
2811 while (++i
< sizeof (first_char
));
2814 /* Template is badly formed or else we can't generate a unique name,
2815 so return empty string */
2821 sys_open (const char * path
, int oflag
, int mode
)
2823 const char* mpath
= map_w32_filename (path
, NULL
);
2824 /* Try to open file without _O_CREAT, to be able to write to hidden
2825 and system files. Force all file handles to be
2827 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2830 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2834 sys_rename (const char * oldname
, const char * newname
)
2837 char temp
[MAX_PATH
];
2839 /* MoveFile on Windows 95 doesn't correctly change the short file name
2840 alias in a number of circumstances (it is not easy to predict when
2841 just by looking at oldname and newname, unfortunately). In these
2842 cases, renaming through a temporary name avoids the problem.
2844 A second problem on Windows 95 is that renaming through a temp name when
2845 newname is uppercase fails (the final long name ends up in
2846 lowercase, although the short alias might be uppercase) UNLESS the
2847 long temp name is not 8.3.
2849 So, on Windows 95 we always rename through a temp name, and we make sure
2850 the temp name has a long extension to ensure correct renaming. */
2852 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2854 if (os_subtype
== OS_WIN95
)
2860 oldname
= map_w32_filename (oldname
, NULL
);
2861 if (o
= strrchr (oldname
, '\\'))
2864 o
= (char *) oldname
;
2866 if (p
= strrchr (temp
, '\\'))
2873 /* Force temp name to require a manufactured 8.3 alias - this
2874 seems to make the second rename work properly. */
2875 sprintf (p
, "_.%s.%u", o
, i
);
2877 result
= rename (oldname
, temp
);
2879 /* This loop must surely terminate! */
2880 while (result
< 0 && errno
== EEXIST
);
2885 /* Emulate Unix behavior - newname is deleted if it already exists
2886 (at least if it is a file; don't do this for directories).
2888 Since we mustn't do this if we are just changing the case of the
2889 file name (we would end up deleting the file we are trying to
2890 rename!), we let rename detect if the destination file already
2891 exists - that way we avoid the possible pitfalls of trying to
2892 determine ourselves whether two names really refer to the same
2893 file, which is not always possible in the general case. (Consider
2894 all the permutations of shared or subst'd drives, etc.) */
2896 newname
= map_w32_filename (newname
, NULL
);
2897 result
= rename (temp
, newname
);
2901 && _chmod (newname
, 0666) == 0
2902 && _unlink (newname
) == 0)
2903 result
= rename (temp
, newname
);
2909 sys_rmdir (const char * path
)
2911 return _rmdir (map_w32_filename (path
, NULL
));
2915 sys_unlink (const char * path
)
2917 path
= map_w32_filename (path
, NULL
);
2919 /* On Unix, unlink works without write permission. */
2920 _chmod (path
, 0666);
2921 return _unlink (path
);
2924 static FILETIME utc_base_ft
;
2925 static ULONGLONG utc_base
; /* In 100ns units */
2926 static int init
= 0;
2928 #define FILETIME_TO_U64(result, ft) \
2930 ULARGE_INTEGER uiTemp; \
2931 uiTemp.LowPart = (ft).dwLowDateTime; \
2932 uiTemp.HighPart = (ft).dwHighDateTime; \
2933 result = uiTemp.QuadPart; \
2937 initialize_utc_base (void)
2939 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2948 st
.wMilliseconds
= 0;
2950 SystemTimeToFileTime (&st
, &utc_base_ft
);
2951 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
2955 convert_time (FILETIME ft
)
2961 initialize_utc_base ();
2965 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2968 FILETIME_TO_U64 (tmp
, ft
);
2969 return (time_t) ((tmp
- utc_base
) / 10000000L);
2973 convert_from_time_t (time_t time
, FILETIME
* pft
)
2979 initialize_utc_base ();
2983 /* time in 100ns units since 1-Jan-1601 */
2984 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
2985 pft
->dwHighDateTime
= tmp
.HighPart
;
2986 pft
->dwLowDateTime
= tmp
.LowPart
;
2990 /* No reason to keep this; faking inode values either by hashing or even
2991 using the file index from GetInformationByHandle, is not perfect and
2992 so by default Emacs doesn't use the inode values on Windows.
2993 Instead, we now determine file-truename correctly (except for
2994 possible drive aliasing etc). */
2996 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2998 hashval (const unsigned char * str
)
3003 h
= (h
<< 4) + *str
++;
3009 /* Return the hash value of the canonical pathname, excluding the
3010 drive/UNC header, to get a hopefully unique inode number. */
3012 generate_inode_val (const char * name
)
3014 char fullname
[ MAX_PATH
];
3018 /* Get the truly canonical filename, if it exists. (Note: this
3019 doesn't resolve aliasing due to subst commands, or recognise hard
3021 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3024 parse_root (fullname
, &p
);
3025 /* Normal W32 filesystems are still case insensitive. */
3032 static PSECURITY_DESCRIPTOR
3033 get_file_security_desc (const char *fname
)
3035 PSECURITY_DESCRIPTOR psd
= NULL
;
3037 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3038 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3040 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3042 err
= GetLastError ();
3043 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3047 psd
= xmalloc (sd_len
);
3048 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3060 unsigned n_subauthorities
;
3062 /* Use the last sub-authority value of the RID, the relative
3063 portion of the SID, as user/group ID. */
3064 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3065 if (n_subauthorities
< 1)
3066 return 0; /* the "World" RID */
3067 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3070 /* Caching SID and account values for faster lokup. */
3073 # define FLEXIBLE_ARRAY_MEMBER
3075 # define FLEXIBLE_ARRAY_MEMBER 1
3080 struct w32_id
*next
;
3082 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3085 static struct w32_id
*w32_idlist
;
3088 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3090 struct w32_id
*tail
, *found
;
3092 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3094 if (equal_sid ((PSID
)tail
->sid
, sid
))
3103 strcpy (name
, found
->name
);
3111 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3114 struct w32_id
*new_entry
;
3116 /* We don't want to leave behind stale cache from when Emacs was
3120 sid_len
= get_length_sid (sid
);
3121 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3124 new_entry
->rid
= id
;
3125 strcpy (new_entry
->name
, name
);
3126 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3127 new_entry
->next
= w32_idlist
;
3128 w32_idlist
= new_entry
;
3137 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3138 unsigned *id
, char *nm
, int what
)
3141 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3143 SID_NAME_USE ignore
;
3145 DWORD name_len
= sizeof (name
);
3147 DWORD domain_len
= sizeof (domain
);
3153 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3154 else if (what
== GID
)
3155 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3159 if (!result
|| !is_valid_sid (sid
))
3161 else if (!w32_cached_id (sid
, id
, nm
))
3163 /* If FNAME is a UNC, we need to lookup account on the
3164 specified machine. */
3165 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3166 && fname
[2] != '\0')
3171 for (s
= fname
+ 2, p
= machine
;
3172 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3178 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3179 domain
, &domain_len
, &ignore
)
3180 || name_len
> UNLEN
+1)
3184 *id
= get_rid (sid
);
3186 w32_add_to_cache (sid
, *id
, name
);
3193 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3197 int dflt_usr
= 0, dflt_grp
= 0;
3206 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3208 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3211 /* Consider files to belong to current user/group, if we cannot get
3212 more accurate information. */
3215 st
->st_uid
= dflt_passwd
.pw_uid
;
3216 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3220 st
->st_gid
= dflt_passwd
.pw_gid
;
3221 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3225 /* Return non-zero if NAME is a potentially slow filesystem. */
3227 is_slow_fs (const char *name
)
3232 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3233 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3234 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3235 devtype
= GetDriveType (NULL
); /* use root of current drive */
3238 /* GetDriveType needs the root directory of the drive. */
3239 strncpy (drive_root
, name
, 2);
3240 drive_root
[2] = '\\';
3241 drive_root
[3] = '\0';
3242 devtype
= GetDriveType (drive_root
);
3244 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3247 /* MSVC stat function can't cope with UNC names and has other bugs, so
3248 replace it with our own. This also allows us to calculate consistent
3249 inode values without hacks in the main Emacs code. */
3251 stat (const char * path
, struct stat
* buf
)
3254 WIN32_FIND_DATA wfd
;
3256 unsigned __int64 fake_inode
;
3259 int rootdir
= FALSE
;
3260 PSECURITY_DESCRIPTOR psd
= NULL
;
3262 if (path
== NULL
|| buf
== NULL
)
3268 name
= (char *) map_w32_filename (path
, &path
);
3269 /* Must be valid filename, no wild cards or other invalid
3270 characters. We use _mbspbrk to support multibyte strings that
3271 might look to strpbrk as if they included literal *, ?, and other
3272 characters mentioned below that are disallowed by Windows
3274 if (_mbspbrk (name
, "*?|<>\""))
3280 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3281 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3282 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3287 /* Remove trailing directory separator, unless name is the root
3288 directory of a drive or UNC volume in which case ensure there
3289 is a trailing separator. */
3290 len
= strlen (name
);
3291 rootdir
= (path
>= name
+ len
- 1
3292 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3293 name
= strcpy (alloca (len
+ 2), name
);
3295 if (is_unc_volume (name
))
3297 DWORD attrs
= unc_volume_file_attributes (name
);
3302 memset (&wfd
, 0, sizeof (wfd
));
3303 wfd
.dwFileAttributes
= attrs
;
3304 wfd
.ftCreationTime
= utc_base_ft
;
3305 wfd
.ftLastAccessTime
= utc_base_ft
;
3306 wfd
.ftLastWriteTime
= utc_base_ft
;
3307 strcpy (wfd
.cFileName
, name
);
3311 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3312 strcat (name
, "\\");
3313 if (GetDriveType (name
) < 2)
3318 memset (&wfd
, 0, sizeof (wfd
));
3319 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
3320 wfd
.ftCreationTime
= utc_base_ft
;
3321 wfd
.ftLastAccessTime
= utc_base_ft
;
3322 wfd
.ftLastWriteTime
= utc_base_ft
;
3323 strcpy (wfd
.cFileName
, name
);
3327 if (IS_DIRECTORY_SEP (name
[len
-1]))
3330 /* (This is hacky, but helps when doing file completions on
3331 network drives.) Optimize by using information available from
3332 active readdir if possible. */
3333 len
= strlen (dir_pathname
);
3334 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3336 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3337 && strnicmp (name
, dir_pathname
, len
) == 0
3338 && IS_DIRECTORY_SEP (name
[len
])
3339 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3341 /* This was the last entry returned by readdir. */
3342 wfd
= dir_find_data
;
3346 logon_network_drive (name
);
3348 fh
= FindFirstFile (name
, &wfd
);
3349 if (fh
== INVALID_HANDLE_VALUE
)
3358 if (!(NILP (Vw32_get_true_file_attributes
)
3359 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3360 /* No access rights required to get info. */
3361 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3362 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
3363 != INVALID_HANDLE_VALUE
)
3365 /* This is more accurate in terms of gettting the correct number
3366 of links, but is quite slow (it is noticeable when Emacs is
3367 making a list of file name completions). */
3368 BY_HANDLE_FILE_INFORMATION info
;
3370 if (GetFileInformationByHandle (fh
, &info
))
3372 buf
->st_nlink
= info
.nNumberOfLinks
;
3373 /* Might as well use file index to fake inode values, but this
3374 is not guaranteed to be unique unless we keep a handle open
3375 all the time (even then there are situations where it is
3376 not unique). Reputedly, there are at most 48 bits of info
3377 (on NTFS, presumably less on FAT). */
3378 fake_inode
= info
.nFileIndexHigh
;
3380 fake_inode
+= info
.nFileIndexLow
;
3388 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3390 buf
->st_mode
= S_IFDIR
;
3394 switch (GetFileType (fh
))
3396 case FILE_TYPE_DISK
:
3397 buf
->st_mode
= S_IFREG
;
3399 case FILE_TYPE_PIPE
:
3400 buf
->st_mode
= S_IFIFO
;
3402 case FILE_TYPE_CHAR
:
3403 case FILE_TYPE_UNKNOWN
:
3405 buf
->st_mode
= S_IFCHR
;
3409 psd
= get_file_security_desc (name
);
3410 get_file_owner_and_group (psd
, name
, buf
);
3414 /* Don't bother to make this information more accurate. */
3415 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
3420 get_file_owner_and_group (NULL
, name
, buf
);
3425 /* Not sure if there is any point in this. */
3426 if (!NILP (Vw32_generate_fake_inodes
))
3427 fake_inode
= generate_inode_val (name
);
3428 else if (fake_inode
== 0)
3430 /* For want of something better, try to make everything unique. */
3431 static DWORD gen_num
= 0;
3432 fake_inode
= ++gen_num
;
3436 /* MSVC defines _ino_t to be short; other libc's might not. */
3437 if (sizeof (buf
->st_ino
) == 2)
3438 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3440 buf
->st_ino
= fake_inode
;
3442 /* volume_info is set indirectly by map_w32_filename */
3443 buf
->st_dev
= volume_info
.serialnum
;
3444 buf
->st_rdev
= volume_info
.serialnum
;
3446 buf
->st_size
= wfd
.nFileSizeHigh
;
3447 buf
->st_size
<<= 32;
3448 buf
->st_size
+= wfd
.nFileSizeLow
;
3450 /* Convert timestamps to Unix format. */
3451 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
3452 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
3453 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3454 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
3455 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3457 /* determine rwx permissions */
3458 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3459 permission
= S_IREAD
;
3461 permission
= S_IREAD
| S_IWRITE
;
3463 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3464 permission
|= S_IEXEC
;
3465 else if (is_exec (name
))
3466 permission
|= S_IEXEC
;
3468 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3473 /* Provide fstat and utime as well as stat for consistent handling of
3476 fstat (int desc
, struct stat
* buf
)
3478 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3479 BY_HANDLE_FILE_INFORMATION info
;
3480 unsigned __int64 fake_inode
;
3483 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3485 case FILE_TYPE_DISK
:
3486 buf
->st_mode
= S_IFREG
;
3487 if (!GetFileInformationByHandle (fh
, &info
))
3493 case FILE_TYPE_PIPE
:
3494 buf
->st_mode
= S_IFIFO
;
3496 case FILE_TYPE_CHAR
:
3497 case FILE_TYPE_UNKNOWN
:
3499 buf
->st_mode
= S_IFCHR
;
3501 memset (&info
, 0, sizeof (info
));
3502 info
.dwFileAttributes
= 0;
3503 info
.ftCreationTime
= utc_base_ft
;
3504 info
.ftLastAccessTime
= utc_base_ft
;
3505 info
.ftLastWriteTime
= utc_base_ft
;
3508 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3509 buf
->st_mode
= S_IFDIR
;
3511 buf
->st_nlink
= info
.nNumberOfLinks
;
3512 /* Might as well use file index to fake inode values, but this
3513 is not guaranteed to be unique unless we keep a handle open
3514 all the time (even then there are situations where it is
3515 not unique). Reputedly, there are at most 48 bits of info
3516 (on NTFS, presumably less on FAT). */
3517 fake_inode
= info
.nFileIndexHigh
;
3519 fake_inode
+= info
.nFileIndexLow
;
3521 /* MSVC defines _ino_t to be short; other libc's might not. */
3522 if (sizeof (buf
->st_ino
) == 2)
3523 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3525 buf
->st_ino
= fake_inode
;
3527 /* Consider files to belong to current user.
3528 FIXME: this should use GetSecurityInfo API, but it is only
3529 available for _WIN32_WINNT >= 0x501. */
3530 buf
->st_uid
= dflt_passwd
.pw_uid
;
3531 buf
->st_gid
= dflt_passwd
.pw_gid
;
3532 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3533 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3535 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3536 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3538 buf
->st_size
= info
.nFileSizeHigh
;
3539 buf
->st_size
<<= 32;
3540 buf
->st_size
+= info
.nFileSizeLow
;
3542 /* Convert timestamps to Unix format. */
3543 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3544 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3545 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3546 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3547 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3549 /* determine rwx permissions */
3550 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3551 permission
= S_IREAD
;
3553 permission
= S_IREAD
| S_IWRITE
;
3555 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3556 permission
|= S_IEXEC
;
3559 #if 0 /* no way of knowing the filename */
3560 char * p
= strrchr (name
, '.');
3562 (xstrcasecmp (p
, ".exe") == 0 ||
3563 xstrcasecmp (p
, ".com") == 0 ||
3564 xstrcasecmp (p
, ".bat") == 0 ||
3565 xstrcasecmp (p
, ".cmd") == 0))
3566 permission
|= S_IEXEC
;
3570 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3576 utime (const char *name
, struct utimbuf
*times
)
3578 struct utimbuf deftime
;
3585 deftime
.modtime
= deftime
.actime
= time (NULL
);
3589 /* Need write access to set times. */
3590 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3591 0, OPEN_EXISTING
, 0, NULL
);
3594 convert_from_time_t (times
->actime
, &atime
);
3595 convert_from_time_t (times
->modtime
, &mtime
);
3596 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3613 /* Symlink-related functions that always fail. Used in fileio.c to
3616 symlink (char const *dummy1
, char const *dummy2
)
3623 readlink (const char *name
, char *dummy1
, size_t dummy2
)
3625 /* `access' is much faster than `stat' on MS-Windows. */
3626 if (sys_access (name
, 0) == 0)
3632 /* Support for browsing other processes and their attributes. See
3633 process.c for the Lisp bindings. */
3635 /* Helper wrapper functions. */
3637 static HANDLE WINAPI
3638 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
3640 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
3642 if (g_b_init_create_toolhelp32_snapshot
== 0)
3644 g_b_init_create_toolhelp32_snapshot
= 1;
3645 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
3646 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3647 "CreateToolhelp32Snapshot");
3649 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
3651 return INVALID_HANDLE_VALUE
;
3653 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
3657 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
3659 static Process32First_Proc s_pfn_Process32_First
= NULL
;
3661 if (g_b_init_process32_first
== 0)
3663 g_b_init_process32_first
= 1;
3664 s_pfn_Process32_First
= (Process32First_Proc
)
3665 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3668 if (s_pfn_Process32_First
== NULL
)
3672 return (s_pfn_Process32_First (hSnapshot
, lppe
));
3676 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
3678 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
3680 if (g_b_init_process32_next
== 0)
3682 g_b_init_process32_next
= 1;
3683 s_pfn_Process32_Next
= (Process32Next_Proc
)
3684 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3687 if (s_pfn_Process32_Next
== NULL
)
3691 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
3695 open_thread_token (HANDLE ThreadHandle
,
3696 DWORD DesiredAccess
,
3698 PHANDLE TokenHandle
)
3700 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
3701 HMODULE hm_advapi32
= NULL
;
3702 if (is_windows_9x () == TRUE
)
3704 SetLastError (ERROR_NOT_SUPPORTED
);
3707 if (g_b_init_open_thread_token
== 0)
3709 g_b_init_open_thread_token
= 1;
3710 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3711 s_pfn_Open_Thread_Token
=
3712 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
3714 if (s_pfn_Open_Thread_Token
== NULL
)
3716 SetLastError (ERROR_NOT_SUPPORTED
);
3720 s_pfn_Open_Thread_Token (
3729 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
3731 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
3732 HMODULE hm_advapi32
= NULL
;
3733 if (is_windows_9x () == TRUE
)
3737 if (g_b_init_impersonate_self
== 0)
3739 g_b_init_impersonate_self
= 1;
3740 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3741 s_pfn_Impersonate_Self
=
3742 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
3744 if (s_pfn_Impersonate_Self
== NULL
)
3748 return s_pfn_Impersonate_Self (ImpersonationLevel
);
3752 revert_to_self (void)
3754 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
3755 HMODULE hm_advapi32
= NULL
;
3756 if (is_windows_9x () == TRUE
)
3760 if (g_b_init_revert_to_self
== 0)
3762 g_b_init_revert_to_self
= 1;
3763 hm_advapi32
= LoadLibrary ("Advapi32.dll");
3764 s_pfn_Revert_To_Self
=
3765 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
3767 if (s_pfn_Revert_To_Self
== NULL
)
3771 return s_pfn_Revert_To_Self ();
3775 get_process_memory_info (HANDLE h_proc
,
3776 PPROCESS_MEMORY_COUNTERS mem_counters
,
3779 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
3780 HMODULE hm_psapi
= NULL
;
3781 if (is_windows_9x () == TRUE
)
3785 if (g_b_init_get_process_memory_info
== 0)
3787 g_b_init_get_process_memory_info
= 1;
3788 hm_psapi
= LoadLibrary ("Psapi.dll");
3790 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
3791 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
3793 if (s_pfn_Get_Process_Memory_Info
== NULL
)
3797 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
3801 get_process_working_set_size (HANDLE h_proc
,
3805 static GetProcessWorkingSetSize_Proc
3806 s_pfn_Get_Process_Working_Set_Size
= NULL
;
3808 if (is_windows_9x () == TRUE
)
3812 if (g_b_init_get_process_working_set_size
== 0)
3814 g_b_init_get_process_working_set_size
= 1;
3815 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
3816 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3817 "GetProcessWorkingSetSize");
3819 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
3823 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
3827 global_memory_status (MEMORYSTATUS
*buf
)
3829 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
3831 if (is_windows_9x () == TRUE
)
3835 if (g_b_init_global_memory_status
== 0)
3837 g_b_init_global_memory_status
= 1;
3838 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
3839 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3840 "GlobalMemoryStatus");
3842 if (s_pfn_Global_Memory_Status
== NULL
)
3846 return s_pfn_Global_Memory_Status (buf
);
3850 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
3852 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
3854 if (is_windows_9x () == TRUE
)
3858 if (g_b_init_global_memory_status_ex
== 0)
3860 g_b_init_global_memory_status_ex
= 1;
3861 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
3862 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3863 "GlobalMemoryStatusEx");
3865 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
3869 return s_pfn_Global_Memory_Status_Ex (buf
);
3873 list_system_processes (void)
3875 struct gcpro gcpro1
;
3876 Lisp_Object proclist
= Qnil
;
3879 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
3881 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
3883 PROCESSENTRY32 proc_entry
;
3889 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
3890 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
3891 res
= process32_next (h_snapshot
, &proc_entry
))
3893 proc_id
= proc_entry
.th32ProcessID
;
3894 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
3897 CloseHandle (h_snapshot
);
3899 proclist
= Fnreverse (proclist
);
3906 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
3908 TOKEN_PRIVILEGES priv
;
3909 DWORD priv_size
= sizeof (priv
);
3910 DWORD opriv_size
= sizeof (*old_priv
);
3911 HANDLE h_token
= NULL
;
3912 HANDLE h_thread
= GetCurrentThread ();
3916 res
= open_thread_token (h_thread
,
3917 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3919 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
3921 if (impersonate_self (SecurityImpersonation
))
3922 res
= open_thread_token (h_thread
,
3923 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3928 priv
.PrivilegeCount
= 1;
3929 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
3930 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
3931 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
3932 old_priv
, &opriv_size
)
3933 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
3937 CloseHandle (h_token
);
3943 restore_privilege (TOKEN_PRIVILEGES
*priv
)
3945 DWORD priv_size
= sizeof (*priv
);
3946 HANDLE h_token
= NULL
;
3949 if (open_thread_token (GetCurrentThread (),
3950 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
3953 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
3954 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
3958 CloseHandle (h_token
);
3964 ltime (long time_sec
, long time_usec
)
3966 return list3 (make_number ((time_sec
>> 16) & 0xffff),
3967 make_number (time_sec
& 0xffff),
3968 make_number (time_usec
));
3971 #define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
3974 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
3975 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
3978 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
3979 ULONGLONG tem1
, tem2
, tem3
, tem
;
3982 || !get_process_times_fn
3983 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
3984 &ft_kernel
, &ft_user
))
3987 GetSystemTimeAsFileTime (&ft_current
);
3989 FILETIME_TO_U64 (tem1
, ft_kernel
);
3991 *stime
= U64_TO_LISP_TIME (tem1
);
3993 FILETIME_TO_U64 (tem2
, ft_user
);
3995 *utime
= U64_TO_LISP_TIME (tem2
);
3998 *ttime
= U64_TO_LISP_TIME (tem3
);
4000 FILETIME_TO_U64 (tem
, ft_creation
);
4001 /* Process no 4 (System) returns zero creation time. */
4003 tem
= (tem
- utc_base
) / 10L;
4004 *ctime
= U64_TO_LISP_TIME (tem
);
4008 FILETIME_TO_U64 (tem3
, ft_current
);
4009 tem
= (tem3
- utc_base
) / 10L - tem
;
4011 *etime
= U64_TO_LISP_TIME (tem
);
4015 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4026 system_process_attributes (Lisp_Object pid
)
4028 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4029 Lisp_Object attrs
= Qnil
;
4030 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4031 HANDLE h_snapshot
, h_proc
;
4034 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4035 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4036 DWORD glength
= sizeof (gname
);
4037 HANDLE token
= NULL
;
4038 SID_NAME_USE user_type
;
4039 unsigned char *buf
= NULL
;
4041 TOKEN_USER user_token
;
4042 TOKEN_PRIMARY_GROUP group_token
;
4045 PROCESS_MEMORY_COUNTERS mem
;
4046 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4047 DWORD minrss
, maxrss
;
4049 MEMORY_STATUS_EX memstex
;
4050 double totphys
= 0.0;
4051 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4053 BOOL result
= FALSE
;
4055 CHECK_NUMBER_OR_FLOAT (pid
);
4056 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4058 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4060 GCPRO3 (attrs
, decoded_cmd
, tem
);
4062 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4067 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4068 for (res
= process32_first (h_snapshot
, &pe
); res
;
4069 res
= process32_next (h_snapshot
, &pe
))
4071 if (proc_id
== pe
.th32ProcessID
)
4074 decoded_cmd
= build_string ("Idle");
4077 /* Decode the command name from locale-specific
4079 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4080 strlen (pe
.szExeFile
));
4082 code_convert_string_norecord (cmd_str
,
4083 Vlocale_coding_system
, 0);
4085 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4086 attrs
= Fcons (Fcons (Qppid
,
4087 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4089 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4091 attrs
= Fcons (Fcons (Qthcount
,
4092 make_fixnum_or_float (pe
.cntThreads
)),
4099 CloseHandle (h_snapshot
);
4108 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4110 /* If we were denied a handle to the process, try again after
4111 enabling the SeDebugPrivilege in our process. */
4114 TOKEN_PRIVILEGES priv_current
;
4116 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4118 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4120 restore_privilege (&priv_current
);
4126 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4129 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4130 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4132 buf
= xmalloc (blen
);
4133 result
= get_token_information (token
, TokenUser
,
4134 (LPVOID
)buf
, blen
, &needed
);
4137 memcpy (&user_token
, buf
, sizeof (user_token
));
4138 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4140 euid
= get_rid (user_token
.User
.Sid
);
4141 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4146 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4149 strcpy (uname
, "unknown");
4153 ulength
= strlen (uname
);
4159 /* Determine a reasonable euid and gid values. */
4160 if (xstrcasecmp ("administrator", uname
) == 0)
4162 euid
= 500; /* well-known Administrator uid */
4163 egid
= 513; /* well-known None gid */
4167 /* Get group id and name. */
4168 result
= get_token_information (token
, TokenPrimaryGroup
,
4169 (LPVOID
)buf
, blen
, &needed
);
4170 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4172 buf
= xrealloc (buf
, blen
= needed
);
4173 result
= get_token_information (token
, TokenPrimaryGroup
,
4174 (LPVOID
)buf
, blen
, &needed
);
4178 memcpy (&group_token
, buf
, sizeof (group_token
));
4179 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
4181 egid
= get_rid (group_token
.PrimaryGroup
);
4182 dlength
= sizeof (domain
);
4184 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
4185 gname
, &glength
, NULL
, &dlength
,
4188 w32_add_to_cache (group_token
.PrimaryGroup
,
4192 strcpy (gname
, "None");
4196 glength
= strlen (gname
);
4204 if (!is_windows_9x ())
4206 /* We couldn't open the process token, presumably because of
4207 insufficient access rights. Assume this process is run
4209 strcpy (uname
, "SYSTEM");
4210 strcpy (gname
, "None");
4211 euid
= 18; /* SYSTEM */
4212 egid
= 513; /* None */
4213 glength
= strlen (gname
);
4214 ulength
= strlen (uname
);
4216 /* If we are running under Windows 9X, where security calls are
4217 not supported, we assume all processes are run by the current
4219 else if (GetUserName (uname
, &ulength
))
4221 if (xstrcasecmp ("administrator", uname
) == 0)
4226 strcpy (gname
, "None");
4227 glength
= strlen (gname
);
4228 ulength
= strlen (uname
);
4234 strcpy (uname
, "administrator");
4235 ulength
= strlen (uname
);
4236 strcpy (gname
, "None");
4237 glength
= strlen (gname
);
4240 CloseHandle (token
);
4243 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
4244 tem
= make_unibyte_string (uname
, ulength
);
4245 attrs
= Fcons (Fcons (Quser
,
4246 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
4248 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
4249 tem
= make_unibyte_string (gname
, glength
);
4250 attrs
= Fcons (Fcons (Qgroup
,
4251 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
4254 if (global_memory_status_ex (&memstex
))
4255 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
4256 totphys
= memstex
.ullTotalPhys
/ 1024.0;
4258 /* Visual Studio 6 cannot convert an unsigned __int64 type to
4259 double, so we need to do this for it... */
4261 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
4262 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
4263 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
4265 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
4267 #endif /* __GNUC__ || _MSC_VER >= 1300 */
4268 else if (global_memory_status (&memst
))
4269 totphys
= memst
.dwTotalPhys
/ 1024.0;
4272 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
4275 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
4277 attrs
= Fcons (Fcons (Qmajflt
,
4278 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
4280 attrs
= Fcons (Fcons (Qvsize
,
4281 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
4283 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
4285 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4288 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
4290 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
4292 attrs
= Fcons (Fcons (Qmajflt
,
4293 make_fixnum_or_float (mem
.PageFaultCount
)),
4295 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
4297 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4300 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
4302 DWORD rss
= maxrss
/ 1024;
4304 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
4306 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
4309 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
4311 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
4312 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
4313 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
4314 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
4315 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
4316 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
4319 /* FIXME: Retrieve command line by walking the PEB of the process. */
4322 CloseHandle (h_proc
);
4328 /* Wrappers for winsock functions to map between our file descriptors
4329 and winsock's handles; also set h_errno for convenience.
4331 To allow Emacs to run on systems which don't have winsock support
4332 installed, we dynamically link to winsock on startup if present, and
4333 otherwise provide the minimum necessary functionality
4334 (eg. gethostname). */
4336 /* function pointers for relevant socket functions */
4337 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
4338 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
4339 int (PASCAL
*pfn_WSAGetLastError
) (void);
4340 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
4341 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
4342 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
4343 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
4344 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
4345 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
4346 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
4347 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
4348 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
4349 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
4350 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
4351 int (PASCAL
*pfn_WSACleanup
) (void);
4353 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
4354 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
4355 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
4356 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
4357 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
4358 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
4359 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
4360 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
4361 const char * optval
, int optlen
);
4362 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
4363 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
4365 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
4366 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
4367 struct sockaddr
* from
, int * fromlen
);
4368 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
4369 const struct sockaddr
* to
, int tolen
);
4371 /* SetHandleInformation is only needed to make sockets non-inheritable. */
4372 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
4373 #ifndef HANDLE_FLAG_INHERIT
4374 #define HANDLE_FLAG_INHERIT 1
4378 static int winsock_inuse
;
4383 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
4385 /* Not sure what would cause WSAENETDOWN, or even if it can happen
4386 after WSAStartup returns successfully, but it seems reasonable
4387 to allow unloading winsock anyway in that case. */
4388 if (pfn_WSACleanup () == 0 ||
4389 pfn_WSAGetLastError () == WSAENETDOWN
)
4391 if (FreeLibrary (winsock_lib
))
4400 init_winsock (int load_now
)
4402 WSADATA winsockData
;
4404 if (winsock_lib
!= NULL
)
4407 pfn_SetHandleInformation
4408 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
4409 "SetHandleInformation");
4411 winsock_lib
= LoadLibrary ("Ws2_32.dll");
4413 if (winsock_lib
!= NULL
)
4415 /* dynamically link to socket functions */
4417 #define LOAD_PROC(fn) \
4418 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
4421 LOAD_PROC (WSAStartup
);
4422 LOAD_PROC (WSASetLastError
);
4423 LOAD_PROC (WSAGetLastError
);
4424 LOAD_PROC (WSAEventSelect
);
4425 LOAD_PROC (WSACreateEvent
);
4426 LOAD_PROC (WSACloseEvent
);
4429 LOAD_PROC (connect
);
4430 LOAD_PROC (ioctlsocket
);
4433 LOAD_PROC (closesocket
);
4434 LOAD_PROC (shutdown
);
4437 LOAD_PROC (inet_addr
);
4438 LOAD_PROC (gethostname
);
4439 LOAD_PROC (gethostbyname
);
4440 LOAD_PROC (getservbyname
);
4441 LOAD_PROC (getpeername
);
4442 LOAD_PROC (WSACleanup
);
4443 LOAD_PROC (setsockopt
);
4445 LOAD_PROC (getsockname
);
4447 LOAD_PROC (recvfrom
);
4451 /* specify version 1.1 of winsock */
4452 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
4454 if (winsockData
.wVersion
!= 0x101)
4459 /* Report that winsock exists and is usable, but leave
4460 socket functions disabled. I am assuming that calling
4461 WSAStartup does not require any network interaction,
4462 and in particular does not cause or require a dial-up
4463 connection to be established. */
4466 FreeLibrary (winsock_lib
);
4474 FreeLibrary (winsock_lib
);
4484 /* function to set h_errno for compatibility; map winsock error codes to
4485 normal system codes where they overlap (non-overlapping definitions
4486 are already in <sys/socket.h> */
4490 if (winsock_lib
== NULL
)
4493 h_errno
= pfn_WSAGetLastError ();
4497 case WSAEACCES
: h_errno
= EACCES
; break;
4498 case WSAEBADF
: h_errno
= EBADF
; break;
4499 case WSAEFAULT
: h_errno
= EFAULT
; break;
4500 case WSAEINTR
: h_errno
= EINTR
; break;
4501 case WSAEINVAL
: h_errno
= EINVAL
; break;
4502 case WSAEMFILE
: h_errno
= EMFILE
; break;
4503 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
4504 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
4512 if (h_errno
== 0 && winsock_lib
!= NULL
)
4513 pfn_WSASetLastError (0);
4516 /* Extend strerror to handle the winsock-specific error codes. */
4520 } _wsa_errlist
[] = {
4521 {WSAEINTR
, "Interrupted function call"},
4522 {WSAEBADF
, "Bad file descriptor"},
4523 {WSAEACCES
, "Permission denied"},
4524 {WSAEFAULT
, "Bad address"},
4525 {WSAEINVAL
, "Invalid argument"},
4526 {WSAEMFILE
, "Too many open files"},
4528 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
4529 {WSAEINPROGRESS
, "Operation now in progress"},
4530 {WSAEALREADY
, "Operation already in progress"},
4531 {WSAENOTSOCK
, "Socket operation on non-socket"},
4532 {WSAEDESTADDRREQ
, "Destination address required"},
4533 {WSAEMSGSIZE
, "Message too long"},
4534 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
4535 {WSAENOPROTOOPT
, "Bad protocol option"},
4536 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
4537 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
4538 {WSAEOPNOTSUPP
, "Operation not supported"},
4539 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
4540 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
4541 {WSAEADDRINUSE
, "Address already in use"},
4542 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
4543 {WSAENETDOWN
, "Network is down"},
4544 {WSAENETUNREACH
, "Network is unreachable"},
4545 {WSAENETRESET
, "Network dropped connection on reset"},
4546 {WSAECONNABORTED
, "Software caused connection abort"},
4547 {WSAECONNRESET
, "Connection reset by peer"},
4548 {WSAENOBUFS
, "No buffer space available"},
4549 {WSAEISCONN
, "Socket is already connected"},
4550 {WSAENOTCONN
, "Socket is not connected"},
4551 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
4552 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
4553 {WSAETIMEDOUT
, "Connection timed out"},
4554 {WSAECONNREFUSED
, "Connection refused"},
4555 {WSAELOOP
, "Network loop"}, /* not sure */
4556 {WSAENAMETOOLONG
, "Name is too long"},
4557 {WSAEHOSTDOWN
, "Host is down"},
4558 {WSAEHOSTUNREACH
, "No route to host"},
4559 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
4560 {WSAEPROCLIM
, "Too many processes"},
4561 {WSAEUSERS
, "Too many users"}, /* not sure */
4562 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
4563 {WSAESTALE
, "Data is stale"}, /* not sure */
4564 {WSAEREMOTE
, "Remote error"}, /* not sure */
4566 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
4567 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
4568 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
4569 {WSAEDISCON
, "Graceful shutdown in progress"},
4571 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
4572 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
4573 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
4574 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
4575 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
4576 {WSASYSCALLFAILURE
, "System call failure"},
4577 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
4578 {WSATYPE_NOT_FOUND
, "Class type not found"},
4579 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
4580 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
4581 {WSAEREFUSED
, "Operation refused"}, /* not sure */
4584 {WSAHOST_NOT_FOUND
, "Host not found"},
4585 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
4586 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
4587 {WSANO_DATA
, "Valid name, no data record of requested type"},
4593 sys_strerror (int error_no
)
4596 static char unknown_msg
[40];
4598 if (error_no
>= 0 && error_no
< sys_nerr
)
4599 return sys_errlist
[error_no
];
4601 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
4602 if (_wsa_errlist
[i
].errnum
== error_no
)
4603 return _wsa_errlist
[i
].msg
;
4605 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
4609 /* [andrewi 3-May-96] I've had conflicting results using both methods,
4610 but I believe the method of keeping the socket handle separate (and
4611 insuring it is not inheritable) is the correct one. */
4613 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
4615 static int socket_to_fd (SOCKET s
);
4618 sys_socket (int af
, int type
, int protocol
)
4622 if (winsock_lib
== NULL
)
4625 return INVALID_SOCKET
;
4630 /* call the real socket function */
4631 s
= pfn_socket (af
, type
, protocol
);
4633 if (s
!= INVALID_SOCKET
)
4634 return socket_to_fd (s
);
4640 /* Convert a SOCKET to a file descriptor. */
4642 socket_to_fd (SOCKET s
)
4647 /* Although under NT 3.5 _open_osfhandle will accept a socket
4648 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
4649 that does not work under NT 3.1. However, we can get the same
4650 effect by using a backdoor function to replace an existing
4651 descriptor handle with the one we want. */
4653 /* allocate a file descriptor (with appropriate flags) */
4654 fd
= _open ("NUL:", _O_RDWR
);
4657 /* Make a non-inheritable copy of the socket handle. Note
4658 that it is possible that sockets aren't actually kernel
4659 handles, which appears to be the case on Windows 9x when
4660 the MS Proxy winsock client is installed. */
4662 /* Apparently there is a bug in NT 3.51 with some service
4663 packs, which prevents using DuplicateHandle to make a
4664 socket handle non-inheritable (causes WSACleanup to
4665 hang). The work-around is to use SetHandleInformation
4666 instead if it is available and implemented. */
4667 if (pfn_SetHandleInformation
)
4669 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
4673 HANDLE parent
= GetCurrentProcess ();
4674 HANDLE new_s
= INVALID_HANDLE_VALUE
;
4676 if (DuplicateHandle (parent
,
4682 DUPLICATE_SAME_ACCESS
))
4684 /* It is possible that DuplicateHandle succeeds even
4685 though the socket wasn't really a kernel handle,
4686 because a real handle has the same value. So
4687 test whether the new handle really is a socket. */
4688 long nonblocking
= 0;
4689 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
4691 pfn_closesocket (s
);
4696 CloseHandle (new_s
);
4701 fd_info
[fd
].hnd
= (HANDLE
) s
;
4703 /* set our own internal flags */
4704 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
4710 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
4712 /* attach child_process to fd_info */
4713 if (fd_info
[ fd
].cp
!= NULL
)
4715 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
4719 fd_info
[ fd
].cp
= cp
;
4722 winsock_inuse
++; /* count open sockets */
4729 pfn_closesocket (s
);
4735 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
4737 if (winsock_lib
== NULL
)
4740 return SOCKET_ERROR
;
4744 if (fd_info
[s
].flags
& FILE_SOCKET
)
4746 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
4747 if (rc
== SOCKET_ERROR
)
4752 return SOCKET_ERROR
;
4756 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
4758 if (winsock_lib
== NULL
)
4761 return SOCKET_ERROR
;
4765 if (fd_info
[s
].flags
& FILE_SOCKET
)
4767 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
4768 if (rc
== SOCKET_ERROR
)
4773 return SOCKET_ERROR
;
4777 sys_htons (u_short hostshort
)
4779 return (winsock_lib
!= NULL
) ?
4780 pfn_htons (hostshort
) : hostshort
;
4784 sys_ntohs (u_short netshort
)
4786 return (winsock_lib
!= NULL
) ?
4787 pfn_ntohs (netshort
) : netshort
;
4791 sys_inet_addr (const char * cp
)
4793 return (winsock_lib
!= NULL
) ?
4794 pfn_inet_addr (cp
) : INADDR_NONE
;
4798 sys_gethostname (char * name
, int namelen
)
4800 if (winsock_lib
!= NULL
)
4801 return pfn_gethostname (name
, namelen
);
4803 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
4804 return !GetComputerName (name
, (DWORD
*)&namelen
);
4807 return SOCKET_ERROR
;
4811 sys_gethostbyname (const char * name
)
4813 struct hostent
* host
;
4815 if (winsock_lib
== NULL
)
4822 host
= pfn_gethostbyname (name
);
4829 sys_getservbyname (const char * name
, const char * proto
)
4831 struct servent
* serv
;
4833 if (winsock_lib
== NULL
)
4840 serv
= pfn_getservbyname (name
, proto
);
4847 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
4849 if (winsock_lib
== NULL
)
4852 return SOCKET_ERROR
;
4856 if (fd_info
[s
].flags
& FILE_SOCKET
)
4858 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
4859 if (rc
== SOCKET_ERROR
)
4864 return SOCKET_ERROR
;
4868 sys_shutdown (int s
, int how
)
4870 if (winsock_lib
== NULL
)
4873 return SOCKET_ERROR
;
4877 if (fd_info
[s
].flags
& FILE_SOCKET
)
4879 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
4880 if (rc
== SOCKET_ERROR
)
4885 return SOCKET_ERROR
;
4889 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
4891 if (winsock_lib
== NULL
)
4894 return SOCKET_ERROR
;
4898 if (fd_info
[s
].flags
& FILE_SOCKET
)
4900 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
4901 (const char *)optval
, optlen
);
4902 if (rc
== SOCKET_ERROR
)
4907 return SOCKET_ERROR
;
4911 sys_listen (int s
, int backlog
)
4913 if (winsock_lib
== NULL
)
4916 return SOCKET_ERROR
;
4920 if (fd_info
[s
].flags
& FILE_SOCKET
)
4922 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
4923 if (rc
== SOCKET_ERROR
)
4926 fd_info
[s
].flags
|= FILE_LISTEN
;
4930 return SOCKET_ERROR
;
4934 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
4936 if (winsock_lib
== NULL
)
4939 return SOCKET_ERROR
;
4943 if (fd_info
[s
].flags
& FILE_SOCKET
)
4945 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
4946 if (rc
== SOCKET_ERROR
)
4951 return SOCKET_ERROR
;
4955 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
4957 if (winsock_lib
== NULL
)
4964 if (fd_info
[s
].flags
& FILE_LISTEN
)
4966 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
4968 if (t
== INVALID_SOCKET
)
4971 fd
= socket_to_fd (t
);
4973 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
4974 ResetEvent (fd_info
[s
].cp
->char_avail
);
4982 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
4983 struct sockaddr
* from
, int * fromlen
)
4985 if (winsock_lib
== NULL
)
4988 return SOCKET_ERROR
;
4992 if (fd_info
[s
].flags
& FILE_SOCKET
)
4994 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
4995 if (rc
== SOCKET_ERROR
)
5000 return SOCKET_ERROR
;
5004 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5005 const struct sockaddr
* to
, int tolen
)
5007 if (winsock_lib
== NULL
)
5010 return SOCKET_ERROR
;
5014 if (fd_info
[s
].flags
& FILE_SOCKET
)
5016 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5017 if (rc
== SOCKET_ERROR
)
5022 return SOCKET_ERROR
;
5025 /* Windows does not have an fcntl function. Provide an implementation
5026 solely for making sockets non-blocking. */
5028 fcntl (int s
, int cmd
, int options
)
5030 if (winsock_lib
== NULL
)
5037 if (fd_info
[s
].flags
& FILE_SOCKET
)
5039 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
5041 unsigned long nblock
= 1;
5042 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5043 if (rc
== SOCKET_ERROR
)
5045 /* Keep track of the fact that we set this to non-blocking. */
5046 fd_info
[s
].flags
|= FILE_NDELAY
;
5052 return SOCKET_ERROR
;
5056 return SOCKET_ERROR
;
5060 /* Shadow main io functions: we need to handle pipes and sockets more
5061 intelligently, and implement non-blocking mode as well. */
5074 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5076 child_process
* cp
= fd_info
[fd
].cp
;
5078 fd_info
[fd
].cp
= NULL
;
5080 if (CHILD_ACTIVE (cp
))
5082 /* if last descriptor to active child_process then cleanup */
5084 for (i
= 0; i
< MAXDESC
; i
++)
5088 if (fd_info
[i
].cp
== cp
)
5093 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5095 if (winsock_lib
== NULL
) abort ();
5097 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5098 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5100 winsock_inuse
--; /* count open sockets */
5107 /* Note that sockets do not need special treatment here (at least on
5108 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5109 closesocket is equivalent to CloseHandle, which is to be expected
5110 because socket handles are fully fledged kernel handles. */
5113 if (rc
== 0 && fd
< MAXDESC
)
5114 fd_info
[fd
].flags
= 0;
5125 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5127 /* duplicate our internal info as well */
5128 fd_info
[new_fd
] = fd_info
[fd
];
5134 sys_dup2 (int src
, int dst
)
5138 if (dst
< 0 || dst
>= MAXDESC
)
5144 /* make sure we close the destination first if it's a pipe or socket */
5145 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5148 rc
= _dup2 (src
, dst
);
5151 /* duplicate our internal info as well */
5152 fd_info
[dst
] = fd_info
[src
];
5157 /* Unix pipe() has only one arg */
5159 sys_pipe (int * phandles
)
5164 /* make pipe handles non-inheritable; when we spawn a child, we
5165 replace the relevant handle with an inheritable one. Also put
5166 pipes into binary mode; we will do text mode translation ourselves
5168 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5172 /* Protect against overflow, since Windows can open more handles than
5173 our fd_info array has room for. */
5174 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5176 _close (phandles
[0]);
5177 _close (phandles
[1]);
5182 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
5183 fd_info
[phandles
[0]].flags
= flags
;
5185 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
5186 fd_info
[phandles
[1]].flags
= flags
;
5193 /* Function to do blocking read of one byte, needed to implement
5194 select. It is only allowed on sockets and pipes. */
5196 _sys_read_ahead (int fd
)
5201 if (fd
< 0 || fd
>= MAXDESC
)
5202 return STATUS_READ_ERROR
;
5204 cp
= fd_info
[fd
].cp
;
5206 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
5207 return STATUS_READ_ERROR
;
5209 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
5210 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
5212 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
5216 cp
->status
= STATUS_READ_IN_PROGRESS
;
5218 if (fd_info
[fd
].flags
& FILE_PIPE
)
5220 rc
= _read (fd
, &cp
->chr
, sizeof (char));
5222 /* Give subprocess time to buffer some more output for us before
5223 reporting that input is available; we need this because Windows 95
5224 connects DOS programs to pipes by making the pipe appear to be
5225 the normal console stdout - as a result most DOS programs will
5226 write to stdout without buffering, ie. one character at a
5227 time. Even some W32 programs do this - "dir" in a command
5228 shell on NT is very slow if we don't do this. */
5231 int wait
= w32_pipe_read_delay
;
5237 /* Yield remainder of our time slice, effectively giving a
5238 temporary priority boost to the child process. */
5242 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
5244 HANDLE hnd
= fd_info
[fd
].hnd
;
5245 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
5248 /* Configure timeouts for blocking read. */
5249 if (!GetCommTimeouts (hnd
, &ct
))
5250 return STATUS_READ_ERROR
;
5251 ct
.ReadIntervalTimeout
= 0;
5252 ct
.ReadTotalTimeoutMultiplier
= 0;
5253 ct
.ReadTotalTimeoutConstant
= 0;
5254 if (!SetCommTimeouts (hnd
, &ct
))
5255 return STATUS_READ_ERROR
;
5257 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
5259 if (GetLastError () != ERROR_IO_PENDING
)
5260 return STATUS_READ_ERROR
;
5261 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
5262 return STATUS_READ_ERROR
;
5265 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
5267 unsigned long nblock
= 0;
5268 /* We always want this to block, so temporarily disable NDELAY. */
5269 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5270 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5272 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
5274 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5277 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5281 if (rc
== sizeof (char))
5282 cp
->status
= STATUS_READ_SUCCEEDED
;
5284 cp
->status
= STATUS_READ_FAILED
;
5290 _sys_wait_accept (int fd
)
5296 if (fd
< 0 || fd
>= MAXDESC
)
5297 return STATUS_READ_ERROR
;
5299 cp
= fd_info
[fd
].cp
;
5301 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
5302 return STATUS_READ_ERROR
;
5304 cp
->status
= STATUS_READ_FAILED
;
5306 hEv
= pfn_WSACreateEvent ();
5307 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
5308 if (rc
!= SOCKET_ERROR
)
5310 rc
= WaitForSingleObject (hEv
, INFINITE
);
5311 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
5312 if (rc
== WAIT_OBJECT_0
)
5313 cp
->status
= STATUS_READ_SUCCEEDED
;
5315 pfn_WSACloseEvent (hEv
);
5321 sys_read (int fd
, char * buffer
, unsigned int count
)
5326 char * orig_buffer
= buffer
;
5334 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
5336 child_process
*cp
= fd_info
[fd
].cp
;
5338 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
5346 /* re-read CR carried over from last read */
5347 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
5349 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
5353 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
5356 /* presence of a child_process structure means we are operating in
5357 non-blocking mode - otherwise we just call _read directly.
5358 Note that the child_process structure might be missing because
5359 reap_subprocess has been called; in this case the pipe is
5360 already broken, so calling _read on it is okay. */
5363 int current_status
= cp
->status
;
5365 switch (current_status
)
5367 case STATUS_READ_FAILED
:
5368 case STATUS_READ_ERROR
:
5369 /* report normal EOF if nothing in buffer */
5371 fd_info
[fd
].flags
|= FILE_AT_EOF
;
5374 case STATUS_READ_READY
:
5375 case STATUS_READ_IN_PROGRESS
:
5376 DebPrint (("sys_read called when read is in progress\n"));
5377 errno
= EWOULDBLOCK
;
5380 case STATUS_READ_SUCCEEDED
:
5381 /* consume read-ahead char */
5382 *buffer
++ = cp
->chr
;
5385 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5386 ResetEvent (cp
->char_avail
);
5388 case STATUS_READ_ACKNOWLEDGED
:
5392 DebPrint (("sys_read: bad status %d\n", current_status
));
5397 if (fd_info
[fd
].flags
& FILE_PIPE
)
5399 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
5400 to_read
= min (waiting
, (DWORD
) count
);
5403 nchars
+= _read (fd
, buffer
, to_read
);
5405 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
5407 HANDLE hnd
= fd_info
[fd
].hnd
;
5408 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
5414 /* Configure timeouts for non-blocking read. */
5415 if (!GetCommTimeouts (hnd
, &ct
))
5420 ct
.ReadIntervalTimeout
= MAXDWORD
;
5421 ct
.ReadTotalTimeoutMultiplier
= 0;
5422 ct
.ReadTotalTimeoutConstant
= 0;
5423 if (!SetCommTimeouts (hnd
, &ct
))
5429 if (!ResetEvent (ovl
->hEvent
))
5434 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
5436 if (GetLastError () != ERROR_IO_PENDING
)
5441 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
5450 else /* FILE_SOCKET */
5452 if (winsock_lib
== NULL
) abort ();
5454 /* do the equivalent of a non-blocking read */
5455 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
5456 if (waiting
== 0 && nchars
== 0)
5458 h_errno
= errno
= EWOULDBLOCK
;
5464 /* always use binary mode for sockets */
5465 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
5466 if (res
== SOCKET_ERROR
)
5468 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
5469 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
5479 int nread
= _read (fd
, buffer
, count
);
5482 else if (nchars
== 0)
5487 fd_info
[fd
].flags
|= FILE_AT_EOF
;
5488 /* Perform text mode translation if required. */
5489 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
5491 nchars
= crlf_to_lf (nchars
, orig_buffer
);
5492 /* If buffer contains only CR, return that. To be absolutely
5493 sure we should attempt to read the next char, but in
5494 practice a CR to be followed by LF would not appear by
5495 itself in the buffer. */
5496 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
5498 fd_info
[fd
].flags
|= FILE_LAST_CR
;
5504 nchars
= _read (fd
, buffer
, count
);
5509 /* From w32xfns.c */
5510 extern HANDLE interrupt_handle
;
5512 /* For now, don't bother with a non-blocking mode */
5514 sys_write (int fd
, const void * buffer
, unsigned int count
)
5524 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
5526 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
5532 /* Perform text mode translation if required. */
5533 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
5535 char * tmpbuf
= alloca (count
* 2);
5536 unsigned char * src
= (void *)buffer
;
5537 unsigned char * dst
= tmpbuf
;
5542 unsigned char *next
;
5543 /* copy next line or remaining bytes */
5544 next
= _memccpy (dst
, src
, '\n', nbytes
);
5547 /* copied one line ending with '\n' */
5548 int copied
= next
- dst
;
5551 /* insert '\r' before '\n' */
5558 /* copied remaining partial line -> now finished */
5565 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
5567 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
5568 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
5569 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
5572 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
5574 if (GetLastError () != ERROR_IO_PENDING
)
5579 if (detect_input_pending ())
5580 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
5583 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
5584 if (active
== WAIT_OBJECT_0
)
5585 { /* User pressed C-g, cancel write, then leave. Don't bother
5586 cleaning up as we may only get stuck in buggy drivers. */
5587 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
5592 if (active
== WAIT_OBJECT_0
+ 1
5593 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
5600 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
5602 unsigned long nblock
= 0;
5603 if (winsock_lib
== NULL
) abort ();
5605 /* TODO: implement select() properly so non-blocking I/O works. */
5606 /* For now, make sure the write blocks. */
5607 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5608 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5610 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
5612 /* Set the socket back to non-blocking if it was before,
5613 for other operations that support it. */
5614 if (fd_info
[fd
].flags
& FILE_NDELAY
)
5617 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
5620 if (nchars
== SOCKET_ERROR
)
5622 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
5623 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
5629 /* Some networked filesystems don't like too large writes, so
5630 break them into smaller chunks. See the Comments section of
5631 the MSDN documentation of WriteFile for details behind the
5632 choice of the value of CHUNK below. See also the thread
5633 http://thread.gmane.org/gmane.comp.version-control.git/145294
5634 in the git mailing list. */
5635 const unsigned char *p
= buffer
;
5636 const unsigned chunk
= 30 * 1024 * 1024;
5641 unsigned this_chunk
= count
< chunk
? count
: chunk
;
5642 int n
= _write (fd
, p
, this_chunk
);
5650 else if (n
< this_chunk
)
5661 check_windows_init_file (void)
5663 /* A common indication that Emacs is not installed properly is when
5664 it cannot find the Windows installation file. If this file does
5665 not exist in the expected place, tell the user. */
5667 if (!noninteractive
&& !inhibit_window_system
)
5669 Lisp_Object objs
[2];
5670 Lisp_Object full_load_path
;
5671 Lisp_Object init_file
;
5674 objs
[0] = Vload_path
;
5675 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
5676 full_load_path
= Fappend (2, objs
);
5677 init_file
= build_string ("term/w32-win");
5678 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
5681 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
5682 char *init_file_name
= SDATA (init_file
);
5683 char *load_path
= SDATA (load_path_print
);
5684 char *buffer
= alloca (1024
5685 + strlen (init_file_name
)
5686 + strlen (load_path
));
5689 "The Emacs Windows initialization file \"%s.el\" "
5690 "could not be found in your Emacs installation. "
5691 "Emacs checked the following directories for this file:\n"
5693 "When Emacs cannot find this file, it usually means that it "
5694 "was not installed properly, or its distribution file was "
5695 "not unpacked properly.\nSee the README.W32 file in the "
5696 "top-level Emacs directory for more information.",
5697 init_file_name
, load_path
);
5700 "Emacs Abort Dialog",
5701 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
5702 /* Use the low-level Emacs abort. */
5716 /* shutdown the socket interface if necessary */
5725 /* Initialise the socket interface now if available and requested by
5726 the user by defining PRELOAD_WINSOCK; otherwise loading will be
5727 delayed until open-network-stream is called (w32-has-winsock can
5728 also be used to dynamically load or reload winsock).
5730 Conveniently, init_environment is called before us, so
5731 PRELOAD_WINSOCK can be set in the registry. */
5733 /* Always initialize this correctly. */
5736 if (getenv ("PRELOAD_WINSOCK") != NULL
)
5737 init_winsock (TRUE
);
5739 /* Initial preparation for subprocess support: replace our standard
5740 handles with non-inheritable versions. */
5743 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
5744 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
5745 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
5747 parent
= GetCurrentProcess ();
5749 /* ignore errors when duplicating and closing; typically the
5750 handles will be invalid when running as a gui program. */
5751 DuplicateHandle (parent
,
5752 GetStdHandle (STD_INPUT_HANDLE
),
5757 DUPLICATE_SAME_ACCESS
);
5759 DuplicateHandle (parent
,
5760 GetStdHandle (STD_OUTPUT_HANDLE
),
5765 DUPLICATE_SAME_ACCESS
);
5767 DuplicateHandle (parent
,
5768 GetStdHandle (STD_ERROR_HANDLE
),
5773 DUPLICATE_SAME_ACCESS
);
5779 if (stdin_save
!= INVALID_HANDLE_VALUE
)
5780 _open_osfhandle ((long) stdin_save
, O_TEXT
);
5782 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
5785 if (stdout_save
!= INVALID_HANDLE_VALUE
)
5786 _open_osfhandle ((long) stdout_save
, O_TEXT
);
5788 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
5791 if (stderr_save
!= INVALID_HANDLE_VALUE
)
5792 _open_osfhandle ((long) stderr_save
, O_TEXT
);
5794 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
5798 /* unfortunately, atexit depends on implementation of malloc */
5799 /* atexit (term_ntproc); */
5800 signal (SIGABRT
, term_ntproc
);
5802 /* determine which drives are fixed, for GetCachedVolumeInformation */
5804 /* GetDriveType must have trailing backslash. */
5805 char drive
[] = "A:\\";
5807 /* Loop over all possible drive letters */
5808 while (*drive
<= 'Z')
5810 /* Record if this drive letter refers to a fixed drive. */
5811 fixed_drives
[DRIVE_INDEX (*drive
)] =
5812 (GetDriveType (drive
) == DRIVE_FIXED
);
5817 /* Reset the volume info cache. */
5818 volume_cache
= NULL
;
5821 /* Check to see if Emacs has been installed correctly. */
5822 check_windows_init_file ();
5826 shutdown_handler ensures that buffers' autosave files are
5827 up to date when the user logs off, or the system shuts down.
5830 shutdown_handler (DWORD type
)
5832 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
5833 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
5834 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
5835 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
5837 /* Shut down cleanly, making sure autosave files are up to date. */
5838 shut_down_emacs (0, 0, Qnil
);
5841 /* Allow other handlers to handle this signal. */
5846 globals_of_w32 is used to initialize those global variables that
5847 must always be initialized on startup even when the global variable
5848 initialized is non zero (see the function main in emacs.c).
5851 globals_of_w32 (void)
5853 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
5855 get_process_times_fn
= (GetProcessTimes_Proc
)
5856 GetProcAddress (kernel32
, "GetProcessTimes");
5858 g_b_init_is_windows_9x
= 0;
5859 g_b_init_open_process_token
= 0;
5860 g_b_init_get_token_information
= 0;
5861 g_b_init_lookup_account_sid
= 0;
5862 g_b_init_get_sid_sub_authority
= 0;
5863 g_b_init_get_sid_sub_authority_count
= 0;
5864 g_b_init_get_file_security
= 0;
5865 g_b_init_get_security_descriptor_owner
= 0;
5866 g_b_init_get_security_descriptor_group
= 0;
5867 g_b_init_is_valid_sid
= 0;
5868 g_b_init_create_toolhelp32_snapshot
= 0;
5869 g_b_init_process32_first
= 0;
5870 g_b_init_process32_next
= 0;
5871 g_b_init_open_thread_token
= 0;
5872 g_b_init_impersonate_self
= 0;
5873 g_b_init_revert_to_self
= 0;
5874 g_b_init_get_process_memory_info
= 0;
5875 g_b_init_get_process_working_set_size
= 0;
5876 g_b_init_global_memory_status
= 0;
5877 g_b_init_global_memory_status_ex
= 0;
5878 g_b_init_equal_sid
= 0;
5879 g_b_init_copy_sid
= 0;
5880 g_b_init_get_length_sid
= 0;
5881 g_b_init_get_native_system_info
= 0;
5882 g_b_init_get_system_times
= 0;
5883 num_of_processors
= 0;
5884 /* The following sets a handler for shutdown notifications for
5885 console apps. This actually applies to Emacs in both console and
5886 GUI modes, since we had to fool windows into thinking emacs is a
5887 console application to get console mode to work. */
5888 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
5890 /* "None" is the default group name on standalone workstations. */
5891 strcpy (dflt_group_name
, "None");
5894 /* For make-serial-process */
5896 serial_open (char *port
)
5902 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
5903 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
5904 if (hnd
== INVALID_HANDLE_VALUE
)
5905 error ("Could not open %s", port
);
5906 fd
= (int) _open_osfhandle ((int) hnd
, 0);
5908 error ("Could not open %s", port
);
5912 error ("Could not create child process");
5914 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5915 fd_info
[ fd
].hnd
= hnd
;
5916 fd_info
[ fd
].flags
|=
5917 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
5918 if (fd_info
[ fd
].cp
!= NULL
)
5920 error ("fd_info[fd = %d] is already in use", fd
);
5922 fd_info
[ fd
].cp
= cp
;
5923 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
5924 if (cp
->ovl_read
.hEvent
== NULL
)
5925 error ("Could not create read event");
5926 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
5927 if (cp
->ovl_write
.hEvent
== NULL
)
5928 error ("Could not create write event");
5933 /* For serial-process-configure */
5935 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
5937 Lisp_Object childp2
= Qnil
;
5938 Lisp_Object tem
= Qnil
;
5942 char summary
[4] = "???"; /* This usually becomes "8N1". */
5944 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
5945 error ("Not a serial process");
5946 hnd
= fd_info
[ p
->outfd
].hnd
;
5948 childp2
= Fcopy_sequence (p
->childp
);
5950 /* Initialize timeouts for blocking read and blocking write. */
5951 if (!GetCommTimeouts (hnd
, &ct
))
5952 error ("GetCommTimeouts() failed");
5953 ct
.ReadIntervalTimeout
= 0;
5954 ct
.ReadTotalTimeoutMultiplier
= 0;
5955 ct
.ReadTotalTimeoutConstant
= 0;
5956 ct
.WriteTotalTimeoutMultiplier
= 0;
5957 ct
.WriteTotalTimeoutConstant
= 0;
5958 if (!SetCommTimeouts (hnd
, &ct
))
5959 error ("SetCommTimeouts() failed");
5960 /* Read port attributes and prepare default configuration. */
5961 memset (&dcb
, 0, sizeof (dcb
));
5962 dcb
.DCBlength
= sizeof (DCB
);
5963 if (!GetCommState (hnd
, &dcb
))
5964 error ("GetCommState() failed");
5967 dcb
.fAbortOnError
= FALSE
;
5968 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
5973 /* Configure speed. */
5974 if (!NILP (Fplist_member (contact
, QCspeed
)))
5975 tem
= Fplist_get (contact
, QCspeed
);
5977 tem
= Fplist_get (p
->childp
, QCspeed
);
5979 dcb
.BaudRate
= XINT (tem
);
5980 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
5982 /* Configure bytesize. */
5983 if (!NILP (Fplist_member (contact
, QCbytesize
)))
5984 tem
= Fplist_get (contact
, QCbytesize
);
5986 tem
= Fplist_get (p
->childp
, QCbytesize
);
5988 tem
= make_number (8);
5990 if (XINT (tem
) != 7 && XINT (tem
) != 8)
5991 error (":bytesize must be nil (8), 7, or 8");
5992 dcb
.ByteSize
= XINT (tem
);
5993 summary
[0] = XINT (tem
) + '0';
5994 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
5996 /* Configure parity. */
5997 if (!NILP (Fplist_member (contact
, QCparity
)))
5998 tem
= Fplist_get (contact
, QCparity
);
6000 tem
= Fplist_get (p
->childp
, QCparity
);
6001 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6002 error (":parity must be nil (no parity), `even', or `odd'");
6003 dcb
.fParity
= FALSE
;
6004 dcb
.Parity
= NOPARITY
;
6005 dcb
.fErrorChar
= FALSE
;
6010 else if (EQ (tem
, Qeven
))
6014 dcb
.Parity
= EVENPARITY
;
6015 dcb
.fErrorChar
= TRUE
;
6017 else if (EQ (tem
, Qodd
))
6021 dcb
.Parity
= ODDPARITY
;
6022 dcb
.fErrorChar
= TRUE
;
6024 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6026 /* Configure stopbits. */
6027 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6028 tem
= Fplist_get (contact
, QCstopbits
);
6030 tem
= Fplist_get (p
->childp
, QCstopbits
);
6032 tem
= make_number (1);
6034 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6035 error (":stopbits must be nil (1 stopbit), 1, or 2");
6036 summary
[2] = XINT (tem
) + '0';
6037 if (XINT (tem
) == 1)
6038 dcb
.StopBits
= ONESTOPBIT
;
6039 else if (XINT (tem
) == 2)
6040 dcb
.StopBits
= TWOSTOPBITS
;
6041 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6043 /* Configure flowcontrol. */
6044 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6045 tem
= Fplist_get (contact
, QCflowcontrol
);
6047 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6048 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6049 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6050 dcb
.fOutxCtsFlow
= FALSE
;
6051 dcb
.fOutxDsrFlow
= FALSE
;
6052 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6053 dcb
.fDsrSensitivity
= FALSE
;
6054 dcb
.fTXContinueOnXoff
= FALSE
;
6057 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6058 dcb
.XonChar
= 17; /* Control-Q */
6059 dcb
.XoffChar
= 19; /* Control-S */
6062 /* Already configured. */
6064 else if (EQ (tem
, Qhw
))
6066 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6067 dcb
.fOutxCtsFlow
= TRUE
;
6069 else if (EQ (tem
, Qsw
))
6074 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6076 /* Activate configuration. */
6077 if (!SetCommState (hnd
, &dcb
))
6078 error ("SetCommState() failed");
6080 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6081 p
->childp
= childp2
;