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