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