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