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