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