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