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