HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* coding.c: Remove vars that are set but not used.
[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);
94eab1c8 1508
f332b293 1509void
aa7b87b0 1510init_environment (char ** argv)
f332b293 1511{
b3308d2e
KH		 1512 static const char * const tempdirs[] = {
1513 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1514 };
2d5324c5 1515
b3308d2e 1516 int i;
2d5324c5 1517
b3308d2e
KH		 1518 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
1519
1520 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1521 temporary files and assume "/tmp" if $TMPDIR is unset, which
1522 will break on DOS/Windows. Refuse to work if we cannot find
1523 a directory, not even "c:/", usable for that purpose. */
1524 for (i = 0; i < imax ; i++)
1525 {
1526 const char *tmp = tempdirs[i];
1527
1528 if (*tmp == '$')
1529 tmp = getenv (tmp + 1);
1530 /* Note that `access' can lie to us if the directory resides on a
1531 read-only filesystem, like CD-ROM or a write-protected floppy.
1532 The only way to be really sure is to actually create a file and
1533 see if it succeeds. But I think that's too much to ask. */
a302c7ae 1534 if (tmp && _access (tmp, D_OK) == 0)
b3308d2e
KH		 1535 {
1536 char * var = alloca (strlen (tmp) + 8);
1537 sprintf (var, "TMPDIR=%s", tmp);
aca583b2 1538 _putenv (strdup (var));
b3308d2e
KH		 1539 break;
1540 }
1541 }
1542 if (i >= imax)
1543 cmd_error_internal
1544 (Fcons (Qerror,
1545 Fcons (build_string ("no usable temporary directories found!!"),
1546 Qnil)),
1547 "While setting TMPDIR: ");
1548
ca149beb
AI		 1549 /* Check for environment variables and use registry settings if they
1550 don't exist. Fallback on default values where applicable. */
f332b293 1551 {
480b0c5b
GV		 1552 int i;
1553 LPBYTE lpval;
1554 DWORD dwType;
69fb0241 1555 char locale_name[32];
2d5324c5
JR		 1556 struct stat ignored;
1557 char default_home[MAX_PATH];
f332b293 1558
e00b99c8 1559 static const struct env_entry
ca149beb
AI		 1560 {
1561 char * name;
1562 char * def_value;
e00b99c8 1563 } dflt_envvars[] =
ca149beb
AI		 1564 {
1565 {"HOME", "C:/"},
1566 {"PRELOAD_WINSOCK", NULL},
1567 {"emacs_dir", "C:/emacs"},
cc14250a 1568 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
ca149beb
AI		 1569 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1570 {"EMACSDATA", "%emacs_dir%/etc"},
1571 {"EMACSPATH", "%emacs_dir%/bin"},
76b3903d 1572 /* We no longer set INFOPATH because Info-default-directory-list
ca149beb
AI		 1573 is then ignored. */
1574 /* {"INFOPATH", "%emacs_dir%/info"}, */
1575 {"EMACSDOC", "%emacs_dir%/etc"},
69fb0241
JR		 1576 {"TERM", "cmd"},
1577 {"LANG", NULL},
480b0c5b
GV		 1578 };
1579
ed3751c8 1580#define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
e00b99c8
EZ		 1581
1582 /* We need to copy dflt_envvars[] and work on the copy because we
1583 don't want the dumped Emacs to inherit the values of
1584 environment variables we saw during dumping (which could be on
1585 a different system). The defaults above must be left intact. */
1586 struct env_entry env_vars[N_ENV_VARS];
1587
1588 for (i = 0; i < N_ENV_VARS; i++)
1589 env_vars[i] = dflt_envvars[i];
1590
2d5324c5
JR		 1591 /* For backwards compatibility, check if a .emacs file exists in C:/
1592 If not, then we can try to default to the appdata directory under the
1593 user's profile, which is more likely to be writable. */
1594 if (stat ("C:/.emacs", &ignored) < 0)
94eab1c8
JB		 1595 {
1596 HRESULT profile_result;
1597 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1598 of Windows 95 and NT4 that have not been updated to include
1599 MSIE 5. */
1600 ShGetFolderPath_fn get_folder_path;
1601 get_folder_path = (ShGetFolderPath_fn)
1602 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1603
1604 if (get_folder_path != NULL)
1605 {
1606 profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
1607 0, default_home);
2d5324c5 1608
94eab1c8
JB		 1609 /* If we can't get the appdata dir, revert to old behavior. */
1610 if (profile_result == S_OK)
1611 env_vars[0].def_value = default_home;
1612 }
1613 }
2d5324c5 1614
69fb0241
JR		 1615 /* Get default locale info and use it for LANG. */
1616 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
1617 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1618 locale_name, sizeof (locale_name)))
1619 {
e00b99c8 1620 for (i = 0; i < N_ENV_VARS; i++)
69fb0241
JR		 1621 {
1622 if (strcmp (env_vars[i].name, "LANG") == 0)
1623 {
1624 env_vars[i].def_value = locale_name;
1625 break;
1626 }
1627 }
1628 }
1629
ca149beb
AI		 1630#define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1631
1632 /* Treat emacs_dir specially: set it unconditionally based on our
1633 location, if it appears that we are running from the bin subdir
1634 of a standard installation. */
1635 {
1636 char *p;
1637 char modname[MAX_PATH];
1638
1639 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1640 abort ();
1641 if ((p = strrchr (modname, '\\')) == NULL)
1642 abort ();
1643 *p = 0;
1644
05131107 1645 if ((p = strrchr (modname, '\\')) && xstrcasecmp (p, "\\bin") == 0)
ca149beb
AI		 1646 {
1647 char buf[SET_ENV_BUF_SIZE];
1648
1649 *p = 0;
1650 for (p = modname; *p; p++)
1651 if (*p == '\\') *p = '/';
177c0ea7 1652
ed3751c8 1653 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
a302c7ae 1654 _putenv (strdup (buf));
ca149beb 1655 }
950090be
JR		 1656 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1657
1658 /* FIXME: should use substring of get_emacs_configuration ().
1659 But I don't think the Windows build supports alpha, mips etc
1660 anymore, so have taken the easy option for now. */
05131107 1661 else if (p && xstrcasecmp (p, "\\i386") == 0)
950090be
JR		 1662 {
1663 *p = 0;
1664 p = strrchr (modname, '\\');
1665 if (p != NULL)
1666 {
1667 *p = 0;
1668 p = strrchr (modname, '\\');
05131107 1669 if (p && xstrcasecmp (p, "\\src") == 0)
950090be
JR		 1670 {
1671 char buf[SET_ENV_BUF_SIZE];
1672
1673 *p = 0;
1674 for (p = modname; *p; p++)
1675 if (*p == '\\') *p = '/';
1676
ed3751c8 1677 _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
950090be
JR		 1678 _putenv (strdup (buf));
1679 }
1680 }
1681 }
ca149beb
AI		 1682 }
1683
e00b99c8 1684 for (i = 0; i < N_ENV_VARS; i++)
f332b293 1685 {
ca149beb 1686 if (!getenv (env_vars[i].name))
480b0c5b 1687 {
ca149beb 1688 int dont_free = 0;
480b0c5b 1689
aa5ee2a3
JB		 1690 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL
1691 /* Also ignore empty environment variables. */
1692 || *lpval == 0)
ca149beb 1693 {
70fdbb46 1694 xfree (lpval);
ca149beb
AI		 1695 lpval = env_vars[i].def_value;
1696 dwType = REG_EXPAND_SZ;
1697 dont_free = 1;
480b0c5b 1698 }
ca149beb
AI		 1699
1700 if (lpval)
480b0c5b 1701 {
892eb237 1702 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
ca149beb 1703
892eb237 1704 if (dwType == REG_EXPAND_SZ)
ed3751c8 1705 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof (buf1));
ca149beb 1706 else if (dwType == REG_SZ)
892eb237
EZ		 1707 strcpy (buf1, lpval);
1708 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
ca149beb 1709 {
ed3751c8 1710 _snprintf (buf2, sizeof (buf2)-1, "%s=%s", env_vars[i].name,
892eb237
EZ		 1711 buf1);
1712 _putenv (strdup (buf2));
ca149beb 1713 }
f332b293 1714
ca149beb
AI		 1715 if (!dont_free)
1716 xfree (lpval);
1717 }
480b0c5b
GV		 1718 }
1719 }
1720 }
1721
75b08edb
GV		 1722 /* Rebuild system configuration to reflect invoking system. */
1723 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1724
76b3903d
GV		 1725 /* Another special case: on NT, the PATH variable is actually named
1726 "Path" although cmd.exe (perhaps NT itself) arranges for
1727 environment variable lookup and setting to be case insensitive.
1728 However, Emacs assumes a fully case sensitive environment, so we
1729 need to change "Path" to "PATH" to match the expectations of
1730 various elisp packages. We do this by the sneaky method of
1731 modifying the string in the C runtime environ entry.
1732
1733 The same applies to COMSPEC. */
1734 {
1735 char ** envp;
1736
1737 for (envp = environ; *envp; envp++)
1738 if (_strnicmp (*envp, "PATH=", 5) == 0)
1739 memcpy (*envp, "PATH=", 5);
1740 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
1741 memcpy (*envp, "COMSPEC=", 8);
1742 }
1743
1744 /* Remember the initial working directory for getwd, then make the
1745 real wd be the location of emacs.exe to avoid conflicts when
1746 renaming or deleting directories. (We also don't call chdir when
1747 running subprocesses for the same reason.) */
1748 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
1749 abort ();
1750
1751 {
1752 char *p;
aa7b87b0 1753 static char modname[MAX_PATH];
76b3903d
GV		 1754
1755 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1756 abort ();
1757 if ((p = strrchr (modname, '\\')) == NULL)
1758 abort ();
1759 *p = 0;
1760
1761 SetCurrentDirectory (modname);
aa7b87b0
AI		 1762
1763 /* Ensure argv[0] has the full path to Emacs. */
1764 *p = '\\';
1765 argv[0] = modname;
76b3903d
GV		 1766 }
1767
20af4831
JR		 1768 /* Determine if there is a middle mouse button, to allow parse_button
1769 to decide whether right mouse events should be mouse-2 or
1770 mouse-3. */
e0c181dd 1771 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
20af4831 1772
480b0c5b
GV		 1773 init_user_info ();
1774}
1775
bf794306
EZ		 1776char *
1777emacs_root_dir (void)
1778{
1779 static char root_dir[FILENAME_MAX];
1780 const char *p;
1781
1782 p = getenv ("emacs_dir");
1783 if (p == NULL)
1784 abort ();
1785 strcpy (root_dir, p);
1786 root_dir[parse_root (root_dir, NULL)] = '\0';
1787 dostounix_filename (root_dir);
1788 return root_dir;
1789}
1790
480b0c5b
GV		 1791/* We don't have scripts to automatically determine the system configuration
1792 for Emacs before it's compiled, and we don't want to have to make the
1793 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1794 routine. */
1795
480b0c5b
GV		 1796char *
1797get_emacs_configuration (void)
1798{
1799 char *arch, *oem, *os;
c5247da2 1800 int build_num;
a302c7ae 1801 static char configuration_buffer[32];
480b0c5b
GV		 1802
1803 /* Determine the processor type. */
177c0ea7 1804 switch (get_processor_type ())
480b0c5b
GV		 1805 {
1806
1807#ifdef PROCESSOR_INTEL_386
1808 case PROCESSOR_INTEL_386:
1809 case PROCESSOR_INTEL_486:
1810 case PROCESSOR_INTEL_PENTIUM:
1811 arch = "i386";
1812 break;
1813#endif
1814
480b0c5b
GV		 1815#ifdef PROCESSOR_MIPS_R2000
1816 case PROCESSOR_MIPS_R2000:
1817 case PROCESSOR_MIPS_R3000:
1818 case PROCESSOR_MIPS_R4000:
1819 arch = "mips";
1820 break;
1821#endif
1822
1823#ifdef PROCESSOR_ALPHA_21064
1824 case PROCESSOR_ALPHA_21064:
1825 arch = "alpha";
1826 break;
1827#endif
1828
1829 default:
1830 arch = "unknown";
1831 break;
f332b293 1832 }
480b0c5b 1833
a302c7ae
AI		 1834 /* Use the OEM field to reflect the compiler/library combination. */
1835#ifdef _MSC_VER
1836#define COMPILER_NAME "msvc"
1837#else
1838#ifdef __GNUC__
1839#define COMPILER_NAME "mingw"
1840#else
1841#define COMPILER_NAME "unknown"
1842#endif
1843#endif
1844 oem = COMPILER_NAME;
480b0c5b 1845
c5247da2
GV		 1846 switch (osinfo_cache.dwPlatformId) {
1847 case VER_PLATFORM_WIN32_NT:
1848 os = "nt";
1849 build_num = osinfo_cache.dwBuildNumber;
1850 break;
1851 case VER_PLATFORM_WIN32_WINDOWS:
1852 if (osinfo_cache.dwMinorVersion == 0) {
1853 os = "windows95";
1854 } else {
1855 os = "windows98";
1856 }
1857 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1858 break;
1859 case VER_PLATFORM_WIN32s:
1860 /* Not supported, should not happen. */
1861 os = "windows32s";
1862 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1863 break;
1864 default:
1865 os = "unknown";
1866 build_num = 0;
1867 break;
1868 }
1869
1870 if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1871 sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
1872 get_w32_major_version (), get_w32_minor_version (), build_num);
1873 } else {
1874 sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
1875 }
480b0c5b 1876
480b0c5b 1877 return configuration_buffer;
f332b293
GV		 1878}
1879
a302c7ae
AI		 1880char *
1881get_emacs_configuration_options (void)
1882{
38c54d9d
JB		 1883 static char *options_buffer;
1884 char cv[32]; /* Enough for COMPILER_VERSION. */
1885 char *options[] = {
1886 cv, /* To be filled later. */
1887#ifdef EMACSDEBUG
1888 " --no-opt",
1889#endif
1890 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1891 with a starting space to save work here. */
1892#ifdef USER_CFLAGS
1893 " --cflags", USER_CFLAGS,
1894#endif
1895#ifdef USER_LDFLAGS
1896 " --ldflags", USER_LDFLAGS,
1897#endif
1898 NULL
1899 };
1900 size_t size = 0;
1901 int i;
a302c7ae
AI		 1902
1903/* Work out the effective configure options for this build. */
1904#ifdef _MSC_VER
1905#define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1906#else
1907#ifdef __GNUC__
1908#define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1909#else
1910#define COMPILER_VERSION ""
1911#endif
1912#endif
1913
83e245c4 1914 if (_snprintf (cv, sizeof (cv) - 1, COMPILER_VERSION) < 0)
38c54d9d 1915 return "Error: not enough space for compiler version";
83e245c4 1916 cv[sizeof (cv) - 1] = '\0';
38c54d9d
JB		 1917
1918 for (i = 0; options[i]; i++)
1919 size += strlen (options[i]);
1920
1921 options_buffer = xmalloc (size + 1);
fc33e153 1922 options_buffer[0] = '\0';
38c54d9d
JB		 1923
1924 for (i = 0; options[i]; i++)
1925 strcat (options_buffer, options[i]);
1926
a302c7ae
AI		 1927 return options_buffer;
1928}
1929
1930
35f0d482
KH		 1931#include <sys/timeb.h>
1932
1933/* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
177c0ea7 1934void
35f0d482
KH		 1935gettimeofday (struct timeval *tv, struct timezone *tz)
1936{
6e602566 1937 struct _timeb tb;
35f0d482
KH		 1938 _ftime (&tb);
1939
1940 tv->tv_sec = tb.time;
1941 tv->tv_usec = tb.millitm * 1000L;
177c0ea7 1942 if (tz)
35f0d482
KH		 1943 {
1944 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
1945 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
1946 }
1947}
35f0d482 1948
480b0c5b 1949/* ------------------------------------------------------------------------- */
fbd6baed 1950/* IO support and wrapper functions for W32 API. */
480b0c5b 1951/* ------------------------------------------------------------------------- */
95ed0025 1952
480b0c5b 1953/* Place a wrapper around the MSVC version of ctime. It returns NULL
177c0ea7 1954 on network directories, so we handle that case here.
480b0c5b
GV		 1955 (Ulrich Leodolter, 1/11/95). */
1956char *
1957sys_ctime (const time_t *t)
1958{
1959 char *str = (char *) ctime (t);
1960 return (str ? str : "Sun Jan 01 00:00:00 1970");
1961}
1962
1963/* Emulate sleep...we could have done this with a define, but that
1964 would necessitate including windows.h in the files that used it.
1965 This is much easier. */
1966void
1967sys_sleep (int seconds)
1968{
1969 Sleep (seconds * 1000);
1970}
1971
76b3903d 1972/* Internal MSVC functions for low-level descriptor munging */
480b0c5b
GV		 1973extern int __cdecl _set_osfhnd (int fd, long h);
1974extern int __cdecl _free_osfhnd (int fd);
1975
1976/* parallel array of private info on file handles */
1977filedesc fd_info [ MAXDESC ];
1978
76b3903d
GV		 1979typedef struct volume_info_data {
1980 struct volume_info_data * next;
1981
1982 /* time when info was obtained */
1983 DWORD timestamp;
1984
1985 /* actual volume info */
1986 char * root_dir;
480b0c5b
GV		 1987 DWORD serialnum;
1988 DWORD maxcomp;
1989 DWORD flags;
76b3903d
GV		 1990 char * name;
1991 char * type;
1992} volume_info_data;
1993
1994/* Global referenced by various functions. */
1995static volume_info_data volume_info;
1996
1997/* Vector to indicate which drives are local and fixed (for which cached
1998 data never expires). */
1999static BOOL fixed_drives[26];
2000
2001/* Consider cached volume information to be stale if older than 10s,
2002 at least for non-local drives. Info for fixed drives is never stale. */
2003#define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2004#define VOLINFO_STILL_VALID( root_dir, info ) \
2005 ( ( isalpha (root_dir[0]) && \
2006 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2007 || GetTickCount () - info->timestamp < 10000 )
2008
2009/* Cache support functions. */
2010
2011/* Simple linked list with linear search is sufficient. */
2012static volume_info_data *volume_cache = NULL;
2013
2014static volume_info_data *
2015lookup_volume_info (char * root_dir)
2016{
2017 volume_info_data * info;
2018
2019 for (info = volume_cache; info; info = info->next)
05131107 2020 if (xstrcasecmp (info->root_dir, root_dir) == 0)
76b3903d
GV		 2021 break;
2022 return info;
2023}
2024
2025static void
2026add_volume_info (char * root_dir, volume_info_data * info)
2027{
a302c7ae 2028 info->root_dir = xstrdup (root_dir);
76b3903d
GV		 2029 info->next = volume_cache;
2030 volume_cache = info;
2031}
2032
2033
2034/* Wrapper for GetVolumeInformation, which uses caching to avoid
2035 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2036 cdrom drive, ~5-10ms or more for remote drives on LAN). */
bedf4aab 2037static volume_info_data *
76b3903d
GV		 2038GetCachedVolumeInformation (char * root_dir)
2039{
2040 volume_info_data * info;
2041 char default_root[ MAX_PATH ];
2042
2043 /* NULL for root_dir means use root from current directory. */
2044 if (root_dir == NULL)
2045 {
2046 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
2047 return NULL;
2048 parse_root (default_root, &root_dir);
2049 *root_dir = 0;
2050 root_dir = default_root;
2051 }
2052
2053 /* Local fixed drives can be cached permanently. Removable drives
2054 cannot be cached permanently, since the volume name and serial
2055 number (if nothing else) can change. Remote drives should be
2056 treated as if they are removable, since there is no sure way to
2057 tell whether they are or not. Also, the UNC association of drive
2058 letters mapped to remote volumes can be changed at any time (even
2059 by other processes) without notice.
177c0ea7 2060
76b3903d
GV		 2061 As a compromise, so we can benefit from caching info for remote
2062 volumes, we use a simple expiry mechanism to invalidate cache
2063 entries that are more than ten seconds old. */
2064
2065#if 0
2066 /* No point doing this, because WNetGetConnection is even slower than
2067 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2068 GetDriveType is about the only call of this type which does not
2069 involve network access, and so is extremely quick). */
2070
2071 /* Map drive letter to UNC if remote. */
ed3751c8 2072 if (isalpha (root_dir[0]) && !fixed[DRIVE_INDEX (root_dir[0])])
76b3903d
GV		 2073 {
2074 char remote_name[ 256 ];
2075 char drive[3] = { root_dir[0], ':' };
2076
2077 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
2078 == NO_ERROR)
2079 /* do something */ ;
2080 }
2081#endif
2082
2083 info = lookup_volume_info (root_dir);
2084
2085 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
94eab1c8
JB		 2086 {
2087 char name[ 256 ];
2088 DWORD serialnum;
2089 DWORD maxcomp;
2090 DWORD flags;
2091 char type[ 256 ];
2092
2093 /* Info is not cached, or is stale. */
2094 if (!GetVolumeInformation (root_dir,
2095 name, sizeof (name),
2096 &serialnum,
2097 &maxcomp,
2098 &flags,
2099 type, sizeof (type)))
2100 return NULL;
76b3903d 2101
94eab1c8
JB		 2102 /* Cache the volume information for future use, overwriting existing
2103 entry if present. */
2104 if (info == NULL)
2105 {
2106 info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
2107 add_volume_info (root_dir, info);
2108 }
2109 else
2110 {
2111 xfree (info->name);
2112 xfree (info->type);
2113 }
2114
2115 info->name = xstrdup (name);
2116 info->serialnum = serialnum;
2117 info->maxcomp = maxcomp;
2118 info->flags = flags;
2119 info->type = xstrdup (type);
2120 info->timestamp = GetTickCount ();
2121 }
76b3903d
GV		 2122
2123 return info;
2124}
480b0c5b
GV		 2125
2126/* Get information on the volume where name is held; set path pointer to
2127 start of pathname in name (past UNC header\volume header if present). */
bedf4aab 2128static int
480b0c5b 2129get_volume_info (const char * name, const char ** pPath)
95ed0025 2130{
480b0c5b
GV		 2131 char temp[MAX_PATH];
2132 char *rootname = NULL; /* default to current volume */
76b3903d 2133 volume_info_data * info;
480b0c5b
GV		 2134
2135 if (name == NULL)
2136 return FALSE;
2137
2138 /* find the root name of the volume if given */
2139 if (isalpha (name[0]) && name[1] == ':')
2140 {
2141 rootname = temp;
2142 temp[0] = *name++;
2143 temp[1] = *name++;
2144 temp[2] = '\\';
2145 temp[3] = 0;
2146 }
2147 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
95ed0025 2148 {
480b0c5b
GV		 2149 char *str = temp;
2150 int slashes = 4;
2151 rootname = temp;
2152 do
2153 {
2154 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
2155 break;
2156 *str++ = *name++;
2157 }
2158 while ( *name );
2159
480b0c5b
GV		 2160 *str++ = '\\';
2161 *str = 0;
95ed0025 2162 }
480b0c5b
GV		 2163
2164 if (pPath)
2165 *pPath = name;
177c0ea7 2166
76b3903d
GV		 2167 info = GetCachedVolumeInformation (rootname);
2168 if (info != NULL)
95ed0025 2169 {
76b3903d
GV		 2170 /* Set global referenced by other functions. */
2171 volume_info = *info;
480b0c5b 2172 return TRUE;
95ed0025 2173 }
480b0c5b
GV		 2174 return FALSE;
2175}
2176
2177/* Determine if volume is FAT format (ie. only supports short 8.3
2178 names); also set path pointer to start of pathname in name. */
bedf4aab 2179static int
480b0c5b
GV		 2180is_fat_volume (const char * name, const char ** pPath)
2181{
2182 if (get_volume_info (name, pPath))
2183 return (volume_info.maxcomp == 12);
2184 return FALSE;
2185}
2186
4d90eee4 2187/* Map filename to a valid 8.3 name if necessary. */
480b0c5b 2188const char *
fbd6baed 2189map_w32_filename (const char * name, const char ** pPath)
480b0c5b
GV		 2190{
2191 static char shortname[MAX_PATH];
2192 char * str = shortname;
2193 char c;
480b0c5b 2194 char * path;
76b3903d 2195 const char * save_name = name;
480b0c5b 2196
ca149beb
AI		 2197 if (strlen (name) >= MAX_PATH)
2198 {
2199 /* Return a filename which will cause callers to fail. */
2200 strcpy (shortname, "?");
2201 return shortname;
2202 }
2203
a302c7ae 2204 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
95ed0025 2205 {
480b0c5b
GV		 2206 register int left = 8; /* maximum number of chars in part */
2207 register int extn = 0; /* extension added? */
2208 register int dots = 2; /* maximum number of dots allowed */
2209
2210 while (name < path)
2211 *str++ = *name++; /* skip past UNC header */
2212
2213 while ((c = *name++))
2214 {
2215 switch ( c )
2216 {
2217 case '\\':
2218 case '/':
2219 *str++ = '\\';
2220 extn = 0; /* reset extension flags */
2221 dots = 2; /* max 2 dots */
2222 left = 8; /* max length 8 for main part */
2223 break;
2224 case ':':
2225 *str++ = ':';
2226 extn = 0; /* reset extension flags */
2227 dots = 2; /* max 2 dots */
2228 left = 8; /* max length 8 for main part */
2229 break;
2230 case '.':
2231 if ( dots )
2232 {
2233 /* Convert path components of the form .xxx to _xxx,
2234 but leave . and .. as they are. This allows .emacs
2235 to be read as _emacs, for example. */
2236
2237 if (! *name ||
2238 *name == '.' ||
2239 IS_DIRECTORY_SEP (*name))
2240 {
2241 *str++ = '.';
2242 dots--;
2243 }
2244 else
2245 {
2246 *str++ = '_';
2247 left--;
2248 dots = 0;
2249 }
2250 }
2251 else if ( !extn )
2252 {
2253 *str++ = '.';
2254 extn = 1; /* we've got an extension */
2255 left = 3; /* 3 chars in extension */
2256 }
2257 else
2258 {
2259 /* any embedded dots after the first are converted to _ */
2260 *str++ = '_';
2261 }
2262 break;
2263 case '~':
2264 case '#': /* don't lose these, they're important */
2265 if ( ! left )
2266 str[-1] = c; /* replace last character of part */
2267 /* FALLTHRU */
2268 default:
2269 if ( left )
2270 {
2271 *str++ = tolower (c); /* map to lower case (looks nicer) */
2272 left--;
2273 dots = 0; /* started a path component */
2274 }
2275 break;
2276 }
2277 }
2278 *str = '\0';
fc85cb29
RS		 2279 }
2280 else
2281 {
2282 strcpy (shortname, name);
2283 unixtodos_filename (shortname);
95ed0025 2284 }
480b0c5b
GV		 2285
2286 if (pPath)
76b3903d 2287 *pPath = shortname + (path - save_name);
480b0c5b 2288
fc85cb29 2289 return shortname;
480b0c5b
GV		 2290}
2291
b3308d2e
KH		 2292static int
2293is_exec (const char * name)
2294{
2295 char * p = strrchr (name, '.');
2296 return
2297 (p != NULL
05131107
JR		 2298 && (xstrcasecmp (p, ".exe") == 0 ||
2299 xstrcasecmp (p, ".com") == 0 ||
2300 xstrcasecmp (p, ".bat") == 0 ||
2301 xstrcasecmp (p, ".cmd") == 0));
b3308d2e
KH		 2302}
2303
177c0ea7 2304/* Emulate the Unix directory procedures opendir, closedir,
76b3903d
GV		 2305 and readdir. We can't use the procedures supplied in sysdep.c,
2306 so we provide them here. */
2307
2308struct direct dir_static; /* simulated directory contents */
2309static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
2310static int dir_is_fat;
2311static char dir_pathname[MAXPATHLEN+1];
2312static WIN32_FIND_DATA dir_find_data;
2313
9d3355d1
GV		 2314/* Support shares on a network resource as subdirectories of a read-only
2315 root directory. */
2316static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
bedf4aab
JB		 2317static HANDLE open_unc_volume (const char *);
2318static char *read_unc_volume (HANDLE, char *, int);
2319static void close_unc_volume (HANDLE);
9d3355d1 2320
76b3903d
GV		 2321DIR *
2322opendir (char *filename)
2323{
2324 DIR *dirp;
2325
2326 /* Opening is done by FindFirstFile. However, a read is inherent to
2327 this operation, so we defer the open until read time. */
2328
76b3903d
GV		 2329 if (dir_find_handle != INVALID_HANDLE_VALUE)
2330 return NULL;
9d3355d1
GV		 2331 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2332 return NULL;
2333
2334 if (is_unc_volume (filename))
2335 {
2336 wnet_enum_handle = open_unc_volume (filename);
2337 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
2338 return NULL;
2339 }
2340
2341 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
2342 return NULL;
76b3903d
GV		 2343
2344 dirp->dd_fd = 0;
2345 dirp->dd_loc = 0;
2346 dirp->dd_size = 0;
2347
2348 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
2349 dir_pathname[MAXPATHLEN] = '\0';
2350 dir_is_fat = is_fat_volume (filename, NULL);
2351
2352 return dirp;
2353}
2354
2355void
2356closedir (DIR *dirp)
2357{
2358 /* If we have a find-handle open, close it. */
2359 if (dir_find_handle != INVALID_HANDLE_VALUE)
2360 {
2361 FindClose (dir_find_handle);
2362 dir_find_handle = INVALID_HANDLE_VALUE;
2363 }
9d3355d1
GV		 2364 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2365 {
2366 close_unc_volume (wnet_enum_handle);
2367 wnet_enum_handle = INVALID_HANDLE_VALUE;
2368 }
76b3903d
GV		 2369 xfree ((char *) dirp);
2370}
2371
2372struct direct *
2373readdir (DIR *dirp)
2374{
b07103dc
EZ		 2375 int downcase = !NILP (Vw32_downcase_file_names);
2376
9d3355d1
GV		 2377 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2378 {
177c0ea7 2379 if (!read_unc_volume (wnet_enum_handle,
59eb0929
JB		 2380 dir_find_data.cFileName,
2381 MAX_PATH))
9d3355d1
GV		 2382 return NULL;
2383 }
76b3903d 2384 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
9d3355d1 2385 else if (dir_find_handle == INVALID_HANDLE_VALUE)
76b3903d
GV		 2386 {
2387 char filename[MAXNAMLEN + 3];
2388 int ln;
2389
2390 strcpy (filename, dir_pathname);
2391 ln = strlen (filename) - 1;
2392 if (!IS_DIRECTORY_SEP (filename[ln]))
2393 strcat (filename, "\\");
2394 strcat (filename, "*");
2395
2396 dir_find_handle = FindFirstFile (filename, &dir_find_data);
2397
2398 if (dir_find_handle == INVALID_HANDLE_VALUE)
2399 return NULL;
2400 }
2401 else
2402 {
2403 if (!FindNextFile (dir_find_handle, &dir_find_data))
2404 return NULL;
2405 }
177c0ea7 2406
76b3903d
GV		 2407 /* Emacs never uses this value, so don't bother making it match
2408 value returned by stat(). */
2409 dir_static.d_ino = 1;
177c0ea7 2410
b07103dc
EZ		 2411 strcpy (dir_static.d_name, dir_find_data.cFileName);
2412
2413 /* If the file name in cFileName[] includes `?' characters, it means
2414 the original file name used characters that cannot be represented
2415 by the current ANSI codepage. To avoid total lossage, retrieve
2416 the short 8+3 alias of the long file name. */
2417 if (_mbspbrk (dir_static.d_name, "?"))
2418 {
2419 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2420 downcase = 1; /* 8+3 aliases are returned in all caps */
2421 }
2422 dir_static.d_namlen = strlen (dir_static.d_name);
76b3903d
GV		 2423 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
2424 dir_static.d_namlen - dir_static.d_namlen % 4;
177c0ea7 2425
192788d7
EZ		 2426 /* If the file name in cFileName[] includes `?' characters, it means
2427 the original file name used characters that cannot be represented
2428 by the current ANSI codepage. To avoid total lossage, retrieve
2429 the short 8+3 alias of the long file name. */
2430 if (_mbspbrk (dir_find_data.cFileName, "?"))
2431 {
2432 strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2433 /* 8+3 aliases are returned in all caps, which could break
2434 various alists that look at filenames' extensions. */
2435 downcase = 1;
2436 }
2437 else
2438 strcpy (dir_static.d_name, dir_find_data.cFileName);
2439 dir_static.d_namlen = strlen (dir_static.d_name);
76b3903d
GV		 2440 if (dir_is_fat)
2441 _strlwr (dir_static.d_name);
b07103dc 2442 else if (downcase)
76b3903d
GV		 2443 {
2444 register char *p;
2445 for (p = dir_static.d_name; *p; p++)
2446 if (*p >= 'a' && *p <= 'z')
2447 break;
2448 if (!*p)
2449 _strlwr (dir_static.d_name);
2450 }
177c0ea7 2451
76b3903d
GV		 2452 return &dir_static;
2453}
2454
bedf4aab 2455static HANDLE
e0c181dd 2456open_unc_volume (const char *path)
9d3355d1 2457{
177c0ea7 2458 NETRESOURCE nr;
9d3355d1
GV		 2459 HANDLE henum;
2460 int result;
2461
177c0ea7
JB		 2462 nr.dwScope = RESOURCE_GLOBALNET;
2463 nr.dwType = RESOURCETYPE_DISK;
2464 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
2465 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
2466 nr.lpLocalName = NULL;
6e602566 2467 nr.lpRemoteName = (LPSTR)map_w32_filename (path, NULL);
177c0ea7
JB		 2468 nr.lpComment = NULL;
2469 nr.lpProvider = NULL;
9d3355d1 2470
ed3751c8
JB		 2471 result = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
2472 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
9d3355d1
GV		 2473
2474 if (result == NO_ERROR)
2475 return henum;
2476 else
2477 return INVALID_HANDLE_VALUE;
2478}
2479
bedf4aab 2480static char *
9d3355d1
GV		 2481read_unc_volume (HANDLE henum, char *readbuf, int size)
2482{
a302c7ae 2483 DWORD count;
9d3355d1 2484 int result;
a302c7ae 2485 DWORD bufsize = 512;
9d3355d1
GV		 2486 char *buffer;
2487 char *ptr;
2488
2489 count = 1;
2490 buffer = alloca (bufsize);
59eb0929 2491 result = WNetEnumResource (henum, &count, buffer, &bufsize);
9d3355d1
GV		 2492 if (result != NO_ERROR)
2493 return NULL;
2494
2495 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2496 ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
2497 ptr += 2;
2498 while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
2499 ptr++;
2500
2501 strncpy (readbuf, ptr, size);
2502 return readbuf;
2503}
2504
bedf4aab 2505static void
9d3355d1
GV		 2506close_unc_volume (HANDLE henum)
2507{
2508 if (henum != INVALID_HANDLE_VALUE)
2509 WNetCloseEnum (henum);
2510}
2511
bedf4aab 2512static DWORD
e0c181dd 2513unc_volume_file_attributes (const char *path)
9d3355d1
GV		 2514{
2515 HANDLE henum;
2516 DWORD attrs;
2517
2518 henum = open_unc_volume (path);
2519 if (henum == INVALID_HANDLE_VALUE)
2520 return -1;
2521
2522 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
2523
2524 close_unc_volume (henum);
2525
2526 return attrs;
2527}
2528
302d7d54
JR		 2529/* Ensure a network connection is authenticated. */
2530static void
2531logon_network_drive (const char *path)
2532{
2533 NETRESOURCE resource;
2534 char share[MAX_PATH];
2535 int i, n_slashes;
40a339c8 2536 char drive[4];
be4c6380 2537 UINT drvtype;
40a339c8 2538
be4c6380
EZ		 2539 if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
2540 drvtype = DRIVE_REMOTE;
2541 else if (path[0] == '\0' || path[1] != ':')
2542 drvtype = GetDriveType (NULL);
2543 else
2544 {
2545 drive[0] = path[0];
2546 drive[1] = ':';
2547 drive[2] = '\\';
2548 drive[3] = '\0';
2549 drvtype = GetDriveType (drive);
2550 }
302d7d54
JR		 2551
2552 /* Only logon to networked drives. */
be4c6380 2553 if (drvtype != DRIVE_REMOTE)
302d7d54 2554 return;
40a339c8 2555
302d7d54
JR		 2556 n_slashes = 2;
2557 strncpy (share, path, MAX_PATH);
2558 /* Truncate to just server and share name. */
2559 for (i = 2; i < MAX_PATH; i++)
2560 {
2561 if (IS_DIRECTORY_SEP (share[i]) && ++n_slashes > 3)
2562 {
2563 share[i] = '\0';
2564 break;
2565 }
2566 }
2567
2568 resource.dwType = RESOURCETYPE_DISK;
2569 resource.lpLocalName = NULL;
2570 resource.lpRemoteName = share;
2571 resource.lpProvider = NULL;
2572
2573 WNetAddConnection2 (&resource, NULL, NULL, CONNECT_INTERACTIVE);
2574}
480b0c5b
GV		 2575
2576/* Shadow some MSVC runtime functions to map requests for long filenames
2577 to reasonable short names if necessary. This was originally added to
177c0ea7 2578 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
480b0c5b
GV		 2579 long file names. */
2580
2581int
2582sys_access (const char * path, int mode)
2583{
b3308d2e
KH		 2584 DWORD attributes;
2585
2586 /* MSVC implementation doesn't recognize D_OK. */
2587 path = map_w32_filename (path, NULL);
9d3355d1
GV		 2588 if (is_unc_volume (path))
2589 {
2590 attributes = unc_volume_file_attributes (path);
2591 if (attributes == -1) {
2592 errno = EACCES;
2593 return -1;
2594 }
2595 }
2596 else if ((attributes = GetFileAttributes (path)) == -1)
b3308d2e
KH		 2597 {
2598 /* Should try mapping GetLastError to errno; for now just indicate
2599 that path doesn't exist. */
2600 errno = EACCES;
2601 return -1;
2602 }
2603 if ((mode & X_OK) != 0 && !is_exec (path))
2604 {
2605 errno = EACCES;
2606 return -1;
2607 }
2608 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
2609 {
2610 errno = EACCES;
2611 return -1;
2612 }
2613 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
2614 {
2615 errno = EACCES;
2616 return -1;
2617 }
2618 return 0;
480b0c5b
GV		 2619}
2620
2621int
2622sys_chdir (const char * path)
2623{
fbd6baed 2624 return _chdir (map_w32_filename (path, NULL));
480b0c5b
GV		 2625}
2626
2627int
2628sys_chmod (const char * path, int mode)
2629{
fbd6baed 2630 return _chmod (map_w32_filename (path, NULL), mode);
480b0c5b
GV		 2631}
2632
2d5ab4bf
EZ		 2633int
2634sys_chown (const char *path, uid_t owner, gid_t group)
2635{
e3b88685 2636 if (sys_chmod (path, S_IREAD) == -1) /* check if file exists */
2d5ab4bf
EZ		 2637 return -1;
2638 return 0;
2639}
2640
480b0c5b
GV		 2641int
2642sys_creat (const char * path, int mode)
2643{
fbd6baed 2644 return _creat (map_w32_filename (path, NULL), mode);
480b0c5b
GV		 2645}
2646
2647FILE *
b56ceb92 2648sys_fopen (const char * path, const char * mode)
480b0c5b
GV		 2649{
2650 int fd;
2651 int oflag;
2652 const char * mode_save = mode;
2653
2654 /* Force all file handles to be non-inheritable. This is necessary to
2655 ensure child processes don't unwittingly inherit handles that might
2656 prevent future file access. */
2657
2658 if (mode[0] == 'r')
2659 oflag = O_RDONLY;
2660 else if (mode[0] == 'w' || mode[0] == 'a')
2661 oflag = O_WRONLY | O_CREAT | O_TRUNC;
95ed0025 2662 else
480b0c5b
GV		 2663 return NULL;
2664
2665 /* Only do simplistic option parsing. */
2666 while (*++mode)
2667 if (mode[0] == '+')
2668 {
2669 oflag &= ~(O_RDONLY | O_WRONLY);
2670 oflag |= O_RDWR;
2671 }
2672 else if (mode[0] == 'b')
2673 {
2674 oflag &= ~O_TEXT;
2675 oflag |= O_BINARY;
2676 }
2677 else if (mode[0] == 't')
2678 {
2679 oflag &= ~O_BINARY;
2680 oflag |= O_TEXT;
2681 }
2682 else break;
2683
fbd6baed 2684 fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
480b0c5b
GV		 2685 if (fd < 0)
2686 return NULL;
2687
76b3903d 2688 return _fdopen (fd, mode_save);
95ed0025 2689}
480b0c5b 2690
76b3903d 2691/* This only works on NTFS volumes, but is useful to have. */
480b0c5b 2692int
76b3903d 2693sys_link (const char * old, const char * new)
480b0c5b 2694{
76b3903d
GV		 2695 HANDLE fileh;
2696 int result = -1;
2697 char oldname[MAX_PATH], newname[MAX_PATH];
2698
2699 if (old == NULL || new == NULL)
2700 {
2701 errno = ENOENT;
2702 return -1;
2703 }
2704
2705 strcpy (oldname, map_w32_filename (old, NULL));
2706 strcpy (newname, map_w32_filename (new, NULL));
2707
2708 fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
2709 FILE_FLAG_BACKUP_SEMANTICS, NULL);
2710 if (fileh != INVALID_HANDLE_VALUE)
2711 {
2712 int wlen;
2713
2714 /* Confusingly, the "alternate" stream name field does not apply
2715 when restoring a hard link, and instead contains the actual
2716 stream data for the link (ie. the name of the link to create).
2717 The WIN32_STREAM_ID structure before the cStreamName field is
2718 the stream header, which is then immediately followed by the
2719 stream data. */
2720
2721 struct {
2722 WIN32_STREAM_ID wid;
2723 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
2724 } data;
2725
2726 wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
2727 data.wid.cStreamName, MAX_PATH);
2728 if (wlen > 0)
2729 {
2730 LPVOID context = NULL;
2731 DWORD wbytes = 0;
2732
2733 data.wid.dwStreamId = BACKUP_LINK;
2734 data.wid.dwStreamAttributes = 0;
ed3751c8 2735 data.wid.Size.LowPart = wlen * sizeof (WCHAR);
76b3903d
GV		 2736 data.wid.Size.HighPart = 0;
2737 data.wid.dwStreamNameSize = 0;
2738
2739 if (BackupWrite (fileh, (LPBYTE)&data,
2740 offsetof (WIN32_STREAM_ID, cStreamName)
2741 + data.wid.Size.LowPart,
2742 &wbytes, FALSE, FALSE, &context)
2743 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
2744 {
2745 /* succeeded */
2746 result = 0;
2747 }
2748 else
2749 {
2750 /* Should try mapping GetLastError to errno; for now just
2751 indicate a general error (eg. links not supported). */
2752 errno = EINVAL; // perhaps EMLINK?
2753 }
2754 }
2755
2756 CloseHandle (fileh);
2757 }
2758 else
2759 errno = ENOENT;
2760
2761 return result;
480b0c5b
GV		 2762}
2763
2764int
2765sys_mkdir (const char * path)
2766{
fbd6baed 2767 return _mkdir (map_w32_filename (path, NULL));
480b0c5b
GV		 2768}
2769
9d1778b1
RS		 2770/* Because of long name mapping issues, we need to implement this
2771 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2772 a unique name, instead of setting the input template to an empty
2773 string.
2774
2775 Standard algorithm seems to be use pid or tid with a letter on the
2776 front (in place of the 6 X's) and cycle through the letters to find a
2777 unique name. We extend that to allow any reasonable character as the
2778 first of the 6 X's. */
480b0c5b
GV		 2779char *
2780sys_mktemp (char * template)
2781{
9d1778b1
RS		 2782 char * p;
2783 int i;
2784 unsigned uid = GetCurrentThreadId ();
2785 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2786
2787 if (template == NULL)
2788 return NULL;
2789 p = template + strlen (template);
2790 i = 5;
2791 /* replace up to the last 5 X's with uid in decimal */
2792 while (--p >= template && p[0] == 'X' && --i >= 0)
2793 {
2794 p[0] = '0' + uid % 10;
2795 uid /= 10;
2796 }
2797
2798 if (i < 0 && p[0] == 'X')
2799 {
2800 i = 0;
2801 do
2802 {
2803 int save_errno = errno;
2804 p[0] = first_char[i];
2805 if (sys_access (template, 0) < 0)
2806 {
2807 errno = save_errno;
2808 return template;
2809 }
2810 }
2811 while (++i < sizeof (first_char));
2812 }
2813
2814 /* Template is badly formed or else we can't generate a unique name,
2815 so return empty string */
2816 template[0] = 0;
2817 return template;
480b0c5b
GV		 2818}
2819
2820int
2821sys_open (const char * path, int oflag, int mode)
2822{
302f0b29
GM		 2823 const char* mpath = map_w32_filename (path, NULL);
2824 /* Try to open file without _O_CREAT, to be able to write to hidden
2825 and system files. Force all file handles to be
2826 non-inheritable. */
2827 int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
2828 if (res >= 0)
2829 return res;
2830 return _open (mpath, oflag | _O_NOINHERIT, mode);
480b0c5b
GV		 2831}
2832
2833int
2834sys_rename (const char * oldname, const char * newname)
2835{
cfb5e855 2836 BOOL result;
b3308d2e 2837 char temp[MAX_PATH];
480b0c5b 2838
e9e23e23 2839 /* MoveFile on Windows 95 doesn't correctly change the short file name
5162ffce
MB		 2840 alias in a number of circumstances (it is not easy to predict when
2841 just by looking at oldname and newname, unfortunately). In these
2842 cases, renaming through a temporary name avoids the problem.
2843
e9e23e23 2844 A second problem on Windows 95 is that renaming through a temp name when
5162ffce
MB		 2845 newname is uppercase fails (the final long name ends up in
2846 lowercase, although the short alias might be uppercase) UNLESS the
2847 long temp name is not 8.3.
2848
e9e23e23 2849 So, on Windows 95 we always rename through a temp name, and we make sure
5162ffce 2850 the temp name has a long extension to ensure correct renaming. */
480b0c5b 2851
fbd6baed 2852 strcpy (temp, map_w32_filename (oldname, NULL));
480b0c5b 2853
76b3903d 2854 if (os_subtype == OS_WIN95)
480b0c5b 2855 {
b3308d2e 2856 char * o;
480b0c5b 2857 char * p;
b3308d2e
KH		 2858 int i = 0;
2859
2860 oldname = map_w32_filename (oldname, NULL);
2861 if (o = strrchr (oldname, '\\'))
2862 o++;
2863 else
2864 o = (char *) oldname;
480b0c5b 2865
480b0c5b
GV		 2866 if (p = strrchr (temp, '\\'))
2867 p++;
2868 else
2869 p = temp;
b3308d2e
KH		 2870
2871 do
2872 {
2873 /* Force temp name to require a manufactured 8.3 alias - this
2874 seems to make the second rename work properly. */
f313ee82 2875 sprintf (p, "_.%s.%u", o, i);
b3308d2e 2876 i++;
58f0cb7e 2877 result = rename (oldname, temp);
b3308d2e
KH		 2878 }
2879 /* This loop must surely terminate! */
cfb5e855 2880 while (result < 0 && errno == EEXIST);
58f0cb7e 2881 if (result < 0)
480b0c5b
GV		 2882 return -1;
2883 }
2884
fffa137c 2885 /* Emulate Unix behavior - newname is deleted if it already exists
5162ffce 2886 (at least if it is a file; don't do this for directories).
76b3903d 2887
b3308d2e
KH		 2888 Since we mustn't do this if we are just changing the case of the
2889 file name (we would end up deleting the file we are trying to
2890 rename!), we let rename detect if the destination file already
2891 exists - that way we avoid the possible pitfalls of trying to
2892 determine ourselves whether two names really refer to the same
2893 file, which is not always possible in the general case. (Consider
2894 all the permutations of shared or subst'd drives, etc.) */
2895
2896 newname = map_w32_filename (newname, NULL);
eb9ea53f 2897 result = rename (temp, newname);
b3308d2e
KH		 2898
2899 if (result < 0
cfb5e855 2900 && errno == EEXIST
b3308d2e
KH		 2901 && _chmod (newname, 0666) == 0
2902 && _unlink (newname) == 0)
2903 result = rename (temp, newname);
480b0c5b 2904
eb9ea53f 2905 return result;
480b0c5b
GV		 2906}
2907
2908int
2909sys_rmdir (const char * path)
2910{
fbd6baed 2911 return _rmdir (map_w32_filename (path, NULL));
480b0c5b
GV		 2912}
2913
2914int
2915sys_unlink (const char * path)
2916{
16bb7578
GV		 2917 path = map_w32_filename (path, NULL);
2918
2919 /* On Unix, unlink works without write permission. */
2920 _chmod (path, 0666);
2921 return _unlink (path);
480b0c5b
GV		 2922}
2923
2924static FILETIME utc_base_ft;
5da9424d 2925static ULONGLONG utc_base; /* In 100ns units */
480b0c5b
GV		 2926static int init = 0;
2927
5da9424d
JB		 2928#define FILETIME_TO_U64(result, ft) \
2929 do { \
2930 ULARGE_INTEGER uiTemp; \
2931 uiTemp.LowPart = (ft).dwLowDateTime; \
2932 uiTemp.HighPart = (ft).dwHighDateTime; \
2933 result = uiTemp.QuadPart; \
2934 } while (0)
2935
2936static void
b56ceb92 2937initialize_utc_base (void)
7c80d5ec 2938{
5da9424d
JB		 2939 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2940 SYSTEMTIME st;
2941
2942 st.wYear = 1970;
2943 st.wMonth = 1;
2944 st.wDay = 1;
2945 st.wHour = 0;
2946 st.wMinute = 0;
2947 st.wSecond = 0;
2948 st.wMilliseconds = 0;
2949
2950 SystemTimeToFileTime (&st, &utc_base_ft);
2951 FILETIME_TO_U64 (utc_base, utc_base_ft);
7c80d5ec
EZ		 2952}
2953
480b0c5b
GV		 2954static time_t
2955convert_time (FILETIME ft)
2956{
5da9424d 2957 ULONGLONG tmp;
480b0c5b
GV		 2958
2959 if (!init)
2960 {
9d4f32e8 2961 initialize_utc_base ();
480b0c5b
GV		 2962 init = 1;
2963 }
2964
2965 if (CompareFileTime (&ft, &utc_base_ft) < 0)
2966 return 0;
2967
5da9424d
JB		 2968 FILETIME_TO_U64 (tmp, ft);
2969 return (time_t) ((tmp - utc_base) / 10000000L);
480b0c5b
GV		 2970}
2971
bedf4aab 2972static void
480b0c5b
GV		 2973convert_from_time_t (time_t time, FILETIME * pft)
2974{
5da9424d 2975 ULARGE_INTEGER tmp;
480b0c5b
GV		 2976
2977 if (!init)
2978 {
5da9424d 2979 initialize_utc_base ();
480b0c5b
GV		 2980 init = 1;
2981 }
2982
2983 /* time in 100ns units since 1-Jan-1601 */
5da9424d
JB		 2984 tmp.QuadPart = (ULONGLONG) time * 10000000L + utc_base;
2985 pft->dwHighDateTime = tmp.HighPart;
2986 pft->dwLowDateTime = tmp.LowPart;
480b0c5b 2987}
480b0c5b 2988
76b3903d
GV		 2989#if 0
2990/* No reason to keep this; faking inode values either by hashing or even
2991 using the file index from GetInformationByHandle, is not perfect and
2992 so by default Emacs doesn't use the inode values on Windows.
2993 Instead, we now determine file-truename correctly (except for
2994 possible drive aliasing etc). */
2995
2996/* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
480b0c5b 2997static unsigned
76b3903d 2998hashval (const unsigned char * str)
480b0c5b
GV		 2999{
3000 unsigned h = 0;
480b0c5b
GV		 3001 while (*str)
3002 {
3003 h = (h << 4) + *str++;
76b3903d 3004 h ^= (h >> 28);
480b0c5b
GV		 3005 }
3006 return h;
3007}
3008
3009/* Return the hash value of the canonical pathname, excluding the
3010 drive/UNC header, to get a hopefully unique inode number. */
76b3903d 3011static DWORD
480b0c5b
GV		 3012generate_inode_val (const char * name)
3013{
3014 char fullname[ MAX_PATH ];
3015 char * p;
3016 unsigned hash;
3017
76b3903d
GV		 3018 /* Get the truly canonical filename, if it exists. (Note: this
3019 doesn't resolve aliasing due to subst commands, or recognise hard
3020 links. */
3021 if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
3022 abort ();
3023
3024 parse_root (fullname, &p);
fbd6baed 3025 /* Normal W32 filesystems are still case insensitive. */
480b0c5b 3026 _strlwr (p);
76b3903d 3027 return hashval (p);
480b0c5b
GV		 3028}
3029
76b3903d
GV		 3030#endif
3031
8aaaec6b
EZ		 3032static PSECURITY_DESCRIPTOR
3033get_file_security_desc (const char *fname)
3034{
3035 PSECURITY_DESCRIPTOR psd = NULL;
3036 DWORD sd_len, err;
3037 SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3038 | GROUP_SECURITY_INFORMATION /* | DACL_SECURITY_INFORMATION */ ;
3039
3040 if (!get_file_security (fname, si, psd, 0, &sd_len))
3041 {
3042 err = GetLastError ();
3043 if (err != ERROR_INSUFFICIENT_BUFFER)
3044 return NULL;
3045 }
3046
3047 psd = xmalloc (sd_len);
3048 if (!get_file_security (fname, si, psd, sd_len, &sd_len))
3049 {
3050 xfree (psd);
3051 return NULL;
3052 }
3053
3054 return psd;
3055}
3056
3057static DWORD
3058get_rid (PSID sid)
3059{
3060 unsigned n_subauthorities;
3061
3062 /* Use the last sub-authority value of the RID, the relative
3063 portion of the SID, as user/group ID. */
3064 n_subauthorities = *get_sid_sub_authority_count (sid);
3065 if (n_subauthorities < 1)
3066 return 0; /* the "World" RID */
3067 return *get_sid_sub_authority (sid, n_subauthorities - 1);
3068}
3069
f8b35b24
EZ		 3070/* Caching SID and account values for faster lokup. */
3071
3072#ifdef __GNUC__
3073# define FLEXIBLE_ARRAY_MEMBER
3074#else
3075# define FLEXIBLE_ARRAY_MEMBER 1
3076#endif
3077
3078struct w32_id {
22749e9a 3079 unsigned rid;
f8b35b24
EZ		 3080 struct w32_id *next;
3081 char name[GNLEN+1];
3082 unsigned char sid[FLEXIBLE_ARRAY_MEMBER];
3083};
3084
3085static struct w32_id *w32_idlist;
3086
3087static int
22749e9a 3088w32_cached_id (PSID sid, unsigned *id, char *name)
f8b35b24
EZ		 3089{
3090 struct w32_id *tail, *found;
3091
3092 for (found = NULL, tail = w32_idlist; tail; tail = tail->next)
3093 {
3094 if (equal_sid ((PSID)tail->sid, sid))
3095 {
3096 found = tail;
3097 break;
3098 }
3099 }
3100 if (found)
3101 {
3102 *id = found->rid;
3103 strcpy (name, found->name);
3104 return 1;
3105 }
3106 else
3107 return 0;
3108}
3109
3110static void
22749e9a 3111w32_add_to_cache (PSID sid, unsigned id, char *name)
f8b35b24
EZ		 3112{
3113 DWORD sid_len;
3114 struct w32_id *new_entry;
3115
3116 /* We don't want to leave behind stale cache from when Emacs was
3117 dumped. */
3118 if (initialized)
3119 {
3120 sid_len = get_length_sid (sid);
3121 new_entry = xmalloc (offsetof (struct w32_id, sid) + sid_len);
3122 if (new_entry)
3123 {
3124 new_entry->rid = id;
3125 strcpy (new_entry->name, name);
3126 copy_sid (sid_len, (PSID)new_entry->sid, sid);
3127 new_entry->next = w32_idlist;
3128 w32_idlist = new_entry;
3129 }
3130 }
3131}
3132
8aaaec6b
EZ		 3133#define UID 1
3134#define GID 2
3135
3136static int
3137get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
22749e9a 3138 unsigned *id, char *nm, int what)
8aaaec6b
EZ		 3139{
3140 PSID sid = NULL;
3141 char machine[MAX_COMPUTERNAME_LENGTH+1];
3142 BOOL dflt;
3143 SID_NAME_USE ignore;
3144 char name[UNLEN+1];
3145 DWORD name_len = sizeof (name);
3146 char domain[1024];
ed3751c8 3147 DWORD domain_len = sizeof (domain);
8aaaec6b
EZ		 3148 char *mp = NULL;
3149 int use_dflt = 0;
3150 int result;
3151
3152 if (what == UID)
3153 result = get_security_descriptor_owner (psd, &sid, &dflt);
3154 else if (what == GID)
3155 result = get_security_descriptor_group (psd, &sid, &dflt);
3156 else
3157 result = 0;
3158
3159 if (!result || !is_valid_sid (sid))
3160 use_dflt = 1;
f8b35b24 3161 else if (!w32_cached_id (sid, id, nm))
8aaaec6b
EZ		 3162 {
3163 /* If FNAME is a UNC, we need to lookup account on the
3164 specified machine. */
3165 if (IS_DIRECTORY_SEP (fname[0]) && IS_DIRECTORY_SEP (fname[1])
3166 && fname[2] != '\0')
3167 {
3168 const char *s;
3169 char *p;
3170
3171 for (s = fname + 2, p = machine;
3172 *s && !IS_DIRECTORY_SEP (*s); s++, p++)
3173 *p = *s;
3174 *p = '\0';
3175 mp = machine;
3176 }
3177
3178 if (!lookup_account_sid (mp, sid, name, &name_len,
3179 domain, &domain_len, &ignore)
3180 || name_len > UNLEN+1)
3181 use_dflt = 1;
3182 else
3183 {
3184 *id = get_rid (sid);
3185 strcpy (nm, name);
f8b35b24 3186 w32_add_to_cache (sid, *id, name);
8aaaec6b
EZ		 3187 }
3188 }
3189 return use_dflt;
3190}
3191
3192static void
bedf4aab
JB		 3193get_file_owner_and_group (PSECURITY_DESCRIPTOR psd,
3194 const char *fname,
3195 struct stat *st)
8aaaec6b
EZ		 3196{
3197 int dflt_usr = 0, dflt_grp = 0;
3198
3199 if (!psd)
3200 {
3201 dflt_usr = 1;
3202 dflt_grp = 1;
3203 }
3204 else
3205 {
3206 if (get_name_and_id (psd, fname, &st->st_uid, st->st_uname, UID))
3207 dflt_usr = 1;
3208 if (get_name_and_id (psd, fname, &st->st_gid, st->st_gname, GID))
3209 dflt_grp = 1;
3210 }
3211 /* Consider files to belong to current user/group, if we cannot get
3212 more accurate information. */
3213 if (dflt_usr)
3214 {
3215 st->st_uid = dflt_passwd.pw_uid;
3216 strcpy (st->st_uname, dflt_passwd.pw_name);
3217 }
3218 if (dflt_grp)
3219 {
3220 st->st_gid = dflt_passwd.pw_gid;
3221 strcpy (st->st_gname, dflt_group.gr_name);
3222 }
3223}
3224
be4c6380
EZ		 3225/* Return non-zero if NAME is a potentially slow filesystem. */
3226int
3227is_slow_fs (const char *name)
3228{
3229 char drive_root[4];
3230 UINT devtype;
3231
3232 if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
3233 devtype = DRIVE_REMOTE; /* assume UNC name is remote */
3234 else if (!(strlen (name) >= 2 && IS_DEVICE_SEP (name[1])))
3235 devtype = GetDriveType (NULL); /* use root of current drive */
3236 else
3237 {
3238 /* GetDriveType needs the root directory of the drive. */
3239 strncpy (drive_root, name, 2);
3240 drive_root[2] = '\\';
3241 drive_root[3] = '\0';
3242 devtype = GetDriveType (drive_root);
3243 }
3244 return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
3245}
3246
480b0c5b
GV		 3247/* MSVC stat function can't cope with UNC names and has other bugs, so
3248 replace it with our own. This also allows us to calculate consistent
3249 inode values without hacks in the main Emacs code. */
3250int
3251stat (const char * path, struct stat * buf)
3252{
eb9ea53f 3253 char *name, *r;
480b0c5b
GV		 3254 WIN32_FIND_DATA wfd;
3255 HANDLE fh;
e3b88685 3256 unsigned __int64 fake_inode;
480b0c5b
GV		 3257 int permission;
3258 int len;
3259 int rootdir = FALSE;
8aaaec6b 3260 PSECURITY_DESCRIPTOR psd = NULL;
480b0c5b
GV		 3261
3262 if (path == NULL || buf == NULL)
3263 {
3264 errno = EFAULT;
3265 return -1;
3266 }
3267
fbd6baed 3268 name = (char *) map_w32_filename (path, &path);
22189f79
EZ		 3269 /* Must be valid filename, no wild cards or other invalid
3270 characters. We use _mbspbrk to support multibyte strings that
3271 might look to strpbrk as if they included literal *, ?, and other
3272 characters mentioned below that are disallowed by Windows
3273 filesystems. */
3274 if (_mbspbrk (name, "*?|<>\""))
480b0c5b
GV		 3275 {
3276 errno = ENOENT;
3277 return -1;
3278 }
3279
eb9ea53f
GV		 3280 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3281 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
3282 if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
3283 {
3284 r[1] = r[2] = '\0';
3285 }
3286
480b0c5b
GV		 3287 /* Remove trailing directory separator, unless name is the root
3288 directory of a drive or UNC volume in which case ensure there
3289 is a trailing separator. */
3290 len = strlen (name);
3291 rootdir = (path >= name + len - 1
3292 && (IS_DIRECTORY_SEP (*path) || *path == 0));
3293 name = strcpy (alloca (len + 2), name);
3294
9d3355d1
GV		 3295 if (is_unc_volume (name))
3296 {
3297 DWORD attrs = unc_volume_file_attributes (name);
3298
3299 if (attrs == -1)
3300 return -1;
3301
3302 memset (&wfd, 0, sizeof (wfd));
3303 wfd.dwFileAttributes = attrs;
3304 wfd.ftCreationTime = utc_base_ft;
3305 wfd.ftLastAccessTime = utc_base_ft;
3306 wfd.ftLastWriteTime = utc_base_ft;
3307 strcpy (wfd.cFileName, name);
3308 }
3309 else if (rootdir)
480b0c5b
GV		 3310 {
3311 if (!IS_DIRECTORY_SEP (name[len-1]))
3312 strcat (name, "\\");
3313 if (GetDriveType (name) < 2)
3314 {
3315 errno = ENOENT;
3316 return -1;
3317 }
3318 memset (&wfd, 0, sizeof (wfd));
3319 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
3320 wfd.ftCreationTime = utc_base_ft;
3321 wfd.ftLastAccessTime = utc_base_ft;
3322 wfd.ftLastWriteTime = utc_base_ft;
3323 strcpy (wfd.cFileName, name);
3324 }
3325 else
3326 {
3327 if (IS_DIRECTORY_SEP (name[len-1]))
3328 name[len - 1] = 0;
76b3903d
GV		 3329
3330 /* (This is hacky, but helps when doing file completions on
3331 network drives.) Optimize by using information available from
3332 active readdir if possible. */
b19cc00c
GV		 3333 len = strlen (dir_pathname);
3334 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
3335 len--;
76b3903d 3336 if (dir_find_handle != INVALID_HANDLE_VALUE
b19cc00c 3337 && strnicmp (name, dir_pathname, len) == 0
76b3903d 3338 && IS_DIRECTORY_SEP (name[len])
05131107 3339 && xstrcasecmp (name + len + 1, dir_static.d_name) == 0)
480b0c5b 3340 {
76b3903d
GV		 3341 /* This was the last entry returned by readdir. */
3342 wfd = dir_find_data;
3343 }
3344 else
3345 {
513feaa5 3346 logon_network_drive (name);
302d7d54 3347
76b3903d
GV		 3348 fh = FindFirstFile (name, &wfd);
3349 if (fh == INVALID_HANDLE_VALUE)
3350 {
3351 errno = ENOENT;
3352 return -1;
3353 }
3354 FindClose (fh);
480b0c5b 3355 }
480b0c5b
GV		 3356 }
3357
8aaaec6b 3358 if (!(NILP (Vw32_get_true_file_attributes)
19ced600 3359 || (EQ (Vw32_get_true_file_attributes, Qlocal) && is_slow_fs (name)))
93e0f0da
JR		 3360 /* No access rights required to get info. */
3361 && (fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
3362 FILE_FLAG_BACKUP_SEMANTICS, NULL))
3363 != INVALID_HANDLE_VALUE)
480b0c5b 3364 {
480b0c5b 3365 /* This is more accurate in terms of gettting the correct number
aa5ee2a3 3366 of links, but is quite slow (it is noticeable when Emacs is
480b0c5b
GV		 3367 making a list of file name completions). */
3368 BY_HANDLE_FILE_INFORMATION info;
3369
480b0c5b
GV		 3370 if (GetFileInformationByHandle (fh, &info))
3371 {
480b0c5b 3372 buf->st_nlink = info.nNumberOfLinks;
76b3903d
GV		 3373 /* Might as well use file index to fake inode values, but this
3374 is not guaranteed to be unique unless we keep a handle open
3375 all the time (even then there are situations where it is
3376 not unique). Reputedly, there are at most 48 bits of info
3377 (on NTFS, presumably less on FAT). */
e3b88685
EZ		 3378 fake_inode = info.nFileIndexHigh;
3379 fake_inode <<= 32;
3380 fake_inode += info.nFileIndexLow;
480b0c5b
GV		 3381 }
3382 else
3383 {
01f31dfb
AI		 3384 buf->st_nlink = 1;
3385 fake_inode = 0;
3386 }
3387
93e0f0da 3388 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
01f31dfb 3389 {
e3b88685 3390 buf->st_mode = S_IFDIR;
93e0f0da
JR		 3391 }
3392 else
3393 {
3394 switch (GetFileType (fh))
3395 {
3396 case FILE_TYPE_DISK:
e3b88685 3397 buf->st_mode = S_IFREG;
93e0f0da
JR		 3398 break;
3399 case FILE_TYPE_PIPE:
e3b88685 3400 buf->st_mode = S_IFIFO;
93e0f0da
JR		 3401 break;
3402 case FILE_TYPE_CHAR:
3403 case FILE_TYPE_UNKNOWN:
3404 default:
e3b88685 3405 buf->st_mode = S_IFCHR;
93e0f0da 3406 }
480b0c5b 3407 }
01f31dfb 3408 CloseHandle (fh);
8aaaec6b
EZ		 3409 psd = get_file_security_desc (name);
3410 get_file_owner_and_group (psd, name, buf);
76b3903d
GV		 3411 }
3412 else
3413 {
3414 /* Don't bother to make this information more accurate. */
93e0f0da 3415 buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
e3b88685 3416 S_IFDIR : S_IFREG;
480b0c5b 3417 buf->st_nlink = 1;
76b3903d 3418 fake_inode = 0;
8aaaec6b
EZ		 3419
3420 get_file_owner_and_group (NULL, name, buf);
76b3903d 3421 }
70fdbb46 3422 xfree (psd);
76b3903d
GV		 3423
3424#if 0
3425 /* Not sure if there is any point in this. */
3426 if (!NILP (Vw32_generate_fake_inodes))
3427 fake_inode = generate_inode_val (name);
3428 else if (fake_inode == 0)
3429 {
3430 /* For want of something better, try to make everything unique. */
3431 static DWORD gen_num = 0;
3432 fake_inode = ++gen_num;
480b0c5b 3433 }
76b3903d
GV		 3434#endif
3435
3436 /* MSVC defines _ino_t to be short; other libc's might not. */
3437 if (sizeof (buf->st_ino) == 2)
3438 buf->st_ino = fake_inode ^ (fake_inode >> 16);
3439 else
3440 buf->st_ino = fake_inode;
480b0c5b 3441
fbd6baed 3442 /* volume_info is set indirectly by map_w32_filename */
480b0c5b
GV		 3443 buf->st_dev = volume_info.serialnum;
3444 buf->st_rdev = volume_info.serialnum;
3445
8aaaec6b
EZ		 3446 buf->st_size = wfd.nFileSizeHigh;
3447 buf->st_size <<= 32;
3448 buf->st_size += wfd.nFileSizeLow;
480b0c5b
GV		 3449
3450 /* Convert timestamps to Unix format. */
3451 buf->st_mtime = convert_time (wfd.ftLastWriteTime);
3452 buf->st_atime = convert_time (wfd.ftLastAccessTime);
3453 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
3454 buf->st_ctime = convert_time (wfd.ftCreationTime);
3455 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
3456
3457 /* determine rwx permissions */
3458 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
e3b88685 3459 permission = S_IREAD;
480b0c5b 3460 else
e3b88685 3461 permission = S_IREAD | S_IWRITE;
177c0ea7 3462
480b0c5b 3463 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
e3b88685 3464 permission |= S_IEXEC;
b3308d2e 3465 else if (is_exec (name))
e3b88685 3466 permission |= S_IEXEC;
480b0c5b
GV		 3467
3468 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
3469
3470 return 0;
3471}
3472
16bb7578
GV		 3473/* Provide fstat and utime as well as stat for consistent handling of
3474 file timestamps. */
3475int
3476fstat (int desc, struct stat * buf)
3477{
3478 HANDLE fh = (HANDLE) _get_osfhandle (desc);
3479 BY_HANDLE_FILE_INFORMATION info;
e3b88685 3480 unsigned __int64 fake_inode;
16bb7578
GV		 3481 int permission;
3482
3483 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
3484 {
3485 case FILE_TYPE_DISK:
e3b88685 3486 buf->st_mode = S_IFREG;
16bb7578
GV		 3487 if (!GetFileInformationByHandle (fh, &info))
3488 {
3489 errno = EACCES;
3490 return -1;
3491 }
3492 break;
3493 case FILE_TYPE_PIPE:
e3b88685 3494 buf->st_mode = S_IFIFO;
16bb7578
GV		 3495 goto non_disk;
3496 case FILE_TYPE_CHAR:
3497 case FILE_TYPE_UNKNOWN:
3498 default:
e3b88685 3499 buf->st_mode = S_IFCHR;
16bb7578
GV		 3500 non_disk:
3501 memset (&info, 0, sizeof (info));
3502 info.dwFileAttributes = 0;
3503 info.ftCreationTime = utc_base_ft;
3504 info.ftLastAccessTime = utc_base_ft;
3505 info.ftLastWriteTime = utc_base_ft;
3506 }
3507
3508 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
e3b88685 3509 buf->st_mode = S_IFDIR;
93e0f0da
JR		 3510
3511 buf->st_nlink = info.nNumberOfLinks;
3512 /* Might as well use file index to fake inode values, but this
3513 is not guaranteed to be unique unless we keep a handle open
3514 all the time (even then there are situations where it is
3515 not unique). Reputedly, there are at most 48 bits of info
3516 (on NTFS, presumably less on FAT). */
e3b88685
EZ		 3517 fake_inode = info.nFileIndexHigh;
3518 fake_inode <<= 32;
3519 fake_inode += info.nFileIndexLow;
16bb7578
GV		 3520
3521 /* MSVC defines _ino_t to be short; other libc's might not. */
3522 if (sizeof (buf->st_ino) == 2)
3523 buf->st_ino = fake_inode ^ (fake_inode >> 16);
3524 else
3525 buf->st_ino = fake_inode;
3526
8aaaec6b
EZ		 3527 /* Consider files to belong to current user.
3528 FIXME: this should use GetSecurityInfo API, but it is only
3529 available for _WIN32_WINNT >= 0x501. */
07f7980a
EZ		 3530 buf->st_uid = dflt_passwd.pw_uid;
3531 buf->st_gid = dflt_passwd.pw_gid;
8aaaec6b
EZ		 3532 strcpy (buf->st_uname, dflt_passwd.pw_name);
3533 strcpy (buf->st_gname, dflt_group.gr_name);
16bb7578
GV		 3534
3535 buf->st_dev = info.dwVolumeSerialNumber;
3536 buf->st_rdev = info.dwVolumeSerialNumber;
3537
8aaaec6b
EZ		 3538 buf->st_size = info.nFileSizeHigh;
3539 buf->st_size <<= 32;
3540 buf->st_size += info.nFileSizeLow;
16bb7578
GV		 3541
3542 /* Convert timestamps to Unix format. */
3543 buf->st_mtime = convert_time (info.ftLastWriteTime);
3544 buf->st_atime = convert_time (info.ftLastAccessTime);
3545 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
3546 buf->st_ctime = convert_time (info.ftCreationTime);
3547 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
3548
3549 /* determine rwx permissions */
3550 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
e3b88685 3551 permission = S_IREAD;
16bb7578 3552 else
e3b88685 3553 permission = S_IREAD | S_IWRITE;
177c0ea7 3554
16bb7578 3555 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
e3b88685 3556 permission |= S_IEXEC;
16bb7578
GV		 3557 else
3558 {
3559#if 0 /* no way of knowing the filename */
3560 char * p = strrchr (name, '.');
3561 if (p != NULL &&
05131107
JR		 3562 (xstrcasecmp (p, ".exe") == 0 ||
3563 xstrcasecmp (p, ".com") == 0 ||
3564 xstrcasecmp (p, ".bat") == 0 ||
3565 xstrcasecmp (p, ".cmd") == 0))
e3b88685 3566 permission |= S_IEXEC;
16bb7578
GV		 3567#endif
3568 }
3569
3570 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
3571
3572 return 0;
3573}
3574
3575int
3576utime (const char *name, struct utimbuf *times)
3577{
3578 struct utimbuf deftime;
3579 HANDLE fh;
3580 FILETIME mtime;
3581 FILETIME atime;
3582
3583 if (times == NULL)
3584 {
3585 deftime.modtime = deftime.actime = time (NULL);
3586 times = &deftime;
3587 }
3588
3589 /* Need write access to set times. */
3590 fh = CreateFile (name, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
3591 0, OPEN_EXISTING, 0, NULL);
3592 if (fh)
3593 {
3594 convert_from_time_t (times->actime, &atime);
3595 convert_from_time_t (times->modtime, &mtime);
3596 if (!SetFileTime (fh, NULL, &atime, &mtime))
3597 {
3598 CloseHandle (fh);
3599 errno = EACCES;
3600 return -1;
3601 }
3602 CloseHandle (fh);
3603 }
3604 else
3605 {
3606 errno = EINVAL;
3607 return -1;
3608 }
3609 return 0;
3610}
3611
7c80d5ec 3612\f
0f7bb05d
EZ		 3613/* Symlink-related functions that always fail. Used in fileio.c to
3614 avoid #ifdef's. */
3615int
3616symlink (char const *dummy1, char const *dummy2)
3617{
3618 errno = ENOSYS;
3619 return -1;
3620}
3621
3622ssize_t
3623readlink (const char *name, char *dummy1, size_t dummy2)
3624{
3625 /* `access' is much faster than `stat' on MS-Windows. */
3626 if (sys_access (name, 0) == 0)
3627 errno = EINVAL;
3628 return -1;
3629}
3630
3631\f
7c80d5ec
EZ		 3632/* Support for browsing other processes and their attributes. See
3633 process.c for the Lisp bindings. */
3634
3635/* Helper wrapper functions. */
3636
bedf4aab
JB		 3637static HANDLE WINAPI
3638create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
7c80d5ec
EZ		 3639{
3640 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
3641
3642 if (g_b_init_create_toolhelp32_snapshot == 0)
3643 {
3644 g_b_init_create_toolhelp32_snapshot = 1;
3645 s_pfn_Create_Toolhelp32_Snapshot = (CreateToolhelp32Snapshot_Proc)
3646 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3647 "CreateToolhelp32Snapshot");
3648 }
3649 if (s_pfn_Create_Toolhelp32_Snapshot == NULL)
3650 {
3651 return INVALID_HANDLE_VALUE;
3652 }
3653 return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
3654}
3655
bedf4aab
JB		 3656static BOOL WINAPI
3657process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
7c80d5ec
EZ		 3658{
3659 static Process32First_Proc s_pfn_Process32_First = NULL;
3660
3661 if (g_b_init_process32_first == 0)
3662 {
3663 g_b_init_process32_first = 1;
3664 s_pfn_Process32_First = (Process32First_Proc)
3665 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3666 "Process32First");
3667 }
3668 if (s_pfn_Process32_First == NULL)
3669 {
3670 return FALSE;
3671 }
3672 return (s_pfn_Process32_First (hSnapshot, lppe));
3673}
3674
bedf4aab
JB		 3675static BOOL WINAPI
3676process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
7c80d5ec
EZ		 3677{
3678 static Process32Next_Proc s_pfn_Process32_Next = NULL;
3679
3680 if (g_b_init_process32_next == 0)
3681 {
3682 g_b_init_process32_next = 1;
3683 s_pfn_Process32_Next = (Process32Next_Proc)
3684 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3685 "Process32Next");
3686 }
3687 if (s_pfn_Process32_Next == NULL)
3688 {
3689 return FALSE;
3690 }
3691 return (s_pfn_Process32_Next (hSnapshot, lppe));
3692}
3693
bedf4aab
JB		 3694static BOOL WINAPI
3695open_thread_token (HANDLE ThreadHandle,
3696 DWORD DesiredAccess,
3697 BOOL OpenAsSelf,
3698 PHANDLE TokenHandle)
7c80d5ec
EZ		 3699{
3700 static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
3701 HMODULE hm_advapi32 = NULL;
3702 if (is_windows_9x () == TRUE)
3703 {
3704 SetLastError (ERROR_NOT_SUPPORTED);
3705 return FALSE;
3706 }
3707 if (g_b_init_open_thread_token == 0)
3708 {
3709 g_b_init_open_thread_token = 1;
3710 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3711 s_pfn_Open_Thread_Token =
3712 (OpenThreadToken_Proc) GetProcAddress (hm_advapi32, "OpenThreadToken");
3713 }
3714 if (s_pfn_Open_Thread_Token == NULL)
3715 {
3716 SetLastError (ERROR_NOT_SUPPORTED);
3717 return FALSE;
3718 }
3719 return (
3720 s_pfn_Open_Thread_Token (
3721 ThreadHandle,
3722 DesiredAccess,
3723 OpenAsSelf,
3724 TokenHandle)
3725 );
3726}
3727
bedf4aab
JB		 3728static BOOL WINAPI
3729impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
7c80d5ec
EZ		 3730{
3731 static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
3732 HMODULE hm_advapi32 = NULL;
3733 if (is_windows_9x () == TRUE)
3734 {
3735 return FALSE;
3736 }
3737 if (g_b_init_impersonate_self == 0)
3738 {
3739 g_b_init_impersonate_self = 1;
3740 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3741 s_pfn_Impersonate_Self =
3742 (ImpersonateSelf_Proc) GetProcAddress (hm_advapi32, "ImpersonateSelf");
3743 }
3744 if (s_pfn_Impersonate_Self == NULL)
3745 {
3746 return FALSE;
3747 }
3748 return s_pfn_Impersonate_Self (ImpersonationLevel);
3749}
3750
bedf4aab
JB		 3751static BOOL WINAPI
3752revert_to_self (void)
7c80d5ec
EZ		 3753{
3754 static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
3755 HMODULE hm_advapi32 = NULL;
3756 if (is_windows_9x () == TRUE)
3757 {
3758 return FALSE;
3759 }
3760 if (g_b_init_revert_to_self == 0)
3761 {
3762 g_b_init_revert_to_self = 1;
3763 hm_advapi32 = LoadLibrary ("Advapi32.dll");
3764 s_pfn_Revert_To_Self =
3765 (RevertToSelf_Proc) GetProcAddress (hm_advapi32, "RevertToSelf");
3766 }
3767 if (s_pfn_Revert_To_Self == NULL)
3768 {
3769 return FALSE;
3770 }
3771 return s_pfn_Revert_To_Self ();
3772}
3773
bedf4aab
JB		 3774static BOOL WINAPI
3775get_process_memory_info (HANDLE h_proc,
3776 PPROCESS_MEMORY_COUNTERS mem_counters,
3777 DWORD bufsize)
7c80d5ec
EZ		 3778{
3779 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
3780 HMODULE hm_psapi = NULL;
3781 if (is_windows_9x () == TRUE)
3782 {
3783 return FALSE;
3784 }
3785 if (g_b_init_get_process_memory_info == 0)
3786 {
3787 g_b_init_get_process_memory_info = 1;
3788 hm_psapi = LoadLibrary ("Psapi.dll");
3789 if (hm_psapi)
3790 s_pfn_Get_Process_Memory_Info = (GetProcessMemoryInfo_Proc)
3791 GetProcAddress (hm_psapi, "GetProcessMemoryInfo");
3792 }
3793 if (s_pfn_Get_Process_Memory_Info == NULL)
3794 {
3795 return FALSE;
3796 }
3797 return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
3798}
3799
bedf4aab
JB		 3800static BOOL WINAPI
3801get_process_working_set_size (HANDLE h_proc,
3802 DWORD *minrss,
3803 DWORD *maxrss)
7c80d5ec
EZ		 3804{
3805 static GetProcessWorkingSetSize_Proc
3806 s_pfn_Get_Process_Working_Set_Size = NULL;
3807
3808 if (is_windows_9x () == TRUE)
3809 {
3810 return FALSE;
3811 }
3812 if (g_b_init_get_process_working_set_size == 0)
3813 {
3814 g_b_init_get_process_working_set_size = 1;
3815 s_pfn_Get_Process_Working_Set_Size = (GetProcessWorkingSetSize_Proc)
3816 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3817 "GetProcessWorkingSetSize");
3818 }
3819 if (s_pfn_Get_Process_Working_Set_Size == NULL)
3820 {
3821 return FALSE;
3822 }
3823 return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
3824}
3825
bedf4aab
JB		 3826static BOOL WINAPI
3827global_memory_status (MEMORYSTATUS *buf)
7c80d5ec
EZ		 3828{
3829 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
3830
3831 if (is_windows_9x () == TRUE)
3832 {
3833 return FALSE;
3834 }
3835 if (g_b_init_global_memory_status == 0)
3836 {
3837 g_b_init_global_memory_status = 1;
3838 s_pfn_Global_Memory_Status = (GlobalMemoryStatus_Proc)
3839 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3840 "GlobalMemoryStatus");
3841 }
3842 if (s_pfn_Global_Memory_Status == NULL)
3843 {
3844 return FALSE;
3845 }
3846 return s_pfn_Global_Memory_Status (buf);
3847}
3848
bedf4aab
JB		 3849static BOOL WINAPI
3850global_memory_status_ex (MEMORY_STATUS_EX *buf)
7c80d5ec
EZ		 3851{
3852 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
3853
3854 if (is_windows_9x () == TRUE)
3855 {
3856 return FALSE;
3857 }
3858 if (g_b_init_global_memory_status_ex == 0)
3859 {
3860 g_b_init_global_memory_status_ex = 1;
3861 s_pfn_Global_Memory_Status_Ex = (GlobalMemoryStatusEx_Proc)
3862 GetProcAddress (GetModuleHandle ("kernel32.dll"),
3863 "GlobalMemoryStatusEx");
3864 }
3865 if (s_pfn_Global_Memory_Status_Ex == NULL)
3866 {
3867 return FALSE;
3868 }
3869 return s_pfn_Global_Memory_Status_Ex (buf);
3870}
3871
3872Lisp_Object
b56ceb92 3873list_system_processes (void)
7c80d5ec
EZ		 3874{
3875 struct gcpro gcpro1;
3876 Lisp_Object proclist = Qnil;
3877 HANDLE h_snapshot;
3878
3879 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
3880
3881 if (h_snapshot != INVALID_HANDLE_VALUE)
3882 {
3883 PROCESSENTRY32 proc_entry;
3884 DWORD proc_id;
3885 BOOL res;
3886
3887 GCPRO1 (proclist);
3888
3889 proc_entry.dwSize = sizeof (PROCESSENTRY32);
3890 for (res = process32_first (h_snapshot, &proc_entry); res;
3891 res = process32_next (h_snapshot, &proc_entry))
3892 {
3893 proc_id = proc_entry.th32ProcessID;
3894 proclist = Fcons (make_fixnum_or_float (proc_id), proclist);
3895 }
3896
3897 CloseHandle (h_snapshot);
3898 UNGCPRO;
3899 proclist = Fnreverse (proclist);
3900 }
3901
3902 return proclist;
3903}
3904
3905static int
3906enable_privilege (LPCTSTR priv_name, BOOL enable_p, TOKEN_PRIVILEGES *old_priv)
3907{
3908 TOKEN_PRIVILEGES priv;
3909 DWORD priv_size = sizeof (priv);
3910 DWORD opriv_size = sizeof (*old_priv);
3911 HANDLE h_token = NULL;
3912 HANDLE h_thread = GetCurrentThread ();
3913 int ret_val = 0;
3914 BOOL res;
3915
3916 res = open_thread_token (h_thread,
3917 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3918 FALSE, &h_token);
3919 if (!res && GetLastError () == ERROR_NO_TOKEN)
3920 {
3921 if (impersonate_self (SecurityImpersonation))
3922 res = open_thread_token (h_thread,
3923 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3924 FALSE, &h_token);
3925 }
3926 if (res)
3927 {
3928 priv.PrivilegeCount = 1;
3929 priv.Privileges[0].Attributes = enable_p ? SE_PRIVILEGE_ENABLED : 0;
3930 LookupPrivilegeValue (NULL, priv_name, &priv.Privileges[0].Luid);
3931 if (AdjustTokenPrivileges (h_token, FALSE, &priv, priv_size,
3932 old_priv, &opriv_size)
3933 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
3934 ret_val = 1;
3935 }
3936 if (h_token)
3937 CloseHandle (h_token);
3938
3939 return ret_val;
3940}
3941
3942static int
3943restore_privilege (TOKEN_PRIVILEGES *priv)
3944{
3945 DWORD priv_size = sizeof (*priv);
3946 HANDLE h_token = NULL;
3947 int ret_val = 0;
3948
3949 if (open_thread_token (GetCurrentThread (),
3950 TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
3951 FALSE, &h_token))
3952 {
3953 if (AdjustTokenPrivileges (h_token, FALSE, priv, priv_size, NULL, NULL)
3954 && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
3955 ret_val = 1;
3956 }
3957 if (h_token)
3958 CloseHandle (h_token);
3959
3960 return ret_val;
3961}
3962
3963static Lisp_Object
b56ceb92 3964ltime (long time_sec, long time_usec)
7c80d5ec
EZ		 3965{
3966 return list3 (make_number ((time_sec >> 16) & 0xffff),
3967 make_number (time_sec & 0xffff),
3968 make_number (time_usec));
3969}
3970
5da9424d
JB		 3971#define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L)
3972
7c80d5ec 3973static int
b56ceb92
JB		 3974process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
3975 Lisp_Object *stime, Lisp_Object *utime, Lisp_Object *ttime,
3976 double *pcpu)
7c80d5ec
EZ		 3977{
3978 FILETIME ft_creation, ft_exit, ft_kernel, ft_user, ft_current;
5da9424d 3979 ULONGLONG tem1, tem2, tem3, tem;
7c80d5ec
EZ		 3980
3981 if (!h_proc
3982 || !get_process_times_fn
ed3751c8
JB		 3983 || !(*get_process_times_fn) (h_proc, &ft_creation, &ft_exit,
3984 &ft_kernel, &ft_user))
7c80d5ec
EZ		 3985 return 0;
3986
3987 GetSystemTimeAsFileTime (&ft_current);
3988
5da9424d
JB		 3989 FILETIME_TO_U64 (tem1, ft_kernel);
3990 tem1 /= 10L;
3991 *stime = U64_TO_LISP_TIME (tem1);
3992
3993 FILETIME_TO_U64 (tem2, ft_user);
3994 tem2 /= 10L;
3995 *utime = U64_TO_LISP_TIME (tem2);
3996
3997 tem3 = tem1 + tem2;
3998 *ttime = U64_TO_LISP_TIME (tem3);
3999
4000 FILETIME_TO_U64 (tem, ft_creation);
3af03101
EZ		 4001 /* Process no 4 (System) returns zero creation time. */
4002 if (tem)
5da9424d
JB		 4003 tem = (tem - utc_base) / 10L;
4004 *ctime = U64_TO_LISP_TIME (tem);
4005
3af03101 4006 if (tem)
5da9424d
JB		 4007 {
4008 FILETIME_TO_U64 (tem3, ft_current);
4009 tem = (tem3 - utc_base) / 10L - tem;
4010 }
4011 *etime = U64_TO_LISP_TIME (tem);
7c80d5ec 4012
3af03101
EZ		 4013 if (tem)
4014 {
4015 *pcpu = 100.0 * (tem1 + tem2) / tem;
4016 if (*pcpu > 100)
4017 *pcpu = 100.0;
4018 }
4019 else
4020 *pcpu = 0;
4021
4022 return 1;
7c80d5ec
EZ		 4023}
4024
4025Lisp_Object
b56ceb92 4026system_process_attributes (Lisp_Object pid)
7c80d5ec
EZ		 4027{
4028 struct gcpro gcpro1, gcpro2, gcpro3;
4029 Lisp_Object attrs = Qnil;
4030 Lisp_Object cmd_str, decoded_cmd, tem;
4031 HANDLE h_snapshot, h_proc;
4032 DWORD proc_id;
754a2d13 4033 int found_proc = 0;
7c80d5ec 4034 char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
32cef06e 4035 DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
7c80d5ec
EZ		 4036 DWORD glength = sizeof (gname);
4037 HANDLE token = NULL;
4038 SID_NAME_USE user_type;
32cef06e
EZ		 4039 unsigned char *buf = NULL;
4040 DWORD blen = 0;
7c80d5ec
EZ		 4041 TOKEN_USER user_token;
4042 TOKEN_PRIMARY_GROUP group_token;
22749e9a
EZ		 4043 unsigned euid;
4044 unsigned egid;
7c80d5ec
EZ		 4045 PROCESS_MEMORY_COUNTERS mem;
4046 PROCESS_MEMORY_COUNTERS_EX mem_ex;
4047 DWORD minrss, maxrss;
4048 MEMORYSTATUS memst;
b8526f6e 4049 MEMORY_STATUS_EX memstex;
7c80d5ec 4050 double totphys = 0.0;
031da700 4051 Lisp_Object ctime, stime, utime, etime, ttime;
7c80d5ec 4052 double pcpu;
32cef06e 4053 BOOL result = FALSE;
7c80d5ec
EZ		 4054
4055 CHECK_NUMBER_OR_FLOAT (pid);
4056 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
4057
4058 h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
4059
4060 GCPRO3 (attrs, decoded_cmd, tem);
4061
4062 if (h_snapshot != INVALID_HANDLE_VALUE)
4063 {
4064 PROCESSENTRY32 pe;
4065 BOOL res;
4066
4067 pe.dwSize = sizeof (PROCESSENTRY32);
4068 for (res = process32_first (h_snapshot, &pe); res;
4069 res = process32_next (h_snapshot, &pe))
4070 {
4071 if (proc_id == pe.th32ProcessID)
4072 {
4073 if (proc_id == 0)
4074 decoded_cmd = build_string ("Idle");
4075 else
4076 {
4077 /* Decode the command name from locale-specific
4078 encoding. */
4079 cmd_str = make_unibyte_string (pe.szExeFile,
4080 strlen (pe.szExeFile));
4081 decoded_cmd =
4082 code_convert_string_norecord (cmd_str,
4083 Vlocale_coding_system, 0);
4084 }
4085 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
4086 attrs = Fcons (Fcons (Qppid,
4087 make_fixnum_or_float (pe.th32ParentProcessID)),
4088 attrs);
4089 attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
4090 attrs);
4091 attrs = Fcons (Fcons (Qthcount,
4092 make_fixnum_or_float (pe.cntThreads)),
4093 attrs);
754a2d13 4094 found_proc = 1;
7c80d5ec
EZ		 4095 break;
4096 }
4097 }
4098
4099 CloseHandle (h_snapshot);
4100 }
4101
754a2d13
EZ		 4102 if (!found_proc)
4103 {
4104 UNGCPRO;
4105 return Qnil;
4106 }
4107
7c80d5ec
EZ		 4108 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4109 FALSE, proc_id);
4110 /* If we were denied a handle to the process, try again after
4111 enabling the SeDebugPrivilege in our process. */
4112 if (!h_proc)
4113 {
4114 TOKEN_PRIVILEGES priv_current;
4115
4116 if (enable_privilege (SE_DEBUG_NAME, TRUE, &priv_current))
4117 {
4118 h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
4119 FALSE, proc_id);
4120 restore_privilege (&priv_current);
4121 revert_to_self ();
4122 }
4123 }
32cef06e 4124 if (h_proc)
7c80d5ec 4125 {
32cef06e
EZ		 4126 result = open_process_token (h_proc, TOKEN_QUERY, &token);
4127 if (result)
f8b35b24 4128 {
32cef06e
EZ		 4129 result = get_token_information (token, TokenUser, NULL, 0, &blen);
4130 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
4131 {
4132 buf = xmalloc (blen);
4133 result = get_token_information (token, TokenUser,
4134 (LPVOID)buf, blen, &needed);
4135 if (result)
4136 {
4137 memcpy (&user_token, buf, sizeof (user_token));
4138 if (!w32_cached_id (user_token.User.Sid, &euid, uname))
4139 {
4140 euid = get_rid (user_token.User.Sid);
4141 result = lookup_account_sid (NULL, user_token.User.Sid,
4142 uname, &ulength,
4143 domain, &dlength,
4144 &user_type);
4145 if (result)
4146 w32_add_to_cache (user_token.User.Sid, euid, uname);
4147 else
4148 {
4149 strcpy (uname, "unknown");
4150 result = TRUE;
4151 }
4152 }
4153 ulength = strlen (uname);
4154 }
4155 }
7c80d5ec 4156 }
32cef06e 4157 if (result)
7c80d5ec 4158 {
32cef06e
EZ		 4159 /* Determine a reasonable euid and gid values. */
4160 if (xstrcasecmp ("administrator", uname) == 0)
7c80d5ec 4161 {
32cef06e
EZ		 4162 euid = 500; /* well-known Administrator uid */
4163 egid = 513; /* well-known None gid */
4164 }
4165 else
4166 {
4167 /* Get group id and name. */
4168 result = get_token_information (token, TokenPrimaryGroup,
4169 (LPVOID)buf, blen, &needed);
4170 if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
f8b35b24 4171 {
32cef06e
EZ		 4172 buf = xrealloc (buf, blen = needed);
4173 result = get_token_information (token, TokenPrimaryGroup,
4174 (LPVOID)buf, blen, &needed);
4175 }
4176 if (result)
4177 {
4178 memcpy (&group_token, buf, sizeof (group_token));
4179 if (!w32_cached_id (group_token.PrimaryGroup, &egid, gname))
4180 {
4181 egid = get_rid (group_token.PrimaryGroup);
4182 dlength = sizeof (domain);
4183 result =
4184 lookup_account_sid (NULL, group_token.PrimaryGroup,
4185 gname, &glength, NULL, &dlength,
4186 &user_type);
4187 if (result)
4188 w32_add_to_cache (group_token.PrimaryGroup,
4189 egid, gname);
4190 else
4191 {
4192 strcpy (gname, "None");
4193 result = TRUE;
4194 }
4195 }
4196 glength = strlen (gname);
f8b35b24 4197 }
7c80d5ec 4198 }
7c80d5ec 4199 }
5f445726 4200 xfree (buf);
7c80d5ec 4201 }
32cef06e 4202 if (!result)
7c80d5ec 4203 {
32cef06e
EZ		 4204 if (!is_windows_9x ())
4205 {
4206 /* We couldn't open the process token, presumably because of
4207 insufficient access rights. Assume this process is run
4208 by the system. */
4209 strcpy (uname, "SYSTEM");
4210 strcpy (gname, "None");
4211 euid = 18; /* SYSTEM */
4212 egid = 513; /* None */
4213 glength = strlen (gname);
4214 ulength = strlen (uname);
4215 }
4216 /* If we are running under Windows 9X, where security calls are
4217 not supported, we assume all processes are run by the current
4218 user. */
4219 else if (GetUserName (uname, &ulength))
4220 {
4221 if (xstrcasecmp ("administrator", uname) == 0)
4222 euid = 0;
4223 else
4224 euid = 123;
4225 egid = euid;
4226 strcpy (gname, "None");
4227 glength = strlen (gname);
4228 ulength = strlen (uname);
4229 }
7c80d5ec 4230 else
32cef06e
EZ		 4231 {
4232 euid = 123;
4233 egid = 123;
4234 strcpy (uname, "administrator");
4235 ulength = strlen (uname);
4236 strcpy (gname, "None");
4237 glength = strlen (gname);
4238 }
4239 if (token)
4240 CloseHandle (token);
7c80d5ec 4241 }
7c80d5ec
EZ		 4242
4243 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (euid)), attrs);
4244 tem = make_unibyte_string (uname, ulength);
4245 attrs = Fcons (Fcons (Quser,
4246 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
4247 attrs);
4248 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (egid)), attrs);
4249 tem = make_unibyte_string (gname, glength);
4250 attrs = Fcons (Fcons (Qgroup,
4251 code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
4252 attrs);
4253
4254 if (global_memory_status_ex (&memstex))
235661f6 4255#if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
7c80d5ec 4256 totphys = memstex.ullTotalPhys / 1024.0;
235661f6
EZ		 4257#else
4258 /* Visual Studio 6 cannot convert an unsigned __int64 type to
4259 double, so we need to do this for it... */
4260 {
4261 DWORD tot_hi = memstex.ullTotalPhys >> 32;
4262 DWORD tot_md = (memstex.ullTotalPhys & 0x00000000ffffffff) >> 10;
4263 DWORD tot_lo = memstex.ullTotalPhys % 1024;
4264
4265 totphys = tot_hi * 4194304.0 + tot_md + tot_lo / 1024.0;
4266 }
4267#endif /* __GNUC__ || _MSC_VER >= 1300 */
7c80d5ec
EZ		 4268 else if (global_memory_status (&memst))
4269 totphys = memst.dwTotalPhys / 1024.0;
4270
4271 if (h_proc
4272 && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
4273 sizeof (mem_ex)))
4274 {
4275 DWORD rss = mem_ex.WorkingSetSize / 1024;
4276
4277 attrs = Fcons (Fcons (Qmajflt,
4278 make_fixnum_or_float (mem_ex.PageFaultCount)),
4279 attrs);
4280 attrs = Fcons (Fcons (Qvsize,
4281 make_fixnum_or_float (mem_ex.PrivateUsage / 1024)),
4282 attrs);
4283 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
4284 if (totphys)
4285 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4286 }
4287 else if (h_proc
4288 && get_process_memory_info (h_proc, &mem, sizeof (mem)))
4289 {
4290 DWORD rss = mem_ex.WorkingSetSize / 1024;
4291
4292 attrs = Fcons (Fcons (Qmajflt,
4293 make_fixnum_or_float (mem.PageFaultCount)),
4294 attrs);
4295 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
4296 if (totphys)
4297 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4298 }
4299 else if (h_proc
4300 && get_process_working_set_size (h_proc, &minrss, &maxrss))
4301 {
4302 DWORD rss = maxrss / 1024;
4303
4304 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (maxrss / 1024)), attrs);
4305 if (totphys)
4306 attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
4307 }
4308
031da700 4309 if (process_times (h_proc, &ctime, &etime, &stime, &utime, &ttime, &pcpu))
7c80d5ec
EZ		 4310 {
4311 attrs = Fcons (Fcons (Qutime, utime), attrs);
4312 attrs = Fcons (Fcons (Qstime, stime), attrs);
031da700 4313 attrs = Fcons (Fcons (Qtime, ttime), attrs);
7c80d5ec
EZ		 4314 attrs = Fcons (Fcons (Qstart, ctime), attrs);
4315 attrs = Fcons (Fcons (Qetime, etime), attrs);
4316 attrs = Fcons (Fcons (Qpcpu, make_float (pcpu)), attrs);
4317 }
4318
4319 /* FIXME: Retrieve command line by walking the PEB of the process. */
4320
4321 if (h_proc)
4322 CloseHandle (h_proc);
4323 UNGCPRO;
4324 return attrs;
4325}
4326
4327\f
480b0c5b
GV		 4328/* Wrappers for winsock functions to map between our file descriptors
4329 and winsock's handles; also set h_errno for convenience.
4330
4331 To allow Emacs to run on systems which don't have winsock support
4332 installed, we dynamically link to winsock on startup if present, and
4333 otherwise provide the minimum necessary functionality
4334 (eg. gethostname). */
4335
4336/* function pointers for relevant socket functions */
4337int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
4338void (PASCAL *pfn_WSASetLastError) (int iError);
4339int (PASCAL *pfn_WSAGetLastError) (void);
26fb7bc4 4340int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
64570b36
KS		 4341HANDLE (PASCAL *pfn_WSACreateEvent) (void);
4342int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
480b0c5b
GV		 4343int (PASCAL *pfn_socket) (int af, int type, int protocol);
4344int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
4345int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
4346int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
4347int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
4348int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
4349int (PASCAL *pfn_closesocket) (SOCKET s);
4350int (PASCAL *pfn_shutdown) (SOCKET s, int how);
4351int (PASCAL *pfn_WSACleanup) (void);
4352
4353u_short (PASCAL *pfn_htons) (u_short hostshort);
4354u_short (PASCAL *pfn_ntohs) (u_short netshort);
4355unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
4356int (PASCAL *pfn_gethostname) (char * name, int namelen);
4357struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
4358struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
ecd270eb 4359int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
962955c5
JR		 4360int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
4361 const char * optval, int optlen);
4362int (PASCAL *pfn_listen) (SOCKET s, int backlog);
4363int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
4364 int * namelen);
4365SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
4366int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
4367 struct sockaddr * from, int * fromlen);
4368int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
4369 const struct sockaddr * to, int tolen);
4370
f1614061
RS		 4371/* SetHandleInformation is only needed to make sockets non-inheritable. */
4372BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
4373#ifndef HANDLE_FLAG_INHERIT
4374#define HANDLE_FLAG_INHERIT 1
4375#endif
480b0c5b 4376
f249a012
RS		 4377HANDLE winsock_lib;
4378static int winsock_inuse;
480b0c5b 4379
f249a012 4380BOOL
480b0c5b
GV		 4381term_winsock (void)
4382{
f249a012 4383 if (winsock_lib != NULL && winsock_inuse == 0)
480b0c5b 4384 {
f249a012
RS		 4385 /* Not sure what would cause WSAENETDOWN, or even if it can happen
4386 after WSAStartup returns successfully, but it seems reasonable
4387 to allow unloading winsock anyway in that case. */
4388 if (pfn_WSACleanup () == 0 ||
4389 pfn_WSAGetLastError () == WSAENETDOWN)
4390 {
4391 if (FreeLibrary (winsock_lib))
4392 winsock_lib = NULL;
4393 return TRUE;
4394 }
480b0c5b 4395 }
f249a012 4396 return FALSE;
480b0c5b
GV		 4397}
4398
f249a012
RS		 4399BOOL
4400init_winsock (int load_now)
480b0c5b
GV		 4401{
4402 WSADATA winsockData;
4403
f249a012
RS		 4404 if (winsock_lib != NULL)
4405 return TRUE;
f1614061 4406
f1614061
RS		 4407 pfn_SetHandleInformation
4408 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
4409 "SetHandleInformation");
4410
64570b36 4411 winsock_lib = LoadLibrary ("Ws2_32.dll");
480b0c5b
GV		 4412
4413 if (winsock_lib != NULL)
4414 {
4415 /* dynamically link to socket functions */
4416
4417#define LOAD_PROC(fn) \
4418 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
4419 goto fail;
4420
ed3751c8
JB		 4421 LOAD_PROC (WSAStartup);
4422 LOAD_PROC (WSASetLastError);
4423 LOAD_PROC (WSAGetLastError);
4424 LOAD_PROC (WSAEventSelect);
4425 LOAD_PROC (WSACreateEvent);
4426 LOAD_PROC (WSACloseEvent);
4427 LOAD_PROC (socket);
4428 LOAD_PROC (bind);
4429 LOAD_PROC (connect);
4430 LOAD_PROC (ioctlsocket);
4431 LOAD_PROC (recv);
4432 LOAD_PROC (send);
4433 LOAD_PROC (closesocket);
4434 LOAD_PROC (shutdown);
4435 LOAD_PROC (htons);
4436 LOAD_PROC (ntohs);
4437 LOAD_PROC (inet_addr);
4438 LOAD_PROC (gethostname);
4439 LOAD_PROC (gethostbyname);
4440 LOAD_PROC (getservbyname);
4441 LOAD_PROC (getpeername);
4442 LOAD_PROC (WSACleanup);
4443 LOAD_PROC (setsockopt);
4444 LOAD_PROC (listen);
4445 LOAD_PROC (getsockname);
4446 LOAD_PROC (accept);
4447 LOAD_PROC (recvfrom);
4448 LOAD_PROC (sendto);
f249a012
RS		 4449#undef LOAD_PROC
4450
480b0c5b
GV		 4451 /* specify version 1.1 of winsock */
4452 if (pfn_WSAStartup (0x101, &winsockData) == 0)
4453 {
f249a012
RS		 4454 if (winsockData.wVersion != 0x101)
4455 goto fail;
4456
4457 if (!load_now)
4458 {
4459 /* Report that winsock exists and is usable, but leave
4460 socket functions disabled. I am assuming that calling
4461 WSAStartup does not require any network interaction,
4462 and in particular does not cause or require a dial-up
4463 connection to be established. */
4464
4465 pfn_WSACleanup ();
4466 FreeLibrary (winsock_lib);
4467 winsock_lib = NULL;
4468 }
4469 winsock_inuse = 0;
4470 return TRUE;
480b0c5b
GV		 4471 }
4472
4473 fail:
4474 FreeLibrary (winsock_lib);
f249a012 4475 winsock_lib = NULL;
480b0c5b 4476 }
f249a012
RS		 4477
4478 return FALSE;
480b0c5b
GV		 4479}
4480
4481
4482int h_errno = 0;
4483
f8381794 4484/* function to set h_errno for compatibility; map winsock error codes to
480b0c5b
GV		 4485 normal system codes where they overlap (non-overlapping definitions
4486 are already in <sys/socket.h> */
9bfb11f9 4487static void
b56ceb92 4488set_errno (void)
480b0c5b 4489{
f249a012 4490 if (winsock_lib == NULL)
480b0c5b
GV		 4491 h_errno = EINVAL;
4492 else
4493 h_errno = pfn_WSAGetLastError ();
4494
4495 switch (h_errno)
4496 {
4497 case WSAEACCES: h_errno = EACCES; break;
4498 case WSAEBADF: h_errno = EBADF; break;
4499 case WSAEFAULT: h_errno = EFAULT; break;
4500 case WSAEINTR: h_errno = EINTR; break;
4501 case WSAEINVAL: h_errno = EINVAL; break;
4502 case WSAEMFILE: h_errno = EMFILE; break;
4503 case WSAENAMETOOLONG: h_errno = ENAMETOOLONG; break;
4504 case WSAENOTEMPTY: h_errno = ENOTEMPTY; break;
4505 }
4506 errno = h_errno;
4507}
4508
9bfb11f9 4509static void
b56ceb92 4510check_errno (void)
480b0c5b 4511{
f249a012 4512 if (h_errno == 0 && winsock_lib != NULL)
480b0c5b
GV		 4513 pfn_WSASetLastError (0);
4514}
4515
d8fcc1b9
AI		 4516/* Extend strerror to handle the winsock-specific error codes. */
4517struct {
4518 int errnum;
4519 char * msg;
4520} _wsa_errlist[] = {
1db5b1ad
JB		 4521 {WSAEINTR , "Interrupted function call"},
4522 {WSAEBADF , "Bad file descriptor"},
4523 {WSAEACCES , "Permission denied"},
4524 {WSAEFAULT , "Bad address"},
4525 {WSAEINVAL , "Invalid argument"},
4526 {WSAEMFILE , "Too many open files"},
4527
4528 {WSAEWOULDBLOCK , "Resource temporarily unavailable"},
4529 {WSAEINPROGRESS , "Operation now in progress"},
4530 {WSAEALREADY , "Operation already in progress"},
4531 {WSAENOTSOCK , "Socket operation on non-socket"},
4532 {WSAEDESTADDRREQ , "Destination address required"},
4533 {WSAEMSGSIZE , "Message too long"},
4534 {WSAEPROTOTYPE , "Protocol wrong type for socket"},
4535 {WSAENOPROTOOPT , "Bad protocol option"},
4536 {WSAEPROTONOSUPPORT , "Protocol not supported"},
4537 {WSAESOCKTNOSUPPORT , "Socket type not supported"},
4538 {WSAEOPNOTSUPP , "Operation not supported"},
4539 {WSAEPFNOSUPPORT , "Protocol family not supported"},
4540 {WSAEAFNOSUPPORT , "Address family not supported by protocol family"},
4541 {WSAEADDRINUSE , "Address already in use"},
4542 {WSAEADDRNOTAVAIL , "Cannot assign requested address"},
4543 {WSAENETDOWN , "Network is down"},
4544 {WSAENETUNREACH , "Network is unreachable"},
4545 {WSAENETRESET , "Network dropped connection on reset"},
4546 {WSAECONNABORTED , "Software caused connection abort"},
4547 {WSAECONNRESET , "Connection reset by peer"},
4548 {WSAENOBUFS , "No buffer space available"},
4549 {WSAEISCONN , "Socket is already connected"},
4550 {WSAENOTCONN , "Socket is not connected"},
4551 {WSAESHUTDOWN , "Cannot send after socket shutdown"},
4552 {WSAETOOMANYREFS , "Too many references"}, /* not sure */
4553 {WSAETIMEDOUT , "Connection timed out"},
4554 {WSAECONNREFUSED , "Connection refused"},
4555 {WSAELOOP , "Network loop"}, /* not sure */
4556 {WSAENAMETOOLONG , "Name is too long"},
4557 {WSAEHOSTDOWN , "Host is down"},
4558 {WSAEHOSTUNREACH , "No route to host"},
4559 {WSAENOTEMPTY , "Buffer not empty"}, /* not sure */
4560 {WSAEPROCLIM , "Too many processes"},
4561 {WSAEUSERS , "Too many users"}, /* not sure */
4562 {WSAEDQUOT , "Double quote in host name"}, /* really not sure */
4563 {WSAESTALE , "Data is stale"}, /* not sure */
4564 {WSAEREMOTE , "Remote error"}, /* not sure */
4565
4566 {WSASYSNOTREADY , "Network subsystem is unavailable"},
4567 {WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range"},
4568 {WSANOTINITIALISED , "Winsock not initialized successfully"},
4569 {WSAEDISCON , "Graceful shutdown in progress"},
d8fcc1b9 4570#ifdef WSAENOMORE
1db5b1ad
JB		 4571 {WSAENOMORE , "No more operations allowed"}, /* not sure */
4572 {WSAECANCELLED , "Operation cancelled"}, /* not sure */
4573 {WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider"},
4574 {WSAEINVALIDPROVIDER , "Invalid service provider version number"},
4575 {WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider"},
4576 {WSASYSCALLFAILURE , "System call failure"},
4577 {WSASERVICE_NOT_FOUND , "Service not found"}, /* not sure */
4578 {WSATYPE_NOT_FOUND , "Class type not found"},
4579 {WSA_E_NO_MORE , "No more resources available"}, /* really not sure */
4580 {WSA_E_CANCELLED , "Operation already cancelled"}, /* really not sure */
4581 {WSAEREFUSED , "Operation refused"}, /* not sure */
d8fcc1b9 4582#endif
177c0ea7 4583
1db5b1ad
JB		 4584 {WSAHOST_NOT_FOUND , "Host not found"},
4585 {WSATRY_AGAIN , "Authoritative host not found during name lookup"},
4586 {WSANO_RECOVERY , "Non-recoverable error during name lookup"},
4587 {WSANO_DATA , "Valid name, no data record of requested type"},
d8fcc1b9 4588
1db5b1ad 4589 {-1, NULL}
d8fcc1b9
AI		 4590};
4591
4592char *
ed3751c8 4593sys_strerror (int error_no)
d8fcc1b9
AI		 4594{
4595 int i;
4596 static char unknown_msg[40];
4597
a302c7ae
AI		 4598 if (error_no >= 0 && error_no < sys_nerr)
4599 return sys_errlist[error_no];
d8fcc1b9
AI		 4600
4601 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
4602 if (_wsa_errlist[i].errnum == error_no)
4603 return _wsa_errlist[i].msg;
4604
ed3751c8 4605 sprintf (unknown_msg, "Unidentified error: %d", error_no);
d8fcc1b9
AI		 4606 return unknown_msg;
4607}
4608
480b0c5b
GV		 4609/* [andrewi 3-May-96] I've had conflicting results using both methods,
4610 but I believe the method of keeping the socket handle separate (and
4611 insuring it is not inheritable) is the correct one. */
4612
480b0c5b 4613#define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
480b0c5b 4614
bedf4aab 4615static int socket_to_fd (SOCKET s);
962955c5 4616
480b0c5b 4617int
ed3751c8 4618sys_socket (int af, int type, int protocol)
480b0c5b 4619{
962955c5 4620 SOCKET s;
480b0c5b 4621
f249a012 4622 if (winsock_lib == NULL)
480b0c5b
GV		 4623 {
4624 h_errno = ENETDOWN;
4625 return INVALID_SOCKET;
4626 }
4627
4628 check_errno ();
4629
4630 /* call the real socket function */
962955c5 4631 s = pfn_socket (af, type, protocol);
177c0ea7 4632
480b0c5b 4633 if (s != INVALID_SOCKET)
962955c5 4634 return socket_to_fd (s);
480b0c5b 4635
962955c5
JR		 4636 set_errno ();
4637 return -1;
4638}
4639
4640/* Convert a SOCKET to a file descriptor. */
bedf4aab 4641static int
962955c5
JR		 4642socket_to_fd (SOCKET s)
4643{
4644 int fd;
4645 child_process * cp;
4646
4647 /* Although under NT 3.5 _open_osfhandle will accept a socket
4648 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
4649 that does not work under NT 3.1. However, we can get the same
4650 effect by using a backdoor function to replace an existing
4651 descriptor handle with the one we want. */
4652
4653 /* allocate a file descriptor (with appropriate flags) */
4654 fd = _open ("NUL:", _O_RDWR);
4655 if (fd >= 0)
4656 {
962955c5
JR		 4657 /* Make a non-inheritable copy of the socket handle. Note
4658 that it is possible that sockets aren't actually kernel
4659 handles, which appears to be the case on Windows 9x when
4660 the MS Proxy winsock client is installed. */
4661 {
4662 /* Apparently there is a bug in NT 3.51 with some service
4663 packs, which prevents using DuplicateHandle to make a
4664 socket handle non-inheritable (causes WSACleanup to
4665 hang). The work-around is to use SetHandleInformation
4666 instead if it is available and implemented. */
4667 if (pfn_SetHandleInformation)
480b0c5b 4668 {
962955c5
JR		 4669 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
4670 }
4671 else
4672 {
4673 HANDLE parent = GetCurrentProcess ();
4674 HANDLE new_s = INVALID_HANDLE_VALUE;
4675
4676 if (DuplicateHandle (parent,
4677 (HANDLE) s,
4678 parent,
4679 &new_s,
4680 0,
4681 FALSE,
4682 DUPLICATE_SAME_ACCESS))
f1614061 4683 {
962955c5
JR		 4684 /* It is possible that DuplicateHandle succeeds even
4685 though the socket wasn't really a kernel handle,
4686 because a real handle has the same value. So
4687 test whether the new handle really is a socket. */
4688 long nonblocking = 0;
4689 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
ca149beb 4690 {
962955c5
JR		 4691 pfn_closesocket (s);
4692 s = (SOCKET) new_s;
4693 }
4694 else
4695 {
4696 CloseHandle (new_s);
4697 }
177c0ea7 4698 }
480b0c5b 4699 }
962955c5
JR		 4700 }
4701 fd_info[fd].hnd = (HANDLE) s;
480b0c5b 4702
962955c5
JR		 4703 /* set our own internal flags */
4704 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
480b0c5b 4705
962955c5
JR		 4706 cp = new_child ();
4707 if (cp)
4708 {
4709 cp->fd = fd;
4710 cp->status = STATUS_READ_ACKNOWLEDGED;
480b0c5b 4711
962955c5
JR		 4712 /* attach child_process to fd_info */
4713 if (fd_info[ fd ].cp != NULL)
4714 {
4715 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
4716 abort ();
480b0c5b
GV		 4717 }
4718
962955c5
JR		 4719 fd_info[ fd ].cp = cp;
4720
4721 /* success! */
4722 winsock_inuse++; /* count open sockets */
4723 return fd;
480b0c5b 4724 }
480b0c5b 4725
962955c5
JR		 4726 /* clean up */
4727 _close (fd);
4728 }
4729 pfn_closesocket (s);
4730 h_errno = EMFILE;
480b0c5b
GV		 4731 return -1;
4732}
4733
480b0c5b
GV		 4734int
4735sys_bind (int s, const struct sockaddr * addr, int namelen)
4736{
f249a012 4737 if (winsock_lib == NULL)
480b0c5b
GV		 4738 {
4739 h_errno = ENOTSOCK;
4740 return SOCKET_ERROR;
4741 }
4742
4743 check_errno ();
4744 if (fd_info[s].flags & FILE_SOCKET)
4745 {
4746 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
4747 if (rc == SOCKET_ERROR)
4748 set_errno ();
4749 return rc;
4750 }
4751 h_errno = ENOTSOCK;
4752 return SOCKET_ERROR;
4753}
4754
480b0c5b
GV		 4755int
4756sys_connect (int s, const struct sockaddr * name, int namelen)
4757{
f249a012 4758 if (winsock_lib == NULL)
480b0c5b
GV		 4759 {
4760 h_errno = ENOTSOCK;
4761 return SOCKET_ERROR;
4762 }
4763
4764 check_errno ();
4765 if (fd_info[s].flags & FILE_SOCKET)
4766 {
4767 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
4768 if (rc == SOCKET_ERROR)
4769 set_errno ();
4770 return rc;
4771 }
4772 h_errno = ENOTSOCK;
4773 return SOCKET_ERROR;
4774}
4775
4776u_short
4777sys_htons (u_short hostshort)
4778{
f249a012 4779 return (winsock_lib != NULL) ?
480b0c5b
GV		 4780 pfn_htons (hostshort) : hostshort;
4781}
4782
4783u_short
4784sys_ntohs (u_short netshort)
4785{
f249a012 4786 return (winsock_lib != NULL) ?
480b0c5b
GV		 4787 pfn_ntohs (netshort) : netshort;
4788}
4789
4790unsigned long
4791sys_inet_addr (const char * cp)
4792{
f249a012 4793 return (winsock_lib != NULL) ?
480b0c5b
GV		 4794 pfn_inet_addr (cp) : INADDR_NONE;
4795}
4796
4797int
4798sys_gethostname (char * name, int namelen)
4799{
f249a012 4800 if (winsock_lib != NULL)
480b0c5b
GV		 4801 return pfn_gethostname (name, namelen);
4802
4803 if (namelen > MAX_COMPUTERNAME_LENGTH)
a302c7ae 4804 return !GetComputerName (name, (DWORD *)&namelen);
480b0c5b
GV		 4805
4806 h_errno = EFAULT;
4807 return SOCKET_ERROR;
4808}
4809
4810struct hostent *
ed3751c8 4811sys_gethostbyname (const char * name)
480b0c5b
GV		 4812{
4813 struct hostent * host;
4814
f249a012 4815 if (winsock_lib == NULL)
480b0c5b
GV		 4816 {
4817 h_errno = ENETDOWN;
4818 return NULL;
4819 }
4820
4821 check_errno ();
4822 host = pfn_gethostbyname (name);
4823 if (!host)
4824 set_errno ();
4825 return host;
4826}
4827
4828struct servent *
ed3751c8 4829sys_getservbyname (const char * name, const char * proto)
480b0c5b
GV		 4830{
4831 struct servent * serv;
4832
f249a012 4833 if (winsock_lib == NULL)
480b0c5b
GV		 4834 {
4835 h_errno = ENETDOWN;
4836 return NULL;
4837 }
4838
4839 check_errno ();
4840 serv = pfn_getservbyname (name, proto);
4841 if (!serv)
4842 set_errno ();
4843 return serv;
4844}
4845
ecd270eb
JR		 4846int
4847sys_getpeername (int s, struct sockaddr *addr, int * namelen)
4848{
4849 if (winsock_lib == NULL)
4850 {
4851 h_errno = ENETDOWN;
4852 return SOCKET_ERROR;
4853 }
4854
4855 check_errno ();
4856 if (fd_info[s].flags & FILE_SOCKET)
4857 {
4858 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
4859 if (rc == SOCKET_ERROR)
4860 set_errno ();
4861 return rc;
4862 }
4863 h_errno = ENOTSOCK;
4864 return SOCKET_ERROR;
4865}
4866
380961a6
GV		 4867int
4868sys_shutdown (int s, int how)
4869{
380961a6
GV		 4870 if (winsock_lib == NULL)
4871 {
4872 h_errno = ENETDOWN;
4873 return SOCKET_ERROR;
4874 }
4875
4876 check_errno ();
4877 if (fd_info[s].flags & FILE_SOCKET)
4878 {
4879 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
962955c5
JR		 4880 if (rc == SOCKET_ERROR)
4881 set_errno ();
4882 return rc;
4883 }
4884 h_errno = ENOTSOCK;
4885 return SOCKET_ERROR;
4886}
4887
4888int
a5a389bb 4889sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
962955c5
JR		 4890{
4891 if (winsock_lib == NULL)
4892 {
4893 h_errno = ENETDOWN;
4894 return SOCKET_ERROR;
4895 }
4896
4897 check_errno ();
4898 if (fd_info[s].flags & FILE_SOCKET)
4899 {
4900 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
a5a389bb 4901 (const char *)optval, optlen);
962955c5
JR		 4902 if (rc == SOCKET_ERROR)
4903 set_errno ();
4904 return rc;
4905 }
4906 h_errno = ENOTSOCK;
177c0ea7 4907 return SOCKET_ERROR;
962955c5
JR		 4908}
4909
4910int
4911sys_listen (int s, int backlog)
4912{
4913 if (winsock_lib == NULL)
4914 {
4915 h_errno = ENETDOWN;
4916 return SOCKET_ERROR;
4917 }
4918
4919 check_errno ();
4920 if (fd_info[s].flags & FILE_SOCKET)
4921 {
4922 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
4923 if (rc == SOCKET_ERROR)
4924 set_errno ();
26fb7bc4 4925 else
64570b36 4926 fd_info[s].flags |= FILE_LISTEN;
962955c5
JR		 4927 return rc;
4928 }
4929 h_errno = ENOTSOCK;
177c0ea7 4930 return SOCKET_ERROR;
962955c5
JR		 4931}
4932
4933int
4934sys_getsockname (int s, struct sockaddr * name, int * namelen)
4935{
4936 if (winsock_lib == NULL)
4937 {
4938 h_errno = ENETDOWN;
4939 return SOCKET_ERROR;
4940 }
4941
4942 check_errno ();
4943 if (fd_info[s].flags & FILE_SOCKET)
4944 {
4945 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
4946 if (rc == SOCKET_ERROR)
4947 set_errno ();
4948 return rc;
4949 }
4950 h_errno = ENOTSOCK;
177c0ea7 4951 return SOCKET_ERROR;
962955c5
JR		 4952}
4953
4954int
4955sys_accept (int s, struct sockaddr * addr, int * addrlen)
4956{
4957 if (winsock_lib == NULL)
4958 {
4959 h_errno = ENETDOWN;
4960 return -1;
4961 }
4962
4963 check_errno ();
26fb7bc4 4964 if (fd_info[s].flags & FILE_LISTEN)
962955c5 4965 {
a0ad1860 4966 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
64570b36
KS		 4967 int fd = -1;
4968 if (t == INVALID_SOCKET)
4969 set_errno ();
4970 else
4971 fd = socket_to_fd (t);
962955c5 4972
64570b36
KS		 4973 fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
4974 ResetEvent (fd_info[s].cp->char_avail);
4975 return fd;
962955c5
JR		 4976 }
4977 h_errno = ENOTSOCK;
4978 return -1;
4979}
4980
4981int
4982sys_recvfrom (int s, char * buf, int len, int flags,
b56ceb92 4983 struct sockaddr * from, int * fromlen)
962955c5
JR		 4984{
4985 if (winsock_lib == NULL)
4986 {
4987 h_errno = ENETDOWN;
4988 return SOCKET_ERROR;
4989 }
4990
4991 check_errno ();
4992 if (fd_info[s].flags & FILE_SOCKET)
4993 {
4994 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
4995 if (rc == SOCKET_ERROR)
4996 set_errno ();
4997 return rc;
4998 }
4999 h_errno = ENOTSOCK;
5000 return SOCKET_ERROR;
5001}
5002
5003int
5004sys_sendto (int s, const char * buf, int len, int flags,
5005 const struct sockaddr * to, int tolen)
5006{
5007 if (winsock_lib == NULL)
5008 {
5009 h_errno = ENETDOWN;
5010 return SOCKET_ERROR;
5011 }
5012
5013 check_errno ();
5014 if (fd_info[s].flags & FILE_SOCKET)
5015 {
5016 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
380961a6
GV		 5017 if (rc == SOCKET_ERROR)
5018 set_errno ();
5019 return rc;
5020 }
5021 h_errno = ENOTSOCK;
5022 return SOCKET_ERROR;
5023}
5024
ecd270eb
JR		 5025/* Windows does not have an fcntl function. Provide an implementation
5026 solely for making sockets non-blocking. */
5027int
5028fcntl (int s, int cmd, int options)
5029{
5030 if (winsock_lib == NULL)
5031 {
5032 h_errno = ENETDOWN;
5033 return -1;
5034 }
5035
5036 check_errno ();
5037 if (fd_info[s].flags & FILE_SOCKET)
5038 {
5039 if (cmd == F_SETFL && options == O_NDELAY)
5040 {
5041 unsigned long nblock = 1;
5042 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
5043 if (rc == SOCKET_ERROR)
9d4f32e8 5044 set_errno ();
ecd270eb
JR		 5045 /* Keep track of the fact that we set this to non-blocking. */
5046 fd_info[s].flags |= FILE_NDELAY;
5047 return rc;
5048 }
5049 else
5050 {
5051 h_errno = EINVAL;
5052 return SOCKET_ERROR;
5053 }
5054 }
5055 h_errno = ENOTSOCK;
5056 return SOCKET_ERROR;
5057}
5058
480b0c5b
GV		 5059
5060/* Shadow main io functions: we need to handle pipes and sockets more
5061 intelligently, and implement non-blocking mode as well. */
5062
5063int
5064sys_close (int fd)
5065{
5066 int rc;
5067
7559f399 5068 if (fd < 0)
480b0c5b
GV		 5069 {
5070 errno = EBADF;
5071 return -1;
5072 }
5073
7559f399 5074 if (fd < MAXDESC && fd_info[fd].cp)
480b0c5b
GV		 5075 {
5076 child_process * cp = fd_info[fd].cp;
5077
5078 fd_info[fd].cp = NULL;
5079
5080 if (CHILD_ACTIVE (cp))
5081 {
5082 /* if last descriptor to active child_process then cleanup */
5083 int i;
5084 for (i = 0; i < MAXDESC; i++)
5085 {
5086 if (i == fd)
5087 continue;
5088 if (fd_info[i].cp == cp)
5089 break;
5090 }
5091 if (i == MAXDESC)
5092 {
480b0c5b
GV		 5093 if (fd_info[fd].flags & FILE_SOCKET)
5094 {
f249a012 5095 if (winsock_lib == NULL) abort ();
480b0c5b
GV		 5096
5097 pfn_shutdown (SOCK_HANDLE (fd), 2);
5098 rc = pfn_closesocket (SOCK_HANDLE (fd));
7d701334 5099
f249a012 5100 winsock_inuse--; /* count open sockets */
480b0c5b 5101 }
480b0c5b
GV		 5102 delete_child (cp);
5103 }
5104 }
5105 }
5106
5107 /* Note that sockets do not need special treatment here (at least on
e9e23e23 5108 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
480b0c5b
GV		 5109 closesocket is equivalent to CloseHandle, which is to be expected
5110 because socket handles are fully fledged kernel handles. */
5111 rc = _close (fd);
5112
7559f399 5113 if (rc == 0 && fd < MAXDESC)
480b0c5b
GV		 5114 fd_info[fd].flags = 0;
5115
5116 return rc;
5117}
5118
5119int
5120sys_dup (int fd)
5121{
5122 int new_fd;
5123
5124 new_fd = _dup (fd);
7559f399 5125 if (new_fd >= 0 && new_fd < MAXDESC)
480b0c5b
GV		 5126 {
5127 /* duplicate our internal info as well */
5128 fd_info[new_fd] = fd_info[fd];
5129 }
5130 return new_fd;
5131}
5132
480b0c5b
GV		 5133int
5134sys_dup2 (int src, int dst)
5135{
5136 int rc;
5137
5138 if (dst < 0 || dst >= MAXDESC)
5139 {
5140 errno = EBADF;
5141 return -1;
5142 }
5143
5144 /* make sure we close the destination first if it's a pipe or socket */
5145 if (src != dst && fd_info[dst].flags != 0)
5146 sys_close (dst);
177c0ea7 5147
480b0c5b
GV		 5148 rc = _dup2 (src, dst);
5149 if (rc == 0)
5150 {
5151 /* duplicate our internal info as well */
5152 fd_info[dst] = fd_info[src];
5153 }
5154 return rc;
5155}
5156
480b0c5b
GV		 5157/* Unix pipe() has only one arg */
5158int
5159sys_pipe (int * phandles)
5160{
5161 int rc;
5162 unsigned flags;
480b0c5b 5163
76b3903d
GV		 5164 /* make pipe handles non-inheritable; when we spawn a child, we
5165 replace the relevant handle with an inheritable one. Also put
5166 pipes into binary mode; we will do text mode translation ourselves
5167 if required. */
5168 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
480b0c5b
GV		 5169
5170 if (rc == 0)
5171 {
cb72110d
JR		 5172 /* Protect against overflow, since Windows can open more handles than
5173 our fd_info array has room for. */
5174 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
5175 {
5176 _close (phandles[0]);
5177 _close (phandles[1]);
5178 rc = -1;
5179 }
5180 else
5181 {
5182 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
5183 fd_info[phandles[0]].flags = flags;
480b0c5b 5184
cb72110d
JR		 5185 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
5186 fd_info[phandles[1]].flags = flags;
5187 }
480b0c5b
GV		 5188 }
5189
5190 return rc;
5191}
5192
5193/* Function to do blocking read of one byte, needed to implement
5194 select. It is only allowed on sockets and pipes. */
5195int
5196_sys_read_ahead (int fd)
5197{
5198 child_process * cp;
5199 int rc;
5200
5201 if (fd < 0 || fd >= MAXDESC)
5202 return STATUS_READ_ERROR;
5203
5204 cp = fd_info[fd].cp;
5205
5206 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
5207 return STATUS_READ_ERROR;
5208
d888760c 5209 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SERIAL | FILE_SOCKET)) == 0
480b0c5b
GV		 5210 || (fd_info[fd].flags & FILE_READ) == 0)
5211 {
d888760c 5212 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd));
480b0c5b
GV		 5213 abort ();
5214 }
177c0ea7 5215
480b0c5b 5216 cp->status = STATUS_READ_IN_PROGRESS;
177c0ea7 5217
480b0c5b 5218 if (fd_info[fd].flags & FILE_PIPE)
f7554349 5219 {
f7554349
KH		 5220 rc = _read (fd, &cp->chr, sizeof (char));
5221
5222 /* Give subprocess time to buffer some more output for us before
e9e23e23 5223 reporting that input is available; we need this because Windows 95
f7554349
KH		 5224 connects DOS programs to pipes by making the pipe appear to be
5225 the normal console stdout - as a result most DOS programs will
d888760c 5226 write to stdout without buffering, ie. one character at a
fbd6baed 5227 time. Even some W32 programs do this - "dir" in a command
f7554349
KH		 5228 shell on NT is very slow if we don't do this. */
5229 if (rc > 0)
5230 {
78806724 5231 int wait = w32_pipe_read_delay;
f7554349
KH		 5232
5233 if (wait > 0)
5234 Sleep (wait);
5235 else if (wait < 0)
5236 while (++wait <= 0)
5237 /* Yield remainder of our time slice, effectively giving a
5238 temporary priority boost to the child process. */
5239 Sleep (0);
5240 }
5241 }
d888760c
GM		 5242 else if (fd_info[fd].flags & FILE_SERIAL)
5243 {
5244 HANDLE hnd = fd_info[fd].hnd;
5245 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
5246 COMMTIMEOUTS ct;
5247
5248 /* Configure timeouts for blocking read. */
5249 if (!GetCommTimeouts (hnd, &ct))
5250 return STATUS_READ_ERROR;
5251 ct.ReadIntervalTimeout = 0;
5252 ct.ReadTotalTimeoutMultiplier = 0;
5253 ct.ReadTotalTimeoutConstant = 0;
5254 if (!SetCommTimeouts (hnd, &ct))
5255 return STATUS_READ_ERROR;
5256
5257 if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
5258 {
5259 if (GetLastError () != ERROR_IO_PENDING)
5260 return STATUS_READ_ERROR;
5261 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
5262 return STATUS_READ_ERROR;
5263 }
5264 }
480b0c5b 5265 else if (fd_info[fd].flags & FILE_SOCKET)
ecd270eb
JR		 5266 {
5267 unsigned long nblock = 0;
5268 /* We always want this to block, so temporarily disable NDELAY. */
5269 if (fd_info[fd].flags & FILE_NDELAY)
5270 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5271
5272 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
5273
5274 if (fd_info[fd].flags & FILE_NDELAY)
5275 {
5276 nblock = 1;
5277 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5278 }
5279 }
177c0ea7 5280
480b0c5b
GV		 5281 if (rc == sizeof (char))
5282 cp->status = STATUS_READ_SUCCEEDED;
5283 else
5284 cp->status = STATUS_READ_FAILED;
5285
5286 return cp->status;
5287}
5288
9bfb11f9
KS		 5289int
5290_sys_wait_accept (int fd)
64570b36
KS		 5291{
5292 HANDLE hEv;
5293 child_process * cp;
5294 int rc;
5295
5296 if (fd < 0 || fd >= MAXDESC)
5297 return STATUS_READ_ERROR;
5298
5299 cp = fd_info[fd].cp;
5300
5301 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
5302 return STATUS_READ_ERROR;
5303
5304 cp->status = STATUS_READ_FAILED;
5305
5306 hEv = pfn_WSACreateEvent ();
5307 rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
5308 if (rc != SOCKET_ERROR)
5309 {
5310 rc = WaitForSingleObject (hEv, INFINITE);
5311 pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
64570b36
KS		 5312 if (rc == WAIT_OBJECT_0)
5313 cp->status = STATUS_READ_SUCCEEDED;
5314 }
7046f191 5315 pfn_WSACloseEvent (hEv);
64570b36
KS		 5316
5317 return cp->status;
5318}
5319
480b0c5b
GV		 5320int
5321sys_read (int fd, char * buffer, unsigned int count)
5322{
5323 int nchars;
480b0c5b
GV		 5324 int to_read;
5325 DWORD waiting;
76b3903d 5326 char * orig_buffer = buffer;
480b0c5b 5327
7559f399 5328 if (fd < 0)
480b0c5b
GV		 5329 {
5330 errno = EBADF;
5331 return -1;
5332 }
5333
d888760c 5334 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
480b0c5b
GV		 5335 {
5336 child_process *cp = fd_info[fd].cp;
5337
5338 if ((fd_info[fd].flags & FILE_READ) == 0)
5339 {
5340 errno = EBADF;
5341 return -1;
5342 }
5343
76b3903d
GV		 5344 nchars = 0;
5345
5346 /* re-read CR carried over from last read */
5347 if (fd_info[fd].flags & FILE_LAST_CR)
5348 {
5349 if (fd_info[fd].flags & FILE_BINARY) abort ();
5350 *buffer++ = 0x0d;
5351 count--;
5352 nchars++;
f52eb3ef 5353 fd_info[fd].flags &= ~FILE_LAST_CR;
76b3903d
GV		 5354 }
5355
480b0c5b
GV		 5356 /* presence of a child_process structure means we are operating in
5357 non-blocking mode - otherwise we just call _read directly.
5358 Note that the child_process structure might be missing because
5359 reap_subprocess has been called; in this case the pipe is
5360 already broken, so calling _read on it is okay. */
5361 if (cp)
5362 {
5363 int current_status = cp->status;
5364
5365 switch (current_status)
5366 {
5367 case STATUS_READ_FAILED:
5368 case STATUS_READ_ERROR:
f52eb3ef
GV		 5369 /* report normal EOF if nothing in buffer */
5370 if (nchars <= 0)
5371 fd_info[fd].flags |= FILE_AT_EOF;
5372 return nchars;
480b0c5b
GV		 5373
5374 case STATUS_READ_READY:
5375 case STATUS_READ_IN_PROGRESS:
5376 DebPrint (("sys_read called when read is in progress\n"));
5377 errno = EWOULDBLOCK;
5378 return -1;
5379
5380 case STATUS_READ_SUCCEEDED:
5381 /* consume read-ahead char */
5382 *buffer++ = cp->chr;
5383 count--;
76b3903d 5384 nchars++;
480b0c5b
GV		 5385 cp->status = STATUS_READ_ACKNOWLEDGED;
5386 ResetEvent (cp->char_avail);
5387
5388 case STATUS_READ_ACKNOWLEDGED:
5389 break;
5390
5391 default:
5392 DebPrint (("sys_read: bad status %d\n", current_status));
5393 errno = EBADF;
5394 return -1;
5395 }
5396
5397 if (fd_info[fd].flags & FILE_PIPE)
5398 {
5399 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
5400 to_read = min (waiting, (DWORD) count);
f52eb3ef
GV		 5401
5402 if (to_read > 0)
5403 nchars += _read (fd, buffer, to_read);
480b0c5b 5404 }
d888760c
GM		 5405 else if (fd_info[fd].flags & FILE_SERIAL)
5406 {
5407 HANDLE hnd = fd_info[fd].hnd;
5408 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
d888760c
GM		 5409 int rc = 0;
5410 COMMTIMEOUTS ct;
5411
5412 if (count > 0)
5413 {
5414 /* Configure timeouts for non-blocking read. */
5415 if (!GetCommTimeouts (hnd, &ct))
5416 {
5417 errno = EIO;
5418 return -1;
5419 }
5420 ct.ReadIntervalTimeout = MAXDWORD;
5421 ct.ReadTotalTimeoutMultiplier = 0;
5422 ct.ReadTotalTimeoutConstant = 0;
5423 if (!SetCommTimeouts (hnd, &ct))
5424 {
5425 errno = EIO;
5426 return -1;
5427 }
5428
5429 if (!ResetEvent (ovl->hEvent))
5430 {
5431 errno = EIO;
5432 return -1;
5433 }
5434 if (!ReadFile (hnd, buffer, count, (DWORD*) &rc, ovl))
5435 {
5436 if (GetLastError () != ERROR_IO_PENDING)
5437 {
5438 errno = EIO;
5439 return -1;
5440 }
5441 if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
5442 {
5443 errno = EIO;
5444 return -1;
5445 }
5446 }
5447 nchars += rc;
5448 }
5449 }
480b0c5b
GV		 5450 else /* FILE_SOCKET */
5451 {
f249a012 5452 if (winsock_lib == NULL) abort ();
480b0c5b
GV		 5453
5454 /* do the equivalent of a non-blocking read */
5455 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
76b3903d 5456 if (waiting == 0 && nchars == 0)
480b0c5b
GV		 5457 {
5458 h_errno = errno = EWOULDBLOCK;
5459 return -1;
5460 }
5461
480b0c5b
GV		 5462 if (waiting)
5463 {
5464 /* always use binary mode for sockets */
76b3903d
GV		 5465 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
5466 if (res == SOCKET_ERROR)
480b0c5b 5467 {
ed3751c8
JB		 5468 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
5469 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
76b3903d
GV		 5470 set_errno ();
5471 return -1;
480b0c5b 5472 }
76b3903d 5473 nchars += res;
480b0c5b
GV		 5474 }
5475 }
480b0c5b
GV		 5476 }
5477 else
f52eb3ef
GV		 5478 {
5479 int nread = _read (fd, buffer, count);
5480 if (nread >= 0)
5481 nchars += nread;
5482 else if (nchars == 0)
5483 nchars = nread;
5484 }
76b3903d 5485
f52eb3ef
GV		 5486 if (nchars <= 0)
5487 fd_info[fd].flags |= FILE_AT_EOF;
76b3903d 5488 /* Perform text mode translation if required. */
f52eb3ef 5489 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
76b3903d
GV		 5490 {
5491 nchars = crlf_to_lf (nchars, orig_buffer);
5492 /* If buffer contains only CR, return that. To be absolutely
5493 sure we should attempt to read the next char, but in
5494 practice a CR to be followed by LF would not appear by
5495 itself in the buffer. */
5496 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
5497 {
5498 fd_info[fd].flags |= FILE_LAST_CR;
5499 nchars--;
5500 }
76b3903d 5501 }
480b0c5b
GV		 5502 }
5503 else
5504 nchars = _read (fd, buffer, count);
5505
76b3903d 5506 return nchars;
480b0c5b
GV		 5507}
5508
d888760c
GM		 5509/* From w32xfns.c */
5510extern HANDLE interrupt_handle;
5511
480b0c5b
GV		 5512/* For now, don't bother with a non-blocking mode */
5513int
5514sys_write (int fd, const void * buffer, unsigned int count)
5515{
5516 int nchars;
5517
7559f399 5518 if (fd < 0)
480b0c5b
GV		 5519 {
5520 errno = EBADF;
5521 return -1;
5522 }
5523
d888760c 5524 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
76b3903d
GV		 5525 {
5526 if ((fd_info[fd].flags & FILE_WRITE) == 0)
5527 {
5528 errno = EBADF;
5529 return -1;
5530 }
5531
5532 /* Perform text mode translation if required. */
5533 if ((fd_info[fd].flags & FILE_BINARY) == 0)
5534 {
5535 char * tmpbuf = alloca (count * 2);
5536 unsigned char * src = (void *)buffer;
5537 unsigned char * dst = tmpbuf;
5538 int nbytes = count;
5539
5540 while (1)
5541 {
5542 unsigned char *next;
5543 /* copy next line or remaining bytes */
5544 next = _memccpy (dst, src, '\n', nbytes);
5545 if (next)
5546 {
5547 /* copied one line ending with '\n' */
5548 int copied = next - dst;
5549 nbytes -= copied;
5550 src += copied;
5551 /* insert '\r' before '\n' */
5552 next[-1] = '\r';
5553 next[0] = '\n';
5554 dst = next + 1;
5555 count++;
177c0ea7 5556 }
76b3903d
GV		 5557 else
5558 /* copied remaining partial line -> now finished */
5559 break;
5560 }
5561 buffer = tmpbuf;
5562 }
5563 }
5564
d888760c
GM		 5565 if (fd < MAXDESC && fd_info[fd].flags & FILE_SERIAL)
5566 {
5567 HANDLE hnd = (HANDLE) _get_osfhandle (fd);
5568 OVERLAPPED *ovl = &fd_info[fd].cp->ovl_write;
5569 HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
5570 DWORD active = 0;
5571
5572 if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
5573 {
5574 if (GetLastError () != ERROR_IO_PENDING)
5575 {
5576 errno = EIO;
5577 return -1;
5578 }
5579 if (detect_input_pending ())
5580 active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
5581 QS_ALLINPUT);
5582 else
5583 active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
5584 if (active == WAIT_OBJECT_0)
5585 { /* User pressed C-g, cancel write, then leave. Don't bother
5586 cleaning up as we may only get stuck in buggy drivers. */
5587 PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
5588 CancelIo (hnd);
5589 errno = EIO;
5590 return -1;
5591 }
5592 if (active == WAIT_OBJECT_0 + 1
5593 && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
5594 {
5595 errno = EIO;
5596 return -1;
5597 }
5598 }
5599 }
7d701334 5600 else if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
480b0c5b 5601 {
30a32e0e 5602 unsigned long nblock = 0;
f249a012 5603 if (winsock_lib == NULL) abort ();
30a32e0e
JR		 5604
5605 /* TODO: implement select() properly so non-blocking I/O works. */
5606 /* For now, make sure the write blocks. */
5607 if (fd_info[fd].flags & FILE_NDELAY)
5608 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5609
480b0c5b 5610 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
30a32e0e
JR		 5611
5612 /* Set the socket back to non-blocking if it was before,
5613 for other operations that support it. */
5614 if (fd_info[fd].flags & FILE_NDELAY)
5615 {
5616 nblock = 1;
5617 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
5618 }
5619
480b0c5b
GV		 5620 if (nchars == SOCKET_ERROR)
5621 {
ed3751c8
JB		 5622 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
5623 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
480b0c5b
GV		 5624 set_errno ();
5625 }
5626 }
5627 else
6e83d800
EZ		 5628 {
5629 /* Some networked filesystems don't like too large writes, so
5630 break them into smaller chunks. See the Comments section of
5631 the MSDN documentation of WriteFile for details behind the
5632 choice of the value of CHUNK below. See also the thread
5633 http://thread.gmane.org/gmane.comp.version-control.git/145294
5634 in the git mailing list. */
5635 const unsigned char *p = buffer;
5636 const unsigned chunk = 30 * 1024 * 1024;
5637
5638 nchars = 0;
5639 while (count > 0)
5640 {
5641 unsigned this_chunk = count < chunk ? count : chunk;
5642 int n = _write (fd, p, this_chunk);
5643
5644 nchars += n;
5645 if (n < 0)
5646 {
5647 nchars = n;
5648 break;
5649 }
5650 else if (n < this_chunk)
5651 break;
5652 count -= n;
5653 p += n;
5654 }
5655 }
480b0c5b
GV		 5656
5657 return nchars;
5658}
5659
f52eb3ef 5660static void
b56ceb92 5661check_windows_init_file (void)
f52eb3ef 5662{
f52eb3ef
GV		 5663 /* A common indication that Emacs is not installed properly is when
5664 it cannot find the Windows installation file. If this file does
5665 not exist in the expected place, tell the user. */
5666
177c0ea7 5667 if (!noninteractive && !inhibit_window_system)
d54abccd 5668 {
a0b9c838 5669 Lisp_Object objs[2];
96ef7d42 5670 Lisp_Object full_load_path;
d54abccd
GV		 5671 Lisp_Object init_file;
5672 int fd;
f52eb3ef 5673
a0b9c838
GV		 5674 objs[0] = Vload_path;
5675 objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
5676 full_load_path = Fappend (2, objs);
d54abccd 5677 init_file = build_string ("term/w32-win");
c50a2aa6 5678 fd = openp (full_load_path, init_file, Fget_load_suffixes (), NULL, Qnil);
177c0ea7 5679 if (fd < 0)
d54abccd 5680 {
96ef7d42 5681 Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
d5db4077
KR		 5682 char *init_file_name = SDATA (init_file);
5683 char *load_path = SDATA (load_path_print);
acc23b87
KS		 5684 char *buffer = alloca (1024
5685 + strlen (init_file_name)
5686 + strlen (load_path));
d54abccd 5687
177c0ea7 5688 sprintf (buffer,
d54abccd
GV		 5689 "The Emacs Windows initialization file \"%s.el\" "
5690 "could not be found in your Emacs installation. "
5691 "Emacs checked the following directories for this file:\n"
5692 "\n%s\n\n"
5693 "When Emacs cannot find this file, it usually means that it "
5694 "was not installed properly, or its distribution file was "
5695 "not unpacked properly.\nSee the README.W32 file in the "
5696 "top-level Emacs directory for more information.",
5697 init_file_name, load_path);
5698 MessageBox (NULL,
5699 buffer,
5700 "Emacs Abort Dialog",
5701 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
f52eb3ef
GV		 5702 /* Use the low-level Emacs abort. */
5703#undef abort
d54abccd
GV		 5704 abort ();
5705 }
5706 else
5707 {
a302c7ae 5708 _close (fd);
d54abccd 5709 }
f52eb3ef 5710 }
f52eb3ef 5711}
480b0c5b
GV		 5712
5713void
b56ceb92 5714term_ntproc (void)
480b0c5b 5715{
480b0c5b
GV		 5716 /* shutdown the socket interface if necessary */
5717 term_winsock ();
52c7f9ee
JR		 5718
5719 term_w32select ();
480b0c5b
GV		 5720}
5721
5722void
b56ceb92 5723init_ntproc (void)
480b0c5b 5724{
f249a012
RS		 5725 /* Initialise the socket interface now if available and requested by
5726 the user by defining PRELOAD_WINSOCK; otherwise loading will be
fbd6baed 5727 delayed until open-network-stream is called (w32-has-winsock can
f249a012
RS		 5728 also be used to dynamically load or reload winsock).
5729
5730 Conveniently, init_environment is called before us, so
5731 PRELOAD_WINSOCK can be set in the registry. */
5732
5733 /* Always initialize this correctly. */
5734 winsock_lib = NULL;
5735
5736 if (getenv ("PRELOAD_WINSOCK") != NULL)
5737 init_winsock (TRUE);
480b0c5b
GV		 5738
5739 /* Initial preparation for subprocess support: replace our standard
5740 handles with non-inheritable versions. */
5741 {
5742 HANDLE parent;
5743 HANDLE stdin_save = INVALID_HANDLE_VALUE;
5744 HANDLE stdout_save = INVALID_HANDLE_VALUE;
5745 HANDLE stderr_save = INVALID_HANDLE_VALUE;
5746
5747 parent = GetCurrentProcess ();
5748
5749 /* ignore errors when duplicating and closing; typically the
5750 handles will be invalid when running as a gui program. */
177c0ea7
JB		 5751 DuplicateHandle (parent,
5752 GetStdHandle (STD_INPUT_HANDLE),
480b0c5b 5753 parent,
177c0ea7
JB		 5754 &stdin_save,
5755 0,
5756 FALSE,
480b0c5b 5757 DUPLICATE_SAME_ACCESS);
177c0ea7 5758
480b0c5b
GV		 5759 DuplicateHandle (parent,
5760 GetStdHandle (STD_OUTPUT_HANDLE),
5761 parent,
5762 &stdout_save,
5763 0,
5764 FALSE,
5765 DUPLICATE_SAME_ACCESS);
177c0ea7 5766
480b0c5b
GV		 5767 DuplicateHandle (parent,
5768 GetStdHandle (STD_ERROR_HANDLE),
5769 parent,
5770 &stderr_save,
5771 0,
5772 FALSE,
5773 DUPLICATE_SAME_ACCESS);
177c0ea7 5774
480b0c5b
GV		 5775 fclose (stdin);
5776 fclose (stdout);
5777 fclose (stderr);
5778
5779 if (stdin_save != INVALID_HANDLE_VALUE)
5780 _open_osfhandle ((long) stdin_save, O_TEXT);
5781 else
76b3903d
GV		 5782 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
5783 _fdopen (0, "r");
480b0c5b
GV		 5784
5785 if (stdout_save != INVALID_HANDLE_VALUE)
5786 _open_osfhandle ((long) stdout_save, O_TEXT);
5787 else
76b3903d
GV		 5788 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
5789 _fdopen (1, "w");
480b0c5b
GV		 5790
5791 if (stderr_save != INVALID_HANDLE_VALUE)
5792 _open_osfhandle ((long) stderr_save, O_TEXT);
5793 else
76b3903d
GV		 5794 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
5795 _fdopen (2, "w");
480b0c5b
GV		 5796 }
5797
5798 /* unfortunately, atexit depends on implementation of malloc */
5799 /* atexit (term_ntproc); */
5800 signal (SIGABRT, term_ntproc);
76b3903d
GV		 5801
5802 /* determine which drives are fixed, for GetCachedVolumeInformation */
5803 {
5804 /* GetDriveType must have trailing backslash. */
5805 char drive[] = "A:\\";
5806
5807 /* Loop over all possible drive letters */
5808 while (*drive <= 'Z')
5809 {
5810 /* Record if this drive letter refers to a fixed drive. */
177c0ea7 5811 fixed_drives[DRIVE_INDEX (*drive)] =
76b3903d
GV		 5812 (GetDriveType (drive) == DRIVE_FIXED);
5813
5814 (*drive)++;
5815 }
a302c7ae
AI		 5816
5817 /* Reset the volume info cache. */
5818 volume_cache = NULL;
76b3903d 5819 }
177c0ea7 5820
d54abccd
GV		 5821 /* Check to see if Emacs has been installed correctly. */
5822 check_windows_init_file ();
480b0c5b
GV		 5823}
5824
a8c3a596
JR		 5825/*
5826 shutdown_handler ensures that buffers' autosave files are
5827 up to date when the user logs off, or the system shuts down.
5828*/
bedf4aab 5829static BOOL WINAPI
ed3751c8 5830shutdown_handler (DWORD type)
a8c3a596
JR		 5831{
5832 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
5833 if (type == CTRL_CLOSE_EVENT /* User closes console window. */
5834 || type == CTRL_LOGOFF_EVENT /* User logs off. */
5835 || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown. */
5836 {
5837 /* Shut down cleanly, making sure autosave files are up to date. */
5838 shut_down_emacs (0, 0, Qnil);
5839 }
5840
7046f191 5841 /* Allow other handlers to handle this signal. */
a8c3a596
JR		 5842 return FALSE;
5843}
5844
9785d95b
BK		 5845/*
5846 globals_of_w32 is used to initialize those global variables that
5847 must always be initialized on startup even when the global variable
5848 initialized is non zero (see the function main in emacs.c).
5849*/
9bfb11f9 5850void
b56ceb92 5851globals_of_w32 (void)
9785d95b 5852{
74258518
JR		 5853 HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
5854
5855 get_process_times_fn = (GetProcessTimes_Proc)
5856 GetProcAddress (kernel32, "GetProcessTimes");
5857
9785d95b
BK		 5858 g_b_init_is_windows_9x = 0;
5859 g_b_init_open_process_token = 0;
5860 g_b_init_get_token_information = 0;
5861 g_b_init_lookup_account_sid = 0;
9d95a291
EZ		 5862 g_b_init_get_sid_sub_authority = 0;
5863 g_b_init_get_sid_sub_authority_count = 0;
8aaaec6b
EZ		 5864 g_b_init_get_file_security = 0;
5865 g_b_init_get_security_descriptor_owner = 0;
5866 g_b_init_get_security_descriptor_group = 0;
5867 g_b_init_is_valid_sid = 0;
7c80d5ec
EZ		 5868 g_b_init_create_toolhelp32_snapshot = 0;
5869 g_b_init_process32_first = 0;
5870 g_b_init_process32_next = 0;
5871 g_b_init_open_thread_token = 0;
5872 g_b_init_impersonate_self = 0;
5873 g_b_init_revert_to_self = 0;
5874 g_b_init_get_process_memory_info = 0;
5875 g_b_init_get_process_working_set_size = 0;
5876 g_b_init_global_memory_status = 0;
5877 g_b_init_global_memory_status_ex = 0;
f8b35b24
EZ		 5878 g_b_init_equal_sid = 0;
5879 g_b_init_copy_sid = 0;
5880 g_b_init_get_length_sid = 0;
ad9e2d54
EZ		 5881 g_b_init_get_native_system_info = 0;
5882 g_b_init_get_system_times = 0;
5883 num_of_processors = 0;
a8c3a596
JR		 5884 /* The following sets a handler for shutdown notifications for
5885 console apps. This actually applies to Emacs in both console and
5886 GUI modes, since we had to fool windows into thinking emacs is a
5887 console application to get console mode to work. */
ed3751c8 5888 SetConsoleCtrlHandler (shutdown_handler, TRUE);
8aaaec6b
EZ		 5889
5890 /* "None" is the default group name on standalone workstations. */
5891 strcpy (dflt_group_name, "None");
9785d95b
BK		 5892}
5893
d888760c 5894/* For make-serial-process */
b56ceb92
JB		 5895int
5896serial_open (char *port)
d888760c
GM		 5897{
5898 HANDLE hnd;
5899 child_process *cp;
5900 int fd = -1;
5901
5902 hnd = CreateFile (port, GENERIC_READ | GENERIC_WRITE, 0, 0,
5903 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
5904 if (hnd == INVALID_HANDLE_VALUE)
5905 error ("Could not open %s", port);
5906 fd = (int) _open_osfhandle ((int) hnd, 0);
5907 if (fd == -1)
5908 error ("Could not open %s", port);
5909
5910 cp = new_child ();
5911 if (!cp)
5912 error ("Could not create child process");
5913 cp->fd = fd;
5914 cp->status = STATUS_READ_ACKNOWLEDGED;
5915 fd_info[ fd ].hnd = hnd;
5916 fd_info[ fd ].flags |=
5917 FILE_READ | FILE_WRITE | FILE_BINARY | FILE_SERIAL;
5918 if (fd_info[ fd ].cp != NULL)
5919 {
5920 error ("fd_info[fd = %d] is already in use", fd);
5921 }
5922 fd_info[ fd ].cp = cp;
5923 cp->ovl_read.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
5924 if (cp->ovl_read.hEvent == NULL)
5925 error ("Could not create read event");
5926 cp->ovl_write.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
5927 if (cp->ovl_write.hEvent == NULL)
5928 error ("Could not create write event");
5929
5930 return fd;
5931}
5932
5933/* For serial-process-configure */
5934void
9d4f32e8 5935serial_configure (struct Lisp_Process *p, Lisp_Object contact)
d888760c
GM		 5936{
5937 Lisp_Object childp2 = Qnil;
5938 Lisp_Object tem = Qnil;
5939 HANDLE hnd;
5940 DCB dcb;
5941 COMMTIMEOUTS ct;
5942 char summary[4] = "???"; /* This usually becomes "8N1". */
5943
5944 if ((fd_info[ p->outfd ].flags & FILE_SERIAL) == 0)
5945 error ("Not a serial process");
5946 hnd = fd_info[ p->outfd ].hnd;
5947
5948 childp2 = Fcopy_sequence (p->childp);
5949
5950 /* Initialize timeouts for blocking read and blocking write. */
5951 if (!GetCommTimeouts (hnd, &ct))
5952 error ("GetCommTimeouts() failed");
5953 ct.ReadIntervalTimeout = 0;
5954 ct.ReadTotalTimeoutMultiplier = 0;
5955 ct.ReadTotalTimeoutConstant = 0;
5956 ct.WriteTotalTimeoutMultiplier = 0;
5957 ct.WriteTotalTimeoutConstant = 0;
5958 if (!SetCommTimeouts (hnd, &ct))
5959 error ("SetCommTimeouts() failed");
5960 /* Read port attributes and prepare default configuration. */
5961 memset (&dcb, 0, sizeof (dcb));
5962 dcb.DCBlength = sizeof (DCB);
5963 if (!GetCommState (hnd, &dcb))
5964 error ("GetCommState() failed");
5965 dcb.fBinary = TRUE;
5966 dcb.fNull = FALSE;
5967 dcb.fAbortOnError = FALSE;
5968 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
5969 dcb.ErrorChar = 0;
5970 dcb.EofChar = 0;
5971 dcb.EvtChar = 0;
5972
5973 /* Configure speed. */
5974 if (!NILP (Fplist_member (contact, QCspeed)))
5975 tem = Fplist_get (contact, QCspeed);
5976 else
5977 tem = Fplist_get (p->childp, QCspeed);
5978 CHECK_NUMBER (tem);
5979 dcb.BaudRate = XINT (tem);
5980 childp2 = Fplist_put (childp2, QCspeed, tem);
5981
5982 /* Configure bytesize. */
5983 if (!NILP (Fplist_member (contact, QCbytesize)))
5984 tem = Fplist_get (contact, QCbytesize);
5985 else
5986 tem = Fplist_get (p->childp, QCbytesize);
5987 if (NILP (tem))
5988 tem = make_number (8);
5989 CHECK_NUMBER (tem);
5990 if (XINT (tem) != 7 && XINT (tem) != 8)
5991 error (":bytesize must be nil (8), 7, or 8");
5992 dcb.ByteSize = XINT (tem);
5993 summary[0] = XINT (tem) + '0';
5994 childp2 = Fplist_put (childp2, QCbytesize, tem);
5995
5996 /* Configure parity. */
5997 if (!NILP (Fplist_member (contact, QCparity)))
5998 tem = Fplist_get (contact, QCparity);
5999 else
6000 tem = Fplist_get (p->childp, QCparity);
6001 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
6002 error (":parity must be nil (no parity), `even', or `odd'");
6003 dcb.fParity = FALSE;
6004 dcb.Parity = NOPARITY;
6005 dcb.fErrorChar = FALSE;
6006 if (NILP (tem))
6007 {
6008 summary[1] = 'N';
6009 }
6010 else if (EQ (tem, Qeven))
6011 {
6012 summary[1] = 'E';
6013 dcb.fParity = TRUE;
6014 dcb.Parity = EVENPARITY;
6015 dcb.fErrorChar = TRUE;
6016 }
6017 else if (EQ (tem, Qodd))
6018 {
6019 summary[1] = 'O';
6020 dcb.fParity = TRUE;
6021 dcb.Parity = ODDPARITY;
6022 dcb.fErrorChar = TRUE;
6023 }
6024 childp2 = Fplist_put (childp2, QCparity, tem);
6025
6026 /* Configure stopbits. */
6027 if (!NILP (Fplist_member (contact, QCstopbits)))
6028 tem = Fplist_get (contact, QCstopbits);
6029 else
6030 tem = Fplist_get (p->childp, QCstopbits);
6031 if (NILP (tem))
6032 tem = make_number (1);
6033 CHECK_NUMBER (tem);
6034 if (XINT (tem) != 1 && XINT (tem) != 2)
6035 error (":stopbits must be nil (1 stopbit), 1, or 2");
6036 summary[2] = XINT (tem) + '0';
6037 if (XINT (tem) == 1)
6038 dcb.StopBits = ONESTOPBIT;
6039 else if (XINT (tem) == 2)
6040 dcb.StopBits = TWOSTOPBITS;
6041 childp2 = Fplist_put (childp2, QCstopbits, tem);
6042
6043 /* Configure flowcontrol. */
6044 if (!NILP (Fplist_member (contact, QCflowcontrol)))
6045 tem = Fplist_get (contact, QCflowcontrol);
6046 else
6047 tem = Fplist_get (p->childp, QCflowcontrol);
6048 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
6049 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6050 dcb.fOutxCtsFlow = FALSE;
6051 dcb.fOutxDsrFlow = FALSE;
6052 dcb.fDtrControl = DTR_CONTROL_DISABLE;
6053 dcb.fDsrSensitivity = FALSE;
6054 dcb.fTXContinueOnXoff = FALSE;
6055 dcb.fOutX = FALSE;
6056 dcb.fInX = FALSE;
6057 dcb.fRtsControl = RTS_CONTROL_DISABLE;
6058 dcb.XonChar = 17; /* Control-Q */
6059 dcb.XoffChar = 19; /* Control-S */
6060 if (NILP (tem))
6061 {
6062 /* Already configured. */
6063 }
6064 else if (EQ (tem, Qhw))
6065 {
6066 dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
6067 dcb.fOutxCtsFlow = TRUE;
6068 }
6069 else if (EQ (tem, Qsw))
6070 {
6071 dcb.fOutX = TRUE;
6072 dcb.fInX = TRUE;
6073 }
6074 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
6075
6076 /* Activate configuration. */
6077 if (!SetCommState (hnd, &dcb))
6078 error ("SetCommState() failed");
6079
6080 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
6081 p->childp = childp2;
6082}
6083
aa5ee2a3 6084/* end of w32.c */
ab5796a9 6085
Unnamed repository; edit this file 'description' to name the repository.