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