HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lisp/mouse-drag.el (mouse-drag-throw): Fix typo in docstring.
[bpt/emacs.git] / src / w32.c
CommitLineData
e9e23e23 1/* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
f8381794 2 Copyright (C) 1994, 1995, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
5df4f04c 3 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
95ed0025 4
3b7ad313
EN		 5This file is part of GNU Emacs.
6
9ec0b715 7GNU Emacs is free software: you can redistribute it and/or modify
3b7ad313 8it under the terms of the GNU General Public License as published by
9ec0b715
GM		 9the Free Software Foundation, either version 3 of the License, or
10(at your option) any later version.
3b7ad313
EN		 11
12GNU Emacs is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
9ec0b715 18along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
95ed0025 19
9ec0b715 20/*
95ed0025
RS		 21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22*/
76b3903d 23#include <stddef.h> /* for offsetof */
95ed0025
RS		 24#include <stdlib.h>
25#include <stdio.h>
ad9e2d54 26#include <float.h> /* for DBL_EPSILON */
95ed0025 27#include <io.h>
480b0c5b 28#include <errno.h>
95ed0025
RS		 29#include <fcntl.h>
30#include <ctype.h>
480b0c5b 31#include <signal.h>
b3308d2e 32#include <sys/file.h>
480b0c5b 33#include <sys/time.h>
16bb7578 34#include <sys/utime.h>
22189f79 35#include <mbstring.h> /* for _mbspbrk */
7c80d5ec 36#include <math.h>
d7306fe6 37#include <setjmp.h>
480b0c5b
GV		 38
39/* must include CRT headers *before* config.h */
4838e624
PJ		 40
41#ifdef HAVE_CONFIG_H
42#include <config.h>
43#endif
44
480b0c5b
GV		 45#undef access
46#undef chdir
47#undef chmod
48#undef creat
49#undef ctime
50#undef fopen
51#undef link
52#undef mkdir
53#undef mktemp
54#undef open
55#undef rename
56#undef rmdir
57#undef unlink
58
59#undef close
60#undef dup
61#undef dup2
62#undef pipe
63#undef read
64#undef write
95ed0025 65
d8fcc1b9
AI		 66#undef strerror
67
95ed0025 68#include "lisp.h"
95ed0025
RS		 69
70#include <pwd.h>
3d19b645 71#include <grp.h>
95ed0025 72
971bce75
AI		 73#ifdef __GNUC__
74#define _ANONYMOUS_UNION
75#define _ANONYMOUS_STRUCT
76#endif
480b0c5b 77#include <windows.h>
b8526f6e
EZ		 78/* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
79 use a different name to avoid compilation problems. */
80typedef struct _MEMORY_STATUS_EX {
7c80d5ec
EZ		 81 DWORD dwLength;
82 DWORD dwMemoryLoad;
83 DWORDLONG ullTotalPhys;
84 DWORDLONG ullAvailPhys;
85 DWORDLONG ullTotalPageFile;
86 DWORDLONG ullAvailPageFile;
87 DWORDLONG ullTotalVirtual;
88 DWORDLONG ullAvailVirtual;
89 DWORDLONG ullAvailExtendedVirtual;
b8526f6e 90} MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
7c80d5ec 91
634d3003 92#include <lmcons.h>
2d5324c5 93#include <shlobj.h>
00b3b7b3 94
7c80d5ec
EZ		 95#include <tlhelp32.h>
96#include <psapi.h>
b8e5cf1d
EZ		 97#include <w32api.h>
98#if !defined(__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
7c80d5ec 99/* This either is not in psapi.h or guarded by higher value of
b8e5cf1d
EZ		 100 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
101 defines it in psapi.h */
7c80d5ec
EZ		 102typedef struct _PROCESS_MEMORY_COUNTERS_EX {
103 DWORD cb;
104 DWORD PageFaultCount;
105 DWORD PeakWorkingSetSize;
106 DWORD WorkingSetSize;
107 DWORD QuotaPeakPagedPoolUsage;
108 DWORD QuotaPagedPoolUsage;
109 DWORD QuotaPeakNonPagedPoolUsage;
110 DWORD QuotaNonPagedPoolUsage;
111 DWORD PagefileUsage;
112 DWORD PeakPagefileUsage;
113 DWORD PrivateUsage;
114} PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
b8e5cf1d 115#endif
7c80d5ec 116
480b0c5b
GV		 117#ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
118#include <sys/socket.h>
119#undef socket
120#undef bind
121#undef connect
122#undef htons
123#undef ntohs
124#undef inet_addr
125#undef gethostname
126#undef gethostbyname
127#undef getservbyname
ecd270eb 128#undef getpeername
380961a6 129#undef shutdown
962955c5
JR		 130#undef setsockopt
131#undef listen
132#undef getsockname
133#undef accept
134#undef recvfrom
135#undef sendto
480b0c5b 136#endif
00b3b7b3 137
489f9371 138#include "w32.h"
480b0c5b 139#include "ndir.h"
489f9371 140#include "w32heap.h"
253574a6 141#include "systime.h"
f481eb31 142#include "dispextern.h" /* for xstrcasecmp */
7c80d5ec 143#include "coding.h" /* for Vlocale_coding_system */
253574a6 144
1eb8fd91 145/* For serial_configure and serial_open. */
d888760c
GM		 146#include "process.h"
147/* From process.c */
148extern Lisp_Object QCport, QCspeed, QCprocess;
149extern Lisp_Object QCbytesize, QCstopbits, QCparity, Qodd, Qeven;
150extern Lisp_Object QCflowcontrol, Qhw, Qsw, QCsummary;
151
2d5324c5
JR		 152typedef HRESULT (WINAPI * ShGetFolderPath_fn)
153 (IN HWND, IN int, IN HANDLE, IN DWORD, OUT char *);
154
9785d95b 155void globals_of_w32 ();
8aaaec6b 156static DWORD get_rid (PSID);
9785d95b 157
76b3903d
GV		 158extern Lisp_Object Vw32_downcase_file_names;
159extern Lisp_Object Vw32_generate_fake_inodes;
160extern Lisp_Object Vw32_get_true_file_attributes;
ac0af113
JR		 161/* Defined in process.c for its own purpose. */
162extern Lisp_Object Qlocal;
163
e0c181dd 164extern int w32_num_mouse_buttons;
76b3903d 165
18e070ac 166\f
9d95a291
EZ		 167/* Initialization states.
168
169 WARNING: If you add any more such variables for additional APIs,
170 you MUST add initialization for them to globals_of_w32
171 below. This is because these variables might get set
172 to non-NULL values during dumping, but the dumped Emacs
173 cannot reuse those values, because it could be run on a
174 different version of the OS, where API addresses are
175 different. */
9785d95b
BK		 176static BOOL g_b_init_is_windows_9x;
177static BOOL g_b_init_open_process_token;
178static BOOL g_b_init_get_token_information;
179static BOOL g_b_init_lookup_account_sid;
180static BOOL g_b_init_get_sid_identifier_authority;
c617afce
EZ		 181static BOOL g_b_init_get_sid_sub_authority;
182static BOOL g_b_init_get_sid_sub_authority_count;
8aaaec6b
EZ		 183static BOOL g_b_init_get_file_security;
184static BOOL g_b_init_get_security_descriptor_owner;
185static BOOL g_b_init_get_security_descriptor_group;
186static BOOL g_b_init_is_valid_sid;
7c80d5ec
EZ		 187static BOOL g_b_init_create_toolhelp32_snapshot;
188static BOOL g_b_init_process32_first;
189static BOOL g_b_init_process32_next;
190static BOOL g_b_init_open_thread_token;
191static BOOL g_b_init_impersonate_self;
192static BOOL g_b_init_revert_to_self;
193static BOOL g_b_init_get_process_memory_info;
194static BOOL g_b_init_get_process_working_set_size;
195static BOOL g_b_init_global_memory_status;
196static BOOL g_b_init_global_memory_status_ex;
f8b35b24
EZ		 197static BOOL g_b_init_get_length_sid;
198static BOOL g_b_init_equal_sid;
199static BOOL g_b_init_copy_sid;
ad9e2d54
EZ		 200static BOOL g_b_init_get_native_system_info;
201static BOOL g_b_init_get_system_times;
9785d95b 202
f60ae425
BK		 203/*
204 BEGIN: Wrapper functions around OpenProcessToken
205 and other functions in advapi32.dll that are only
206 supported in Windows NT / 2k / XP
207*/
208 /* ** Function pointer typedefs ** */
209typedef BOOL (WINAPI * OpenProcessToken_Proc) (
210 HANDLE ProcessHandle,
211 DWORD DesiredAccess,
212 PHANDLE TokenHandle);
213typedef BOOL (WINAPI * GetTokenInformation_Proc) (
214 HANDLE TokenHandle,
215 TOKEN_INFORMATION_CLASS TokenInformationClass,
216 LPVOID TokenInformation,
217 DWORD TokenInformationLength,
218 PDWORD ReturnLength);
74258518
JR		 219typedef BOOL (WINAPI * GetProcessTimes_Proc) (
220 HANDLE process_handle,
221 LPFILETIME creation_time,
222 LPFILETIME exit_time,
223 LPFILETIME kernel_time,
224 LPFILETIME user_time);
225
226GetProcessTimes_Proc get_process_times_fn = NULL;
227
f60ae425
BK		 228#ifdef _UNICODE
229const char * const LookupAccountSid_Name = "LookupAccountSidW";
8aaaec6b 230const char * const GetFileSecurity_Name = "GetFileSecurityW";
f60ae425
BK		 231#else
232const char * const LookupAccountSid_Name = "LookupAccountSidA";
8aaaec6b 233const char * const GetFileSecurity_Name = "GetFileSecurityA";
f60ae425
BK		 234#endif
235typedef BOOL (WINAPI * LookupAccountSid_Proc) (
236 LPCTSTR lpSystemName,
237 PSID Sid,
238 LPTSTR Name,
239 LPDWORD cbName,
240 LPTSTR DomainName,
241 LPDWORD cbDomainName,
242 PSID_NAME_USE peUse);
243typedef PSID_IDENTIFIER_AUTHORITY (WINAPI * GetSidIdentifierAuthority_Proc) (
244 PSID pSid);
c617afce
EZ		 245typedef PDWORD (WINAPI * GetSidSubAuthority_Proc) (
246 PSID pSid,
247 DWORD n);
248typedef PUCHAR (WINAPI * GetSidSubAuthorityCount_Proc) (
249 PSID pSid);
8aaaec6b
EZ		 250typedef BOOL (WINAPI * GetFileSecurity_Proc) (
251 LPCTSTR lpFileName,
252 SECURITY_INFORMATION RequestedInformation,
253 PSECURITY_DESCRIPTOR pSecurityDescriptor,
254 DWORD nLength,
255 LPDWORD lpnLengthNeeded);
256typedef BOOL (WINAPI * GetSecurityDescriptorOwner_Proc) (
257 PSECURITY_DESCRIPTOR pSecurityDescriptor,
258 PSID *pOwner,
259 LPBOOL lpbOwnerDefaulted);
260typedef BOOL (WINAPI * GetSecurityDescriptorGroup_Proc) (
261 PSECURITY_DESCRIPTOR pSecurityDescriptor,
262 PSID *pGroup,
263 LPBOOL lpbGroupDefaulted);
264typedef BOOL (WINAPI * IsValidSid_Proc) (
265 PSID sid);
7c80d5ec
EZ		 266typedef HANDLE (WINAPI * CreateToolhelp32Snapshot_Proc) (
267 DWORD dwFlags,
268 DWORD th32ProcessID);
269typedef BOOL (WINAPI * Process32First_Proc) (
270 HANDLE hSnapshot,
271 LPPROCESSENTRY32 lppe);
272typedef BOOL (WINAPI * Process32Next_Proc) (
273 HANDLE hSnapshot,
274 LPPROCESSENTRY32 lppe);
275typedef BOOL (WINAPI * OpenThreadToken_Proc) (
276 HANDLE ThreadHandle,
277 DWORD DesiredAccess,
278 BOOL OpenAsSelf,
279 PHANDLE TokenHandle);
280typedef BOOL (WINAPI * ImpersonateSelf_Proc) (
281 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
282typedef BOOL (WINAPI * RevertToSelf_Proc) (void);
283typedef BOOL (WINAPI * GetProcessMemoryInfo_Proc) (
284 HANDLE Process,
285 PPROCESS_MEMORY_COUNTERS ppsmemCounters,
286 DWORD cb);
287typedef BOOL (WINAPI * GetProcessWorkingSetSize_Proc) (
288 HANDLE hProcess,
289 DWORD * lpMinimumWorkingSetSize,
290 DWORD * lpMaximumWorkingSetSize);
291typedef BOOL (WINAPI * GlobalMemoryStatus_Proc) (
292 LPMEMORYSTATUS lpBuffer);
293typedef BOOL (WINAPI * GlobalMemoryStatusEx_Proc) (
b8526f6e 294 LPMEMORY_STATUS_EX lpBuffer);
f8b35b24
EZ		 295typedef BOOL (WINAPI * CopySid_Proc) (
296 DWORD nDestinationSidLength,
297 PSID pDestinationSid,
298 PSID pSourceSid);
299typedef BOOL (WINAPI * EqualSid_Proc) (
300 PSID pSid1,
301 PSID pSid2);
302typedef DWORD (WINAPI * GetLengthSid_Proc) (
303 PSID pSid);
ad9e2d54
EZ		 304typedef void (WINAPI * GetNativeSystemInfo_Proc) (
305 LPSYSTEM_INFO lpSystemInfo);
306typedef BOOL (WINAPI * GetSystemTimes_Proc) (
307 LPFILETIME lpIdleTime,
308 LPFILETIME lpKernelTime,
309 LPFILETIME lpUserTime);
f8b35b24
EZ		 310
311
f60ae425
BK		 312
313 /* ** A utility function ** */
9bfb11f9
KS		 314static BOOL
315is_windows_9x ()
f60ae425 316{
9785d95b 317 static BOOL s_b_ret=0;
f60ae425 318 OSVERSIONINFO os_ver;
9785d95b 319 if (g_b_init_is_windows_9x == 0)
f60ae425 320 {
9785d95b 321 g_b_init_is_windows_9x = 1;
9d4f32e8
JB		 322 ZeroMemory (&os_ver, sizeof (OSVERSIONINFO));
323 os_ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
9785d95b
BK		 324 if (GetVersionEx (&os_ver))
325 {
326 s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
327 }
f60ae425 328 }
9785d95b 329 return s_b_ret;
f60ae425
BK		 330}
331
74258518
JR		 332/* Get total user and system times for get-internal-run-time.
333 Returns a list of three integers if the times are provided by the OS
334 (NT derivatives), otherwise it returns the result of current-time. */
335Lisp_Object
336w32_get_internal_run_time ()
337{
338 if (get_process_times_fn)
339 {
340 FILETIME create, exit, kernel, user;
9d4f32e8 341 HANDLE proc = GetCurrentProcess ();
74258518
JR		 342 if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
343 {
344 LARGE_INTEGER user_int, kernel_int, total;
345 int microseconds;
346 user_int.LowPart = user.dwLowDateTime;
347 user_int.HighPart = user.dwHighDateTime;
348 kernel_int.LowPart = kernel.dwLowDateTime;
349 kernel_int.HighPart = kernel.dwHighDateTime;
350 total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
351 /* FILETIME is 100 nanosecond increments, Emacs only wants
352 microsecond resolution. */
353 total.QuadPart /= 10;
354 microseconds = total.QuadPart % 1000000;
355 total.QuadPart /= 1000000;
356
357 /* Sanity check to make sure we can represent the result. */
358 if (total.HighPart == 0)
359 {
360 int secs = total.LowPart;
361
362 return list3 (make_number ((secs >> 16) & 0xffff),
363 make_number (secs & 0xffff),
364 make_number (microseconds));
365 }
366 }
367 }
368
369 return Fcurrent_time ();
370}
371
f60ae425
BK		 372 /* ** The wrapper functions ** */
373
9d4f32e8
JB		 374BOOL WINAPI
375open_process_token (HANDLE ProcessHandle,
376 DWORD DesiredAccess,
377 PHANDLE TokenHandle)
f60ae425 378{
9785d95b 379 static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
f60ae425
BK		 380 HMODULE hm_advapi32 = NULL;
381 if (is_windows_9x () == TRUE)
382 {
383 return FALSE;
384 }
9785d95b
BK		 385 if (g_b_init_open_process_token == 0)
386 {
387 g_b_init_open_process_token = 1;
388 hm_advapi32 = LoadLibrary ("Advapi32.dll");
389 s_pfn_Open_Process_Token =
390 (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
391 }
392 if (s_pfn_Open_Process_Token == NULL)
f60ae425
BK		 393 {
394 return FALSE;
395 }
396 return (
9785d95b 397 s_pfn_Open_Process_Token (
f60ae425
BK		 398 ProcessHandle,
399 DesiredAccess,
400 TokenHandle)
401 );
402}
403
9d4f32e8
JB		 404BOOL WINAPI
405get_token_information (HANDLE TokenHandle,
406 TOKEN_INFORMATION_CLASS TokenInformationClass,
407 LPVOID TokenInformation,
408 DWORD TokenInformationLength,
409 PDWORD ReturnLength)
f60ae425 410{
9785d95b 411 static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
f60ae425
BK		 412 HMODULE hm_advapi32 = NULL;
413 if (is_windows_9x () == TRUE)
414 {
415 return FALSE;
416 }
9785d95b
BK		 417 if (g_b_init_get_token_information == 0)
418 {
419 g_b_init_get_token_information = 1;
420 hm_advapi32 = LoadLibrary ("Advapi32.dll");
421 s_pfn_Get_Token_Information =
422 (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
423 }
424 if (s_pfn_Get_Token_Information == NULL)
f60ae425
BK		 425 {
426 return FALSE;
427 }
428 return (
9785d95b 429 s_pfn_Get_Token_Information (
f60ae425
BK		 430 TokenHandle,
431 TokenInformationClass,
432 TokenInformation,
433 TokenInformationLength,
434 ReturnLength)
435 );
436}
437
9d4f32e8
JB		 438BOOL WINAPI
439lookup_account_sid (LPCTSTR lpSystemName,
440 PSID Sid,
441 LPTSTR Name,
442 LPDWORD cbName,
443 LPTSTR DomainName,
444 LPDWORD cbDomainName,
445 PSID_NAME_USE peUse)
f60ae425 446{
9785d95b 447 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
f60ae425
BK		 448 HMODULE hm_advapi32 = NULL;
449 if (is_windows_9x () == TRUE)
450 {
451 return FALSE;
452 }
9785d95b
BK		 453 if (g_b_init_lookup_account_sid == 0)
454 {
455 g_b_init_lookup_account_sid = 1;
456 hm_advapi32 = LoadLibrary ("Advapi32.dll");
457 s_pfn_Lookup_Account_Sid =
458 (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
459 }
460 if (s_pfn_Lookup_Account_Sid == NULL)
f60ae425
BK		 461 {
462 return FALSE;
463 }
464 return (
9785d95b 465 s_pfn_Lookup_Account_Sid (
f60ae425
BK		 466 lpSystemName,
467 Sid,
468 Name,
469 cbName,
470 DomainName,
471 cbDomainName,
472 peUse)
473 );
474}
475
9d4f32e8
JB		 476PSID_IDENTIFIER_AUTHORITY WINAPI
477get_sid_identifier_authority (PSID pSid)
f60ae425 478{
9785d95b 479 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority = NULL;
f60ae425
BK		 480 HMODULE hm_advapi32 = NULL;
481 if (is_windows_9x () == TRUE)
482 {
483 return NULL;
484 }
9785d95b
BK		 485 if (g_b_init_get_sid_identifier_authority == 0)
486 {
487 g_b_init_get_sid_identifier_authority = 1;
488 hm_advapi32 = LoadLibrary ("Advapi32.dll");
489 s_pfn_Get_Sid_Identifier_Authority =
490 (GetSidIdentifierAuthority_Proc) GetProcAddress (
491 hm_advapi32, "GetSidIdentifierAuthority");
492 }
493 if (s_pfn_Get_Sid_Identifier_Authority == NULL)
f60ae425
BK		 494 {
495 return NULL;
496 }
9785d95b 497 return (s_pfn_Get_Sid_Identifier_Authority (pSid));
f60ae425
BK		 498}
499
9d4f32e8
JB		 500PDWORD WINAPI
501get_sid_sub_authority (PSID pSid, DWORD n)
c617afce
EZ		 502{
503 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority = NULL;
6811b9f4 504 static DWORD zero = 0U;
c617afce
EZ		 505 HMODULE hm_advapi32 = NULL;
506 if (is_windows_9x () == TRUE)
507 {
6811b9f4 508 return &zero;
c617afce
EZ		 509 }
510 if (g_b_init_get_sid_sub_authority == 0)
511 {
512 g_b_init_get_sid_sub_authority = 1;
513 hm_advapi32 = LoadLibrary ("Advapi32.dll");
514 s_pfn_Get_Sid_Sub_Authority =
515 (GetSidSubAuthority_Proc) GetProcAddress (
516 hm_advapi32, "GetSidSubAuthority");
517 }
518 if (s_pfn_Get_Sid_Sub_Authority == NULL)
519 {
6811b9f4 520 return &zero;
c617afce
EZ		 521 }
522 return (s_pfn_Get_Sid_Sub_Authority (pSid, n));
523}
524
9d4f32e8
JB		 525PUCHAR WINAPI
526get_sid_sub_authority_count (PSID pSid)
c617afce
EZ		 527{
528 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count = NULL;
6811b9f4 529 static UCHAR zero = 0U;
c617afce
EZ		 530 HMODULE hm_advapi32 = NULL;
531 if (is_windows_9x () == TRUE)
532 {
6811b9f4 533 return &zero;
c617afce
EZ		 534 }
535 if (g_b_init_get_sid_sub_authority_count == 0)
536 {
537 g_b_init_get_sid_sub_authority_count = 1;
538 hm_advapi32 = LoadLibrary ("Advapi32.dll");
539 s_pfn_Get_Sid_Sub_Authority_Count =
540 (GetSidSubAuthorityCount_Proc) GetProcAddress (
541 hm_advapi32, "GetSidSubAuthorityCount");
542 }
543 if (s_pfn_Get_Sid_Sub_Authority_Count == NULL)
544 {
6811b9f4 545 return &zero;
c617afce
EZ		 546 }
547 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid));
548}
549
9d4f32e8
JB		 550BOOL WINAPI
551get_file_security (LPCTSTR lpFileName,
552 SECURITY_INFORMATION RequestedInformation,
553 PSECURITY_DESCRIPTOR pSecurityDescriptor,
554 DWORD nLength,
555 LPDWORD lpnLengthNeeded)
8aaaec6b
EZ		 556{
557 static GetFileSecurity_Proc s_pfn_Get_File_Security = NULL;
558 HMODULE hm_advapi32 = NULL;
559 if (is_windows_9x () == TRUE)
560 {
561 return FALSE;
562 }
563 if (g_b_init_get_file_security == 0)
564 {
565 g_b_init_get_file_security = 1;
566 hm_advapi32 = LoadLibrary ("Advapi32.dll");
567 s_pfn_Get_File_Security =
568 (GetFileSecurity_Proc) GetProcAddress (
569 hm_advapi32, GetFileSecurity_Name);
570 }
571 if (s_pfn_Get_File_Security == NULL)
572 {
573 return FALSE;
574 }
575 return (s_pfn_Get_File_Security (lpFileName, RequestedInformation,
576 pSecurityDescriptor, nLength,
577 lpnLengthNeeded));
578}
579
9d4f32e8
JB		 580BOOL WINAPI
581get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
582 PSID *pOwner,
583 LPBOOL lpbOwnerDefaulted)
8aaaec6b
EZ		 584{
585 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner = NULL;
586 HMODULE hm_advapi32 = NULL;
587 if (is_windows_9x () == TRUE)
588 {
589 return FALSE;
590 }
591 if (g_b_init_get_security_descriptor_owner == 0)
592 {
593 g_b_init_get_security_descriptor_owner = 1;
594 hm_advapi32 = LoadLibrary ("Advapi32.dll");
595 s_pfn_Get_Security_Descriptor_Owner =
596 (GetSecurityDescriptorOwner_Proc) GetProcAddress (
597 hm_advapi32, "GetSecurityDescriptorOwner");
598 }
599 if (s_pfn_Get_Security_Descriptor_Owner == NULL)
600 {
601 return FALSE;
602 }
603 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor, pOwner,
604 lpbOwnerDefaulted));
605}
606
9d4f32e8
JB		 607BOOL WINAPI
608get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
609 PSID *pGroup,
610 LPBOOL lpbGroupDefaulted)
8aaaec6b
EZ		 611{
612 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group = NULL;
613 HMODULE hm_advapi32 = NULL;
614 if (is_windows_9x () == TRUE)
615 {
616 return FALSE;
617 }
618 if (g_b_init_get_security_descriptor_group == 0)
619 {
620 g_b_init_get_security_descriptor_group = 1;
621 hm_advapi32 = LoadLibrary ("Advapi32.dll");
622 s_pfn_Get_Security_Descriptor_Group =
623 (GetSecurityDescriptorGroup_Proc) GetProcAddress (
624 hm_advapi32, "GetSecurityDescriptorGroup");
625 }
626 if (s_pfn_Get_Security_Descriptor_Group == NULL)
627 {
628 return FALSE;
629 }
630 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor, pGroup,
631 lpbGroupDefaulted));
632}
633
9d4f32e8
JB		 634BOOL WINAPI
635is_valid_sid (PSID sid)
8aaaec6b
EZ		 636{
637 static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
638 HMODULE hm_advapi32 = NULL;
639 if (is_windows_9x () == TRUE)
640 {
641 return FALSE;
642 }
643 if (g_b_init_is_valid_sid == 0)
644 {
645 g_b_init_is_valid_sid = 1;
646 hm_advapi32 = LoadLibrary ("Advapi32.dll");
647 s_pfn_Is_Valid_Sid =
648 (IsValidSid_Proc) GetProcAddress (
649 hm_advapi32, "IsValidSid");
650 }
651 if (s_pfn_Is_Valid_Sid == NULL)
652 {
653 return FALSE;
654 }
655 return (s_pfn_Is_Valid_Sid (sid));
656}
657
9d4f32e8
JB		 658BOOL WINAPI
659equal_sid (PSID sid1, PSID sid2)
f8b35b24
EZ		 660{
661 static EqualSid_Proc s_pfn_Equal_Sid = NULL;
662 HMODULE hm_advapi32 = NULL;
663 if (is_windows_9x () == TRUE)
664 {
665 return FALSE;
666 }
667 if (g_b_init_equal_sid == 0)
668 {
669 g_b_init_equal_sid = 1;
670 hm_advapi32 = LoadLibrary ("Advapi32.dll");
671 s_pfn_Equal_Sid =
672 (EqualSid_Proc) GetProcAddress (
673 hm_advapi32, "EqualSid");
674 }
675 if (s_pfn_Equal_Sid == NULL)
676 {
677 return FALSE;
678 }
679 return (s_pfn_Equal_Sid (sid1, sid2));
680}
681
9d4f32e8
JB		 682DWORD WINAPI
683get_length_sid (PSID sid)
f8b35b24
EZ		 684{
685 static GetLengthSid_Proc s_pfn_Get_Length_Sid = NULL;
686 HMODULE hm_advapi32 = NULL;
687 if (is_windows_9x () == TRUE)
688 {
689 return 0;
690 }
691 if (g_b_init_get_length_sid == 0)
692 {
693 g_b_init_get_length_sid = 1;
694 hm_advapi32 = LoadLibrary ("Advapi32.dll");
695 s_pfn_Get_Length_Sid =
696 (GetLengthSid_Proc) GetProcAddress (
697 hm_advapi32, "GetLengthSid");
698 }
699 if (s_pfn_Get_Length_Sid == NULL)
700 {
701 return 0;
702 }
703 return (s_pfn_Get_Length_Sid (sid));
704}
705
9d4f32e8
JB		 706BOOL WINAPI
707copy_sid (DWORD destlen, PSID dest, PSID src)
f8b35b24
EZ		 708{
709 static CopySid_Proc s_pfn_Copy_Sid = NULL;
710 HMODULE hm_advapi32 = NULL;
711 if (is_windows_9x () == TRUE)
712 {
713 return FALSE;
714 }
715 if (g_b_init_copy_sid == 0)
716 {
717 g_b_init_copy_sid = 1;
718 hm_advapi32 = LoadLibrary ("Advapi32.dll");
719 s_pfn_Copy_Sid =
720 (CopySid_Proc) GetProcAddress (
721 hm_advapi32, "CopySid");
722 }
723 if (s_pfn_Copy_Sid == NULL)
724 {
725 return FALSE;
726 }
727 return (s_pfn_Copy_Sid (destlen, dest, src));
728}
729
f60ae425
BK		 730/*
731 END: Wrapper functions around OpenProcessToken
732 and other functions in advapi32.dll that are only
733 supported in Windows NT / 2k / XP
734*/
735
9d4f32e8
JB		 736void WINAPI
737get_native_system_info (LPSYSTEM_INFO lpSystemInfo)
ad9e2d54
EZ		 738{
739 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info = NULL;
740 if (is_windows_9x () != TRUE)
741 {
742 if (g_b_init_get_native_system_info == 0)
743 {
744 g_b_init_get_native_system_info = 1;
745 s_pfn_Get_Native_System_Info =
746 (GetNativeSystemInfo_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
747 "GetNativeSystemInfo");
748 }
749 if (s_pfn_Get_Native_System_Info != NULL)
750 s_pfn_Get_Native_System_Info (lpSystemInfo);
751 }
752 else
753 lpSystemInfo->dwNumberOfProcessors = -1;
754}
755
9d4f32e8
JB		 756BOOL WINAPI
757get_system_times (LPFILETIME lpIdleTime,
758 LPFILETIME lpKernelTime,
759 LPFILETIME lpUserTime)
ad9e2d54
EZ		 760{
761 static GetSystemTimes_Proc s_pfn_Get_System_times = NULL;
762 if (is_windows_9x () == TRUE)
763 {
764 return FALSE;
765 }
766 if (g_b_init_get_system_times == 0)
767 {
768 g_b_init_get_system_times = 1;
769 s_pfn_Get_System_times =
770 (GetSystemTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
771 "GetSystemTimes");
772 }
773 if (s_pfn_Get_System_times == NULL)
774 return FALSE;
775 return (s_pfn_Get_System_times (lpIdleTime, lpKernelTime, lpUserTime));
776}
f60ae425 777\f
18e070ac
AI		 778/* Equivalent of strerror for W32 error codes. */
779char *
780w32_strerror (int error_no)
781{
782 static char buf[500];
783
784 if (error_no == 0)
785 error_no = GetLastError ();
786
787 buf[0] = '\0';
788 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
789 error_no,
790 0, /* choose most suitable language */
791 buf, sizeof (buf), NULL))
792 sprintf (buf, "w32 error %u", error_no);
793 return buf;
794}
795
ed91b2ad
EZ		 796/* Return 1 if P is a valid pointer to an object of size SIZE. Return
797 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
798
799 This is called from alloc.c:valid_pointer_p. */
800int
801w32_valid_pointer_p (void *p, int size)
802{
803 SIZE_T done;
804 HANDLE h = OpenProcess (PROCESS_VM_READ, FALSE, GetCurrentProcessId ());
805
806 if (h)
807 {
808 unsigned char *buf = alloca (size);
809 int retval = ReadProcessMemory (h, p, buf, size, &done);
810
811 CloseHandle (h);
812 return retval;
813 }
814 else
815 return -1;
816}
817
76b3903d 818static char startup_dir[MAXPATHLEN];
00b3b7b3 819
95ed0025 820/* Get the current working directory. */
480b0c5b 821char *
95ed0025
RS		 822getwd (char *dir)
823{
76b3903d 824#if 0
480b0c5b
GV		 825 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
826 return dir;
827 return NULL;
76b3903d
GV		 828#else
829 /* Emacs doesn't actually change directory itself, and we want to
830 force our real wd to be where emacs.exe is to avoid unnecessary
831 conflicts when trying to rename or delete directories. */
832 strcpy (dir, startup_dir);
833 return dir;
834#endif
95ed0025
RS		 835}
836
480b0c5b 837#ifndef HAVE_SOCKETS
95ed0025
RS		 838/* Emulate gethostname. */
839int
840gethostname (char *buffer, int size)
841{
177c0ea7 842 /* NT only allows small host names, so the buffer is
95ed0025
RS		 843 certainly large enough. */
844 return !GetComputerName (buffer, &size);
845}
480b0c5b 846#endif /* HAVE_SOCKETS */
95ed0025
RS		 847
848/* Emulate getloadavg. */
ad9e2d54
EZ		 849
850struct load_sample {
851 time_t sample_time;
852 ULONGLONG idle;
853 ULONGLONG kernel;
854 ULONGLONG user;
855};
856
857/* Number of processors on this machine. */
858static unsigned num_of_processors;
859
860/* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
861static struct load_sample samples[16*60];
862static int first_idx = -1, last_idx = -1;
863static int max_idx = sizeof (samples) / sizeof (samples[0]);
864
865static int
866buf_next (int from)
867{
868 int next_idx = from + 1;
869
870 if (next_idx >= max_idx)
871 next_idx = 0;
872
873 return next_idx;
874}
875
876static int
877buf_prev (int from)
878{
879 int prev_idx = from - 1;
880
881 if (prev_idx < 0)
882 prev_idx = max_idx - 1;
883
884 return prev_idx;
885}
886
887static void
888sample_system_load (ULONGLONG *idle, ULONGLONG *kernel, ULONGLONG *user)
889{
890 SYSTEM_INFO sysinfo;
891 FILETIME ft_idle, ft_user, ft_kernel;
892
893 /* Initialize the number of processors on this machine. */
894 if (num_of_processors <= 0)
895 {
896 get_native_system_info (&sysinfo);
897 num_of_processors = sysinfo.dwNumberOfProcessors;
898 if (num_of_processors <= 0)
899 {
900 GetSystemInfo (&sysinfo);
901 num_of_processors = sysinfo.dwNumberOfProcessors;
902 }
903 if (num_of_processors <= 0)
904 num_of_processors = 1;
905 }
906
907 /* TODO: Take into account threads that are ready to run, by
908 sampling the "\System\Processor Queue Length" performance
909 counter. The code below accounts only for threads that are
910 actually running. */
911
912 if (get_system_times (&ft_idle, &ft_kernel, &ft_user))
913 {
914 ULARGE_INTEGER uidle, ukernel, uuser;
915
916 memcpy (&uidle, &ft_idle, sizeof (ft_idle));
917 memcpy (&ukernel, &ft_kernel, sizeof (ft_kernel));
918 memcpy (&uuser, &ft_user, sizeof (ft_user));
919 *idle = uidle.QuadPart;
920 *kernel = ukernel.QuadPart;
921 *user = uuser.QuadPart;
922 }
923 else
924 {
925 *idle = 0;
926 *kernel = 0;
927 *user = 0;
928 }
929}
930
931/* Produce the load average for a given time interval, using the
932 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
933 1-minute, 5-minute, or 15-minute average, respectively. */
934static double
935getavg (int which)
936{
937 double retval = -1.0;
938 double tdiff;
939 int idx;
940 double span = (which == 0 ? 1.0 : (which == 1 ? 5.0 : 15.0)) * 60;
941 time_t now = samples[last_idx].sample_time;
942
943 if (first_idx != last_idx)
944 {
945 for (idx = buf_prev (last_idx); ; idx = buf_prev (idx))
946 {
947 tdiff = difftime (now, samples[idx].sample_time);
948 if (tdiff >= span - 2*DBL_EPSILON*now)
949 {
950 long double sys =
951 samples[last_idx].kernel + samples[last_idx].user
952 - (samples[idx].kernel + samples[idx].user);
953 long double idl = samples[last_idx].idle - samples[idx].idle;
954
955 retval = (1.0 - idl / sys) * num_of_processors;
956 break;
957 }
958 if (idx == first_idx)
959 break;
960 }
961 }
962
963 return retval;
964}
965
95ed0025
RS		 966int
967getloadavg (double loadavg[], int nelem)
968{
ad9e2d54
EZ		 969 int elem;
970 ULONGLONG idle, kernel, user;
971 time_t now = time (NULL);
972
973 /* Store another sample. We ignore samples that are less than 1 sec
974 apart. */
975 if (difftime (now, samples[last_idx].sample_time) >= 1.0 - 2*DBL_EPSILON*now)
976 {
977 sample_system_load (&idle, &kernel, &user);
978 last_idx = buf_next (last_idx);
979 samples[last_idx].sample_time = now;
980 samples[last_idx].idle = idle;
981 samples[last_idx].kernel = kernel;
982 samples[last_idx].user = user;
983 /* If the buffer has more that 15 min worth of samples, discard
984 the old ones. */
985 if (first_idx == -1)
986 first_idx = last_idx;
987 while (first_idx != last_idx
988 && (difftime (now, samples[first_idx].sample_time)
989 >= 15.0*60 + 2*DBL_EPSILON*now))
990 first_idx = buf_next (first_idx);
991 }
95ed0025 992
ad9e2d54 993 for (elem = 0; elem < nelem; elem++)
95ed0025 994 {
ad9e2d54
EZ		 995 double avg = getavg (elem);
996
997 if (avg < 0)
998 break;
999 loadavg[elem] = avg;
95ed0025 1000 }
ad9e2d54
EZ		 1001
1002 return elem;
95ed0025
RS		 1003}
1004
480b0c5b 1005/* Emulate getpwuid, getpwnam and others. */
95ed0025 1006
051fe60d
GV		 1007#define PASSWD_FIELD_SIZE 256
1008
07f7980a
EZ		 1009static char dflt_passwd_name[PASSWD_FIELD_SIZE];
1010static char dflt_passwd_passwd[PASSWD_FIELD_SIZE];
1011static char dflt_passwd_gecos[PASSWD_FIELD_SIZE];
1012static char dflt_passwd_dir[PASSWD_FIELD_SIZE];
1013static char dflt_passwd_shell[PASSWD_FIELD_SIZE];
95ed0025 1014
07f7980a 1015static struct passwd dflt_passwd =
95ed0025 1016{
07f7980a
EZ		 1017 dflt_passwd_name,
1018 dflt_passwd_passwd,
95ed0025
RS		 1019 0,
1020 0,
1021 0,
07f7980a
EZ		 1022 dflt_passwd_gecos,
1023 dflt_passwd_dir,
1024 dflt_passwd_shell,
95ed0025
RS		 1025};
1026
07f7980a
EZ		 1027static char dflt_group_name[GNLEN+1];
1028
1029static struct group dflt_group =
3d19b645 1030{
07f7980a
EZ		 1031 /* When group information is not available, we return this as the
1032 group for all files. */
1033 dflt_group_name,
1034 0,
3d19b645
LH		 1035};
1036
22749e9a 1037unsigned
177c0ea7
JB		 1038getuid ()
1039{
07f7980a 1040 return dflt_passwd.pw_uid;
480b0c5b
GV		 1041}
1042
22749e9a 1043unsigned
177c0ea7
JB		 1044geteuid ()
1045{
480b0c5b
GV		 1046 /* I could imagine arguing for checking to see whether the user is
1047 in the Administrators group and returning a UID of 0 for that
1048 case, but I don't know how wise that would be in the long run. */
177c0ea7 1049 return getuid ();
480b0c5b
GV		 1050}
1051
22749e9a 1052unsigned
177c0ea7
JB		 1053getgid ()
1054{
07f7980a 1055 return dflt_passwd.pw_gid;
480b0c5b
GV		 1056}
1057
22749e9a 1058unsigned
177c0ea7
JB		 1059getegid ()
1060{
480b0c5b
GV		 1061 return getgid ();
1062}
1063
95ed0025 1064struct passwd *
22749e9a 1065getpwuid (unsigned uid)
95ed0025 1066{
07f7980a
EZ		 1067 if (uid == dflt_passwd.pw_uid)
1068 return &dflt_passwd;
480b0c5b 1069 return NULL;
95ed0025
RS		 1070}
1071
3d19b645
LH		 1072struct group *
1073getgrgid (gid_t gid)
1074{
07f7980a 1075 return &dflt_group;
3d19b645
LH		 1076}
1077
95ed0025
RS		 1078struct passwd *
1079getpwnam (char *name)
1080{
1081 struct passwd *pw;
177c0ea7 1082
95ed0025
RS		 1083 pw = getpwuid (getuid ());
1084 if (!pw)
1085 return pw;
1086
05131107 1087 if (xstrcasecmp (name, pw->pw_name))
95ed0025
RS		 1088 return NULL;
1089
1090 return pw;
1091}
1092
480b0c5b
GV		 1093void
1094init_user_info ()
95ed0025 1095{
480b0c5b
GV		 1096 /* Find the user's real name by opening the process token and
1097 looking up the name associated with the user-sid in that token.
1098
1099 Use the relative portion of the identifier authority value from
1100 the user-sid as the user id value (same for group id using the
1101 primary group sid from the process token). */
1102
07f7980a 1103 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
32cef06e 1104 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
07f7980a 1105 DWORD glength = sizeof (gname);
10aabbf9
JB		 1106 HANDLE token = NULL;
1107 SID_NAME_USE user_type;
32cef06e
EZ		 1108 unsigned char *buf = NULL;
1109 DWORD blen = 0;
634d3003
EZ		 1110 TOKEN_USER user_token;
1111 TOKEN_PRIMARY_GROUP group_token;
32cef06e 1112 BOOL result;
10aabbf9 1113
32cef06e
EZ		 1114 result = open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token);
1115 if (result)
1116 {
1117 result = get_token_information (token, TokenUser, NULL, 0, &blen);
1118 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1119 {
1120 buf = xmalloc (blen);
1121 result = get_token_information (token, TokenUser,
1122 (LPVOID)buf, blen, &needed);
1123 if (result)
1124 {
1125 memcpy (&user_token, buf, sizeof (user_token));
1126 result = lookup_account_sid (NULL, user_token.User.Sid,
1127 uname, &ulength,
1128 domain, &dlength, &user_type);
1129 }
1130 }
1131 else
1132 result = FALSE;
1133 }
1134 if (result)
d1c1c3d2 1135 {
07f7980a 1136 strcpy (dflt_passwd.pw_name, uname);
c617afce 1137 /* Determine a reasonable uid value. */
05131107 1138 if (xstrcasecmp ("administrator", uname) == 0)
480b0c5b 1139 {
07f7980a
EZ		 1140 dflt_passwd.pw_uid = 500; /* well-known Administrator uid */
1141 dflt_passwd.pw_gid = 513; /* well-known None gid */
480b0c5b
GV		 1142 }
1143 else
1144 {
ce0ee994
EZ		 1145 /* Use the last sub-authority value of the RID, the relative
1146 portion of the SID, as user/group ID. */
8aaaec6b 1147 dflt_passwd.pw_uid = get_rid (user_token.User.Sid);
480b0c5b 1148
8aaaec6b 1149 /* Get group id and name. */
32cef06e
EZ		 1150 result = get_token_information (token, TokenPrimaryGroup,
1151 (LPVOID)buf, blen, &needed);
1152 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1153 {
1154 buf = xrealloc (buf, blen = needed);
1155 result = get_token_information (token, TokenPrimaryGroup,
1156 (LPVOID)buf, blen, &needed);
1157 }
1158 if (result)
480b0c5b 1159 {
634d3003 1160 memcpy (&group_token, buf, sizeof (group_token));
8aaaec6b 1161 dflt_passwd.pw_gid = get_rid (group_token.PrimaryGroup);
07f7980a 1162 dlength = sizeof (domain);
32cef06e
EZ		 1163 /* If we can get at the real Primary Group name, use that.
1164 Otherwise, the default group name was already set to
1165 "None" in globals_of_w32. */
07f7980a
EZ		 1166 if (lookup_account_sid (NULL, group_token.PrimaryGroup,
1167 gname, &glength, NULL, &dlength,
1168 &user_type))
1169 strcpy (dflt_group_name, gname);
480b0c5b
GV		 1170 }
1171 else
07f7980a 1172 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
480b0c5b
GV		 1173 }
1174 }
1175 /* If security calls are not supported (presumably because we
32cef06e 1176 are running under Windows 9X), fallback to this: */
07f7980a 1177 else if (GetUserName (uname, &ulength))
480b0c5b 1178 {
07f7980a 1179 strcpy (dflt_passwd.pw_name, uname);
05131107 1180 if (xstrcasecmp ("administrator", uname) == 0)
07f7980a 1181 dflt_passwd.pw_uid = 0;
480b0c5b 1182 else
07f7980a
EZ		 1183 dflt_passwd.pw_uid = 123;
1184 dflt_passwd.pw_gid = dflt_passwd.pw_uid;
480b0c5b
GV		 1185 }
1186 else
1187 {
07f7980a
EZ		 1188 strcpy (dflt_passwd.pw_name, "unknown");
1189 dflt_passwd.pw_uid = 123;
1190 dflt_passwd.pw_gid = 123;
d1c1c3d2 1191 }
07f7980a 1192 dflt_group.gr_gid = dflt_passwd.pw_gid;
95ed0025 1193
480b0c5b
GV		 1194 /* Ensure HOME and SHELL are defined. */
1195 if (getenv ("HOME") == NULL)
ca149beb 1196 abort ();
480b0c5b 1197 if (getenv ("SHELL") == NULL)
ca149beb 1198 abort ();
95ed0025 1199
480b0c5b 1200 /* Set dir and shell from environment variables. */
07f7980a
EZ		 1201 strcpy (dflt_passwd.pw_dir, getenv ("HOME"));
1202 strcpy (dflt_passwd.pw_shell, getenv ("SHELL"));
bd4a449f 1203
32cef06e 1204 xfree (buf);
480b0c5b
GV		 1205 if (token)
1206 CloseHandle (token);
95ed0025
RS		 1207}
1208
95ed0025 1209int
480b0c5b 1210random ()
95ed0025 1211{
480b0c5b
GV		 1212 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1213 return ((rand () << 15) | rand ());
95ed0025
RS		 1214}
1215
95ed0025 1216void
480b0c5b 1217srandom (int seed)
95ed0025 1218{
480b0c5b 1219 srand (seed);
95ed0025
RS		 1220}
1221
76b3903d 1222
cbe39279
RS		 1223/* Normalize filename by converting all path separators to
1224 the specified separator. Also conditionally convert upper
1225 case path name components to lower case. */
1226
1227static void
1228normalize_filename (fp, path_sep)
1229 register char *fp;
1230 char path_sep;
1231{
1232 char sep;
1233 char *elem;
1234
5162ffce
MB		 1235 /* Always lower-case drive letters a-z, even if the filesystem
1236 preserves case in filenames.
1237 This is so filenames can be compared by string comparison
1238 functions that are case-sensitive. Even case-preserving filesystems
1239 do not distinguish case in drive letters. */
1240 if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
1241 {
1242 *fp += 'a' - 'A';
1243 fp += 2;
1244 }
1245
fbd6baed 1246 if (NILP (Vw32_downcase_file_names))
cbe39279
RS		 1247 {
1248 while (*fp)
1249 {
1250 if (*fp == '/' || *fp == '\\')
1251 *fp = path_sep;
1252 fp++;
1253 }
1254 return;
1255 }
1256
1257 sep = path_sep; /* convert to this path separator */
1258 elem = fp; /* start of current path element */
1259
1260 do {
1261 if (*fp >= 'a' && *fp <= 'z')
1262 elem = 0; /* don't convert this element */
1263
1264 if (*fp == 0 || *fp == ':')
1265 {
1266 sep = *fp; /* restore current separator (or 0) */
1267 *fp = '/'; /* after conversion of this element */
1268 }
1269
1270 if (*fp == '/' || *fp == '\\')
1271 {
1272 if (elem && elem != fp)
1273 {
1274 *fp = 0; /* temporary end of string */
1275 _strlwr (elem); /* while we convert to lower case */
1276 }
1277 *fp = sep; /* convert (or restore) path separator */
1278 elem = fp + 1; /* next element starts after separator */
1279 sep = path_sep;
1280 }
1281 } while (*fp++);
1282}
1283
480b0c5b 1284/* Destructively turn backslashes into slashes. */
95ed0025 1285void
480b0c5b
GV		 1286dostounix_filename (p)
1287 register char *p;
95ed0025 1288{
cbe39279 1289 normalize_filename (p, '/');
95ed0025
RS		 1290}
1291
480b0c5b 1292/* Destructively turn slashes into backslashes. */
95ed0025 1293void
480b0c5b
GV		 1294unixtodos_filename (p)
1295 register char *p;
95ed0025 1296{
cbe39279 1297 normalize_filename (p, '\\');
95ed0025
RS		 1298}
1299
480b0c5b
GV		 1300/* Remove all CR's that are followed by a LF.
1301 (From msdos.c...probably should figure out a way to share it,
1302 although this code isn't going to ever change.) */
35f0d482 1303int
480b0c5b
GV		 1304crlf_to_lf (n, buf)
1305 register int n;
1306 register unsigned char *buf;
35f0d482 1307{
480b0c5b
GV		 1308 unsigned char *np = buf;
1309 unsigned char *startp = buf;
1310 unsigned char *endp = buf + n;
35f0d482 1311
480b0c5b
GV		 1312 if (n == 0)
1313 return n;
1314 while (buf < endp - 1)
95ed0025 1315 {
480b0c5b
GV		 1316 if (*buf == 0x0d)
1317 {
1318 if (*(++buf) != 0x0a)
1319 *np++ = 0x0d;
1320 }
1321 else
1322 *np++ = *buf++;
95ed0025 1323 }
480b0c5b
GV		 1324 if (buf < endp)
1325 *np++ = *buf++;
1326 return np - startp;
95ed0025
RS		 1327}
1328
76b3903d
GV		 1329/* Parse the root part of file name, if present. Return length and
1330 optionally store pointer to char after root. */
1331static int
1332parse_root (char * name, char ** pPath)
1333{
1334 char * start = name;
1335
1336 if (name == NULL)
1337 return 0;
1338
1339 /* find the root name of the volume if given */
1340 if (isalpha (name[0]) && name[1] == ':')
1341 {
1342 /* skip past drive specifier */
1343 name += 2;
1344 if (IS_DIRECTORY_SEP (name[0]))
1345 name++;
1346 }
1347 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1348 {
1349 int slashes = 2;
1350 name += 2;
1351 do
1352 {
1353 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1354 break;
1355 name++;
1356 }
1357 while ( *name );
1358 if (IS_DIRECTORY_SEP (name[0]))
1359 name++;
1360 }
1361
1362 if (pPath)
1363 *pPath = name;
1364
1365 return name - start;
1366}
1367
1368/* Get long base name for name; name is assumed to be absolute. */
1369static int
1370get_long_basename (char * name, char * buf, int size)
1371{
1372 WIN32_FIND_DATA find_data;
1373 HANDLE dir_handle;
1374 int len = 0;
1375
9ab8560d 1376 /* must be valid filename, no wild cards or other invalid characters */
22189f79 1377 if (_mbspbrk (name, "*?|<>\""))
bb1584c8
RS		 1378 return 0;
1379
76b3903d
GV		 1380 dir_handle = FindFirstFile (name, &find_data);
1381 if (dir_handle != INVALID_HANDLE_VALUE)
1382 {
1383 if ((len = strlen (find_data.cFileName)) < size)
1384 memcpy (buf, find_data.cFileName, len + 1);
1385 else
1386 len = 0;
1387 FindClose (dir_handle);
1388 }
1389 return len;
1390}
1391
1392/* Get long name for file, if possible (assumed to be absolute). */
1393BOOL
1394w32_get_long_filename (char * name, char * buf, int size)
1395{
1396 char * o = buf;
1397 char * p;
1398 char * q;
1399 char full[ MAX_PATH ];
1400 int len;
1401
1402 len = strlen (name);
1403 if (len >= MAX_PATH)
1404 return FALSE;
1405
1406 /* Use local copy for destructive modification. */
1407 memcpy (full, name, len+1);
1408 unixtodos_filename (full);
1409
1410 /* Copy root part verbatim. */
1411 len = parse_root (full, &p);
1412 memcpy (o, full, len);
1413 o += len;
4f8ac0b2 1414 *o = '\0';
76b3903d
GV		 1415 size -= len;
1416
4f8ac0b2 1417 while (p != NULL && *p)
76b3903d
GV		 1418 {
1419 q = p;
1420 p = strchr (q, '\\');
1421 if (p) *p = '\0';
1422 len = get_long_basename (full, o, size);
1423 if (len > 0)
1424 {
1425 o += len;
1426 size -= len;
1427 if (p != NULL)
1428 {
1429 *p++ = '\\';
1430 if (size < 2)
1431 return FALSE;
1432 *o++ = '\\';
1433 size--;
1434 *o = '\0';
1435 }
1436 }
1437 else
1438 return FALSE;
1439 }
76b3903d
GV		 1440
1441 return TRUE;
1442}
1443
9d3355d1
GV		 1444int
1445is_unc_volume (const char *filename)
1446{
1447 const char *ptr = filename;
1448
1449 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
1450 return 0;
1451
22189f79 1452 if (_mbspbrk (ptr + 2, "*?|<>\"\\/"))
9d3355d1
GV		 1453 return 0;
1454
1455 return 1;
1456}
76b3903d 1457
95ed0025
RS		 1458/* Routines that are no-ops on NT but are defined to get Emacs to compile. */
1459
177c0ea7
JB		 1460int
1461sigsetmask (int signal_mask)
1462{
95ed0025
RS		 1463 return 0;
1464}
1465
177c0ea7
JB		 1466int
1467sigmask (int sig)
1468{
8f900f6e
AI		 1469 return 0;
1470}
1471
177c0ea7
JB		 1472int
1473sigblock (int sig)
1474{
95ed0025
RS		 1475 return 0;
1476}
1477
177c0ea7
JB		 1478int
1479sigunblock (int sig)
1480{
8f900f6e
AI		 1481 return 0;
1482}
1483
177c0ea7
JB		 1484int
1485setpgrp (int pid, int gid)
1486{
95ed0025
RS		 1487 return 0;
1488}
1489
177c0ea7
JB		 1490int
1491alarm (int seconds)
1492{
95ed0025
RS		 1493 return 0;
1494}
1495
480b0c5b 1496#define REG_ROOT "SOFTWARE\\GNU\\Emacs"
f332b293 1497
177c0ea7 1498LPBYTE
fbd6baed 1499w32_get_resource (key, lpdwtype)
f332b293
GV		 1500 char *key;
1501 LPDWORD lpdwtype;
1502{
1503 LPBYTE lpvalue;
1504 HKEY hrootkey = NULL;
1505 DWORD cbData;
177c0ea7
JB		 1506
1507 /* Check both the current user and the local machine to see if
f332b293 1508 we have any resources. */
177c0ea7 1509
f332b293
GV		 1510 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1511 {
1512 lpvalue = NULL;
1513
177c0ea7
JB		 1514 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1515 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
f332b293
GV		 1516 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1517 {
4da4d9bb 1518 RegCloseKey (hrootkey);
f332b293
GV		 1519 return (lpvalue);
1520 }
1521
70fdbb46 1522 xfree (lpvalue);
177c0ea7 1523
f332b293 1524 RegCloseKey (hrootkey);
177c0ea7
JB		 1525 }
1526
f332b293
GV		 1527 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1528 {
1529 lpvalue = NULL;
177c0ea7 1530
76b3903d
GV		 1531 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1532 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
1533 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
f332b293 1534 {
4da4d9bb 1535 RegCloseKey (hrootkey);
f332b293
GV		 1536 return (lpvalue);
1537 }
177c0ea7 1538
70fdbb46 1539 xfree (lpvalue);
177c0ea7 1540
f332b293 1541 RegCloseKey (hrootkey);
177c0ea7
JB		 1542 }
1543
f332b293
GV		 1544 return (NULL);
1545}
1546
75b08edb
GV		 1547char *get_emacs_configuration (void);
1548extern Lisp_Object Vsystem_configuration;
1549
f332b293 1550void
aa7b87b0 1551init_environment (char ** argv)
f332b293 1552{
b3308d2e
KH		 1553 static const char * const tempdirs[] = {
1554 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1555 };
2d5324c5 1556
b3308d2e 1557 int i;
2d5324c5 1558
b3308d2e
KH		 1559 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
1560
1561 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1562 temporary files and assume "/tmp" if $TMPDIR is unset, which
1563 will break on DOS/Windows. Refuse to work if we cannot find
1564 a directory, not even "c:/", usable for that purpose. */
1565 for (i = 0; i < imax ; i++)
1566 {
1567 const char *tmp = tempdirs[i];
1568
1569 if (*tmp == '$')
1570 tmp = getenv (tmp + 1);
1571 /* Note that `access' can lie to us if the directory resides on a
1572 read-only filesystem, like CD-ROM or a write-protected floppy.
1573 The only way to be really sure is to actually create a file and
1574 see if it succeeds. But I think that's too much to ask. */
a302c7ae 1575 if (tmp && _access (tmp, D_OK) == 0)
b3308d2e
KH		 1576 {
1577 char * var = alloca (strlen (tmp) + 8);
1578 sprintf (var, "TMPDIR=%s", tmp);
aca583b2 1579 _putenv (strdup (var));
b3308d2e
KH		 1580 break;
1581 }
1582 }
1583 if (i >= imax)
1584 cmd_error_internal
1585 (Fcons (Qerror,
1586 Fcons (build_string ("no usable temporary directories found!!"),
1587 Qnil)),
1588 "While setting TMPDIR: ");
1589
ca149beb
AI		 1590 /* Check for environment variables and use registry settings if they
1591 don't exist. Fallback on default values where applicable. */
f332b293 1592 {
480b0c5b
GV		 1593 int i;
1594 LPBYTE lpval;
1595 DWORD dwType;
69fb0241 1596 char locale_name[32];
2d5324c5
JR		 1597 struct stat ignored;
1598 char default_home[MAX_PATH];
f332b293 1599
e00b99c8 1600 static const struct env_entry
ca149beb
AI		 1601 {
1602 char * name;
1603 char * def_value;
e00b99c8 1604 } dflt_envvars[] =
ca149beb
AI		 1605 {
1606 {"HOME", "C:/"},
1607 {"PRELOAD_WINSOCK", NULL},
1608 {"emacs_dir", "C:/emacs"},
cc14250a 1609 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
ca149beb
AI		 1610 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1611 {"EMACSDATA", "%emacs_dir%/etc"},
1612 {"EMACSPATH", "%emacs_dir%/bin"},
76b3903d 1613 /* We no longer set INFOPATH because Info-default-directory-list
ca149beb
AI		 1614 is then ignored. */
1615 /* {"INFOPATH", "%emacs_dir%/info"}, */
1616 {"EMACSDOC", "%emacs_dir%/etc"},
69fb0241
JR		 1617 {"TERM", "cmd"},
1618 {"LANG", NULL},
480b0c5b
GV		 1619 };
1620
e00b99c8
EZ		 1621#define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1622
1623 /* We need to copy dflt_envvars[] and work on the copy because we
1624 don't want the dumped Emacs to inherit the values of
1625 environment variables we saw during dumping (which could be on
1626 a different system). The defaults above must be left intact. */
1627 struct env_entry env_vars[N_ENV_VARS];
1628
1629 for (i = 0; i < N_ENV_VARS; i++)
1630 env_vars[i] = dflt_envvars[i];
1631
2d5324c5
JR		 1632 /* For backwards compatibility, check if a .emacs file exists in C:/
1633 If not, then we can try to default to the appdata directory under the
1634 user's profile, which is more likely to be writable. */
1635 if (stat ("C:/.emacs", &ignored) < 0)
1636 {
1637 HRESULT profile_result;
1638 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1639 of Windows 95 and NT4 that have not been updated to include
8b8be8eb 1640 MSIE 5. */
2d5324c5 1641 ShGetFolderPath_fn get_folder_path;
2d5324c5 1642 get_folder_path = (ShGetFolderPath_fn)
8b8be8eb 1643 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2d5324c5
JR		 1644
1645 if (get_folder_path != NULL)
1646 {
1647 profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
1648 0, default_home);
1649
fffa137c 1650 /* If we can't get the appdata dir, revert to old behavior. */
2d5324c5
JR		 1651 if (profile_result == S_OK)
1652 env_vars[0].def_value = default_home;
1653 }
2d5324c5
JR		 1654 }
1655
69fb0241
JR		 1656 /* Get default locale info and use it for LANG. */
1657 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
1658 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1659 locale_name, sizeof (locale_name)))
1660 {
e00b99c8 1661 for (i = 0; i < N_ENV_VARS; i++)
69fb0241
JR		 1662 {
1663 if (strcmp (env_vars[i].name, "LANG") == 0)
1664 {
1665 env_vars[i].def_value = locale_name;
1666 break;
1667 }
1668 }
1669 }
1670
ca149beb
AI		 1671#define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1672
1673 /* Treat emacs_dir specially: set it unconditionally based on our
1674 location, if it appears that we are running from the bin subdir
1675 of a standard installation. */
1676 {
1677 char *p;
1678 char modname[MAX_PATH];
1679
1680 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1681 abort ();
1682 if ((p = strrchr (modname, '\\')) == NULL)
1683 abort ();
1684 *p = 0;
1685
05131107 1686 if ((p = strrchr (modname, '\\')) && xstrcasecmp (p, "\\bin") == 0)
ca149beb
AI		 1687 {
1688 char buf[SET_ENV_BUF_SIZE];
1689
1690 *p = 0;
1691 for (p = modname; *p; p++)
1692 if (*p == '\\') *p = '/';
177c0ea7 1693
9d4f32e8 1694 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
a302c7ae 1695 _putenv (strdup (buf));
ca149beb 1696 }
950090be
JR		 1697 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1698
1699 /* FIXME: should use substring of get_emacs_configuration ().
1700 But I don't think the Windows build supports alpha, mips etc
1701 anymore, so have taken the easy option for now. */
05131107 1702 else if (p && xstrcasecmp (p, "\\i386") == 0)
950090be
JR		 1703 {
1704 *p = 0;
1705 p = strrchr (modname, '\\');
1706 if (p != NULL)
1707 {
1708 *p = 0;
1709 p = strrchr (modname, '\\');
05131107 1710 if (p && xstrcasecmp (p, "\\src") == 0)
950090be
JR		 1711 {
1712 char buf[SET_ENV_BUF_SIZE];
1713
1714 *p = 0;
1715 for (p = modname; *p; p++)
1716 if (*p == '\\') *p = '/';
1717
9d4f32e8 1718 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
950090be
JR		 1719 _putenv (strdup (buf));
1720 }
1721 }
1722 }
ca149beb
AI		 1723 }
1724
e00b99c8 1725 for (i = 0; i < N_ENV_VARS; i++)
f332b293 1726 {
ca149beb 1727 if (!getenv (env_vars[i].name))
480b0c5b 1728 {
ca149beb 1729 int dont_free = 0;
480b0c5b 1730
aa5ee2a3
JB		 1731 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL
1732 /* Also ignore empty environment variables. */
1733 || *lpval == 0)
ca149beb 1734 {
70fdbb46 1735 xfree (lpval);
ca149beb
AI		 1736 lpval = env_vars[i].def_value;
1737 dwType = REG_EXPAND_SZ;
1738 dont_free = 1;
480b0c5b 1739 }
ca149beb
AI		 1740
1741 if (lpval)
480b0c5b 1742 {
892eb237 1743 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
ca149beb 1744
892eb237 1745 if (dwType == REG_EXPAND_SZ)
9d4f32e8 1746 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof (buf1));
ca149beb 1747 else if (dwType == REG_SZ)
892eb237
EZ		 1748 strcpy (buf1, lpval);
1749 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
ca149beb 1750 {
9d4f32e8 1751 _snprintf (buf2, sizeof (buf2)-1, "%s=%s", env_vars[i].name,
892eb237
EZ		 1752 buf1);
1753 _putenv (strdup (buf2));
ca149beb 1754 }
f332b293 1755
ca149beb
AI		 1756 if (!dont_free)
1757 xfree (lpval);
1758 }
480b0c5b
GV		 1759 }
1760 }
1761 }
1762
75b08edb
GV		 1763 /* Rebuild system configuration to reflect invoking system. */
1764 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1765
76b3903d
GV		 1766 /* Another special case: on NT, the PATH variable is actually named
1767 "Path" although cmd.exe (perhaps NT itself) arranges for
1768 environment variable lookup and setting to be case insensitive.
1769 However, Emacs assumes a fully case sensitive environment, so we
1770 need to change "Path" to "PATH" to match the expectations of
1771 various elisp packages. We do this by the sneaky method of
1772 modifying the string in the C runtime environ entry.
1773
1774 The same applies to COMSPEC. */
1775 {
1776 char ** envp;
1777
1778 for (envp = environ; *envp; envp++)
1779 if (_strnicmp (*envp, "PATH=", 5) == 0)
1780 memcpy (*envp, "PATH=", 5);
1781 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
1782 memcpy (*envp, "COMSPEC=", 8);
1783 }
1784
1785 /* Remember the initial working directory for getwd, then make the
1786 real wd be the location of emacs.exe to avoid conflicts when
1787 renaming or deleting directories. (We also don't call chdir when
1788 running subprocesses for the same reason.) */
1789 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
1790 abort ();
1791
1792 {
1793 char *p;
aa7b87b0 1794 static char modname[MAX_PATH];
76b3903d
GV		 1795
1796 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1797 abort ();
1798 if ((p = strrchr (modname, '\\')) == NULL)
1799 abort ();
1800 *p = 0;
1801
1802 SetCurrentDirectory (modname);
aa7b87b0
AI		 1803
1804 /* Ensure argv[0] has the full path to Emacs. */
1805 *p = '\\';
1806 argv[0] = modname;
76b3903d
GV		 1807 }
1808
20af4831
JR		 1809 /* Determine if there is a middle mouse button, to allow parse_button
1810 to decide whether right mouse events should be mouse-2 or
1811 mouse-3. */
e0c181dd 1812 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
20af4831 1813
480b0c5b
GV		 1814 init_user_info ();
1815}
1816
bf794306
EZ		 1817char *
1818emacs_root_dir (void)
1819{
1820 static char root_dir[FILENAME_MAX];
1821 const char *p;
1822
1823 p = getenv ("emacs_dir");
1824 if (p == NULL)
1825 abort ();
1826 strcpy (root_dir, p);
1827 root_dir[parse_root (root_dir, NULL)] = '\0';
1828 dostounix_filename (root_dir);
1829 return root_dir;
1830}
1831
480b0c5b
GV		 1832/* We don't have scripts to automatically determine the system configuration
1833 for Emacs before it's compiled, and we don't want to have to make the
1834 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1835 routine. */
1836
480b0c5b
GV		 1837char *
1838get_emacs_configuration (void)
1839{
1840 char *arch, *oem, *os;
c5247da2 1841 int build_num;
a302c7ae 1842 static char configuration_buffer[32];
480b0c5b
GV		 1843
1844 /* Determine the processor type. */
177c0ea7 1845 switch (get_processor_type ())
480b0c5b
GV		 1846 {
1847
1848#ifdef PROCESSOR_INTEL_386
1849 case PROCESSOR_INTEL_386:
1850 case PROCESSOR_INTEL_486:
1851 case PROCESSOR_INTEL_PENTIUM:
1852 arch = "i386";
1853 break;
1854#endif
1855
480b0c5b
GV		 1856#ifdef PROCESSOR_MIPS_R2000
1857 case PROCESSOR_MIPS_R2000:
1858 case PROCESSOR_MIPS_R3000:
1859 case PROCESSOR_MIPS_R4000:
1860 arch = "mips";
1861 break;
1862#endif
1863
1864#ifdef PROCESSOR_ALPHA_21064
1865 case PROCESSOR_ALPHA_21064:
1866 arch = "alpha";
1867 break;
1868#endif
1869
1870 default:
1871 arch = "unknown";
1872 break;
f332b293 1873 }
480b0c5b 1874
a302c7ae
AI		 1875 /* Use the OEM field to reflect the compiler/library combination. */
1876#ifdef _MSC_VER
1877#define COMPILER_NAME "msvc"
1878#else
1879#ifdef __GNUC__
1880#define COMPILER_NAME "mingw"
1881#else
1882#define COMPILER_NAME "unknown"
1883#endif
1884#endif
1885 oem = COMPILER_NAME;
480b0c5b 1886
c5247da2
GV		 1887 switch (osinfo_cache.dwPlatformId) {
1888 case VER_PLATFORM_WIN32_NT:
1889 os = "nt";
1890 build_num = osinfo_cache.dwBuildNumber;
1891 break;
1892 case VER_PLATFORM_WIN32_WINDOWS:
1893 if (osinfo_cache.dwMinorVersion == 0) {
1894 os = "windows95";
1895 } else {
1896 os = "windows98";
1897 }
1898 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1899 break;
1900 case VER_PLATFORM_WIN32s:
1901 /* Not supported, should not happen. */
1902 os = "windows32s";
1903 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1904 break;
1905 default:
1906 os = "unknown";
1907 build_num = 0;
1908 break;
1909 }
1910
1911 if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1912 sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
1913 get_w32_major_version (), get_w32_minor_version (), build_num);
1914 } else {
1915 sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
1916 }
480b0c5b 1917
480b0c5b 1918 return configuration_buffer;
f332b293
GV		 1919}
1920
a302c7ae
AI		 1921char *
1922get_emacs_configuration_options (void)
1923{
1924 static char options_buffer[256];
1925
1926/* Work out the effective configure options for this build. */
1927#ifdef _MSC_VER
1928#define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1929#else
1930#ifdef __GNUC__
1931#define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1932#else
1933#define COMPILER_VERSION ""
1934#endif
1935#endif
1936
1937 sprintf (options_buffer, COMPILER_VERSION);
1938#ifdef EMACSDEBUG
1939 strcat (options_buffer, " --no-opt");
1940#endif
1941#ifdef USER_CFLAGS
1942 strcat (options_buffer, " --cflags");
1943 strcat (options_buffer, USER_CFLAGS);
1944#endif
1945#ifdef USER_LDFLAGS
1946 strcat (options_buffer, " --ldflags");
1947 strcat (options_buffer, USER_LDFLAGS);
1948#endif
1949 return options_buffer;
1950}
1951
1952
35f0d482
KH		 1953#include <sys/timeb.h>
1954
1955/* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
177c0ea7 1956void
35f0d482
KH		 1957gettimeofday (struct timeval *tv, struct timezone *tz)
1958{
6e602566 1959 struct _timeb tb;
35f0d482
KH		 1960 _ftime (&tb);
1961
1962 tv->tv_sec = tb.time;
1963 tv->tv_usec = tb.millitm * 1000L;
177c0ea7 1964 if (tz)
35f0d482
KH		 1965 {
1966 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
1967 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
1968 }
1969}
35f0d482 1970
480b0c5b 1971/* ------------------------------------------------------------------------- */
fbd6baed 1972/* IO support and wrapper functions for W32 API. */
480b0c5b 1973/* ------------------------------------------------------------------------- */
95ed0025 1974
480b0c5b 1975/* Place a wrapper around the MSVC version of ctime. It returns NULL
177c0ea7 1976 on network directories, so we handle that case here.
480b0c5b
GV		 1977 (Ulrich Leodolter, 1/11/95). */
1978char *
1979sys_ctime (const time_t *t)
1980{
1981 char *str = (char *) ctime (t);
1982 return (str ? str : "Sun Jan 01 00:00:00 1970");
1983}
1984
1985/* Emulate sleep...we could have done this with a define, but that
1986 would necessitate including windows.h in the files that used it.
1987 This is much easier. */
1988void
1989sys_sleep (int seconds)
1990{
1991 Sleep (seconds * 1000);
1992}
1993
76b3903d 1994/* Internal MSVC functions for low-level descriptor munging */
480b0c5b
GV		 1995extern int __cdecl _set_osfhnd (int fd, long h);
1996extern int __cdecl _free_osfhnd (int fd);
1997
1998/* parallel array of private info on file handles */
1999filedesc fd_info [ MAXDESC ];
2000
76b3903d
GV		 2001typedef struct volume_info_data {
2002 struct volume_info_data * next;
2003
2004 /* time when info was obtained */
2005 DWORD timestamp;
2006
2007 /* actual volume info */
2008 char * root_dir;
480b0c5b
GV		 2009 DWORD serialnum;
2010 DWORD maxcomp;
2011 DWORD flags;
76b3903d
GV		 2012 char * name;
2013 char * type;
2014} volume_info_data;
2015
2016/* Global referenced by various functions. */
2017static volume_info_data volume_info;
2018
2019/* Vector to indicate which drives are local and fixed (for which cached
2020 data never expires). */
2021static BOOL fixed_drives[26];
2022
2023/* Consider cached volume information to be stale if older than 10s,
2024 at least for non-local drives. Info for fixed drives is never stale. */
2025#define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2026#define VOLINFO_STILL_VALID( root_dir, info ) \
2027 ( ( isalpha (root_dir[0]) && \
2028 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2029 || GetTickCount () - info->timestamp < 10000 )
2030
2031/* Cache support functions. */
2032
2033/* Simple linked list with linear search is sufficient. */
2034static volume_info_data *volume_cache = NULL;
2035
2036static volume_info_data *
2037lookup_volume_info (char * root_dir)
2038{
2039 volume_info_data * info;
2040
2041 for (info = volume_cache; info; info = info->next)
05131107 2042 if (xstrcasecmp (info->root_dir, root_dir) == 0)
76b3903d
GV		 2043 break;
2044 return info;
2045}
2046
2047static void
2048add_volume_info (char * root_dir, volume_info_data * info)
2049{
a302c7ae 2050 info->root_dir = xstrdup (root_dir);
76b3903d
GV		 2051 info->next = volume_cache;
2052 volume_cache = info;
2053}
2054
2055
2056/* Wrapper for GetVolumeInformation, which uses caching to avoid
2057 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2058 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2059volume_info_data *
2060GetCachedVolumeInformation (char * root_dir)
2061{
2062 volume_info_data * info;
2063 char default_root[ MAX_PATH ];
2064
2065 /* NULL for root_dir means use root from current directory. */
2066 if (root_dir == NULL)
2067 {
2068 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
2069 return NULL;
2070 parse_root (default_root, &root_dir);
2071 *root_dir = 0;
2072 root_dir = default_root;
2073 }
2074
2075 /* Local fixed drives can be cached permanently. Removable drives
2076 cannot be cached permanently, since the volume name and serial
2077 number (if nothing else) can change. Remote drives should be
2078 treated as if they are removable, since there is no sure way to
2079 tell whether they are or not. Also, the UNC association of drive
2080 letters mapped to remote volumes can be changed at any time (even
2081 by other processes) without notice.
177c0ea7 2082
76b3903d
GV		 2083 As a compromise, so we can benefit from caching info for remote
2084 volumes, we use a simple expiry mechanism to invalidate cache
2085 entries that are more than ten seconds old. */
2086
2087#if 0
2088 /* No point doing this, because WNetGetConnection is even slower than
2089 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2090 GetDriveType is about the only call of this type which does not
2091 involve network access, and so is extremely quick). */
2092
2093 /* Map drive letter to UNC if remote. */
9d4f32e8 2094 if ( isalpha (root_dir[0]) && !fixed[ DRIVE_INDEX (root_dir[0]) ] )
76b3903d
GV		 2095 {
2096 char remote_name[ 256 ];
2097 char drive[3] = { root_dir[0], ':' };
2098
2099 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
2100 == NO_ERROR)
2101 /* do something */ ;
2102 }
2103#endif
2104
2105 info = lookup_volume_info (root_dir);
2106
2107 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
2108 {
2109 char name[ 256 ];
2110 DWORD serialnum;
2111 DWORD maxcomp;
2112 DWORD flags;
2113 char type[ 256 ];
2114
2115 /* Info is not cached, or is stale. */
2116 if (!GetVolumeInformation (root_dir,
2117 name, sizeof (name),
2118 &serialnum,
2119 &maxcomp,
2120 &flags,
2121 type, sizeof (type)))
2122 return NULL;
2123
2124 /* Cache the volume information for future use, overwriting existing
2125 entry if present. */
2126 if (info == NULL)
2127 {
2128 info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
2129 add_volume_info (root_dir, info);
2130 }
2131 else
2132 {
a302c7ae
AI		 2133 xfree (info->name);
2134 xfree (info->type);
76b3903d
GV		 2135 }
2136
a302c7ae 2137 info->name = xstrdup (name);
76b3903d
GV		 2138 info->serialnum = serialnum;
2139 info->maxcomp = maxcomp;
2140 info->flags = flags;
a302c7ae 2141 info->type = xstrdup (type);
76b3903d
GV		 2142 info->timestamp = GetTickCount ();
2143 }
2144
2145 return info;
2146}
480b0c5b
GV		 2147
2148/* Get information on the volume where name is held; set path pointer to
2149 start of pathname in name (past UNC header\volume header if present). */
2150int
2151get_volume_info (const char * name, const char ** pPath)
95ed0025 2152{
480b0c5b
GV		 2153 char temp[MAX_PATH];
2154 char *rootname = NULL; /* default to current volume */
76b3903d 2155 volume_info_data * info;
480b0c5b
GV		 2156
2157 if (name == NULL)
2158 return FALSE;
2159
2160 /* find the root name of the volume if given */
2161 if (isalpha (name[0]) && name[1] == ':')
2162 {
2163 rootname = temp;
2164 temp[0] = *name++;
2165 temp[1] = *name++;
2166 temp[2] = '\\';
2167 temp[3] = 0;
2168 }
2169 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
95ed0025 2170 {
480b0c5b
GV		 2171 char *str = temp;
2172 int slashes = 4;
2173 rootname = temp;
2174 do
2175 {
2176 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
2177 break;
2178 *str++ = *name++;
2179 }
2180 while ( *name );
2181
480b0c5b
GV		 2182 *str++ = '\\';
2183 *str = 0;
95ed0025 2184 }
480b0c5b
GV		 2185
2186 if (pPath)
2187 *pPath = name;
177c0ea7 2188
76b3903d
GV		 2189 info = GetCachedVolumeInformation (rootname);
2190 if (info != NULL)
95ed0025 2191 {
76b3903d
GV		 2192 /* Set global referenced by other functions. */
2193 volume_info = *info;
480b0c5b 2194 return TRUE;
95ed0025 2195 }
480b0c5b
GV		 2196 return FALSE;
2197}
2198
2199/* Determine if volume is FAT format (ie. only supports short 8.3
2200 names); also set path pointer to start of pathname in name. */
2201int
2202is_fat_volume (const char * name, const char ** pPath)
2203{
2204 if (get_volume_info (name, pPath))
2205 return (volume_info.maxcomp == 12);
2206 return FALSE;
2207}
2208
4d90eee4 2209/* Map filename to a valid 8.3 name if necessary. */
480b0c5b 2210const char *
fbd6baed 2211map_w32_filename (const char * name, const char ** pPath)
480b0c5b
GV		 2212{
2213 static char shortname[MAX_PATH];
2214 char * str = shortname;
2215 char c;
480b0c5b 2216 char * path;
76b3903d 2217 const char * save_name = name;
480b0c5b 2218
ca149beb
AI		 2219 if (strlen (name) >= MAX_PATH)
2220 {
2221 /* Return a filename which will cause callers to fail. */
2222 strcpy (shortname, "?");
2223 return shortname;
2224 }
2225
a302c7ae 2226 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
95ed0025 2227 {
480b0c5b
GV		 2228 register int left = 8; /* maximum number of chars in part */
2229 register int extn = 0; /* extension added? */
2230 register int dots = 2; /* maximum number of dots allowed */
2231
2232 while (name < path)
2233 *str++ = *name++; /* skip past UNC header */
2234
2235 while ((c = *name++))
2236 {
2237 switch ( c )
2238 {
2239 case '\\':
2240 case '/':
2241 *str++ = '\\';
2242 extn = 0; /* reset extension flags */
2243 dots = 2; /* max 2 dots */
2244 left = 8; /* max length 8 for main part */
2245 break;
2246 case ':':
2247 *str++ = ':';
2248 extn = 0; /* reset extension flags */
2249 dots = 2; /* max 2 dots */
2250 left = 8; /* max length 8 for main part */
2251 break;
2252 case '.':
2253 if ( dots )
2254 {
2255 /* Convert path components of the form .xxx to _xxx,
2256 but leave . and .. as they are. This allows .emacs
2257 to be read as _emacs, for example. */
2258
2259 if (! *name ||
2260 *name == '.' ||
2261 IS_DIRECTORY_SEP (*name))
2262 {
2263 *str++ = '.';
2264 dots--;
2265 }
2266 else
2267 {
2268 *str++ = '_';
2269 left--;
2270 dots = 0;
2271 }
2272 }
2273 else if ( !extn )
2274 {
2275 *str++ = '.';
2276 extn = 1; /* we've got an extension */
2277 left = 3; /* 3 chars in extension */
2278 }
2279 else
2280 {
2281 /* any embedded dots after the first are converted to _ */
2282 *str++ = '_';
2283 }
2284 break;
2285 case '~':
2286 case '#': /* don't lose these, they're important */
2287 if ( ! left )
2288 str[-1] = c; /* replace last character of part */
2289 /* FALLTHRU */
2290 default:
2291 if ( left )
2292 {
2293 *str++ = tolower (c); /* map to lower case (looks nicer) */
2294 left--;
2295 dots = 0; /* started a path component */
2296 }
2297 break;
2298 }
2299 }
2300 *str = '\0';
fc85cb29
RS		 2301 }
2302 else
2303 {
2304 strcpy (shortname, name);
2305 unixtodos_filename (shortname);
95ed0025 2306 }
480b0c5b
GV		 2307
2308 if (pPath)
76b3903d 2309 *pPath = shortname + (path - save_name);
480b0c5b 2310
fc85cb29 2311 return shortname;
480b0c5b
GV		 2312}
2313
b3308d2e
KH		 2314static int
2315is_exec (const char * name)
2316{
2317 char * p = strrchr (name, '.');
2318 return
2319 (p != NULL
05131107
JR		 2320 && (xstrcasecmp (p, ".exe") == 0 ||
2321 xstrcasecmp (p, ".com") == 0 ||
2322 xstrcasecmp (p, ".bat") == 0 ||
2323 xstrcasecmp (p, ".cmd") == 0));
b3308d2e
KH		 2324}
2325
177c0ea7 2326/* Emulate the Unix directory procedures opendir, closedir,
76b3903d
GV		 2327 and readdir. We can't use the procedures supplied in sysdep.c,
2328 so we provide them here. */
2329
2330struct direct dir_static; /* simulated directory contents */
2331static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
2332static int dir_is_fat;
2333static char dir_pathname[MAXPATHLEN+1];
2334static WIN32_FIND_DATA dir_find_data;
2335
9d3355d1
GV		 2336/* Support shares on a network resource as subdirectories of a read-only
2337 root directory. */
2338static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
e0c181dd 2339HANDLE open_unc_volume (const char *);
9d3355d1
GV		 2340char *read_unc_volume (HANDLE, char *, int);
2341void close_unc_volume (HANDLE);
2342
76b3903d
GV		 2343DIR *
2344opendir (char *filename)
2345{
2346 DIR *dirp;
2347
2348 /* Opening is done by FindFirstFile. However, a read is inherent to
2349 this operation, so we defer the open until read time. */
2350
76b3903d
GV		 2351 if (dir_find_handle != INVALID_HANDLE_VALUE)
2352 return NULL;
9d3355d1
GV		 2353 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2354 return NULL;
2355
2356 if (is_unc_volume (filename))
2357 {
2358 wnet_enum_handle = open_unc_volume (filename);
2359 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
2360 return NULL;
2361 }
2362
2363 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
2364 return NULL;
76b3903d
GV		 2365
2366 dirp->dd_fd = 0;
2367 dirp->dd_loc = 0;
2368 dirp->dd_size = 0;
2369
2370 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
2371 dir_pathname[MAXPATHLEN] = '\0';
2372 dir_is_fat = is_fat_volume (filename, NULL);
2373
2374 return dirp;
2375}
2376
2377void
2378closedir (DIR *dirp)
2379{
2380 /* If we have a find-handle open, close it. */
2381 if (dir_find_handle != INVALID_HANDLE_VALUE)
2382 {
2383 FindClose (dir_find_handle);
2384 dir_find_handle = INVALID_HANDLE_VALUE;
2385 }
9d3355d1
GV		 2386 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2387 {
2388 close_unc_volume (wnet_enum_handle);
2389 wnet_enum_handle = INVALID_HANDLE_VALUE;
2390 }
76b3903d
GV		 2391 xfree ((char *) dirp);
2392}
2393
2394struct direct *
2395readdir (DIR *dirp)
2396{
b07103dc
EZ		 2397 int downcase = !NILP (Vw32_downcase_file_names);
2398
9d3355d1
GV		 2399 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2400 {
177c0ea7
JB		 2401 if (!read_unc_volume (wnet_enum_handle,
2402 dir_find_data.cFileName,
9d3355d1
GV		 2403 MAX_PATH))
2404 return NULL;
2405 }
76b3903d 2406 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
9d3355d1 2407 else if (dir_find_handle == INVALID_HANDLE_VALUE)
76b3903d
GV		 2408 {
2409 char filename[MAXNAMLEN + 3];
2410 int ln;
2411
2412 strcpy (filename, dir_pathname);
2413 ln = strlen (filename) - 1;
2414 if (!IS_DIRECTORY_SEP (filename[ln]))
2415 strcat (filename, "\\");
2416 strcat (filename, "*");
2417
2418 dir_find_handle = FindFirstFile (filename, &dir_find_data);
2419
2420 if (dir_find_handle == INVALID_HANDLE_VALUE)
2421 return NULL;
2422 }
2423 else
2424 {
2425 if (!FindNextFile (dir_find_handle, &dir_find_data))
2426 return NULL;
2427 }
177c0ea7 2428
76b3903d
GV		 2429 /* Emacs never uses this value, so don't bother making it match
2430 value returned by stat(). */
2431 dir_static.d_ino = 1;
177c0ea7 2432
b07103dc
EZ		 2433 strcpy (dir_static.d_name, dir_find_data.cFileName);
2434
2435 /* If the file name in cFileName[] includes `?' characters, it means
2436 the original file name used characters that cannot be represented
2437 by the current ANSI codepage. To avoid total lossage, retrieve
2438 the short 8+3 alias of the long file name. */
2439 if (_mbspbrk (dir_static.d_name, "?"))
2440 {
2441 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2442 downcase = 1; /* 8+3 aliases are returned in all caps */
2443 }
2444 dir_static.d_namlen = strlen (dir_static.d_name);
76b3903d
GV		 2445 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
2446 dir_static.d_namlen - dir_static.d_namlen % 4;
177c0ea7 2447
192788d7
EZ		 2448 /* If the file name in cFileName[] includes `?' characters, it means
2449 the original file name used characters that cannot be represented
2450 by the current ANSI codepage. To avoid total lossage, retrieve
2451 the short 8+3 alias of the long file name. */
2452 if (_mbspbrk (dir_find_data.cFileName, "?"))
2453 {
2454 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2455 /* 8+3 aliases are returned in all caps, which could break
2456 various alists that look at filenames' extensions. */
2457 downcase = 1;
2458 }
2459 else
2460 strcpy (dir_static.d_name, dir_find_data.cFileName);
2461 dir_static.d_namlen = strlen (dir_static.d_name);
76b3903d
GV		 2462 if (dir_is_fat)
2463 _strlwr (dir_static.d_name);
b07103dc 2464 else if (downcase)
76b3903d
GV		 2465 {
2466 register char *p;
2467 for (p = dir_static.d_name; *p; p++)
2468 if (*p >= 'a' && *p <= 'z')
2469 break;
2470 if (!*p)
2471 _strlwr (dir_static.d_name);
2472 }
177c0ea7 2473
76b3903d
GV		 2474 return &dir_static;
2475}
2476
9d3355d1 2477HANDLE
e0c181dd 2478open_unc_volume (const char *path)
9d3355d1 2479{
177c0ea7 2480 NETRESOURCE nr;
9d3355d1
GV		 2481 HANDLE henum;
2482 int result;
2483
177c0ea7
JB		 2484 nr.dwScope = RESOURCE_GLOBALNET;
2485 nr.dwType = RESOURCETYPE_DISK;
2486 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
2487 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
2488 nr.lpLocalName = NULL;
6e602566 2489 nr.lpRemoteName = (LPSTR)map_w32_filename (path, NULL);
177c0ea7
JB		 2490 nr.lpComment = NULL;
2491 nr.lpProvider = NULL;
9d3355d1 2492
9d4f32e8
JB		 2493 result = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
2494 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
9d3355d1
GV		 2495
2496 if (result == NO_ERROR)
2497 return henum;
2498 else
2499 return INVALID_HANDLE_VALUE;
2500}
2501
2502char *
2503read_unc_volume (HANDLE henum, char *readbuf, int size)
2504{
a302c7ae 2505 DWORD count;
9d3355d1 2506 int result;
a302c7ae 2507 DWORD bufsize = 512;
9d3355d1
GV		 2508 char *buffer;
2509 char *ptr;
2510
2511 count = 1;
2512 buffer = alloca (bufsize);
2513 result = WNetEnumResource (wnet_enum_handle, &count, buffer, &bufsize);
2514 if (result != NO_ERROR)
2515 return NULL;
2516
2517 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2518 ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
2519 ptr += 2;
2520 while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
2521 ptr++;
2522
2523 strncpy (readbuf, ptr, size);
2524 return readbuf;
2525}
2526
2527void
2528close_unc_volume (HANDLE henum)
2529{
2530 if (henum != INVALID_HANDLE_VALUE)
2531 WNetCloseEnum (henum);
2532}
2533
2534DWORD
e0c181dd 2535unc_volume_file_attributes (const char *path)
9d3355d1
GV		 2536{
2537 HANDLE henum;
2538 DWORD attrs;
2539
2540 henum = open_unc_volume (path);
2541 if (henum == INVALID_HANDLE_VALUE)
2542 return -1;
2543
2544 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
2545
2546 close_unc_volume (henum);
2547
2548 return attrs;
2549}
2550
302d7d54
JR		 2551/* Ensure a network connection is authenticated. */
2552static void
2553logon_network_drive (const char *path)
2554{
2555 NETRESOURCE resource;
2556 char share[MAX_PATH];
2557 int i, n_slashes;
40a339c8 2558 char drive[4];
be4c6380 2559 UINT drvtype;
40a339c8 2560
be4c6380
EZ		 2561 if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
2562 drvtype = DRIVE_REMOTE;
2563 else if (path[0] == '\0' || path[1] != ':')
2564 drvtype = GetDriveType (NULL);
2565 else
2566 {
2567 drive[0] = path[0];
2568 drive[1] = ':';
2569 drive[2] = '\\';
2570 drive[3] = '\0';
2571 drvtype = GetDriveType (drive);
2572 }
302d7d54
JR		 2573
2574 /* Only logon to networked drives. */
be4c6380 2575 if (drvtype != DRIVE_REMOTE)
302d7d54 2576 return;
40a339c8 2577
302d7d54
JR		 2578 n_slashes = 2;
2579 strncpy (share, path, MAX_PATH);
2580 /* Truncate to just server and share name. */
2581 for (i = 2; i < MAX_PATH; i++)
2582 {
2583 if (IS_DIRECTORY_SEP (share[i]) && ++n_slashes > 3)
2584 {
2585 share[i] = '\0';
2586 break;
2587 }
2588 }
2589
2590 resource.dwType = RESOURCETYPE_DISK;
2591 resource.lpLocalName = NULL;
2592 resource.lpRemoteName = share;
2593 resource.lpProvider = NULL;
2594
2595 WNetAddConnection2 (&resource, NULL, NULL, CONNECT_INTERACTIVE);
2596}
480b0c5b
GV		 2597
2598/* Shadow some MSVC runtime functions to map requests for long filenames
2599 to reasonable short names if necessary. This was originally added to
177c0ea7 2600 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
480b0c5b
GV		 2601 long file names. */
2602
2603int
2604sys_access (const char * path, int mode)
2605{
b3308d2e
KH		 2606 DWORD attributes;
2607
2608 /* MSVC implementation doesn't recognize D_OK. */
2609 path = map_w32_filename (path, NULL);
9d3355d1
GV		 2610 if (is_unc_volume (path))
2611 {
2612 attributes = unc_volume_file_attributes (path);
2613 if (attributes == -1) {
2614 errno = EACCES;
2615 return -1;
2616 }
2617 }
2618 else if ((attributes = GetFileAttributes (path)) == -1)
b3308d2e
KH		 2619 {
2620 /* Should try mapping GetLastError to errno; for now just indicate
2621 that path doesn't exist. */
2622 errno = EACCES;
2623 return -1;
2624 }
2625 if ((mode & X_OK) != 0 && !is_exec (path))
2626 {
2627 errno = EACCES;
2628 return -1;
2629 }
2630 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
2631 {
2632 errno = EACCES;
2633 return -1;
2634 }
2635 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
2636 {
2637 errno = EACCES;
2638 return -1;
2639 }
2640 return 0;
480b0c5b
GV		 2641}
2642
2643int
2644sys_chdir (const char * path)
2645{
fbd6baed 2646 return _chdir (map_w32_filename (path, NULL));
480b0c5b
GV		 2647}
2648
2649int
2650sys_chmod (const char * path, int mode)
2651{
fbd6baed 2652 return _chmod (map_w32_filename (path, NULL), mode);
480b0c5b
GV		 2653}
2654
2d5ab4bf
EZ		 2655int
2656sys_chown (const char *path, uid_t owner, gid_t group)
2657{
e3b88685 2658 if (sys_chmod (path, S_IREAD) == -1) /* check if file exists */
2d5ab4bf
EZ		 2659 return -1;
2660 return 0;
2661}
2662
480b0c5b
GV		 2663int
2664sys_creat (const char * path, int mode)
2665{
fbd6baed 2666 return _creat (map_w32_filename (path, NULL), mode);
480b0c5b
GV		 2667}
2668
2669FILE *
9d4f32e8 2670sys_fopen (const char * path, const char * mode)
480b0c5b
GV		 2671{
2672 int fd;
2673 int oflag;
2674 const char * mode_save = mode;
2675
2676 /* Force all file handles to be non-inheritable. This is necessary to
2677 ensure child processes don't unwittingly inherit handles that might
2678 prevent future file access. */
2679
2680 if (mode[0] == 'r')
2681 oflag = O_RDONLY;
2682 else if (mode[0] == 'w' || mode[0] == 'a')
2683 oflag = O_WRONLY | O_CREAT | O_TRUNC;
95ed0025 2684 else
480b0c5b
GV		 2685 return NULL;
2686
2687 /* Only do simplistic option parsing. */
2688 while (*++mode)
2689 if (mode[0] == '+')
2690 {
2691 oflag &= ~(O_RDONLY | O_WRONLY);
2692 oflag |= O_RDWR;
2693 }
2694 else if (mode[0] == 'b')
2695 {
2696 oflag &= ~O_TEXT;
2697 oflag |= O_BINARY;
2698 }
2699 else if (mode[0] == 't')
2700 {
2701 oflag &= ~O_BINARY;
2702 oflag |= O_TEXT;
2703 }
2704 else break;
2705
fbd6baed 2706 fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
480b0c5b
GV		 2707 if (fd < 0)
2708 return NULL;
2709
76b3903d 2710 return _fdopen (fd, mode_save);
95ed0025 2711}
480b0c5b 2712
76b3903d 2713/* This only works on NTFS volumes, but is useful to have. */
480b0c5b 2714int
76b3903d 2715sys_link (const char * old, const char * new)
480b0c5b 2716{
76b3903d
GV		 2717 HANDLE fileh;
2718 int result = -1;
2719 char oldname[MAX_PATH], newname[MAX_PATH];
2720
2721 if (old == NULL || new == NULL)
2722 {
2723 errno = ENOENT;
2724 return -1;
2725 }
2726
2727 strcpy (oldname, map_w32_filename (old, NULL));
2728 strcpy (newname, map_w32_filename (new, NULL));
2729
2730 fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
2731 FILE_FLAG_BACKUP_SEMANTICS, NULL);
2732 if (fileh != INVALID_HANDLE_VALUE)
2733 {
2734 int wlen;
2735
2736 /* Confusingly, the "alternate" stream name field does not apply
2737 when restoring a hard link, and instead contains the actual
2738 stream data for the link (ie. the name of the link to create).
2739 The WIN32_STREAM_ID structure before the cStreamName field is
2740 the stream header, which is then immediately followed by the
2741 stream data. */
2742
2743 struct {
2744 WIN32_STREAM_ID wid;
2745 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
2746 } data;
2747
2748 wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
2749 data.wid.cStreamName, MAX_PATH);
2750 if (wlen > 0)
2751 {
2752 LPVOID context = NULL;
2753 DWORD wbytes = 0;
2754
2755 data.wid.dwStreamId = BACKUP_LINK;
2756 data.wid.dwStreamAttributes = 0;
9d4f32e8 2757 data.wid.Size.LowPart = wlen * sizeof (WCHAR);
76b3903d
GV		 2758 data.wid.Size.HighPart = 0;
2759 data.wid.dwStreamNameSize = 0;
2760
2761 if (BackupWrite (fileh, (LPBYTE)&data,
2762 offsetof (WIN32_STREAM_ID, cStreamName)
2763 + data.wid.Size.LowPart,
2764 &wbytes, FALSE, FALSE, &context)
2765 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
2766 {
2767 /* succeeded */
2768 result = 0;
2769 }
2770 else
2771 {
2772 /* Should try mapping GetLastError to errno; for now just
2773 indicate a general error (eg. links not supported). */
2774 errno = EINVAL; // perhaps EMLINK?
2775 }
2776 }
2777
2778 CloseHandle (fileh);
2779 }
2780 else
2781 errno = ENOENT;
2782
2783 return result;
480b0c5b
GV		 2784}
2785
2786int
2787sys_mkdir (const char * path)
2788{
fbd6baed 2789 return _mkdir (map_w32_filename (path, NULL));
480b0c5b
GV		 2790}
2791
9d1778b1
RS		 2792/* Because of long name mapping issues, we need to implement this
2793 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2794 a unique name, instead of setting the input template to an empty
2795 string.
2796
2797 Standard algorithm seems to be use pid or tid with a letter on the
2798 front (in place of the 6 X's) and cycle through the letters to find a
2799 unique name. We extend that to allow any reasonable character as the
2800 first of the 6 X's. */
480b0c5b
GV		 2801char *
2802sys_mktemp (char * template)
2803{
9d1778b1
RS		 2804 char * p;
2805 int i;
2806 unsigned uid = GetCurrentThreadId ();
2807 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2808
2809 if (template == NULL)
2810 return NULL;
2811 p = template + strlen (template);
2812 i = 5;
2813 /* replace up to the last 5 X's with uid in decimal */
2814 while (--p >= template && p[0] == 'X' && --i >= 0)
2815 {
2816 p[0] = '0' + uid % 10;
2817 uid /= 10;
2818 }
2819
2820 if (i < 0 && p[0] == 'X')
2821 {
2822 i = 0;
2823 do
2824 {
2825 int save_errno = errno;
2826 p[0] = first_char[i];
2827 if (sys_access (template, 0) < 0)
2828 {
2829 errno = save_errno;
2830 return template;
2831 }
2832 }
2833 while (++i < sizeof (first_char));
2834 }
2835
2836 /* Template is badly formed or else we can't generate a unique name,
2837 so return empty string */
2838 template[0] = 0;
2839 return template;
480b0c5b
GV		 2840}
2841
2842int
2843sys_open (const char * path, int oflag, int mode)
2844{
302f0b29
GM		 2845 const char* mpath = map_w32_filename (path, NULL);
2846 /* Try to open file without _O_CREAT, to be able to write to hidden
2847 and system files. Force all file handles to be
2848 non-inheritable. */
2849 int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
2850 if (res >= 0)
2851 return res;
2852 return _open (mpath, oflag | _O_NOINHERIT, mode);
480b0c5b
GV		 2853}
2854
2855int
2856sys_rename (const char * oldname, const char * newname)
2857{
cfb5e855 2858 BOOL result;
b3308d2e 2859 char temp[MAX_PATH];
480b0c5b 2860
e9e23e23 2861 /* MoveFile on Windows 95 doesn't correctly change the short file name
5162ffce
MB		 2862 alias in a number of circumstances (it is not easy to predict when
2863 just by looking at oldname and newname, unfortunately). In these
2864 cases, renaming through a temporary name avoids the problem.
2865
e9e23e23 2866 A second problem on Windows 95 is that renaming through a temp name when
5162ffce
MB		 2867 newname is uppercase fails (the final long name ends up in
2868 lowercase, although the short alias might be uppercase) UNLESS the
2869 long temp name is not 8.3.
2870
e9e23e23 2871 So, on Windows 95 we always rename through a temp name, and we make sure
5162ffce 2872 the temp name has a long extension to ensure correct renaming. */
480b0c5b 2873
fbd6baed 2874 strcpy (temp, map_w32_filename (oldname, NULL));
480b0c5b 2875
76b3903d 2876 if (os_subtype == OS_WIN95)
480b0c5b 2877 {
b3308d2e 2878 char * o;
480b0c5b 2879 char * p;
b3308d2e
KH		 2880 int i = 0;
2881
2882 oldname = map_w32_filename (oldname, NULL);
2883 if (o = strrchr (oldname, '\\'))
2884 o++;
2885 else
2886 o = (char *) oldname;
480b0c5b 2887
480b0c5b
GV		 2888 if (p = strrchr (temp, '\\'))
2889 p++;
2890 else
2891 p = temp;
b3308d2e
KH		 2892
2893 do
2894 {
2895 /* Force temp name to require a manufactured 8.3 alias - this
2896 seems to make the second rename work properly. */
f313ee82 2897 sprintf (p, "_.%s.%u", o, i);
b3308d2e 2898 i++;
58f0cb7e 2899 result = rename (oldname, temp);
b3308d2e
KH		 2900 }
2901 /* This loop must surely terminate! */
cfb5e855 2902 while (result < 0 && errno == EEXIST);
58f0cb7e 2903 if (result < 0)
480b0c5b
GV		 2904 return -1;
2905 }
2906
fffa137c 2907 /* Emulate Unix behavior - newname is deleted if it already exists
5162ffce 2908 (at least if it is a file; don't do this for directories).
76b3903d 2909
b3308d2e
KH		 2910 Since we mustn't do this if we are just changing the case of the
2911 file name (we would end up deleting the file we are trying to
2912 rename!), we let rename detect if the destination file already
2913 exists - that way we avoid the possible pitfalls of trying to
2914 determine ourselves whether two names really refer to the same
2915 file, which is not always possible in the general case. (Consider
2916 all the permutations of shared or subst'd drives, etc.) */
2917
2918 newname = map_w32_filename (newname, NULL);
eb9ea53f 2919 result = rename (temp, newname);
b3308d2e
KH		 2920
2921 if (result < 0
cfb5e855 2922 && errno == EEXIST
b3308d2e
KH		 2923 && _chmod (newname, 0666) == 0
2924 && _unlink (newname) == 0)
2925 result = rename (temp, newname);
480b0c5b 2926
eb9ea53f 2927 return result;
480b0c5b
GV		 2928}
2929
2930int
2931sys_rmdir (const char * path)
2932{
fbd6baed 2933 return _rmdir (map_w32_filename (path, NULL));
480b0c5b
GV		 2934}
2935
2936int
2937sys_unlink (const char * path)
2938{
16bb7578
GV		 2939 path = map_w32_filename (path, NULL);
2940
2941 /* On Unix, unlink works without write permission. */
2942 _chmod (path, 0666);
2943 return _unlink (path);
480b0c5b
GV		 2944}
2945
2946static FILETIME utc_base_ft;
5da9424d 2947static ULONGLONG utc_base; /* In 100ns units */
480b0c5b
GV		 2948static int init = 0;
2949
5da9424d
JB		 2950#define FILETIME_TO_U64(result, ft) \
2951 do { \
2952 ULARGE_INTEGER uiTemp; \
2953 uiTemp.LowPart = (ft).dwLowDateTime; \
2954 uiTemp.HighPart = (ft).dwHighDateTime; \
2955 result = uiTemp.QuadPart; \
2956 } while (0)
2957
2958static void
2959initialize_utc_base ()
7c80d5ec 2960{
5da9424d
JB		 2961 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2962 SYSTEMTIME st;
2963
2964 st.wYear = 1970;
2965 st.wMonth = 1;
2966 st.wDay = 1;
2967 st.wHour = 0;
2968 st.wMinute = 0;
2969 st.wSecond = 0;
2970 st.wMilliseconds = 0;
2971
2972 SystemTimeToFileTime (&st, &utc_base_ft);
2973 FILETIME_TO_U64 (utc_base, utc_base_ft);
7c80d5ec
EZ		 2974}
2975
480b0c5b
GV		 2976static time_t
2977convert_time (FILETIME ft)
2978{
5da9424d 2979 ULONGLONG tmp;
480b0c5b
GV		 2980
2981 if (!init)
2982 {
9d4f32e8 2983 initialize_utc_base ();
480b0c5b
GV		 2984 init = 1;
2985 }
2986
2987 if (CompareFileTime (&ft, &utc_base_ft) < 0)
2988 return 0;
2989
5da9424d
JB		 2990 FILETIME_TO_U64 (tmp, ft);
2991 return (time_t) ((tmp - utc_base) / 10000000L);
480b0c5b
GV		 2992}
2993
7c80d5ec 2994
480b0c5b
GV		 2995void
2996convert_from_time_t (time_t time, FILETIME * pft)
2997{
5da9424d 2998 ULARGE_INTEGER tmp;
480b0c5b
GV		 2999
3000 if (!init)
3001 {
5da9424d 3002 initialize_utc_base ();
480b0c5b
GV		 3003 init = 1;
3004 }
3005
3006 /* time in 100ns units since 1-Jan-1601 */
5da9424d
JB		 3007 tmp.QuadPart = (ULONGLONG) time * 10000000L + utc_base;
3008 pft->dwHighDateTime = tmp.HighPart;
3009 pft->dwLowDateTime = tmp.LowPart;
480b0c5b 3010}
480b0c5b 3011
76b3903d
GV		 3012#if 0
3013/* No reason to keep this; faking inode values either by hashing or even
3014 using the file index from GetInformationByHandle, is not perfect and
3015 so by default Emacs doesn't use the inode values on Windows.
3016 Instead, we now determine file-truename correctly (except for
3017 possible drive aliasing etc). */
3018
3019/* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
480b0c5b 3020static unsigned
76b3903d 3021hashval (const unsigned char * str)
480b0c5b
GV		 3022{
3023 unsigned h = 0;
480b0c5b
GV		 3024 while (*str)
3025 {
3026 h = (h << 4) + *str++;
76b3903d 3027 h ^= (h >> 28);
480b0c5b
GV		 3028 }
3029 return h;
3030}
3031
3032/* Return the hash value of the canonical pathname, excluding the
3033 drive/UNC header, to get a hopefully unique inode number. */
76b3903d 3034static DWORD
480b0c5b
GV		 3035generate_inode_val (const char * name)
3036{
3037 char fullname[ MAX_PATH ];
3038 char * p;
3039 unsigned hash;
3040
76b3903d
GV		 3041 /* Get the truly canonical filename, if it exists. (Note: this
3042 doesn't resolve aliasing due to subst commands, or recognise hard
3043 links. */
3044 if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
3045 abort ();
3046
3047 parse_root (fullname, &p);
fbd6baed 3048 /* Normal W32 filesystems are still case insensitive. */
480b0c5b 3049 _strlwr (p);
76b3903d 3050 return hashval (p);
480b0c5b
GV		 3051}
3052
76b3903d
GV		 3053#endif
3054
8aaaec6b
EZ		 3055static PSECURITY_DESCRIPTOR
3056get_file_security_desc (const char *fname)
3057{
3058 PSECURITY_DESCRIPTOR psd = NULL;
3059 DWORD sd_len, err;
3060 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3061 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
3062
3063 if (!get_file_security (fname, si, psd, 0, &sd_len))
3064 {
3065 err = GetLastError ();
3066 if (err != ERROR_INSUFFICIENT_BUFFER)
3067 return NULL;
3068 }
3069
3070 psd = xmalloc (sd_len);
3071 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
3072 {
3073 xfree (psd);
3074 return NULL;
3075 }
3076
3077 return psd;
3078}
3079
3080static DWORD
3081get_rid (PSID sid)
3082{
3083 unsigned n_subauthorities;
3084
3085 /* Use the last sub-authority value of the RID, the relative
3086 portion of the SID, as user/group ID. */
3087 n_subauthorities = *get_sid_sub_authority_count (sid);
3088 if (n_subauthorities < 1)
3089 return 0; /* the "World" RID */
3090 return *get_sid_sub_authority (sid, n_subauthorities - 1);
3091}
3092
f8b35b24
EZ		 3093/* Caching SID and account values for faster lokup. */
3094
3095#ifdef __GNUC__
3096# define FLEXIBLE_ARRAY_MEMBER
3097#else
3098# define FLEXIBLE_ARRAY_MEMBER 1
3099#endif
3100
3101struct w32_id {
22749e9a 3102 unsigned rid;
f8b35b24
EZ		 3103 struct w32_id *next;
3104 char name[GNLEN+1];
3105 unsigned char sid[FLEXIBLE_ARRAY_MEMBER];
3106};
3107
3108static struct w32_id *w32_idlist;
3109
3110static int
22749e9a 3111w32_cached_id (PSID sid, unsigned *id, char *name)
f8b35b24
EZ		 3112{
3113 struct w32_id *tail, *found;
3114
3115 for (found = NULL, tail = w32_idlist; tail; tail = tail->next)
3116 {
3117 if (equal_sid ((PSID)tail->sid, sid))
3118 {
3119 found = tail;
3120 break;
3121 }
3122 }
3123 if (found)
3124 {
3125 *id = found->rid;
3126 strcpy (name, found->name);
3127 return 1;
3128 }
3129 else
3130 return 0;
3131}
3132
3133static void
22749e9a 3134w32_add_to_cache (PSID sid, unsigned id, char *name)
f8b35b24
EZ		 3135{
3136 DWORD sid_len;
3137 struct w32_id *new_entry;
3138
3139 /* We don't want to leave behind stale cache from when Emacs was
3140 dumped. */
3141 if (initialized)
3142 {
3143 sid_len = get_length_sid (sid);
3144 new_entry = xmalloc (offsetof (struct w32_id, sid) + sid_len);
3145 if (new_entry)
3146 {
3147 new_entry->rid = id;
3148 strcpy (new_entry->name, name);
3149 copy_sid (sid_len, (PSID)new_entry->sid, sid);
3150 new_entry->next = w32_idlist;
3151 w32_idlist = new_entry;
3152 }
3153 }
3154}
3155
8aaaec6b
EZ		 3156#define UID 1
3157#define GID 2
3158
3159static int
3160get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
22749e9a 3161 unsigned *id, char *nm, int what)
8aaaec6b
EZ		 3162{
3163 PSID sid = NULL;
3164 char machine[MAX_COMPUTERNAME_LENGTH+1];
3165 BOOL dflt;
3166 SID_NAME_USE ignore;
3167 char name[UNLEN+1];
3168 DWORD name_len = sizeof (name);
3169 char domain[1024];
9d4f32e8 3170 DWORD domain_len = sizeof (domain);
8aaaec6b
EZ		 3171 char *mp = NULL;
3172 int use_dflt = 0;
3173 int result;
3174
3175 if (what == UID)
3176 result = get_security_descriptor_owner (psd, &sid, &dflt);
3177 else if (what == GID)
3178 result = get_security_descriptor_group (psd, &sid, &dflt);
3179 else
3180 result = 0;
3181
3182 if (!result || !is_valid_sid (sid))
3183 use_dflt = 1;
f8b35b24 3184 else if (!w32_cached_id (sid, id, nm))
8aaaec6b
EZ		 3185 {
3186 /* If FNAME is a UNC, we need to lookup account on the
3187 specified machine. */
3188 if (IS_DIRECTORY_SEP (fname[0]) && IS_DIRECTORY_SEP (fname[1])
3189 && fname[2] != '\0')
3190 {
3191 const char *s;
3192 char *p;
3193
3194 for (s = fname + 2, p = machine;
3195 *s && !IS_DIRECTORY_SEP (*s); s++, p++)
3196 *p = *s;
3197 *p = '\0';
3198 mp = machine;
3199 }
3200
3201 if (!lookup_account_sid (mp, sid, name, &name_len,
3202 domain, &domain_len, &ignore)
3203 || name_len > UNLEN+1)
3204 use_dflt = 1;
3205 else
3206 {
3207 *id = get_rid (sid);
3208 strcpy (nm, name);
f8b35b24 3209 w32_add_to_cache (sid, *id, name);
8aaaec6b
EZ		 3210 }
3211 }
3212 return use_dflt;
3213}
3214
3215static void
9d4f32e8
JB		 3216get_file_owner_and_group (PSECURITY_DESCRIPTOR psd,
3217 const char *fname,
3218 struct stat *st)
8aaaec6b
EZ		 3219{
3220 int dflt_usr = 0, dflt_grp = 0;
3221
3222 if (!psd)
3223 {
3224 dflt_usr = 1;
3225 dflt_grp = 1;
3226 }
3227 else
3228 {
3229 if (get_name_and_id (psd, fname, &st->st_uid, st->st_uname, UID))
3230 dflt_usr = 1;
3231 if (get_name_and_id (psd, fname, &st->st_gid, st->st_gname, GID))
3232 dflt_grp = 1;
3233 }
3234 /* Consider files to belong to current user/group, if we cannot get
3235 more accurate information. */
3236 if (dflt_usr)
3237 {
3238 st->st_uid = dflt_passwd.pw_uid;
3239 strcpy (st->st_uname, dflt_passwd.pw_name);
3240 }
3241 if (dflt_grp)
3242 {
3243 st->st_gid = dflt_passwd.pw_gid;
3244 strcpy (st->st_gname, dflt_group.gr_name);
3245 }
3246}
3247
be4c6380
EZ		 3248/* Return non-zero if NAME is a potentially slow filesystem. */
3249int
3250is_slow_fs (const char *name)
3251{
3252 char drive_root[4];
3253 UINT devtype;
3254
3255 if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
3256 devtype = DRIVE_REMOTE; /* assume UNC name is remote */
3257 else if (!(strlen (name) >= 2 && IS_DEVICE_SEP (name[1])))
3258 devtype = GetDriveType (NULL); /* use root of current drive */
3259 else
3260 {
3261 /* GetDriveType needs the root directory of the drive. */
3262 strncpy (drive_root, name, 2);
3263 drive_root[2] = '\\';
3264 drive_root[3] = '\0';
3265 devtype = GetDriveType (drive_root);
3266 }
3267 return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
3268}
3269
480b0c5b
GV		 3270/* MSVC stat function can't cope with UNC names and has other bugs, so
3271 replace it with our own. This also allows us to calculate consistent
3272 inode values without hacks in the main Emacs code. */
3273int
3274stat (const char * path, struct stat * buf)
3275{
eb9ea53f 3276 char *name, *r;
a644b2e4
EZ		 3277 char drive_root[4];
3278 UINT devtype;
480b0c5b
GV		 3279 WIN32_FIND_DATA wfd;
3280 HANDLE fh;
e3b88685 3281 unsigned __int64 fake_inode;
480b0c5b
GV		 3282 int permission;
3283 int len;
3284 int rootdir = FALSE;
8aaaec6b 3285 PSECURITY_DESCRIPTOR psd = NULL;
480b0c5b
GV		 3286
3287 if (path == NULL || buf == NULL)
3288 {
3289 errno = EFAULT;
3290 return -1;
3291 }
3292
fbd6baed 3293 name = (char *) map_w32_filename (path, &path);
22189f79
EZ		 3294 /* Must be valid filename, no wild cards or other invalid
3295 characters. We use _mbspbrk to support multibyte strings that
3296 might look to strpbrk as if they included literal *, ?, and other
3297 characters mentioned below that are disallowed by Windows
3298 filesystems. */
3299 if (_mbspbrk (name, "*?|<>\""))
480b0c5b
GV		 3300 {
3301 errno = ENOENT;
3302 return -1;
3303 }
3304
eb9ea53f
GV		 3305 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3306 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
3307 if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
3308 {
3309 r[1] = r[2] = '\0';
3310 }
3311
480b0c5b
GV		 3312 /* Remove trailing directory separator, unless name is the root
3313 directory of a drive or UNC volume in which case ensure there
3314 is a trailing separator. */
3315 len = strlen (name);
3316 rootdir = (path >= name + len - 1
3317 && (IS_DIRECTORY_SEP (*path) || *path == 0));
3318 name = strcpy (alloca (len + 2), name);
3319
9d3355d1
GV		 3320 if (is_unc_volume (name))
3321 {
3322 DWORD attrs = unc_volume_file_attributes (name);
3323
3324 if (attrs == -1)
3325 return -1;
3326
3327 memset (&wfd, 0, sizeof (wfd));
3328 wfd.dwFileAttributes = attrs;
3329 wfd.ftCreationTime = utc_base_ft;
3330 wfd.ftLastAccessTime = utc_base_ft;
3331 wfd.ftLastWriteTime = utc_base_ft;
3332 strcpy (wfd.cFileName, name);
3333 }
3334 else if (rootdir)
480b0c5b
GV		 3335 {
3336 if (!IS_DIRECTORY_SEP (name[len-1]))
3337 strcat (name, "\\");
3338 if (GetDriveType (name) < 2)
3339 {
3340 errno = ENOENT;
3341 return -1;
3342 }
3343 memset (&wfd, 0, sizeof (wfd));
3344 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
3345 wfd.ftCreationTime = utc_base_ft;
3346 wfd.ftLastAccessTime = utc_base_ft;
3347 wfd.ftLastWriteTime = utc_base_ft;
3348 strcpy (wfd.cFileName, name);
3349 }
3350 else
3351 {
3352 if (IS_DIRECTORY_SEP (name[len-1]))
3353 name[len - 1] = 0;
76b3903d
GV		 3354
3355 /* (This is hacky, but helps when doing file completions on
3356 network drives.) Optimize by using information available from
3357 active readdir if possible. */
b19cc00c
GV		 3358 len = strlen (dir_pathname);
3359 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
3360 len--;
76b3903d 3361 if (dir_find_handle != INVALID_HANDLE_VALUE
b19cc00c 3362 && strnicmp (name, dir_pathname, len) == 0
76b3903d 3363 && IS_DIRECTORY_SEP (name[len])
05131107 3364 && xstrcasecmp (name + len + 1, dir_static.d_name) == 0)
480b0c5b 3365 {
76b3903d
GV		 3366 /* This was the last entry returned by readdir. */
3367 wfd = dir_find_data;
3368 }
3369 else
3370 {
513feaa5 3371 logon_network_drive (name);
302d7d54 3372
76b3903d
GV		 3373 fh = FindFirstFile (name, &wfd);
3374 if (fh == INVALID_HANDLE_VALUE)
3375 {
3376 errno = ENOENT;
3377 return -1;
3378 }
3379 FindClose (fh);
480b0c5b 3380 }
480b0c5b
GV		 3381 }
3382
8aaaec6b 3383 if (!(NILP (Vw32_get_true_file_attributes)
19ced600 3384 || (EQ (Vw32_get_true_file_attributes, Qlocal) && is_slow_fs (name)))
93e0f0da
JR		 3385 /* No access rights required to get info. */
3386 && (fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
3387 FILE_FLAG_BACKUP_SEMANTICS, NULL))
3388 != INVALID_HANDLE_VALUE)
480b0c5b 3389 {
480b0c5b 3390 /* This is more accurate in terms of gettting the correct number
aa5ee2a3 3391 of links, but is quite slow (it is noticeable when Emacs is
480b0c5b
GV		 3392 making a list of file name completions). */
3393 BY_HANDLE_FILE_INFORMATION info;
3394
480b0c5b
GV		 3395 if (GetFileInformationByHandle (fh, &info))
3396 {
480b0c5b 3397 buf->st_nlink = info.nNumberOfLinks;
76b3903d
GV		 3398 /* Might as well use file index to fake inode values, but this
3399 is not guaranteed to be unique unless we keep a handle open
3400 all the time (even then there are situations where it is
3401 not unique). Reputedly, there are at most 48 bits of info
3402 (on NTFS, presumably less on FAT). */
e3b88685
EZ		 3403 fake_inode = info.nFileIndexHigh;
3404 fake_inode <<= 32;
3405 fake_inode += info.nFileIndexLow;
480b0c5b
GV		 3406 }
3407 else
3408 {
01f31dfb
AI		 3409 buf->st_nlink = 1;
3410 fake_inode = 0;
3411 }
3412
93e0f0da 3413 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
01f31dfb 3414 {
e3b88685 3415 buf->st_mode = S_IFDIR;
93e0f0da
JR		 3416 }
3417 else
3418 {
3419 switch (GetFileType (fh))
3420 {
3421 case FILE_TYPE_DISK:
e3b88685 3422 buf->st_mode = S_IFREG;
93e0f0da
JR		 3423 break;
3424 case FILE_TYPE_PIPE:
e3b88685 3425 buf->st_mode = S_IFIFO;
93e0f0da
JR		 3426 break;
3427 case FILE_TYPE_CHAR:
3428 case FILE_TYPE_UNKNOWN:
3429 default:
e3b88685 3430 buf->st_mode = S_IFCHR;
93e0f0da 3431 }
480b0c5b 3432 }
01f31dfb 3433 CloseHandle (fh);
8aaaec6b
EZ		 3434 psd = get_file_security_desc (name);
3435 get_file_owner_and_group (psd, name, buf);
76b3903d
GV		 3436 }
3437 else
3438 {
3439 /* Don't bother to make this information more accurate. */
93e0f0da 3440 buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
e3b88685 3441 S_IFDIR : S_IFREG;
480b0c5b 3442 buf->st_nlink = 1;
76b3903d 3443 fake_inode = 0;
8aaaec6b
EZ		 3444
3445 get_file_owner_and_group (NULL, name, buf);
76b3903d 3446 }
70fdbb46 3447 xfree (psd);
76b3903d
GV		 3448
3449#if 0
3450 /* Not sure if there is any point in this. */
3451 if (!NILP (Vw32_generate_fake_inodes))
3452 fake_inode = generate_inode_val (name);
3453 else if (fake_inode == 0)
3454 {
3455 /* For want of something better, try to make everything unique. */
3456 static DWORD gen_num = 0;
3457 fake_inode = ++gen_num;
480b0c5b 3458 }
76b3903d
GV		 3459#endif
3460
3461 /* MSVC defines _ino_t to be short; other libc's might not. */
3462 if (sizeof (buf->st_ino) == 2)
3463 buf->st_ino = fake_inode ^ (fake_inode >> 16);
3464 else
3465 buf->st_ino = fake_inode;
480b0c5b 3466
fbd6baed 3467 /* volume_info is set indirectly by map_w32_filename */
480b0c5b
GV		 3468 buf->st_dev = volume_info.serialnum;
3469 buf->st_rdev = volume_info.serialnum;
3470
480b0c5b 3471
8aaaec6b
EZ		 3472 buf->st_size = wfd.nFileSizeHigh;
3473 buf->st_size <<= 32;
3474 buf->st_size += wfd.nFileSizeLow;
480b0c5b
GV		 3475
3476 /* Convert timestamps to Unix format. */
3477 buf->st_mtime = convert_time (wfd.ftLastWriteTime);
3478 buf->st_atime = convert_time (wfd.ftLastAccessTime);
3479 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
3480 buf->st_ctime = convert_time (wfd.ftCreationTime);
3481 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
3482
3483 /* determine rwx permissions */
3484 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
e3b88685 3485 permission = S_IREAD;
480b0c5b 3486 else
e3b88685 3487 permission = S_IREAD | S_IWRITE;
177c0ea7 3488
480b0c5b 3489 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
e3b88685 3490 permission |= S_IEXEC;
b3308d2e 3491 else if (is_exec (name))
e3b88685 3492 permission |= S_IEXEC;
480b0c5b
GV		 3493
3494 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
3495
3496 return 0;
3497}
3498
16bb7578
GV		 3499/* Provide fstat and utime as well as stat for consistent handling of
3500 file timestamps. */
3501int
3502fstat (int desc, struct stat * buf)
3503{
3504 HANDLE fh = (HANDLE) _get_osfhandle (desc);
3505 BY_HANDLE_FILE_INFORMATION info;
e3b88685 3506 unsigned __int64 fake_inode;
16bb7578
GV		 3507 int permission;
3508
3509 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
3510 {
3511 case FILE_TYPE_DISK:
e3b88685 3512 buf->st_mode = S_IFREG;
16bb7578
GV		 3513 if (!GetFileInformationByHandle (fh, &info))
3514 {
3515 errno = EACCES;
3516 return -1;
3517 }
3518 break;
3519 case FILE_TYPE_PIPE:
e3b88685 3520 buf->st_mode = S_IFIFO;
16bb7578
GV		 3521 goto non_disk;
3522 case FILE_TYPE_CHAR:
3523 case FILE_TYPE_UNKNOWN:
3524 default:
e3b88685 3525 buf->st_mode = S_IFCHR;
16bb7578
GV		 3526 non_disk:
3527 memset (&info, 0, sizeof (info));
3528 info.dwFileAttributes = 0;
3529 info.ftCreationTime = utc_base_ft;
3530 info.ftLastAccessTime = utc_base_ft;
3531 info.ftLastWriteTime = utc_base_ft;
3532 }
3533
3534 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
e3b88685 3535 buf->st_mode = S_IFDIR;
93e0f0da
JR		 3536
3537 buf->st_nlink = info.nNumberOfLinks;
3538 /* Might as well use file index to fake inode values, but this
3539 is not guaranteed to be unique unless we keep a handle open
3540 all the time (even then there are situations where it is
3541 not unique). Reputedly, there are at most 48 bits of info
3542 (on NTFS, presumably less on FAT). */
e3b88685
EZ		 3543 fake_inode = info.nFileIndexHigh;
3544 fake_inode <<= 32;
3545 fake_inode += info.nFileIndexLow;
16bb7578
GV		 3546
3547 /* MSVC defines _ino_t to be short; other libc's might not. */
3548 if (sizeof (buf->st_ino) == 2)
3549 buf->st_ino = fake_inode ^ (fake_inode >> 16);
3550 else
3551 buf->st_ino = fake_inode;
3552
8aaaec6b
EZ		 3553 /* Consider files to belong to current user.
3554 FIXME: this should use GetSecurityInfo API, but it is only
3555 available for _WIN32_WINNT >= 0x501. */
07f7980a
EZ		 3556 buf->st_uid = dflt_passwd.pw_uid;
3557 buf->st_gid = dflt_passwd.pw_gid;
8aaaec6b
EZ		 3558 strcpy (buf->st_uname, dflt_passwd.pw_name);
3559 strcpy (buf->st_gname, dflt_group.gr_name);
16bb7578
GV		 3560
3561 buf->st_dev = info.dwVolumeSerialNumber;
3562 buf->st_rdev = info.dwVolumeSerialNumber;
3563
8aaaec6b
EZ		 3564 buf->st_size = info.nFileSizeHigh;
3565 buf->st_size <<= 32;
3566 buf->st_size += info.nFileSizeLow;
16bb7578
GV		 3567
3568 /* Convert timestamps to Unix format. */
3569 buf->st_mtime = convert_time (info.ftLastWriteTime);
3570 buf->st_atime = convert_time (info.ftLastAccessTime);
3571 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
3572 buf->st_ctime = convert_time (info.ftCreationTime);
3573 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
3574
3575 /* determine rwx permissions */
3576 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
e3b88685 3577 permission = S_IREAD;
16bb7578 3578 else
e3b88685 3579 permission = S_IREAD | S_IWRITE;
177c0ea7 3580
16bb7578 3581 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
e3b88685 3582 permission |= S_IEXEC;
16bb7578
GV		 3583 else
3584 {
3585#if 0 /* no way of knowing the filename */
3586 char * p = strrchr (name, '.');
3587 if (p != NULL &&
05131107
JR		 3588 (xstrcasecmp (p, ".exe") == 0 ||
3589 xstrcasecmp (p, ".com") == 0 ||
3590 xstrcasecmp (p, ".bat") == 0 ||
3591 xstrcasecmp (p, ".cmd") == 0))
e3b88685 3592 permission |= S_IEXEC;
16bb7578
GV		 3593#endif
3594 }
3595
3596 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
3597
3598 return 0;
3599}
3600
3601int
3602utime (const char *name, struct utimbuf *times)
3603{
3604 struct utimbuf deftime;
3605 HANDLE fh;
3606 FILETIME mtime;
3607 FILETIME atime;
3608
3609 if (times == NULL)
3610 {
3611 deftime.modtime = deftime.actime = time (NULL);
3612 times = &deftime;
3613 }
3614
3615 /* Need write access to set times. */
3616 fh = CreateFile (name, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
3617 0, OPEN_EXISTING, 0, NULL);
3618 if (fh)
3619 {
3620 convert_from_time_t (times->actime, &atime);
3621 convert_from_time_t (times->modtime, &mtime);
3622 if (!SetFileTime (fh, NULL, &atime, &mtime))
3623 {
3624 CloseHandle (fh);
3625 errno = EACCES;
3626 return -1;
3627 }
3628 CloseHandle (fh);
3629 }
3630 else
3631 {
3632 errno = EINVAL;
3633 return -1;
3634 }
3635 return 0;
3636}
3637
7c80d5ec
EZ		 3638\f
3639/* Support for browsing other processes and their attributes. See
3640 process.c for the Lisp bindings. */
3641
3642/* Helper wrapper functions. */
3643
9d4f32e8
JB		 3644HANDLE WINAPI
3645create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
7c80d5ec
EZ		 3646{
3647 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
3648
3649 if (g_b_init_create_toolhelp32_snapshot == 0)
3650 {
3651 g_b_init_create_toolhelp32_snapshot = 1;
3652 s_pfn_Create_Toolhelp32_Snapshot = (CreateToolhelp32Snapshot_Proc)
3653 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3654 "CreateToolhelp32Snapshot");
3655 }
3656 if (s_pfn_Create_Toolhelp32_Snapshot == NULL)
3657 {
3658 return INVALID_HANDLE_VALUE;
3659 }
3660 return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
3661}
3662
9d4f32e8
JB		 3663BOOL WINAPI
3664process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
7c80d5ec
EZ		 3665{
3666 static Process32First_Proc s_pfn_Process32_First = NULL;
3667
3668 if (g_b_init_process32_first == 0)
3669 {
3670 g_b_init_process32_first = 1;
3671 s_pfn_Process32_First = (Process32First_Proc)
3672 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3673 "Process32First");
3674 }
3675 if (s_pfn_Process32_First == NULL)
3676 {
3677 return FALSE;
3678 }
3679 return (s_pfn_Process32_First (hSnapshot, lppe));
3680}
3681
9d4f32e8
JB		 3682BOOL WINAPI
3683process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
7c80d5ec
EZ		 3684{
3685 static Process32Next_Proc s_pfn_Process32_Next = NULL;
3686
3687 if (g_b_init_process32_next == 0)
3688 {
3689 g_b_init_process32_next = 1;
3690 s_pfn_Process32_Next = (Process32Next_Proc)
3691 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3692 "Process32Next");
3693 }
3694 if (s_pfn_Process32_Next == NULL)
3695 {
3696 return FALSE;
3697 }
3698 return (s_pfn_Process32_Next (hSnapshot, lppe));
3699}
3700
9d4f32e8
JB		 3701BOOL WINAPI
3702open_thread_token (HANDLE ThreadHandle,
3703 DWORD DesiredAccess,
3704 BOOL OpenAsSelf,
3705 PHANDLE TokenHandle)
7c80d5ec
EZ		 3706{
3707 static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
3708 HMODULE hm_advapi32 = NULL;
3709 if (is_windows_9x () == TRUE)
3710 {
3711 SetLastError (ERROR_NOT_SUPPORTED);
3712 return FALSE;
3713 }
3714 if (g_b_init_open_thread_token == 0)
3715 {
3716 g_b_init_open_thread_token = 1;
3717 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3718 s_pfn_Open_Thread_Token =
3719 (OpenThreadToken_Proc) GetProcAddress (hm_advapi32, "OpenThreadToken");
3720 }
3721 if (s_pfn_Open_Thread_Token == NULL)
3722 {
3723 SetLastError (ERROR_NOT_SUPPORTED);
3724 return FALSE;
3725 }
3726 return (
3727 s_pfn_Open_Thread_Token (
3728 ThreadHandle,
3729 DesiredAccess,
3730 OpenAsSelf,
3731 TokenHandle)
3732 );
3733}
3734
9d4f32e8
JB		 3735BOOL WINAPI
3736impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
7c80d5ec
EZ		 3737{
3738 static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
3739 HMODULE hm_advapi32 = NULL;
3740 if (is_windows_9x () == TRUE)
3741 {
3742 return FALSE;
3743 }
3744 if (g_b_init_impersonate_self == 0)
3745 {
3746 g_b_init_impersonate_self = 1;
3747 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3748 s_pfn_Impersonate_Self =
3749 (ImpersonateSelf_Proc) GetProcAddress (hm_advapi32, "ImpersonateSelf");
3750 }
3751 if (s_pfn_Impersonate_Self == NULL)
3752 {
3753 return FALSE;
3754 }
3755 return s_pfn_Impersonate_Self (ImpersonationLevel);
3756}
3757
9d4f32e8
JB		 3758BOOL WINAPI
3759revert_to_self (void)
7c80d5ec
EZ		 3760{
3761 static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
3762 HMODULE hm_advapi32 = NULL;
3763 if (is_windows_9x () == TRUE)
3764 {
3765 return FALSE;
3766 }
3767 if (g_b_init_revert_to_self == 0)
3768 {
3769 g_b_init_revert_to_self = 1;
3770 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3771 s_pfn_Revert_To_Self =
3772 (RevertToSelf_Proc) GetProcAddress (hm_advapi32, "RevertToSelf");
3773 }
3774 if (s_pfn_Revert_To_Self == NULL)
3775 {
3776 return FALSE;
3777 }
3778 return s_pfn_Revert_To_Self ();
3779}
3780
9d4f32e8
JB		 3781BOOL WINAPI
3782get_process_memory_info (HANDLE h_proc,
3783 PPROCESS_MEMORY_COUNTERS mem_counters,
3784 DWORD bufsize)
7c80d5ec
EZ		 3785{
3786 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
3787 HMODULE hm_psapi = NULL;
3788 if (is_windows_9x () == TRUE)
3789 {
3790 return FALSE;
3791 }
3792 if (g_b_init_get_process_memory_info == 0)
3793 {
3794 g_b_init_get_process_memory_info = 1;
3795 hm_psapi = LoadLibrary ("Psapi.dll");
3796 if (hm_psapi)
3797 s_pfn_Get_Process_Memory_Info = (GetProcessMemoryInfo_Proc)
3798 GetProcAddress (hm_psapi, "GetProcessMemoryInfo");
3799 }
3800 if (s_pfn_Get_Process_Memory_Info == NULL)
3801 {
3802 return FALSE;
3803 }
3804 return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
3805}
3806
9d4f32e8
JB		 3807BOOL WINAPI
3808get_process_working_set_size (HANDLE h_proc, DWORD *minrss, DWORD *maxrss)
7c80d5ec
EZ		 3809{
3810 static GetProcessWorkingSetSize_Proc
3811 s_pfn_Get_Process_Working_Set_Size = NULL;
3812
3813 if (is_windows_9x () == TRUE)
3814 {
3815 return FALSE;
3816 }
3817 if (g_b_init_get_process_working_set_size == 0)
3818 {
3819 g_b_init_get_process_working_set_size = 1;
3820 s_pfn_Get_Process_Working_Set_Size = (GetProcessWorkingSetSize_Proc)
3821 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3822 "GetProcessWorkingSetSize");
3823 }
3824 if (s_pfn_Get_Process_Working_Set_Size == NULL)
3825 {
3826 return FALSE;
3827 }
3828 return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
3829}
3830
9d4f32e8
JB		 3831BOOL WINAPI
3832global_memory_status (MEMORYSTATUS *buf)
7c80d5ec
EZ		 3833{
3834 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
3835
3836 if (is_windows_9x () == TRUE)
3837 {
3838 return FALSE;
3839 }
3840 if (g_b_init_global_memory_status == 0)
3841 {
3842 g_b_init_global_memory_status = 1;
3843 s_pfn_Global_Memory_Status = (GlobalMemoryStatus_Proc)
3844 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3845 "GlobalMemoryStatus");
3846 }
3847 if (s_pfn_Global_Memory_Status == NULL)
3848 {
3849 return FALSE;
3850 }
3851 return s_pfn_Global_Memory_Status (buf);
3852}
3853
9d4f32e8
JB		 3854BOOL WINAPI
3855global_memory_status_ex (MEMORY_STATUS_EX *buf)
7c80d5ec
EZ		 3856{
3857 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
3858
3859 if (is_windows_9x () == TRUE)
3860 {
3861 return FALSE;
3862 }
3863 if (g_b_init_global_memory_status_ex == 0)
3864 {
3865 g_b_init_global_memory_status_ex = 1;
3866 s_pfn_Global_Memory_Status_Ex = (GlobalMemoryStatusEx_Proc)
3867 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3868 "GlobalMemoryStatusEx");
3869 }
3870 if (s_pfn_Global_Memory_Status_Ex == NULL)
3871 {
3872 return FALSE;
3873 }
3874 return s_pfn_Global_Memory_Status_Ex (buf);
3875}
3876
3877Lisp_Object
06e111a6 3878list_system_processes ()
7c80d5ec
EZ		 3879{
3880 struct gcpro gcpro1;
3881 Lisp_Object proclist = Qnil;
3882 HANDLE h_snapshot;
3883
3884 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
3885
3886 if (h_snapshot != INVALID_HANDLE_VALUE)
3887 {
3888 PROCESSENTRY32 proc_entry;
3889 DWORD proc_id;
3890 BOOL res;
3891
3892 GCPRO1 (proclist);
3893
3894 proc_entry.dwSize = sizeof (PROCESSENTRY32);
3895 for (res = process32_first (h_snapshot, &proc_entry); res;
3896 res = process32_next (h_snapshot, &proc_entry))
3897 {
3898 proc_id = proc_entry.th32ProcessID;
3899 proclist = Fcons (make_fixnum_or_float (proc_id), proclist);
3900 }
3901
3902 CloseHandle (h_snapshot);
3903 UNGCPRO;
3904 proclist = Fnreverse (proclist);
3905 }
3906
3907 return proclist;
3908}
3909
3910static int
3911enable_privilege (LPCTSTR priv_name, BOOL enable_p, TOKEN_PRIVILEGES *old_priv)
3912{
3913 TOKEN_PRIVILEGES priv;
3914 DWORD priv_size = sizeof (priv);
3915 DWORD opriv_size = sizeof (*old_priv);
3916 HANDLE h_token = NULL;
3917 HANDLE h_thread = GetCurrentThread ();
3918 int ret_val = 0;
3919 BOOL res;
3920
3921 res = open_thread_token (h_thread,
3922 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3923 FALSE, &h_token);
3924 if (!res && GetLastError () == ERROR_NO_TOKEN)
3925 {
3926 if (impersonate_self (SecurityImpersonation))
3927 res = open_thread_token (h_thread,
3928 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3929 FALSE, &h_token);
3930 }
3931 if (res)
3932 {
3933 priv.PrivilegeCount = 1;
3934 priv.Privileges[0].Attributes = enable_p ? SE_PRIVILEGE_ENABLED : 0;
3935 LookupPrivilegeValue (NULL, priv_name, &priv.Privileges[0].Luid);
3936 if (AdjustTokenPrivileges (h_token, FALSE, &priv, priv_size,
3937 old_priv, &opriv_size)
3938 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
3939 ret_val = 1;
3940 }
3941 if (h_token)
3942 CloseHandle (h_token);
3943
3944 return ret_val;
3945}
3946
3947static int
3948restore_privilege (TOKEN_PRIVILEGES *priv)
3949{
3950 DWORD priv_size = sizeof (*priv);
3951 HANDLE h_token = NULL;
3952 int ret_val = 0;
3953
3954 if (open_thread_token (GetCurrentThread (),
3955 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3956 FALSE, &h_token))
3957 {
3958 if (AdjustTokenPrivileges (h_token, FALSE, priv, priv_size, NULL, NULL)
3959 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
3960 ret_val = 1;
3961 }
3962 if (h_token)
3963 CloseHandle (h_token);
3964
3965 return ret_val;
3966}
3967
3968static Lisp_Object
3969ltime (time_sec, time_usec)
3970 long time_sec, time_usec;
3971{
3972 return list3 (make_number ((time_sec >> 16) & 0xffff),
3973 make_number (time_sec & 0xffff),
3974 make_number (time_usec));
3975}
3976
5da9424d
JB		 3977#define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
3978
7c80d5ec 3979static int
031da700 3980process_times (h_proc, ctime, etime, stime, utime, ttime, pcpu)
7c80d5ec 3981 HANDLE h_proc;
031da700 3982 Lisp_Object *ctime, *etime, *stime, *utime, *ttime;
7c80d5ec
EZ		 3983 double *pcpu;
3984{
3985 FILETIME ft_creation, ft_exit, ft_kernel, ft_user, ft_current;
5da9424d 3986 ULONGLONG tem1, tem2, tem3, tem;
7c80d5ec
EZ		 3987
3988 if (!h_proc
3989 || !get_process_times_fn
9d4f32e8
JB		 3990 || !(*get_process_times_fn) (h_proc, &ft_creation, &ft_exit,
3991 &ft_kernel, &ft_user))
7c80d5ec
EZ		 3992 return 0;
3993
3994 GetSystemTimeAsFileTime (&ft_current);
3995
5da9424d
JB		 3996 FILETIME_TO_U64 (tem1, ft_kernel);
3997 tem1 /= 10L;
3998 *stime = U64_TO_LISP_TIME (tem1);
3999
4000 FILETIME_TO_U64 (tem2, ft_user);
4001 tem2 /= 10L;
4002 *utime = U64_TO_LISP_TIME (tem2);
4003
4004 tem3 = tem1 + tem2;
4005 *ttime = U64_TO_LISP_TIME (tem3);
4006
4007 FILETIME_TO_U64 (tem, ft_creation);
3af03101
EZ		 4008 /* Process no 4 (System) returns zero creation time. */
4009 if (tem)
5da9424d
JB		 4010 tem = (tem - utc_base) / 10L;
4011 *ctime = U64_TO_LISP_TIME (tem);
4012
3af03101 4013 if (tem)
5da9424d
JB		 4014 {
4015 FILETIME_TO_U64 (tem3, ft_current);
4016 tem = (tem3 - utc_base) / 10L - tem;
4017 }
4018 *etime = U64_TO_LISP_TIME (tem);
7c80d5ec 4019
3af03101
EZ		 4020 if (tem)
4021 {
4022 *pcpu = 100.0 * (tem1 + tem2) / tem;
4023 if (*pcpu > 100)
4024 *pcpu = 100.0;
4025 }
4026 else
4027 *pcpu = 0;
4028
4029 return 1;
7c80d5ec
EZ		 4030}
4031
4032Lisp_Object
06e111a6 4033system_process_attributes (pid)
7c80d5ec
EZ		 4034 Lisp_Object pid;
4035{
4036 struct gcpro gcpro1, gcpro2, gcpro3;
4037 Lisp_Object attrs = Qnil;
4038 Lisp_Object cmd_str, decoded_cmd, tem;
4039 HANDLE h_snapshot, h_proc;
4040 DWORD proc_id;
754a2d13 4041 int found_proc = 0;
7c80d5ec 4042 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
32cef06e 4043 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
7c80d5ec
EZ		 4044 DWORD glength = sizeof (gname);
4045 HANDLE token = NULL;
4046 SID_NAME_USE user_type;
32cef06e
EZ		 4047 unsigned char *buf = NULL;
4048 DWORD blen = 0;
7c80d5ec
EZ		 4049 TOKEN_USER user_token;
4050 TOKEN_PRIMARY_GROUP group_token;
22749e9a
EZ		 4051 unsigned euid;
4052 unsigned egid;
7c80d5ec
EZ		 4053 DWORD sess;
4054 PROCESS_MEMORY_COUNTERS mem;
4055 PROCESS_MEMORY_COUNTERS_EX mem_ex;
4056 DWORD minrss, maxrss;
4057 MEMORYSTATUS memst;
b8526f6e 4058 MEMORY_STATUS_EX memstex;
7c80d5ec 4059 double totphys = 0.0;
031da700 4060 Lisp_Object ctime, stime, utime, etime, ttime;
7c80d5ec 4061 double pcpu;
32cef06e 4062 BOOL result = FALSE;
7c80d5ec
EZ		 4063
4064 CHECK_NUMBER_OR_FLOAT (pid);
4065 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
4066
4067 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
4068
4069 GCPRO3 (attrs, decoded_cmd, tem);
4070
4071 if (h_snapshot != INVALID_HANDLE_VALUE)
4072 {
4073 PROCESSENTRY32 pe;
4074 BOOL res;
4075
4076 pe.dwSize = sizeof (PROCESSENTRY32);
4077 for (res = process32_first (h_snapshot, &pe); res;
4078 res = process32_next (h_snapshot, &pe))
4079 {
4080 if (proc_id == pe.th32ProcessID)
4081 {
4082 if (proc_id == 0)
4083 decoded_cmd = build_string ("Idle");
4084 else
4085 {
4086 /* Decode the command name from locale-specific
4087 encoding. */
4088 cmd_str = make_unibyte_string (pe.szExeFile,
4089 strlen (pe.szExeFile));
4090 decoded_cmd =
4091 code_convert_string_norecord (cmd_str,
4092 Vlocale_coding_system, 0);
4093 }
4094 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
4095 attrs = Fcons (Fcons (Qppid,
4096 make_fixnum_or_float (pe.th32ParentProcessID)),
4097 attrs);
4098 attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
4099 attrs);
4100 attrs = Fcons (Fcons (Qthcount,
4101 make_fixnum_or_float (pe.cntThreads)),
4102 attrs);
754a2d13 4103 found_proc = 1;
7c80d5ec
EZ		 4104 break;
4105 }
4106 }
4107
4108 CloseHandle (h_snapshot);
4109 }
4110
754a2d13
EZ		 4111 if (!found_proc)
4112 {
4113 UNGCPRO;
4114 return Qnil;
4115 }
4116
7c80d5ec
EZ		 4117 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4118 FALSE, proc_id);
4119 /* If we were denied a handle to the process, try again after
4120 enabling the SeDebugPrivilege in our process. */
4121 if (!h_proc)
4122 {
4123 TOKEN_PRIVILEGES priv_current;
4124
4125 if (enable_privilege (SE_DEBUG_NAME, TRUE, &priv_current))
4126 {
4127 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4128 FALSE, proc_id);
4129 restore_privilege (&priv_current);
4130 revert_to_self ();
4131 }
4132 }
32cef06e 4133 if (h_proc)
7c80d5ec 4134 {
32cef06e
EZ		 4135 result = open_process_token (h_proc, TOKEN_QUERY, &token);
4136 if (result)
f8b35b24 4137 {
32cef06e
EZ		 4138 result = get_token_information (token, TokenUser, NULL, 0, &blen);
4139 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
4140 {
4141 buf = xmalloc (blen);
4142 result = get_token_information (token, TokenUser,
4143 (LPVOID)buf, blen, &needed);
4144 if (result)
4145 {
4146 memcpy (&user_token, buf, sizeof (user_token));
4147 if (!w32_cached_id (user_token.User.Sid, &euid, uname))
4148 {
4149 euid = get_rid (user_token.User.Sid);
4150 result = lookup_account_sid (NULL, user_token.User.Sid,
4151 uname, &ulength,
4152 domain, &dlength,
4153 &user_type);
4154 if (result)
4155 w32_add_to_cache (user_token.User.Sid, euid, uname);
4156 else
4157 {
4158 strcpy (uname, "unknown");
4159 result = TRUE;
4160 }
4161 }
4162 ulength = strlen (uname);
4163 }
4164 }
7c80d5ec 4165 }
32cef06e 4166 if (result)
7c80d5ec 4167 {
32cef06e
EZ		 4168 /* Determine a reasonable euid and gid values. */
4169 if (xstrcasecmp ("administrator", uname) == 0)
7c80d5ec 4170 {
32cef06e
EZ		 4171 euid = 500; /* well-known Administrator uid */
4172 egid = 513; /* well-known None gid */
4173 }
4174 else
4175 {
4176 /* Get group id and name. */
4177 result = get_token_information (token, TokenPrimaryGroup,
4178 (LPVOID)buf, blen, &needed);
4179 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
f8b35b24 4180 {
32cef06e
EZ		 4181 buf = xrealloc (buf, blen = needed);
4182 result = get_token_information (token, TokenPrimaryGroup,
4183 (LPVOID)buf, blen, &needed);
4184 }
4185 if (result)
4186 {
4187 memcpy (&group_token, buf, sizeof (group_token));
4188 if (!w32_cached_id (group_token.PrimaryGroup, &egid, gname))
4189 {
4190 egid = get_rid (group_token.PrimaryGroup);
4191 dlength = sizeof (domain);
4192 result =
4193 lookup_account_sid (NULL, group_token.PrimaryGroup,
4194 gname, &glength, NULL, &dlength,
4195 &user_type);
4196 if (result)
4197 w32_add_to_cache (group_token.PrimaryGroup,
4198 egid, gname);
4199 else
4200 {
4201 strcpy (gname, "None");
4202 result = TRUE;
4203 }
4204 }
4205 glength = strlen (gname);
f8b35b24 4206 }
7c80d5ec 4207 }
7c80d5ec 4208 }
5f445726 4209 xfree (buf);
7c80d5ec 4210 }
32cef06e 4211 if (!result)
7c80d5ec 4212 {
32cef06e
EZ		 4213 if (!is_windows_9x ())
4214 {
4215 /* We couldn't open the process token, presumably because of
4216 insufficient access rights. Assume this process is run
4217 by the system. */
4218 strcpy (uname, "SYSTEM");
4219 strcpy (gname, "None");
4220 euid = 18; /* SYSTEM */
4221 egid = 513; /* None */
4222 glength = strlen (gname);
4223 ulength = strlen (uname);
4224 }
4225 /* If we are running under Windows 9X, where security calls are
4226 not supported, we assume all processes are run by the current
4227 user. */
4228 else if (GetUserName (uname, &ulength))
4229 {
4230 if (xstrcasecmp ("administrator", uname) == 0)
4231 euid = 0;
4232 else
4233 euid = 123;
4234 egid = euid;
4235 strcpy (gname, "None");
4236 glength = strlen (gname);
4237 ulength = strlen (uname);
4238 }
7c80d5ec 4239 else
32cef06e
EZ		 4240 {
4241 euid = 123;
4242 egid = 123;
4243 strcpy (uname, "administrator");
4244 ulength = strlen (uname);
4245 strcpy (gname, "None");
4246 glength = strlen (gname);
4247 }
4248 if (token)
4249 CloseHandle (token);
7c80d5ec 4250 }
7c80d5ec
EZ		 4251
4252 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (euid)), attrs);
4253 tem = make_unibyte_string (uname, ulength);
4254 attrs = Fcons (Fcons (Quser,
4255 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
4256 attrs);
4257 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (egid)), attrs);
4258 tem = make_unibyte_string (gname, glength);
4259 attrs = Fcons (Fcons (Qgroup,
4260 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
4261 attrs);
4262
4263 if (global_memory_status_ex (&memstex))
235661f6 4264#if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
7c80d5ec 4265 totphys = memstex.ullTotalPhys / 1024.0;
235661f6
EZ		 4266#else
4267 /* Visual Studio 6 cannot convert an unsigned __int64 type to
4268 double, so we need to do this for it... */
4269 {
4270 DWORD tot_hi = memstex.ullTotalPhys >> 32;
4271 DWORD tot_md = (memstex.ullTotalPhys & 0x00000000ffffffff) >> 10;
4272 DWORD tot_lo = memstex.ullTotalPhys % 1024;
4273
4274 totphys = tot_hi * 4194304.0 + tot_md + tot_lo / 1024.0;
4275 }
4276#endif /* __GNUC__ || _MSC_VER >= 1300 */
7c80d5ec
EZ		 4277 else if (global_memory_status (&memst))
4278 totphys = memst.dwTotalPhys / 1024.0;
4279
4280 if (h_proc
4281 && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
4282 sizeof (mem_ex)))
4283 {
4284 DWORD rss = mem_ex.WorkingSetSize / 1024;
4285
4286 attrs = Fcons (Fcons (Qmajflt,
4287 make_fixnum_or_float (mem_ex.PageFaultCount)),
4288 attrs);
4289 attrs = Fcons (Fcons (Qvsize,
4290 make_fixnum_or_float (mem_ex.PrivateUsage / 1024)),
4291 attrs);
4292 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
4293 if (totphys)
4294 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4295 }
4296 else if (h_proc
4297 && get_process_memory_info (h_proc, &mem, sizeof (mem)))
4298 {
4299 DWORD rss = mem_ex.WorkingSetSize / 1024;
4300
4301 attrs = Fcons (Fcons (Qmajflt,
4302 make_fixnum_or_float (mem.PageFaultCount)),
4303 attrs);
4304 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
4305 if (totphys)
4306 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4307 }
4308 else if (h_proc
4309 && get_process_working_set_size (h_proc, &minrss, &maxrss))
4310 {
4311 DWORD rss = maxrss / 1024;
4312
4313 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (maxrss / 1024)), attrs);
4314 if (totphys)
4315 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4316 }
4317
031da700 4318 if (process_times (h_proc, &ctime, &etime, &stime, &utime, &ttime, &pcpu))
7c80d5ec
EZ		 4319 {
4320 attrs = Fcons (Fcons (Qutime, utime), attrs);
4321 attrs = Fcons (Fcons (Qstime, stime), attrs);
031da700 4322 attrs = Fcons (Fcons (Qtime, ttime), attrs);
7c80d5ec
EZ		 4323 attrs = Fcons (Fcons (Qstart, ctime), attrs);
4324 attrs = Fcons (Fcons (Qetime, etime), attrs);
4325 attrs = Fcons (Fcons (Qpcpu, make_float (pcpu)), attrs);
4326 }
4327
4328 /* FIXME: Retrieve command line by walking the PEB of the process. */
4329
4330 if (h_proc)
4331 CloseHandle (h_proc);
4332 UNGCPRO;
4333 return attrs;
4334}
4335
4336\f
480b0c5b
GV		 4337#ifdef HAVE_SOCKETS
4338
4339/* Wrappers for winsock functions to map between our file descriptors
4340 and winsock's handles; also set h_errno for convenience.
4341
4342 To allow Emacs to run on systems which don't have winsock support
4343 installed, we dynamically link to winsock on startup if present, and
4344 otherwise provide the minimum necessary functionality
4345 (eg. gethostname). */
4346
4347/* function pointers for relevant socket functions */
4348int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
4349void (PASCAL *pfn_WSASetLastError) (int iError);
4350int (PASCAL *pfn_WSAGetLastError) (void);
26fb7bc4 4351int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
64570b36
KS		 4352HANDLE (PASCAL *pfn_WSACreateEvent) (void);
4353int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
480b0c5b
GV		 4354int (PASCAL *pfn_socket) (int af, int type, int protocol);
4355int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
4356int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
4357int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
4358int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
4359int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
4360int (PASCAL *pfn_closesocket) (SOCKET s);
4361int (PASCAL *pfn_shutdown) (SOCKET s, int how);
4362int (PASCAL *pfn_WSACleanup) (void);
4363
4364u_short (PASCAL *pfn_htons) (u_short hostshort);
4365u_short (PASCAL *pfn_ntohs) (u_short netshort);
4366unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
4367int (PASCAL *pfn_gethostname) (char * name, int namelen);
4368struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
4369struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
ecd270eb 4370int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
962955c5
JR		 4371int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
4372 const char * optval, int optlen);
4373int (PASCAL *pfn_listen) (SOCKET s, int backlog);
4374int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
4375 int * namelen);
4376SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
4377int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
4378 struct sockaddr * from, int * fromlen);
4379int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
4380 const struct sockaddr * to, int tolen);
4381
f1614061
RS		 4382/* SetHandleInformation is only needed to make sockets non-inheritable. */
4383BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
4384#ifndef HANDLE_FLAG_INHERIT
4385#define HANDLE_FLAG_INHERIT 1
4386#endif
480b0c5b 4387
f249a012
RS		 4388HANDLE winsock_lib;
4389static int winsock_inuse;
480b0c5b 4390
f249a012 4391BOOL
480b0c5b
GV		 4392term_winsock (void)
4393{
f249a012 4394 if (winsock_lib != NULL && winsock_inuse == 0)
480b0c5b 4395 {
f249a012
RS		 4396 /* Not sure what would cause WSAENETDOWN, or even if it can happen
4397 after WSAStartup returns successfully, but it seems reasonable
4398 to allow unloading winsock anyway in that case. */
4399 if (pfn_WSACleanup () == 0 ||
4400 pfn_WSAGetLastError () == WSAENETDOWN)
4401 {
4402 if (FreeLibrary (winsock_lib))
4403 winsock_lib = NULL;
4404 return TRUE;
4405 }
480b0c5b 4406 }
f249a012 4407 return FALSE;
480b0c5b
GV		 4408}
4409
f249a012
RS		 4410BOOL
4411init_winsock (int load_now)
480b0c5b
GV		 4412{
4413 WSADATA winsockData;
4414
f249a012
RS		 4415 if (winsock_lib != NULL)
4416 return TRUE;
f1614061
RS		 4417
4418 pfn_SetHandleInformation = NULL;
4419 pfn_SetHandleInformation
4420 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
4421 "SetHandleInformation");
4422
64570b36 4423 winsock_lib = LoadLibrary ("Ws2_32.dll");
480b0c5b
GV		 4424
4425 if (winsock_lib != NULL)
4426 {
4427 /* dynamically link to socket functions */
4428
4429#define LOAD_PROC(fn) \
4430 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
4431 goto fail;
4432
9d4f32e8
JB		 4433 LOAD_PROC (WSAStartup);
4434 LOAD_PROC (WSASetLastError);
4435 LOAD_PROC (WSAGetLastError);
4436 LOAD_PROC (WSAEventSelect);
4437 LOAD_PROC (WSACreateEvent);
4438 LOAD_PROC (WSACloseEvent);
4439 LOAD_PROC (socket);
4440 LOAD_PROC (bind);
4441 LOAD_PROC (connect);
4442 LOAD_PROC (ioctlsocket);
4443 LOAD_PROC (recv);
4444 LOAD_PROC (send);
4445 LOAD_PROC (closesocket);
4446 LOAD_PROC (shutdown);
4447 LOAD_PROC (htons);
4448 LOAD_PROC (ntohs);
4449 LOAD_PROC (inet_addr);
4450 LOAD_PROC (gethostname);
4451 LOAD_PROC (gethostbyname);
4452 LOAD_PROC (getservbyname);
4453 LOAD_PROC (getpeername);
4454 LOAD_PROC (WSACleanup);
4455 LOAD_PROC (setsockopt);
4456 LOAD_PROC (listen);
4457 LOAD_PROC (getsockname);
4458 LOAD_PROC (accept);
4459 LOAD_PROC (recvfrom);
4460 LOAD_PROC (sendto);
f249a012
RS		 4461#undef LOAD_PROC
4462
480b0c5b
GV		 4463 /* specify version 1.1 of winsock */
4464 if (pfn_WSAStartup (0x101, &winsockData) == 0)
4465 {
f249a012
RS		 4466 if (winsockData.wVersion != 0x101)
4467 goto fail;
4468
4469 if (!load_now)
4470 {
4471 /* Report that winsock exists and is usable, but leave
4472 socket functions disabled. I am assuming that calling
4473 WSAStartup does not require any network interaction,
4474 and in particular does not cause or require a dial-up
4475 connection to be established. */
4476
4477 pfn_WSACleanup ();
4478 FreeLibrary (winsock_lib);
4479 winsock_lib = NULL;
4480 }
4481 winsock_inuse = 0;
4482 return TRUE;
480b0c5b
GV		 4483 }
4484
4485 fail:
4486 FreeLibrary (winsock_lib);
f249a012 4487 winsock_lib = NULL;
480b0c5b 4488 }
f249a012
RS		 4489
4490 return FALSE;
480b0c5b
GV		 4491}
4492
4493
4494int h_errno = 0;
4495
f8381794 4496/* function to set h_errno for compatibility; map winsock error codes to
480b0c5b
GV		 4497 normal system codes where they overlap (non-overlapping definitions
4498 are already in <sys/socket.h> */
9bfb11f9
KS		 4499static void
4500set_errno ()
480b0c5b 4501{
f249a012 4502 if (winsock_lib == NULL)
480b0c5b
GV		 4503 h_errno = EINVAL;
4504 else
4505 h_errno = pfn_WSAGetLastError ();
4506
4507 switch (h_errno)
4508 {
4509 case WSAEACCES: h_errno = EACCES; break;
4510 case WSAEBADF: h_errno = EBADF; break;
4511 case WSAEFAULT: h_errno = EFAULT; break;
4512 case WSAEINTR: h_errno = EINTR; break;
4513 case WSAEINVAL: h_errno = EINVAL; break;
4514 case WSAEMFILE: h_errno = EMFILE; break;
4515 case WSAENAMETOOLONG: h_errno = ENAMETOOLONG; break;
4516 case WSAENOTEMPTY: h_errno = ENOTEMPTY; break;
4517 }
4518 errno = h_errno;
4519}
4520
9bfb11f9
KS		 4521static void
4522check_errno ()
480b0c5b 4523{
f249a012 4524 if (h_errno == 0 && winsock_lib != NULL)
480b0c5b
GV		 4525 pfn_WSASetLastError (0);
4526}
4527
d8fcc1b9
AI		 4528/* Extend strerror to handle the winsock-specific error codes. */
4529struct {
4530 int errnum;
4531 char * msg;
4532} _wsa_errlist[] = {
4533 WSAEINTR , "Interrupted function call",
4534 WSAEBADF , "Bad file descriptor",
4535 WSAEACCES , "Permission denied",
4536 WSAEFAULT , "Bad address",
4537 WSAEINVAL , "Invalid argument",
4538 WSAEMFILE , "Too many open files",
177c0ea7 4539
d8fcc1b9
AI		 4540 WSAEWOULDBLOCK , "Resource temporarily unavailable",
4541 WSAEINPROGRESS , "Operation now in progress",
4542 WSAEALREADY , "Operation already in progress",
4543 WSAENOTSOCK , "Socket operation on non-socket",
4544 WSAEDESTADDRREQ , "Destination address required",
4545 WSAEMSGSIZE , "Message too long",
4546 WSAEPROTOTYPE , "Protocol wrong type for socket",
4547 WSAENOPROTOOPT , "Bad protocol option",
4548 WSAEPROTONOSUPPORT , "Protocol not supported",
4549 WSAESOCKTNOSUPPORT , "Socket type not supported",
4550 WSAEOPNOTSUPP , "Operation not supported",
4551 WSAEPFNOSUPPORT , "Protocol family not supported",
4552 WSAEAFNOSUPPORT , "Address family not supported by protocol family",
4553 WSAEADDRINUSE , "Address already in use",
4554 WSAEADDRNOTAVAIL , "Cannot assign requested address",
4555 WSAENETDOWN , "Network is down",
4556 WSAENETUNREACH , "Network is unreachable",
4557 WSAENETRESET , "Network dropped connection on reset",
4558 WSAECONNABORTED , "Software caused connection abort",
4559 WSAECONNRESET , "Connection reset by peer",
4560 WSAENOBUFS , "No buffer space available",
4561 WSAEISCONN , "Socket is already connected",
4562 WSAENOTCONN , "Socket is not connected",
4563 WSAESHUTDOWN , "Cannot send after socket shutdown",
4564 WSAETOOMANYREFS , "Too many references", /* not sure */
4565 WSAETIMEDOUT , "Connection timed out",
4566 WSAECONNREFUSED , "Connection refused",
4567 WSAELOOP , "Network loop", /* not sure */
4568 WSAENAMETOOLONG , "Name is too long",
4569 WSAEHOSTDOWN , "Host is down",
4570 WSAEHOSTUNREACH , "No route to host",
4571 WSAENOTEMPTY , "Buffer not empty", /* not sure */
4572 WSAEPROCLIM , "Too many processes",
4573 WSAEUSERS , "Too many users", /* not sure */
4574 WSAEDQUOT , "Double quote in host name", /* really not sure */
4575 WSAESTALE , "Data is stale", /* not sure */
4576 WSAEREMOTE , "Remote error", /* not sure */
177c0ea7 4577
d8fcc1b9
AI		 4578 WSASYSNOTREADY , "Network subsystem is unavailable",
4579 WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range",
4580 WSANOTINITIALISED , "Winsock not initialized successfully",
4581 WSAEDISCON , "Graceful shutdown in progress",
4582#ifdef WSAENOMORE
4583 WSAENOMORE , "No more operations allowed", /* not sure */
4584 WSAECANCELLED , "Operation cancelled", /* not sure */
4585 WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider",
4586 WSAEINVALIDPROVIDER , "Invalid service provider version number",
4587 WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider",
aa5ee2a3 4588 WSASYSCALLFAILURE , "System call failure",
d8fcc1b9
AI		 4589 WSASERVICE_NOT_FOUND , "Service not found", /* not sure */
4590 WSATYPE_NOT_FOUND , "Class type not found",
4591 WSA_E_NO_MORE , "No more resources available", /* really not sure */
4592 WSA_E_CANCELLED , "Operation already cancelled", /* really not sure */
4593 WSAEREFUSED , "Operation refused", /* not sure */
4594#endif
177c0ea7 4595
d8fcc1b9
AI		 4596 WSAHOST_NOT_FOUND , "Host not found",
4597 WSATRY_AGAIN , "Authoritative host not found during name lookup",
4598 WSANO_RECOVERY , "Non-recoverable error during name lookup",
4599 WSANO_DATA , "Valid name, no data record of requested type",
4600
4601 -1, NULL
4602};
4603
4604char *
9d4f32e8 4605sys_strerror (int error_no)
d8fcc1b9
AI		 4606{
4607 int i;
4608 static char unknown_msg[40];
4609
a302c7ae
AI		 4610 if (error_no >= 0 && error_no < sys_nerr)
4611 return sys_errlist[error_no];
d8fcc1b9
AI		 4612
4613 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
4614 if (_wsa_errlist[i].errnum == error_no)
4615 return _wsa_errlist[i].msg;
4616
9d4f32e8 4617 sprintf (unknown_msg, "Unidentified error: %d", error_no);
d8fcc1b9
AI		 4618 return unknown_msg;
4619}
4620
480b0c5b
GV		 4621/* [andrewi 3-May-96] I've had conflicting results using both methods,
4622 but I believe the method of keeping the socket handle separate (and
4623 insuring it is not inheritable) is the correct one. */
4624
4625//#define SOCK_REPLACE_HANDLE
4626
4627#ifdef SOCK_REPLACE_HANDLE
4628#define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
4629#else
4630#define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
4631#endif
4632
962955c5
JR		 4633int socket_to_fd (SOCKET s);
4634
480b0c5b 4635int
9d4f32e8 4636sys_socket (int af, int type, int protocol)
480b0c5b 4637{
962955c5 4638 SOCKET s;
480b0c5b 4639
f249a012 4640 if (winsock_lib == NULL)
480b0c5b
GV		 4641 {
4642 h_errno = ENETDOWN;
4643 return INVALID_SOCKET;
4644 }
4645
4646 check_errno ();
4647
4648 /* call the real socket function */
962955c5 4649 s = pfn_socket (af, type, protocol);
177c0ea7 4650
480b0c5b 4651 if (s != INVALID_SOCKET)
962955c5 4652 return socket_to_fd (s);
480b0c5b 4653
962955c5
JR		 4654 set_errno ();
4655 return -1;
4656}
4657
4658/* Convert a SOCKET to a file descriptor. */
4659int
4660socket_to_fd (SOCKET s)
4661{
4662 int fd;
4663 child_process * cp;
4664
4665 /* Although under NT 3.5 _open_osfhandle will accept a socket
4666 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
4667 that does not work under NT 3.1. However, we can get the same
4668 effect by using a backdoor function to replace an existing
4669 descriptor handle with the one we want. */
4670
4671 /* allocate a file descriptor (with appropriate flags) */
4672 fd = _open ("NUL:", _O_RDWR);
4673 if (fd >= 0)
4674 {
480b0c5b 4675#ifdef SOCK_REPLACE_HANDLE
962955c5
JR		 4676 /* now replace handle to NUL with our socket handle */
4677 CloseHandle ((HANDLE) _get_osfhandle (fd));
4678 _free_osfhnd (fd);
4679 _set_osfhnd (fd, s);
4680 /* setmode (fd, _O_BINARY); */
480b0c5b 4681#else
962955c5
JR		 4682 /* Make a non-inheritable copy of the socket handle. Note
4683 that it is possible that sockets aren't actually kernel
4684 handles, which appears to be the case on Windows 9x when
4685 the MS Proxy winsock client is installed. */
4686 {
4687 /* Apparently there is a bug in NT 3.51 with some service
4688 packs, which prevents using DuplicateHandle to make a
4689 socket handle non-inheritable (causes WSACleanup to
4690 hang). The work-around is to use SetHandleInformation
4691 instead if it is available and implemented. */
4692 if (pfn_SetHandleInformation)
480b0c5b 4693 {
962955c5
JR		 4694 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
4695 }
4696 else
4697 {
4698 HANDLE parent = GetCurrentProcess ();
4699 HANDLE new_s = INVALID_HANDLE_VALUE;
4700
4701 if (DuplicateHandle (parent,
4702 (HANDLE) s,
4703 parent,
4704 &new_s,
4705 0,
4706 FALSE,
4707 DUPLICATE_SAME_ACCESS))
f1614061 4708 {
962955c5
JR		 4709 /* It is possible that DuplicateHandle succeeds even
4710 though the socket wasn't really a kernel handle,
4711 because a real handle has the same value. So
4712 test whether the new handle really is a socket. */
4713 long nonblocking = 0;
4714 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
ca149beb 4715 {
962955c5
JR		 4716 pfn_closesocket (s);
4717 s = (SOCKET) new_s;
4718 }
4719 else
4720 {
4721 CloseHandle (new_s);
4722 }
177c0ea7 4723 }
480b0c5b 4724 }
962955c5
JR		 4725 }
4726 fd_info[fd].hnd = (HANDLE) s;
480b0c5b
GV		 4727#endif
4728
962955c5
JR		 4729 /* set our own internal flags */
4730 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
480b0c5b 4731
962955c5
JR		 4732 cp = new_child ();
4733 if (cp)
4734 {
4735 cp->fd = fd;
4736 cp->status = STATUS_READ_ACKNOWLEDGED;
480b0c5b 4737
962955c5
JR		 4738 /* attach child_process to fd_info */
4739 if (fd_info[ fd ].cp != NULL)
4740 {
4741 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
4742 abort ();
480b0c5b
GV		 4743 }
4744
962955c5
JR		 4745 fd_info[ fd ].cp = cp;
4746
4747 /* success! */
4748 winsock_inuse++; /* count open sockets */
4749 return fd;
480b0c5b 4750 }
480b0c5b 4751
962955c5
JR		 4752 /* clean up */
4753 _close (fd);
4754 }
4755 pfn_closesocket (s);
4756 h_errno = EMFILE;
480b0c5b
GV		 4757 return -1;
4758}
4759
4760
4761int
4762sys_bind (int s, const struct sockaddr * addr, int namelen)
4763{
f249a012 4764 if (winsock_lib == NULL)
480b0c5b
GV		 4765 {
4766 h_errno = ENOTSOCK;
4767 return SOCKET_ERROR;
4768 }
4769
4770 check_errno ();
4771 if (fd_info[s].flags & FILE_SOCKET)
4772 {
4773 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
4774 if (rc == SOCKET_ERROR)
4775 set_errno ();
4776 return rc;
4777 }
4778 h_errno = ENOTSOCK;
4779 return SOCKET_ERROR;
4780}
4781
4782
4783int
4784sys_connect (int s, const struct sockaddr * name, int namelen)
4785{
f249a012 4786 if (winsock_lib == NULL)
480b0c5b
GV		 4787 {
4788 h_errno = ENOTSOCK;
4789 return SOCKET_ERROR;
4790 }
4791
4792 check_errno ();
4793 if (fd_info[s].flags & FILE_SOCKET)
4794 {
4795 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
4796 if (rc == SOCKET_ERROR)
4797 set_errno ();
4798 return rc;
4799 }
4800 h_errno = ENOTSOCK;
4801 return SOCKET_ERROR;
4802}
4803
4804u_short
4805sys_htons (u_short hostshort)
4806{
f249a012 4807 return (winsock_lib != NULL) ?
480b0c5b
GV		 4808 pfn_htons (hostshort) : hostshort;
4809}
4810
4811u_short
4812sys_ntohs (u_short netshort)
4813{
f249a012 4814 return (winsock_lib != NULL) ?
480b0c5b
GV		 4815 pfn_ntohs (netshort) : netshort;
4816}
4817
4818unsigned long
4819sys_inet_addr (const char * cp)
4820{
f249a012 4821 return (winsock_lib != NULL) ?
480b0c5b
GV		 4822 pfn_inet_addr (cp) : INADDR_NONE;
4823}
4824
4825int
4826sys_gethostname (char * name, int namelen)
4827{
f249a012 4828 if (winsock_lib != NULL)
480b0c5b
GV		 4829 return pfn_gethostname (name, namelen);
4830
4831 if (namelen > MAX_COMPUTERNAME_LENGTH)
a302c7ae 4832 return !GetComputerName (name, (DWORD *)&namelen);
480b0c5b
GV		 4833
4834 h_errno = EFAULT;
4835 return SOCKET_ERROR;
4836}
4837
4838struct hostent *
9d4f32e8 4839sys_gethostbyname (const char * name)
480b0c5b
GV		 4840{
4841 struct hostent * host;
4842
f249a012 4843 if (winsock_lib == NULL)
480b0c5b
GV		 4844 {
4845 h_errno = ENETDOWN;
4846 return NULL;
4847 }
4848
4849 check_errno ();
4850 host = pfn_gethostbyname (name);
4851 if (!host)
4852 set_errno ();
4853 return host;
4854}
4855
4856struct servent *
9d4f32e8 4857sys_getservbyname (const char * name, const char * proto)
480b0c5b
GV		 4858{
4859 struct servent * serv;
4860
f249a012 4861 if (winsock_lib == NULL)
480b0c5b
GV		 4862 {
4863 h_errno = ENETDOWN;
4864 return NULL;
4865 }
4866
4867 check_errno ();
4868 serv = pfn_getservbyname (name, proto);
4869 if (!serv)
4870 set_errno ();
4871 return serv;
4872}
4873
ecd270eb
JR		 4874int
4875sys_getpeername (int s, struct sockaddr *addr, int * namelen)
4876{
4877 if (winsock_lib == NULL)
4878 {
4879 h_errno = ENETDOWN;
4880 return SOCKET_ERROR;
4881 }
4882
4883 check_errno ();
4884 if (fd_info[s].flags & FILE_SOCKET)
4885 {
4886 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
4887 if (rc == SOCKET_ERROR)
4888 set_errno ();
4889 return rc;
4890 }
4891 h_errno = ENOTSOCK;
4892 return SOCKET_ERROR;
4893}
4894
4895
380961a6
GV		 4896int
4897sys_shutdown (int s, int how)
4898{
380961a6
GV		 4899 if (winsock_lib == NULL)
4900 {
4901 h_errno = ENETDOWN;
4902 return SOCKET_ERROR;
4903 }
4904
4905 check_errno ();
4906 if (fd_info[s].flags & FILE_SOCKET)
4907 {
4908 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
962955c5
JR		 4909 if (rc == SOCKET_ERROR)
4910 set_errno ();
4911 return rc;
4912 }
4913 h_errno = ENOTSOCK;
4914 return SOCKET_ERROR;
4915}
4916
4917int
a5a389bb 4918sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
962955c5
JR		 4919{
4920 if (winsock_lib == NULL)
4921 {
4922 h_errno = ENETDOWN;
4923 return SOCKET_ERROR;
4924 }
4925
4926 check_errno ();
4927 if (fd_info[s].flags & FILE_SOCKET)
4928 {
4929 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
a5a389bb 4930 (const char *)optval, optlen);
962955c5
JR		 4931 if (rc == SOCKET_ERROR)
4932 set_errno ();
4933 return rc;
4934 }
4935 h_errno = ENOTSOCK;
177c0ea7 4936 return SOCKET_ERROR;
962955c5
JR		 4937}
4938
4939int
4940sys_listen (int s, int backlog)
4941{
4942 if (winsock_lib == NULL)
4943 {
4944 h_errno = ENETDOWN;
4945 return SOCKET_ERROR;
4946 }
4947
4948 check_errno ();
4949 if (fd_info[s].flags & FILE_SOCKET)
4950 {
4951 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
4952 if (rc == SOCKET_ERROR)
4953 set_errno ();
26fb7bc4 4954 else
64570b36 4955 fd_info[s].flags |= FILE_LISTEN;
962955c5
JR		 4956 return rc;
4957 }
4958 h_errno = ENOTSOCK;
177c0ea7 4959 return SOCKET_ERROR;
962955c5
JR		 4960}
4961
4962int
4963sys_getsockname (int s, struct sockaddr * name, int * namelen)
4964{
4965 if (winsock_lib == NULL)
4966 {
4967 h_errno = ENETDOWN;
4968 return SOCKET_ERROR;
4969 }
4970
4971 check_errno ();
4972 if (fd_info[s].flags & FILE_SOCKET)
4973 {
4974 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
4975 if (rc == SOCKET_ERROR)
4976 set_errno ();
4977 return rc;
4978 }
4979 h_errno = ENOTSOCK;
177c0ea7 4980 return SOCKET_ERROR;
962955c5
JR		 4981}
4982
4983int
4984sys_accept (int s, struct sockaddr * addr, int * addrlen)
4985{
4986 if (winsock_lib == NULL)
4987 {
4988 h_errno = ENETDOWN;
4989 return -1;
4990 }
4991
4992 check_errno ();
26fb7bc4 4993 if (fd_info[s].flags & FILE_LISTEN)
962955c5 4994 {
a0ad1860 4995 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
64570b36
KS		 4996 int fd = -1;
4997 if (t == INVALID_SOCKET)
4998 set_errno ();
4999 else
5000 fd = socket_to_fd (t);
962955c5 5001
64570b36
KS		 5002 fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
5003 ResetEvent (fd_info[s].cp->char_avail);
5004 return fd;
962955c5
JR		 5005 }
5006 h_errno = ENOTSOCK;
5007 return -1;
5008}
5009
5010int
5011sys_recvfrom (int s, char * buf, int len, int flags,
9d4f32e8 5012 struct sockaddr * from, int * fromlen)
962955c5
JR		 5013{
5014 if (winsock_lib == NULL)
5015 {
5016 h_errno = ENETDOWN;
5017 return SOCKET_ERROR;
5018 }
5019
5020 check_errno ();
5021 if (fd_info[s].flags & FILE_SOCKET)
5022 {
5023 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
5024 if (rc == SOCKET_ERROR)
5025 set_errno ();
5026 return rc;
5027 }
5028 h_errno = ENOTSOCK;
5029 return SOCKET_ERROR;
5030}
5031
5032int
5033sys_sendto (int s, const char * buf, int len, int flags,
5034 const struct sockaddr * to, int tolen)
5035{
5036 if (winsock_lib == NULL)
5037 {
5038 h_errno = ENETDOWN;
5039 return SOCKET_ERROR;
5040 }
5041
5042 check_errno ();
5043 if (fd_info[s].flags & FILE_SOCKET)
5044 {
5045 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
380961a6
GV		 5046 if (rc == SOCKET_ERROR)
5047 set_errno ();
5048 return rc;
5049 }
5050 h_errno = ENOTSOCK;
5051 return SOCKET_ERROR;
5052}
5053
ecd270eb
JR		 5054/* Windows does not have an fcntl function. Provide an implementation
5055 solely for making sockets non-blocking. */
5056int
5057fcntl (int s, int cmd, int options)
5058{
5059 if (winsock_lib == NULL)
5060 {
5061 h_errno = ENETDOWN;
5062 return -1;
5063 }
5064
5065 check_errno ();
5066 if (fd_info[s].flags & FILE_SOCKET)
5067 {
5068 if (cmd == F_SETFL && options == O_NDELAY)
5069 {
5070 unsigned long nblock = 1;
5071 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
5072 if (rc == SOCKET_ERROR)
9d4f32e8 5073 set_errno ();
ecd270eb
JR		 5074 /* Keep track of the fact that we set this to non-blocking. */
5075 fd_info[s].flags |= FILE_NDELAY;
5076 return rc;
5077 }
5078 else
5079 {
5080 h_errno = EINVAL;
5081 return SOCKET_ERROR;
5082 }
5083 }
5084 h_errno = ENOTSOCK;
5085 return SOCKET_ERROR;
5086}
5087
480b0c5b
GV		 5088#endif /* HAVE_SOCKETS */
5089
5090
5091/* Shadow main io functions: we need to handle pipes and sockets more
5092 intelligently, and implement non-blocking mode as well. */
5093
5094int
5095sys_close (int fd)
5096{
5097 int rc;
5098
7559f399 5099 if (fd < 0)
480b0c5b
GV		 5100 {
5101 errno = EBADF;
5102 return -1;
5103 }
5104
7559f399 5105 if (fd < MAXDESC && fd_info[fd].cp)
480b0c5b
GV		 5106 {
5107 child_process * cp = fd_info[fd].cp;
5108
5109 fd_info[fd].cp = NULL;
5110
5111 if (CHILD_ACTIVE (cp))
5112 {
5113 /* if last descriptor to active child_process then cleanup */
5114 int i;
5115 for (i = 0; i < MAXDESC; i++)
5116 {
5117 if (i == fd)
5118 continue;
5119 if (fd_info[i].cp == cp)
5120 break;
5121 }
5122 if (i == MAXDESC)
5123 {
f249a012 5124#ifdef HAVE_SOCKETS
480b0c5b
GV		 5125 if (fd_info[fd].flags & FILE_SOCKET)
5126 {
f249a012
RS		 5127#ifndef SOCK_REPLACE_HANDLE
5128 if (winsock_lib == NULL) abort ();
480b0c5b
GV		 5129
5130 pfn_shutdown (SOCK_HANDLE (fd), 2);
5131 rc = pfn_closesocket (SOCK_HANDLE (fd));
f249a012
RS		 5132#endif
5133 winsock_inuse--; /* count open sockets */
480b0c5b
GV		 5134 }
5135#endif
5136 delete_child (cp);
5137 }
5138 }
5139 }
5140
5141 /* Note that sockets do not need special treatment here (at least on
e9e23e23 5142 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
480b0c5b
GV		 5143 closesocket is equivalent to CloseHandle, which is to be expected
5144 because socket handles are fully fledged kernel handles. */
5145 rc = _close (fd);
5146
7559f399 5147 if (rc == 0 && fd < MAXDESC)
480b0c5b
GV		 5148 fd_info[fd].flags = 0;
5149
5150 return rc;
5151}
5152
5153int
5154sys_dup (int fd)
5155{
5156 int new_fd;
5157
5158 new_fd = _dup (fd);
7559f399 5159 if (new_fd >= 0 && new_fd < MAXDESC)
480b0c5b
GV		 5160 {
5161 /* duplicate our internal info as well */
5162 fd_info[new_fd] = fd_info[fd];
5163 }
5164 return new_fd;
5165}
5166
5167
5168int
5169sys_dup2 (int src, int dst)
5170{
5171 int rc;
5172
5173 if (dst < 0 || dst >= MAXDESC)
5174 {
5175 errno = EBADF;
5176 return -1;
5177 }
5178
5179 /* make sure we close the destination first if it's a pipe or socket */
5180 if (src != dst && fd_info[dst].flags != 0)
5181 sys_close (dst);
177c0ea7 5182
480b0c5b
GV		 5183 rc = _dup2 (src, dst);
5184 if (rc == 0)
5185 {
5186 /* duplicate our internal info as well */
5187 fd_info[dst] = fd_info[src];
5188 }
5189 return rc;
5190}
5191
480b0c5b
GV		 5192/* Unix pipe() has only one arg */
5193int
5194sys_pipe (int * phandles)
5195{
5196 int rc;
5197 unsigned flags;
480b0c5b 5198
76b3903d
GV		 5199 /* make pipe handles non-inheritable; when we spawn a child, we
5200 replace the relevant handle with an inheritable one. Also put
5201 pipes into binary mode; we will do text mode translation ourselves
5202 if required. */
5203 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
480b0c5b
GV		 5204
5205 if (rc == 0)
5206 {
cb72110d
JR		 5207 /* Protect against overflow, since Windows can open more handles than
5208 our fd_info array has room for. */
5209 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
5210 {
5211 _close (phandles[0]);
5212 _close (phandles[1]);
5213 rc = -1;
5214 }
5215 else
5216 {
5217 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
5218 fd_info[phandles[0]].flags = flags;
480b0c5b 5219
cb72110d
JR		 5220 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
5221 fd_info[phandles[1]].flags = flags;
5222 }
480b0c5b
GV		 5223 }
5224
5225 return rc;
5226}
5227
f7554349 5228/* From ntproc.c */
78806724 5229extern int w32_pipe_read_delay;
f7554349 5230
480b0c5b
GV		 5231/* Function to do blocking read of one byte, needed to implement
5232 select. It is only allowed on sockets and pipes. */
5233int
5234_sys_read_ahead (int fd)
5235{
5236 child_process * cp;
5237 int rc;
5238
5239 if (fd < 0 || fd >= MAXDESC)
5240 return STATUS_READ_ERROR;
5241
5242 cp = fd_info[fd].cp;
5243
5244 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
5245 return STATUS_READ_ERROR;
5246
d888760c 5247 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SERIAL | FILE_SOCKET)) == 0
480b0c5b
GV		 5248 || (fd_info[fd].flags & FILE_READ) == 0)
5249 {
d888760c 5250 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd));
480b0c5b
GV		 5251 abort ();
5252 }
177c0ea7 5253
480b0c5b 5254 cp->status = STATUS_READ_IN_PROGRESS;
177c0ea7 5255
480b0c5b 5256 if (fd_info[fd].flags & FILE_PIPE)
f7554349 5257 {
f7554349
KH		 5258 rc = _read (fd, &cp->chr, sizeof (char));
5259
5260 /* Give subprocess time to buffer some more output for us before
e9e23e23 5261 reporting that input is available; we need this because Windows 95
f7554349
KH		 5262 connects DOS programs to pipes by making the pipe appear to be
5263 the normal console stdout - as a result most DOS programs will
d888760c 5264 write to stdout without buffering, ie. one character at a
fbd6baed 5265 time. Even some W32 programs do this - "dir" in a command
f7554349
KH		 5266 shell on NT is very slow if we don't do this. */
5267 if (rc > 0)
5268 {
78806724 5269 int wait = w32_pipe_read_delay;
f7554349
KH		 5270
5271 if (wait > 0)
5272 Sleep (wait);
5273 else if (wait < 0)
5274 while (++wait <= 0)
5275 /* Yield remainder of our time slice, effectively giving a
5276 temporary priority boost to the child process. */
5277 Sleep (0);
5278 }
5279 }
d888760c
GM		 5280 else if (fd_info[fd].flags & FILE_SERIAL)
5281 {
5282 HANDLE hnd = fd_info[fd].hnd;
5283 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
5284 COMMTIMEOUTS ct;
5285
5286 /* Configure timeouts for blocking read. */
5287 if (!GetCommTimeouts (hnd, &ct))
5288 return STATUS_READ_ERROR;
5289 ct.ReadIntervalTimeout = 0;
5290 ct.ReadTotalTimeoutMultiplier = 0;
5291 ct.ReadTotalTimeoutConstant = 0;
5292 if (!SetCommTimeouts (hnd, &ct))
5293 return STATUS_READ_ERROR;
5294
5295 if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
5296 {
5297 if (GetLastError () != ERROR_IO_PENDING)
5298 return STATUS_READ_ERROR;
5299 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
5300 return STATUS_READ_ERROR;
5301 }
5302 }
480b0c5b
GV		 5303#ifdef HAVE_SOCKETS
5304 else if (fd_info[fd].flags & FILE_SOCKET)
ecd270eb
JR		 5305 {
5306 unsigned long nblock = 0;
5307 /* We always want this to block, so temporarily disable NDELAY. */
5308 if (fd_info[fd].flags & FILE_NDELAY)
5309 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5310
5311 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
5312
5313 if (fd_info[fd].flags & FILE_NDELAY)
5314 {
5315 nblock = 1;
5316 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5317 }
5318 }
480b0c5b 5319#endif
177c0ea7 5320
480b0c5b
GV		 5321 if (rc == sizeof (char))
5322 cp->status = STATUS_READ_SUCCEEDED;
5323 else
5324 cp->status = STATUS_READ_FAILED;
5325
5326 return cp->status;
5327}
5328
9bfb11f9
KS		 5329int
5330_sys_wait_accept (int fd)
64570b36
KS		 5331{
5332 HANDLE hEv;
5333 child_process * cp;
5334 int rc;
5335
5336 if (fd < 0 || fd >= MAXDESC)
5337 return STATUS_READ_ERROR;
5338
5339 cp = fd_info[fd].cp;
5340
5341 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
5342 return STATUS_READ_ERROR;
5343
5344 cp->status = STATUS_READ_FAILED;
5345
5346 hEv = pfn_WSACreateEvent ();
5347 rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
5348 if (rc != SOCKET_ERROR)
5349 {
5350 rc = WaitForSingleObject (hEv, INFINITE);
5351 pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
64570b36
KS		 5352 if (rc == WAIT_OBJECT_0)
5353 cp->status = STATUS_READ_SUCCEEDED;
5354 }
7046f191 5355 pfn_WSACloseEvent (hEv);
64570b36
KS		 5356
5357 return cp->status;
5358}
5359
480b0c5b
GV		 5360int
5361sys_read (int fd, char * buffer, unsigned int count)
5362{
5363 int nchars;
480b0c5b
GV		 5364 int to_read;
5365 DWORD waiting;
76b3903d 5366 char * orig_buffer = buffer;
480b0c5b 5367
7559f399 5368 if (fd < 0)
480b0c5b
GV		 5369 {
5370 errno = EBADF;
5371 return -1;
5372 }
5373
d888760c 5374 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
480b0c5b
GV		 5375 {
5376 child_process *cp = fd_info[fd].cp;
5377
5378 if ((fd_info[fd].flags & FILE_READ) == 0)
5379 {
5380 errno = EBADF;
5381 return -1;
5382 }
5383
76b3903d
GV		 5384 nchars = 0;
5385
5386 /* re-read CR carried over from last read */
5387 if (fd_info[fd].flags & FILE_LAST_CR)
5388 {
5389 if (fd_info[fd].flags & FILE_BINARY) abort ();
5390 *buffer++ = 0x0d;
5391 count--;
5392 nchars++;
f52eb3ef 5393 fd_info[fd].flags &= ~FILE_LAST_CR;
76b3903d
GV		 5394 }
5395
480b0c5b
GV		 5396 /* presence of a child_process structure means we are operating in
5397 non-blocking mode - otherwise we just call _read directly.
5398 Note that the child_process structure might be missing because
5399 reap_subprocess has been called; in this case the pipe is
5400 already broken, so calling _read on it is okay. */
5401 if (cp)
5402 {
5403 int current_status = cp->status;
5404
5405 switch (current_status)
5406 {
5407 case STATUS_READ_FAILED:
5408 case STATUS_READ_ERROR:
f52eb3ef
GV		 5409 /* report normal EOF if nothing in buffer */
5410 if (nchars <= 0)
5411 fd_info[fd].flags |= FILE_AT_EOF;
5412 return nchars;
480b0c5b
GV		 5413
5414 case STATUS_READ_READY:
5415 case STATUS_READ_IN_PROGRESS:
5416 DebPrint (("sys_read called when read is in progress\n"));
5417 errno = EWOULDBLOCK;
5418 return -1;
5419
5420 case STATUS_READ_SUCCEEDED:
5421 /* consume read-ahead char */
5422 *buffer++ = cp->chr;
5423 count--;
76b3903d 5424 nchars++;
480b0c5b
GV		 5425 cp->status = STATUS_READ_ACKNOWLEDGED;
5426 ResetEvent (cp->char_avail);
5427
5428 case STATUS_READ_ACKNOWLEDGED:
5429 break;
5430
5431 default:
5432 DebPrint (("sys_read: bad status %d\n", current_status));
5433 errno = EBADF;
5434 return -1;
5435 }
5436
5437 if (fd_info[fd].flags & FILE_PIPE)
5438 {
5439 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
5440 to_read = min (waiting, (DWORD) count);
f52eb3ef
GV		 5441
5442 if (to_read > 0)
5443 nchars += _read (fd, buffer, to_read);
480b0c5b 5444 }
d888760c
GM		 5445 else if (fd_info[fd].flags & FILE_SERIAL)
5446 {
5447 HANDLE hnd = fd_info[fd].hnd;
5448 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
5449 DWORD err = 0;
5450 int rc = 0;
5451 COMMTIMEOUTS ct;
5452
5453 if (count > 0)
5454 {
5455 /* Configure timeouts for non-blocking read. */
5456 if (!GetCommTimeouts (hnd, &ct))
5457 {
5458 errno = EIO;
5459 return -1;
5460 }
5461 ct.ReadIntervalTimeout = MAXDWORD;
5462 ct.ReadTotalTimeoutMultiplier = 0;
5463 ct.ReadTotalTimeoutConstant = 0;
5464 if (!SetCommTimeouts (hnd, &ct))
5465 {
5466 errno = EIO;
5467 return -1;
5468 }
5469
5470 if (!ResetEvent (ovl->hEvent))
5471 {
5472 errno = EIO;
5473 return -1;
5474 }
5475 if (!ReadFile (hnd, buffer, count, (DWORD*) &rc, ovl))
5476 {
5477 if (GetLastError () != ERROR_IO_PENDING)
5478 {
5479 errno = EIO;
5480 return -1;
5481 }
5482 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
5483 {
5484 errno = EIO;
5485 return -1;
5486 }
5487 }
5488 nchars += rc;
5489 }
5490 }
480b0c5b
GV		 5491#ifdef HAVE_SOCKETS
5492 else /* FILE_SOCKET */
5493 {
f249a012 5494 if (winsock_lib == NULL) abort ();
480b0c5b
GV		 5495
5496 /* do the equivalent of a non-blocking read */
5497 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
76b3903d 5498 if (waiting == 0 && nchars == 0)
480b0c5b
GV		 5499 {
5500 h_errno = errno = EWOULDBLOCK;
5501 return -1;
5502 }
5503
480b0c5b
GV		 5504 if (waiting)
5505 {
5506 /* always use binary mode for sockets */
76b3903d
GV		 5507 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
5508 if (res == SOCKET_ERROR)
480b0c5b 5509 {
9d4f32e8
JB		 5510 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
5511 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
76b3903d
GV		 5512 set_errno ();
5513 return -1;
480b0c5b 5514 }
76b3903d 5515 nchars += res;
480b0c5b
GV		 5516 }
5517 }
5518#endif
5519 }
5520 else
f52eb3ef
GV		 5521 {
5522 int nread = _read (fd, buffer, count);
5523 if (nread >= 0)
5524 nchars += nread;
5525 else if (nchars == 0)
5526 nchars = nread;
5527 }
76b3903d 5528
f52eb3ef
GV		 5529 if (nchars <= 0)
5530 fd_info[fd].flags |= FILE_AT_EOF;
76b3903d 5531 /* Perform text mode translation if required. */
f52eb3ef 5532 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
76b3903d
GV		 5533 {
5534 nchars = crlf_to_lf (nchars, orig_buffer);
5535 /* If buffer contains only CR, return that. To be absolutely
5536 sure we should attempt to read the next char, but in
5537 practice a CR to be followed by LF would not appear by
5538 itself in the buffer. */
5539 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
5540 {
5541 fd_info[fd].flags |= FILE_LAST_CR;
5542 nchars--;
5543 }
76b3903d 5544 }
480b0c5b
GV		 5545 }
5546 else
5547 nchars = _read (fd, buffer, count);
5548
76b3903d 5549 return nchars;
480b0c5b
GV		 5550}
5551
d888760c
GM		 5552/* From w32xfns.c */
5553extern HANDLE interrupt_handle;
5554
480b0c5b
GV		 5555/* For now, don't bother with a non-blocking mode */
5556int
5557sys_write (int fd, const void * buffer, unsigned int count)
5558{
5559 int nchars;
5560
7559f399 5561 if (fd < 0)
480b0c5b
GV		 5562 {
5563 errno = EBADF;
5564 return -1;
5565 }
5566
d888760c 5567 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
76b3903d
GV		 5568 {
5569 if ((fd_info[fd].flags & FILE_WRITE) == 0)
5570 {
5571 errno = EBADF;
5572 return -1;
5573 }
5574
5575 /* Perform text mode translation if required. */
5576 if ((fd_info[fd].flags & FILE_BINARY) == 0)
5577 {
5578 char * tmpbuf = alloca (count * 2);
5579 unsigned char * src = (void *)buffer;
5580 unsigned char * dst = tmpbuf;
5581 int nbytes = count;
5582
5583 while (1)
5584 {
5585 unsigned char *next;
5586 /* copy next line or remaining bytes */
5587 next = _memccpy (dst, src, '\n', nbytes);
5588 if (next)
5589 {
5590 /* copied one line ending with '\n' */
5591 int copied = next - dst;
5592 nbytes -= copied;
5593 src += copied;
5594 /* insert '\r' before '\n' */
5595 next[-1] = '\r';
5596 next[0] = '\n';
5597 dst = next + 1;
5598 count++;
177c0ea7 5599 }
76b3903d
GV		 5600 else
5601 /* copied remaining partial line -> now finished */
5602 break;
5603 }
5604 buffer = tmpbuf;
5605 }
5606 }
5607
d888760c
GM		 5608 if (fd < MAXDESC && fd_info[fd].flags & FILE_SERIAL)
5609 {
5610 HANDLE hnd = (HANDLE) _get_osfhandle (fd);
5611 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_write;
5612 HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
5613 DWORD active = 0;
5614
5615 if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
5616 {
5617 if (GetLastError () != ERROR_IO_PENDING)
5618 {
5619 errno = EIO;
5620 return -1;
5621 }
5622 if (detect_input_pending ())
5623 active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
5624 QS_ALLINPUT);
5625 else
5626 active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
5627 if (active == WAIT_OBJECT_0)
5628 { /* User pressed C-g, cancel write, then leave. Don't bother
5629 cleaning up as we may only get stuck in buggy drivers. */
5630 PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
5631 CancelIo (hnd);
5632 errno = EIO;
5633 return -1;
5634 }
5635 if (active == WAIT_OBJECT_0 + 1
5636 && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
5637 {
5638 errno = EIO;
5639 return -1;
5640 }
5641 }
5642 }
5643 else
480b0c5b 5644#ifdef HAVE_SOCKETS
7559f399 5645 if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
480b0c5b 5646 {
30a32e0e 5647 unsigned long nblock = 0;
f249a012 5648 if (winsock_lib == NULL) abort ();
30a32e0e
JR		 5649
5650 /* TODO: implement select() properly so non-blocking I/O works. */
5651 /* For now, make sure the write blocks. */
5652 if (fd_info[fd].flags & FILE_NDELAY)
5653 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5654
480b0c5b 5655 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
30a32e0e
JR		 5656
5657 /* Set the socket back to non-blocking if it was before,
5658 for other operations that support it. */
5659 if (fd_info[fd].flags & FILE_NDELAY)
5660 {
5661 nblock = 1;
5662 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5663 }
5664
480b0c5b
GV		 5665 if (nchars == SOCKET_ERROR)
5666 {
9d4f32e8
JB		 5667 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
5668 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
480b0c5b
GV		 5669 set_errno ();
5670 }
5671 }
5672 else
5673#endif
5674 nchars = _write (fd, buffer, count);
5675
5676 return nchars;
5677}
5678
f52eb3ef
GV		 5679static void
5680check_windows_init_file ()
5681{
5682 extern int noninteractive, inhibit_window_system;
5683
5684 /* A common indication that Emacs is not installed properly is when
5685 it cannot find the Windows installation file. If this file does
5686 not exist in the expected place, tell the user. */
5687
177c0ea7 5688 if (!noninteractive && !inhibit_window_system)
d54abccd
GV		 5689 {
5690 extern Lisp_Object Vwindow_system, Vload_path, Qfile_exists_p;
a0b9c838 5691 Lisp_Object objs[2];
96ef7d42 5692 Lisp_Object full_load_path;
d54abccd
GV		 5693 Lisp_Object init_file;
5694 int fd;
f52eb3ef 5695
a0b9c838
GV		 5696 objs[0] = Vload_path;
5697 objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
5698 full_load_path = Fappend (2, objs);
d54abccd 5699 init_file = build_string ("term/w32-win");
c50a2aa6 5700 fd = openp (full_load_path, init_file, Fget_load_suffixes (), NULL, Qnil);
177c0ea7 5701 if (fd < 0)
d54abccd 5702 {
96ef7d42 5703 Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
d5db4077
KR		 5704 char *init_file_name = SDATA (init_file);
5705 char *load_path = SDATA (load_path_print);
acc23b87
KS		 5706 char *buffer = alloca (1024
5707 + strlen (init_file_name)
5708 + strlen (load_path));
d54abccd 5709
177c0ea7 5710 sprintf (buffer,
d54abccd
GV		 5711 "The Emacs Windows initialization file \"%s.el\" "
5712 "could not be found in your Emacs installation. "
5713 "Emacs checked the following directories for this file:\n"
5714 "\n%s\n\n"
5715 "When Emacs cannot find this file, it usually means that it "
5716 "was not installed properly, or its distribution file was "
5717 "not unpacked properly.\nSee the README.W32 file in the "
5718 "top-level Emacs directory for more information.",
5719 init_file_name, load_path);
5720 MessageBox (NULL,
5721 buffer,
5722 "Emacs Abort Dialog",
5723 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
f52eb3ef
GV		 5724 /* Use the low-level Emacs abort. */
5725#undef abort
d54abccd
GV		 5726 abort ();
5727 }
5728 else
5729 {
a302c7ae 5730 _close (fd);
d54abccd 5731 }
f52eb3ef 5732 }
f52eb3ef 5733}
480b0c5b
GV		 5734
5735void
5736term_ntproc ()
5737{
5738#ifdef HAVE_SOCKETS
5739 /* shutdown the socket interface if necessary */
5740 term_winsock ();
5741#endif
52c7f9ee
JR		 5742
5743 term_w32select ();
480b0c5b
GV		 5744}
5745
5746void
5747init_ntproc ()
5748{
5749#ifdef HAVE_SOCKETS
f249a012
RS		 5750 /* Initialise the socket interface now if available and requested by
5751 the user by defining PRELOAD_WINSOCK; otherwise loading will be
fbd6baed 5752 delayed until open-network-stream is called (w32-has-winsock can
f249a012
RS		 5753 also be used to dynamically load or reload winsock).
5754
5755 Conveniently, init_environment is called before us, so
5756 PRELOAD_WINSOCK can be set in the registry. */
5757
5758 /* Always initialize this correctly. */
5759 winsock_lib = NULL;
5760
5761 if (getenv ("PRELOAD_WINSOCK") != NULL)
5762 init_winsock (TRUE);
480b0c5b
GV		 5763#endif
5764
5765 /* Initial preparation for subprocess support: replace our standard
5766 handles with non-inheritable versions. */
5767 {
5768 HANDLE parent;
5769 HANDLE stdin_save = INVALID_HANDLE_VALUE;
5770 HANDLE stdout_save = INVALID_HANDLE_VALUE;
5771 HANDLE stderr_save = INVALID_HANDLE_VALUE;
5772
5773 parent = GetCurrentProcess ();
5774
5775 /* ignore errors when duplicating and closing; typically the
5776 handles will be invalid when running as a gui program. */
177c0ea7
JB		 5777 DuplicateHandle (parent,
5778 GetStdHandle (STD_INPUT_HANDLE),
480b0c5b 5779 parent,
177c0ea7
JB		 5780 &stdin_save,
5781 0,
5782 FALSE,
480b0c5b 5783 DUPLICATE_SAME_ACCESS);
177c0ea7 5784
480b0c5b
GV		 5785 DuplicateHandle (parent,
5786 GetStdHandle (STD_OUTPUT_HANDLE),
5787 parent,
5788 &stdout_save,
5789 0,
5790 FALSE,
5791 DUPLICATE_SAME_ACCESS);
177c0ea7 5792
480b0c5b
GV		 5793 DuplicateHandle (parent,
5794 GetStdHandle (STD_ERROR_HANDLE),
5795 parent,
5796 &stderr_save,
5797 0,
5798 FALSE,
5799 DUPLICATE_SAME_ACCESS);
177c0ea7 5800
480b0c5b
GV		 5801 fclose (stdin);
5802 fclose (stdout);
5803 fclose (stderr);
5804
5805 if (stdin_save != INVALID_HANDLE_VALUE)
5806 _open_osfhandle ((long) stdin_save, O_TEXT);
5807 else
76b3903d
GV		 5808 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
5809 _fdopen (0, "r");
480b0c5b
GV		 5810
5811 if (stdout_save != INVALID_HANDLE_VALUE)
5812 _open_osfhandle ((long) stdout_save, O_TEXT);
5813 else
76b3903d
GV		 5814 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
5815 _fdopen (1, "w");
480b0c5b
GV		 5816
5817 if (stderr_save != INVALID_HANDLE_VALUE)
5818 _open_osfhandle ((long) stderr_save, O_TEXT);
5819 else
76b3903d
GV		 5820 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
5821 _fdopen (2, "w");
480b0c5b
GV		 5822 }
5823
5824 /* unfortunately, atexit depends on implementation of malloc */
5825 /* atexit (term_ntproc); */
5826 signal (SIGABRT, term_ntproc);
76b3903d
GV		 5827
5828 /* determine which drives are fixed, for GetCachedVolumeInformation */
5829 {
5830 /* GetDriveType must have trailing backslash. */
5831 char drive[] = "A:\\";
5832
5833 /* Loop over all possible drive letters */
5834 while (*drive <= 'Z')
5835 {
5836 /* Record if this drive letter refers to a fixed drive. */
177c0ea7 5837 fixed_drives[DRIVE_INDEX (*drive)] =
76b3903d
GV		 5838 (GetDriveType (drive) == DRIVE_FIXED);
5839
5840 (*drive)++;
5841 }
a302c7ae
AI		 5842
5843 /* Reset the volume info cache. */
5844 volume_cache = NULL;
76b3903d 5845 }
177c0ea7 5846
d54abccd
GV		 5847 /* Check to see if Emacs has been installed correctly. */
5848 check_windows_init_file ();
480b0c5b
GV		 5849}
5850
a8c3a596
JR		 5851/*
5852 shutdown_handler ensures that buffers' autosave files are
5853 up to date when the user logs off, or the system shuts down.
5854*/
9d4f32e8
JB		 5855BOOL WINAPI
5856shutdown_handler (DWORD type)
a8c3a596
JR		 5857{
5858 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
5859 if (type == CTRL_CLOSE_EVENT /* User closes console window. */
5860 || type == CTRL_LOGOFF_EVENT /* User logs off. */
5861 || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown. */
5862 {
5863 /* Shut down cleanly, making sure autosave files are up to date. */
5864 shut_down_emacs (0, 0, Qnil);
5865 }
5866
7046f191 5867 /* Allow other handlers to handle this signal. */
a8c3a596
JR		 5868 return FALSE;
5869}
5870
9785d95b
BK		 5871/*
5872 globals_of_w32 is used to initialize those global variables that
5873 must always be initialized on startup even when the global variable
5874 initialized is non zero (see the function main in emacs.c).
5875*/
9bfb11f9
KS		 5876void
5877globals_of_w32 ()
9785d95b 5878{
74258518
JR		 5879 HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
5880
5881 get_process_times_fn = (GetProcessTimes_Proc)
5882 GetProcAddress (kernel32, "GetProcessTimes");
5883
9785d95b
BK		 5884 g_b_init_is_windows_9x = 0;
5885 g_b_init_open_process_token = 0;
5886 g_b_init_get_token_information = 0;
5887 g_b_init_lookup_account_sid = 0;
5888 g_b_init_get_sid_identifier_authority = 0;
9d95a291
EZ		 5889 g_b_init_get_sid_sub_authority = 0;
5890 g_b_init_get_sid_sub_authority_count = 0;
8aaaec6b
EZ		 5891 g_b_init_get_file_security = 0;
5892 g_b_init_get_security_descriptor_owner = 0;
5893 g_b_init_get_security_descriptor_group = 0;
5894 g_b_init_is_valid_sid = 0;
7c80d5ec
EZ		 5895 g_b_init_create_toolhelp32_snapshot = 0;
5896 g_b_init_process32_first = 0;
5897 g_b_init_process32_next = 0;
5898 g_b_init_open_thread_token = 0;
5899 g_b_init_impersonate_self = 0;
5900 g_b_init_revert_to_self = 0;
5901 g_b_init_get_process_memory_info = 0;
5902 g_b_init_get_process_working_set_size = 0;
5903 g_b_init_global_memory_status = 0;
5904 g_b_init_global_memory_status_ex = 0;
f8b35b24
EZ		 5905 g_b_init_equal_sid = 0;
5906 g_b_init_copy_sid = 0;
5907 g_b_init_get_length_sid = 0;
ad9e2d54
EZ		 5908 g_b_init_get_native_system_info = 0;
5909 g_b_init_get_system_times = 0;
5910 num_of_processors = 0;
a8c3a596
JR		 5911 /* The following sets a handler for shutdown notifications for
5912 console apps. This actually applies to Emacs in both console and
5913 GUI modes, since we had to fool windows into thinking emacs is a
5914 console application to get console mode to work. */
9d4f32e8 5915 SetConsoleCtrlHandler (shutdown_handler, TRUE);
8aaaec6b
EZ		 5916
5917 /* "None" is the default group name on standalone workstations. */
5918 strcpy (dflt_group_name, "None");
9785d95b
BK		 5919}
5920
d888760c 5921/* For make-serial-process */
9d4f32e8
JB		 5922int
5923serial_open (char *port)
d888760c
GM		 5924{
5925 HANDLE hnd;
5926 child_process *cp;
5927 int fd = -1;
5928
5929 hnd = CreateFile (port, GENERIC_READ | GENERIC_WRITE, 0, 0,
5930 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
5931 if (hnd == INVALID_HANDLE_VALUE)
5932 error ("Could not open %s", port);
5933 fd = (int) _open_osfhandle ((int) hnd, 0);
5934 if (fd == -1)
5935 error ("Could not open %s", port);
5936
5937 cp = new_child ();
5938 if (!cp)
5939 error ("Could not create child process");
5940 cp->fd = fd;
5941 cp->status = STATUS_READ_ACKNOWLEDGED;
5942 fd_info[ fd ].hnd = hnd;
5943 fd_info[ fd ].flags |=
5944 FILE_READ | FILE_WRITE | FILE_BINARY | FILE_SERIAL;
5945 if (fd_info[ fd ].cp != NULL)
5946 {
5947 error ("fd_info[fd = %d] is already in use", fd);
5948 }
5949 fd_info[ fd ].cp = cp;
5950 cp->ovl_read.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
5951 if (cp->ovl_read.hEvent == NULL)
5952 error ("Could not create read event");
5953 cp->ovl_write.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
5954 if (cp->ovl_write.hEvent == NULL)
5955 error ("Could not create write event");
5956
5957 return fd;
5958}
5959
5960/* For serial-process-configure */
5961void
9d4f32e8 5962serial_configure (struct Lisp_Process *p, Lisp_Object contact)
d888760c
GM		 5963{
5964 Lisp_Object childp2 = Qnil;
5965 Lisp_Object tem = Qnil;
5966 HANDLE hnd;
5967 DCB dcb;
5968 COMMTIMEOUTS ct;
5969 char summary[4] = "???"; /* This usually becomes "8N1". */
5970
5971 if ((fd_info[ p->outfd ].flags & FILE_SERIAL) == 0)
5972 error ("Not a serial process");
5973 hnd = fd_info[ p->outfd ].hnd;
5974
5975 childp2 = Fcopy_sequence (p->childp);
5976
5977 /* Initialize timeouts for blocking read and blocking write. */
5978 if (!GetCommTimeouts (hnd, &ct))
5979 error ("GetCommTimeouts() failed");
5980 ct.ReadIntervalTimeout = 0;
5981 ct.ReadTotalTimeoutMultiplier = 0;
5982 ct.ReadTotalTimeoutConstant = 0;
5983 ct.WriteTotalTimeoutMultiplier = 0;
5984 ct.WriteTotalTimeoutConstant = 0;
5985 if (!SetCommTimeouts (hnd, &ct))
5986 error ("SetCommTimeouts() failed");
5987 /* Read port attributes and prepare default configuration. */
5988 memset (&dcb, 0, sizeof (dcb));
5989 dcb.DCBlength = sizeof (DCB);
5990 if (!GetCommState (hnd, &dcb))
5991 error ("GetCommState() failed");
5992 dcb.fBinary = TRUE;
5993 dcb.fNull = FALSE;
5994 dcb.fAbortOnError = FALSE;
5995 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
5996 dcb.ErrorChar = 0;
5997 dcb.EofChar = 0;
5998 dcb.EvtChar = 0;
5999
6000 /* Configure speed. */
6001 if (!NILP (Fplist_member (contact, QCspeed)))
6002 tem = Fplist_get (contact, QCspeed);
6003 else
6004 tem = Fplist_get (p->childp, QCspeed);
6005 CHECK_NUMBER (tem);
6006 dcb.BaudRate = XINT (tem);
6007 childp2 = Fplist_put (childp2, QCspeed, tem);
6008
6009 /* Configure bytesize. */
6010 if (!NILP (Fplist_member (contact, QCbytesize)))
6011 tem = Fplist_get (contact, QCbytesize);
6012 else
6013 tem = Fplist_get (p->childp, QCbytesize);
6014 if (NILP (tem))
6015 tem = make_number (8);
6016 CHECK_NUMBER (tem);
6017 if (XINT (tem) != 7 && XINT (tem) != 8)
6018 error (":bytesize must be nil (8), 7, or 8");
6019 dcb.ByteSize = XINT (tem);
6020 summary[0] = XINT (tem) + '0';
6021 childp2 = Fplist_put (childp2, QCbytesize, tem);
6022
6023 /* Configure parity. */
6024 if (!NILP (Fplist_member (contact, QCparity)))
6025 tem = Fplist_get (contact, QCparity);
6026 else
6027 tem = Fplist_get (p->childp, QCparity);
6028 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
6029 error (":parity must be nil (no parity), `even', or `odd'");
6030 dcb.fParity = FALSE;
6031 dcb.Parity = NOPARITY;
6032 dcb.fErrorChar = FALSE;
6033 if (NILP (tem))
6034 {
6035 summary[1] = 'N';
6036 }
6037 else if (EQ (tem, Qeven))
6038 {
6039 summary[1] = 'E';
6040 dcb.fParity = TRUE;
6041 dcb.Parity = EVENPARITY;
6042 dcb.fErrorChar = TRUE;
6043 }
6044 else if (EQ (tem, Qodd))
6045 {
6046 summary[1] = 'O';
6047 dcb.fParity = TRUE;
6048 dcb.Parity = ODDPARITY;
6049 dcb.fErrorChar = TRUE;
6050 }
6051 childp2 = Fplist_put (childp2, QCparity, tem);
6052
6053 /* Configure stopbits. */
6054 if (!NILP (Fplist_member (contact, QCstopbits)))
6055 tem = Fplist_get (contact, QCstopbits);
6056 else
6057 tem = Fplist_get (p->childp, QCstopbits);
6058 if (NILP (tem))
6059 tem = make_number (1);
6060 CHECK_NUMBER (tem);
6061 if (XINT (tem) != 1 && XINT (tem) != 2)
6062 error (":stopbits must be nil (1 stopbit), 1, or 2");
6063 summary[2] = XINT (tem) + '0';
6064 if (XINT (tem) == 1)
6065 dcb.StopBits = ONESTOPBIT;
6066 else if (XINT (tem) == 2)
6067 dcb.StopBits = TWOSTOPBITS;
6068 childp2 = Fplist_put (childp2, QCstopbits, tem);
6069
6070 /* Configure flowcontrol. */
6071 if (!NILP (Fplist_member (contact, QCflowcontrol)))
6072 tem = Fplist_get (contact, QCflowcontrol);
6073 else
6074 tem = Fplist_get (p->childp, QCflowcontrol);
6075 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
6076 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6077 dcb.fOutxCtsFlow = FALSE;
6078 dcb.fOutxDsrFlow = FALSE;
6079 dcb.fDtrControl = DTR_CONTROL_DISABLE;
6080 dcb.fDsrSensitivity = FALSE;
6081 dcb.fTXContinueOnXoff = FALSE;
6082 dcb.fOutX = FALSE;
6083 dcb.fInX = FALSE;
6084 dcb.fRtsControl = RTS_CONTROL_DISABLE;
6085 dcb.XonChar = 17; /* Control-Q */
6086 dcb.XoffChar = 19; /* Control-S */
6087 if (NILP (tem))
6088 {
6089 /* Already configured. */
6090 }
6091 else if (EQ (tem, Qhw))
6092 {
6093 dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
6094 dcb.fOutxCtsFlow = TRUE;
6095 }
6096 else if (EQ (tem, Qsw))
6097 {
6098 dcb.fOutX = TRUE;
6099 dcb.fInX = TRUE;
6100 }
6101 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
6102
6103 /* Activate configuration. */
6104 if (!SetCommState (hnd, &dcb))
6105 error ("SetCommState() failed");
6106
6107 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
6108 p->childp = childp2;
6109}
6110
aa5ee2a3 6111/* end of w32.c */
ab5796a9
MB		 6112
6113/* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
6114 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.