Improve index entries. Remove redundant/useless ones.
[emacs.git] / src / w32.c
blob9ad82c7a231aa0ecbb6d9f46396f4c749314ae4d
1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994, 1995, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.
22 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
24 #include <stddef.h> /* for offsetof */
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <io.h>
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <ctype.h>
31 #include <signal.h>
32 #include <sys/file.h>
33 #include <sys/time.h>
34 #include <sys/utime.h>
35 #include <mbstring.h> /* for _mbspbrk */
37 /* must include CRT headers *before* config.h */
39 #ifdef HAVE_CONFIG_H
40 #include <config.h>
41 #endif
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
57 #undef close
58 #undef dup
59 #undef dup2
60 #undef pipe
61 #undef read
62 #undef write
64 #undef strerror
66 #include "lisp.h"
68 #include <pwd.h>
69 #include <grp.h>
71 #ifdef __GNUC__
72 #define _ANONYMOUS_UNION
73 #define _ANONYMOUS_STRUCT
74 #endif
75 #include <windows.h>
76 #include <shlobj.h>
78 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
79 #include <sys/socket.h>
80 #undef socket
81 #undef bind
82 #undef connect
83 #undef htons
84 #undef ntohs
85 #undef inet_addr
86 #undef gethostname
87 #undef gethostbyname
88 #undef getservbyname
89 #undef getpeername
90 #undef shutdown
91 #undef setsockopt
92 #undef listen
93 #undef getsockname
94 #undef accept
95 #undef recvfrom
96 #undef sendto
97 #endif
99 #include "w32.h"
100 #include "ndir.h"
101 #include "w32heap.h"
102 #include "systime.h"
104 typedef HRESULT (WINAPI * ShGetFolderPath_fn)
105 (IN HWND, IN int, IN HANDLE, IN DWORD, OUT char *);
107 void globals_of_w32 ();
109 extern Lisp_Object Vw32_downcase_file_names;
110 extern Lisp_Object Vw32_generate_fake_inodes;
111 extern Lisp_Object Vw32_get_true_file_attributes;
112 extern int w32_num_mouse_buttons;
116 Initialization states
118 static BOOL g_b_init_is_windows_9x;
119 static BOOL g_b_init_open_process_token;
120 static BOOL g_b_init_get_token_information;
121 static BOOL g_b_init_lookup_account_sid;
122 static BOOL g_b_init_get_sid_identifier_authority;
125 BEGIN: Wrapper functions around OpenProcessToken
126 and other functions in advapi32.dll that are only
127 supported in Windows NT / 2k / XP
129 /* ** Function pointer typedefs ** */
130 typedef BOOL (WINAPI * OpenProcessToken_Proc) (
131 HANDLE ProcessHandle,
132 DWORD DesiredAccess,
133 PHANDLE TokenHandle);
134 typedef BOOL (WINAPI * GetTokenInformation_Proc) (
135 HANDLE TokenHandle,
136 TOKEN_INFORMATION_CLASS TokenInformationClass,
137 LPVOID TokenInformation,
138 DWORD TokenInformationLength,
139 PDWORD ReturnLength);
140 #ifdef _UNICODE
141 const char * const LookupAccountSid_Name = "LookupAccountSidW";
142 #else
143 const char * const LookupAccountSid_Name = "LookupAccountSidA";
144 #endif
145 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
146 LPCTSTR lpSystemName,
147 PSID Sid,
148 LPTSTR Name,
149 LPDWORD cbName,
150 LPTSTR DomainName,
151 LPDWORD cbDomainName,
152 PSID_NAME_USE peUse);
153 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI * GetSidIdentifierAuthority_Proc) (
154 PSID pSid);
156 /* ** A utility function ** */
157 static BOOL
158 is_windows_9x ()
160 static BOOL s_b_ret=0;
161 OSVERSIONINFO os_ver;
162 if (g_b_init_is_windows_9x == 0)
164 g_b_init_is_windows_9x = 1;
165 ZeroMemory(&os_ver, sizeof(OSVERSIONINFO));
166 os_ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
167 if (GetVersionEx (&os_ver))
169 s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
172 return s_b_ret;
175 /* ** The wrapper functions ** */
177 BOOL WINAPI open_process_token (
178 HANDLE ProcessHandle,
179 DWORD DesiredAccess,
180 PHANDLE TokenHandle)
182 static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
183 HMODULE hm_advapi32 = NULL;
184 if (is_windows_9x () == TRUE)
186 return FALSE;
188 if (g_b_init_open_process_token == 0)
190 g_b_init_open_process_token = 1;
191 hm_advapi32 = LoadLibrary ("Advapi32.dll");
192 s_pfn_Open_Process_Token =
193 (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
195 if (s_pfn_Open_Process_Token == NULL)
197 return FALSE;
199 return (
200 s_pfn_Open_Process_Token (
201 ProcessHandle,
202 DesiredAccess,
203 TokenHandle)
207 BOOL WINAPI get_token_information (
208 HANDLE TokenHandle,
209 TOKEN_INFORMATION_CLASS TokenInformationClass,
210 LPVOID TokenInformation,
211 DWORD TokenInformationLength,
212 PDWORD ReturnLength)
214 static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
215 HMODULE hm_advapi32 = NULL;
216 if (is_windows_9x () == TRUE)
218 return FALSE;
220 if (g_b_init_get_token_information == 0)
222 g_b_init_get_token_information = 1;
223 hm_advapi32 = LoadLibrary ("Advapi32.dll");
224 s_pfn_Get_Token_Information =
225 (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
227 if (s_pfn_Get_Token_Information == NULL)
229 return FALSE;
231 return (
232 s_pfn_Get_Token_Information (
233 TokenHandle,
234 TokenInformationClass,
235 TokenInformation,
236 TokenInformationLength,
237 ReturnLength)
241 BOOL WINAPI lookup_account_sid (
242 LPCTSTR lpSystemName,
243 PSID Sid,
244 LPTSTR Name,
245 LPDWORD cbName,
246 LPTSTR DomainName,
247 LPDWORD cbDomainName,
248 PSID_NAME_USE peUse)
250 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
251 HMODULE hm_advapi32 = NULL;
252 if (is_windows_9x () == TRUE)
254 return FALSE;
256 if (g_b_init_lookup_account_sid == 0)
258 g_b_init_lookup_account_sid = 1;
259 hm_advapi32 = LoadLibrary ("Advapi32.dll");
260 s_pfn_Lookup_Account_Sid =
261 (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
263 if (s_pfn_Lookup_Account_Sid == NULL)
265 return FALSE;
267 return (
268 s_pfn_Lookup_Account_Sid (
269 lpSystemName,
270 Sid,
271 Name,
272 cbName,
273 DomainName,
274 cbDomainName,
275 peUse)
279 PSID_IDENTIFIER_AUTHORITY WINAPI get_sid_identifier_authority (
280 PSID pSid)
282 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority = NULL;
283 HMODULE hm_advapi32 = NULL;
284 if (is_windows_9x () == TRUE)
286 return NULL;
288 if (g_b_init_get_sid_identifier_authority == 0)
290 g_b_init_get_sid_identifier_authority = 1;
291 hm_advapi32 = LoadLibrary ("Advapi32.dll");
292 s_pfn_Get_Sid_Identifier_Authority =
293 (GetSidIdentifierAuthority_Proc) GetProcAddress (
294 hm_advapi32, "GetSidIdentifierAuthority");
296 if (s_pfn_Get_Sid_Identifier_Authority == NULL)
298 return NULL;
300 return (s_pfn_Get_Sid_Identifier_Authority (pSid));
304 END: Wrapper functions around OpenProcessToken
305 and other functions in advapi32.dll that are only
306 supported in Windows NT / 2k / XP
310 /* Equivalent of strerror for W32 error codes. */
311 char *
312 w32_strerror (int error_no)
314 static char buf[500];
316 if (error_no == 0)
317 error_no = GetLastError ();
319 buf[0] = '\0';
320 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
321 error_no,
322 0, /* choose most suitable language */
323 buf, sizeof (buf), NULL))
324 sprintf (buf, "w32 error %u", error_no);
325 return buf;
328 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
329 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
331 This is called from alloc.c:valid_pointer_p. */
333 w32_valid_pointer_p (void *p, int size)
335 SIZE_T done;
336 HANDLE h = OpenProcess (PROCESS_VM_READ, FALSE, GetCurrentProcessId ());
338 if (h)
340 unsigned char *buf = alloca (size);
341 int retval = ReadProcessMemory (h, p, buf, size, &done);
343 CloseHandle (h);
344 return retval;
346 else
347 return -1;
350 static char startup_dir[MAXPATHLEN];
352 /* Get the current working directory. */
353 char *
354 getwd (char *dir)
356 #if 0
357 if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
358 return dir;
359 return NULL;
360 #else
361 /* Emacs doesn't actually change directory itself, and we want to
362 force our real wd to be where emacs.exe is to avoid unnecessary
363 conflicts when trying to rename or delete directories. */
364 strcpy (dir, startup_dir);
365 return dir;
366 #endif
369 #ifndef HAVE_SOCKETS
370 /* Emulate gethostname. */
372 gethostname (char *buffer, int size)
374 /* NT only allows small host names, so the buffer is
375 certainly large enough. */
376 return !GetComputerName (buffer, &size);
378 #endif /* HAVE_SOCKETS */
380 /* Emulate getloadavg. */
382 getloadavg (double loadavg[], int nelem)
384 int i;
386 /* A faithful emulation is going to have to be saved for a rainy day. */
387 for (i = 0; i < nelem; i++)
389 loadavg[i] = 0.0;
391 return i;
394 /* Emulate getpwuid, getpwnam and others. */
396 #define PASSWD_FIELD_SIZE 256
398 static char the_passwd_name[PASSWD_FIELD_SIZE];
399 static char the_passwd_passwd[PASSWD_FIELD_SIZE];
400 static char the_passwd_gecos[PASSWD_FIELD_SIZE];
401 static char the_passwd_dir[PASSWD_FIELD_SIZE];
402 static char the_passwd_shell[PASSWD_FIELD_SIZE];
404 static struct passwd the_passwd =
406 the_passwd_name,
407 the_passwd_passwd,
411 the_passwd_gecos,
412 the_passwd_dir,
413 the_passwd_shell,
416 static struct group the_group =
418 /* There are no groups on NT, so we just return "root" as the
419 group name. */
420 "root",
424 getuid ()
426 return the_passwd.pw_uid;
430 geteuid ()
432 /* I could imagine arguing for checking to see whether the user is
433 in the Administrators group and returning a UID of 0 for that
434 case, but I don't know how wise that would be in the long run. */
435 return getuid ();
439 getgid ()
441 return the_passwd.pw_gid;
445 getegid ()
447 return getgid ();
450 struct passwd *
451 getpwuid (int uid)
453 if (uid == the_passwd.pw_uid)
454 return &the_passwd;
455 return NULL;
458 struct group *
459 getgrgid (gid_t gid)
461 return &the_group;
464 struct passwd *
465 getpwnam (char *name)
467 struct passwd *pw;
469 pw = getpwuid (getuid ());
470 if (!pw)
471 return pw;
473 if (stricmp (name, pw->pw_name))
474 return NULL;
476 return pw;
479 void
480 init_user_info ()
482 /* Find the user's real name by opening the process token and
483 looking up the name associated with the user-sid in that token.
485 Use the relative portion of the identifier authority value from
486 the user-sid as the user id value (same for group id using the
487 primary group sid from the process token). */
489 char user_sid[256], name[256], domain[256];
490 DWORD length = sizeof (name), dlength = sizeof (domain), trash;
491 HANDLE token = NULL;
492 SID_NAME_USE user_type;
494 if (
495 open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token)
496 && get_token_information (
497 token, TokenUser,
498 (PVOID) user_sid, sizeof (user_sid), &trash)
499 && lookup_account_sid (
500 NULL, *((PSID *) user_sid), name, &length,
501 domain, &dlength, &user_type)
504 strcpy (the_passwd.pw_name, name);
505 /* Determine a reasonable uid value. */
506 if (stricmp ("administrator", name) == 0)
508 the_passwd.pw_uid = 0;
509 the_passwd.pw_gid = 0;
511 else
513 SID_IDENTIFIER_AUTHORITY * pSIA;
515 pSIA = get_sid_identifier_authority (*((PSID *) user_sid));
516 /* I believe the relative portion is the last 4 bytes (of 6)
517 with msb first. */
518 the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
519 (pSIA->Value[3] << 16) +
520 (pSIA->Value[4] << 8) +
521 (pSIA->Value[5] << 0));
522 /* restrict to conventional uid range for normal users */
523 the_passwd.pw_uid = the_passwd.pw_uid % 60001;
525 /* Get group id */
526 if (get_token_information (token, TokenPrimaryGroup,
527 (PVOID) user_sid, sizeof (user_sid), &trash))
529 SID_IDENTIFIER_AUTHORITY * pSIA;
531 pSIA = get_sid_identifier_authority (*((PSID *) user_sid));
532 the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
533 (pSIA->Value[3] << 16) +
534 (pSIA->Value[4] << 8) +
535 (pSIA->Value[5] << 0));
536 /* I don't know if this is necessary, but for safety... */
537 the_passwd.pw_gid = the_passwd.pw_gid % 60001;
539 else
540 the_passwd.pw_gid = the_passwd.pw_uid;
543 /* If security calls are not supported (presumably because we
544 are running under Windows 95), fallback to this. */
545 else if (GetUserName (name, &length))
547 strcpy (the_passwd.pw_name, name);
548 if (stricmp ("administrator", name) == 0)
549 the_passwd.pw_uid = 0;
550 else
551 the_passwd.pw_uid = 123;
552 the_passwd.pw_gid = the_passwd.pw_uid;
554 else
556 strcpy (the_passwd.pw_name, "unknown");
557 the_passwd.pw_uid = 123;
558 the_passwd.pw_gid = 123;
561 /* Ensure HOME and SHELL are defined. */
562 if (getenv ("HOME") == NULL)
563 abort ();
564 if (getenv ("SHELL") == NULL)
565 abort ();
567 /* Set dir and shell from environment variables. */
568 strcpy (the_passwd.pw_dir, getenv ("HOME"));
569 strcpy (the_passwd.pw_shell, getenv ("SHELL"));
571 if (token)
572 CloseHandle (token);
576 random ()
578 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
579 return ((rand () << 15) | rand ());
582 void
583 srandom (int seed)
585 srand (seed);
589 /* Normalize filename by converting all path separators to
590 the specified separator. Also conditionally convert upper
591 case path name components to lower case. */
593 static void
594 normalize_filename (fp, path_sep)
595 register char *fp;
596 char path_sep;
598 char sep;
599 char *elem;
601 /* Always lower-case drive letters a-z, even if the filesystem
602 preserves case in filenames.
603 This is so filenames can be compared by string comparison
604 functions that are case-sensitive. Even case-preserving filesystems
605 do not distinguish case in drive letters. */
606 if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
608 *fp += 'a' - 'A';
609 fp += 2;
612 if (NILP (Vw32_downcase_file_names))
614 while (*fp)
616 if (*fp == '/' || *fp == '\\')
617 *fp = path_sep;
618 fp++;
620 return;
623 sep = path_sep; /* convert to this path separator */
624 elem = fp; /* start of current path element */
626 do {
627 if (*fp >= 'a' && *fp <= 'z')
628 elem = 0; /* don't convert this element */
630 if (*fp == 0 || *fp == ':')
632 sep = *fp; /* restore current separator (or 0) */
633 *fp = '/'; /* after conversion of this element */
636 if (*fp == '/' || *fp == '\\')
638 if (elem && elem != fp)
640 *fp = 0; /* temporary end of string */
641 _strlwr (elem); /* while we convert to lower case */
643 *fp = sep; /* convert (or restore) path separator */
644 elem = fp + 1; /* next element starts after separator */
645 sep = path_sep;
647 } while (*fp++);
650 /* Destructively turn backslashes into slashes. */
651 void
652 dostounix_filename (p)
653 register char *p;
655 normalize_filename (p, '/');
658 /* Destructively turn slashes into backslashes. */
659 void
660 unixtodos_filename (p)
661 register char *p;
663 normalize_filename (p, '\\');
666 /* Remove all CR's that are followed by a LF.
667 (From msdos.c...probably should figure out a way to share it,
668 although this code isn't going to ever change.) */
670 crlf_to_lf (n, buf)
671 register int n;
672 register unsigned char *buf;
674 unsigned char *np = buf;
675 unsigned char *startp = buf;
676 unsigned char *endp = buf + n;
678 if (n == 0)
679 return n;
680 while (buf < endp - 1)
682 if (*buf == 0x0d)
684 if (*(++buf) != 0x0a)
685 *np++ = 0x0d;
687 else
688 *np++ = *buf++;
690 if (buf < endp)
691 *np++ = *buf++;
692 return np - startp;
695 /* Parse the root part of file name, if present. Return length and
696 optionally store pointer to char after root. */
697 static int
698 parse_root (char * name, char ** pPath)
700 char * start = name;
702 if (name == NULL)
703 return 0;
705 /* find the root name of the volume if given */
706 if (isalpha (name[0]) && name[1] == ':')
708 /* skip past drive specifier */
709 name += 2;
710 if (IS_DIRECTORY_SEP (name[0]))
711 name++;
713 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
715 int slashes = 2;
716 name += 2;
719 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
720 break;
721 name++;
723 while ( *name );
724 if (IS_DIRECTORY_SEP (name[0]))
725 name++;
728 if (pPath)
729 *pPath = name;
731 return name - start;
734 /* Get long base name for name; name is assumed to be absolute. */
735 static int
736 get_long_basename (char * name, char * buf, int size)
738 WIN32_FIND_DATA find_data;
739 HANDLE dir_handle;
740 int len = 0;
742 /* must be valid filename, no wild cards or other invalid characters */
743 if (_mbspbrk (name, "*?|<>\""))
744 return 0;
746 dir_handle = FindFirstFile (name, &find_data);
747 if (dir_handle != INVALID_HANDLE_VALUE)
749 if ((len = strlen (find_data.cFileName)) < size)
750 memcpy (buf, find_data.cFileName, len + 1);
751 else
752 len = 0;
753 FindClose (dir_handle);
755 return len;
758 /* Get long name for file, if possible (assumed to be absolute). */
759 BOOL
760 w32_get_long_filename (char * name, char * buf, int size)
762 char * o = buf;
763 char * p;
764 char * q;
765 char full[ MAX_PATH ];
766 int len;
768 len = strlen (name);
769 if (len >= MAX_PATH)
770 return FALSE;
772 /* Use local copy for destructive modification. */
773 memcpy (full, name, len+1);
774 unixtodos_filename (full);
776 /* Copy root part verbatim. */
777 len = parse_root (full, &p);
778 memcpy (o, full, len);
779 o += len;
780 *o = '\0';
781 size -= len;
783 while (p != NULL && *p)
785 q = p;
786 p = strchr (q, '\\');
787 if (p) *p = '\0';
788 len = get_long_basename (full, o, size);
789 if (len > 0)
791 o += len;
792 size -= len;
793 if (p != NULL)
795 *p++ = '\\';
796 if (size < 2)
797 return FALSE;
798 *o++ = '\\';
799 size--;
800 *o = '\0';
803 else
804 return FALSE;
807 return TRUE;
811 is_unc_volume (const char *filename)
813 const char *ptr = filename;
815 if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
816 return 0;
818 if (_mbspbrk (ptr + 2, "*?|<>\"\\/"))
819 return 0;
821 return 1;
824 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
827 sigsetmask (int signal_mask)
829 return 0;
833 sigmask (int sig)
835 return 0;
839 sigblock (int sig)
841 return 0;
845 sigunblock (int sig)
847 return 0;
851 setpgrp (int pid, int gid)
853 return 0;
857 alarm (int seconds)
859 return 0;
862 void
863 unrequest_sigio (void)
865 return;
868 void
869 request_sigio (void)
871 return;
874 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
876 LPBYTE
877 w32_get_resource (key, lpdwtype)
878 char *key;
879 LPDWORD lpdwtype;
881 LPBYTE lpvalue;
882 HKEY hrootkey = NULL;
883 DWORD cbData;
884 BOOL ok = FALSE;
886 /* Check both the current user and the local machine to see if
887 we have any resources. */
889 if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
891 lpvalue = NULL;
893 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
894 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
895 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
897 return (lpvalue);
900 if (lpvalue) xfree (lpvalue);
902 RegCloseKey (hrootkey);
905 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
907 lpvalue = NULL;
909 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
910 && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
911 && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
913 return (lpvalue);
916 if (lpvalue) xfree (lpvalue);
918 RegCloseKey (hrootkey);
921 return (NULL);
924 char *get_emacs_configuration (void);
925 extern Lisp_Object Vsystem_configuration;
927 void
928 init_environment (char ** argv)
930 static const char * const tempdirs[] = {
931 "$TMPDIR", "$TEMP", "$TMP", "c:/"
934 int i;
936 const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
938 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
939 temporary files and assume "/tmp" if $TMPDIR is unset, which
940 will break on DOS/Windows. Refuse to work if we cannot find
941 a directory, not even "c:/", usable for that purpose. */
942 for (i = 0; i < imax ; i++)
944 const char *tmp = tempdirs[i];
946 if (*tmp == '$')
947 tmp = getenv (tmp + 1);
948 /* Note that `access' can lie to us if the directory resides on a
949 read-only filesystem, like CD-ROM or a write-protected floppy.
950 The only way to be really sure is to actually create a file and
951 see if it succeeds. But I think that's too much to ask. */
952 if (tmp && _access (tmp, D_OK) == 0)
954 char * var = alloca (strlen (tmp) + 8);
955 sprintf (var, "TMPDIR=%s", tmp);
956 _putenv (strdup (var));
957 break;
960 if (i >= imax)
961 cmd_error_internal
962 (Fcons (Qerror,
963 Fcons (build_string ("no usable temporary directories found!!"),
964 Qnil)),
965 "While setting TMPDIR: ");
967 /* Check for environment variables and use registry settings if they
968 don't exist. Fallback on default values where applicable. */
970 int i;
971 LPBYTE lpval;
972 DWORD dwType;
973 char locale_name[32];
974 struct stat ignored;
975 char default_home[MAX_PATH];
977 static const struct env_entry
979 char * name;
980 char * def_value;
981 } dflt_envvars[] =
983 {"HOME", "C:/"},
984 {"PRELOAD_WINSOCK", NULL},
985 {"emacs_dir", "C:/emacs"},
986 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
987 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
988 {"EMACSDATA", "%emacs_dir%/etc"},
989 {"EMACSPATH", "%emacs_dir%/bin"},
990 /* We no longer set INFOPATH because Info-default-directory-list
991 is then ignored. */
992 /* {"INFOPATH", "%emacs_dir%/info"}, */
993 {"EMACSDOC", "%emacs_dir%/etc"},
994 {"TERM", "cmd"},
995 {"LANG", NULL},
998 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1000 /* We need to copy dflt_envvars[] and work on the copy because we
1001 don't want the dumped Emacs to inherit the values of
1002 environment variables we saw during dumping (which could be on
1003 a different system). The defaults above must be left intact. */
1004 struct env_entry env_vars[N_ENV_VARS];
1006 for (i = 0; i < N_ENV_VARS; i++)
1007 env_vars[i] = dflt_envvars[i];
1009 /* For backwards compatibility, check if a .emacs file exists in C:/
1010 If not, then we can try to default to the appdata directory under the
1011 user's profile, which is more likely to be writable. */
1012 if (stat ("C:/.emacs", &ignored) < 0)
1014 HRESULT profile_result;
1015 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1016 of Windows 95 and NT4 that have not been updated to include
1017 MSIE 5. Also we don't link with shell32.dll by default. */
1018 HMODULE shell32_dll;
1019 ShGetFolderPath_fn get_folder_path;
1020 shell32_dll = GetModuleHandle ("shell32.dll");
1021 get_folder_path = (ShGetFolderPath_fn)
1022 GetProcAddress (shell32_dll, "SHGetFolderPathA");
1024 if (get_folder_path != NULL)
1026 profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
1027 0, default_home);
1029 /* If we can't get the appdata dir, revert to old behaviour. */
1030 if (profile_result == S_OK)
1031 env_vars[0].def_value = default_home;
1034 /* Unload shell32.dll, it is not needed anymore. */
1035 FreeLibrary (shell32_dll);
1038 /* Get default locale info and use it for LANG. */
1039 if (GetLocaleInfo (LOCALE_USER_DEFAULT,
1040 LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
1041 locale_name, sizeof (locale_name)))
1043 for (i = 0; i < N_ENV_VARS; i++)
1045 if (strcmp (env_vars[i].name, "LANG") == 0)
1047 env_vars[i].def_value = locale_name;
1048 break;
1053 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1055 /* Treat emacs_dir specially: set it unconditionally based on our
1056 location, if it appears that we are running from the bin subdir
1057 of a standard installation. */
1059 char *p;
1060 char modname[MAX_PATH];
1062 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1063 abort ();
1064 if ((p = strrchr (modname, '\\')) == NULL)
1065 abort ();
1066 *p = 0;
1068 if ((p = strrchr (modname, '\\')) && stricmp (p, "\\bin") == 0)
1070 char buf[SET_ENV_BUF_SIZE];
1072 *p = 0;
1073 for (p = modname; *p; p++)
1074 if (*p == '\\') *p = '/';
1076 _snprintf (buf, sizeof(buf)-1, "emacs_dir=%s", modname);
1077 _putenv (strdup (buf));
1079 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1081 /* FIXME: should use substring of get_emacs_configuration ().
1082 But I don't think the Windows build supports alpha, mips etc
1083 anymore, so have taken the easy option for now. */
1084 else if (p && stricmp (p, "\\i386") == 0)
1086 *p = 0;
1087 p = strrchr (modname, '\\');
1088 if (p != NULL)
1090 *p = 0;
1091 p = strrchr (modname, '\\');
1092 if (p && stricmp (p, "\\src") == 0)
1094 char buf[SET_ENV_BUF_SIZE];
1096 *p = 0;
1097 for (p = modname; *p; p++)
1098 if (*p == '\\') *p = '/';
1100 _snprintf (buf, sizeof(buf)-1, "emacs_dir=%s", modname);
1101 _putenv (strdup (buf));
1107 for (i = 0; i < N_ENV_VARS; i++)
1109 if (!getenv (env_vars[i].name))
1111 int dont_free = 0;
1113 if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL)
1115 lpval = env_vars[i].def_value;
1116 dwType = REG_EXPAND_SZ;
1117 dont_free = 1;
1120 if (lpval)
1122 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
1124 if (dwType == REG_EXPAND_SZ)
1125 ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof(buf1));
1126 else if (dwType == REG_SZ)
1127 strcpy (buf1, lpval);
1128 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
1130 _snprintf (buf2, sizeof(buf2)-1, "%s=%s", env_vars[i].name,
1131 buf1);
1132 _putenv (strdup (buf2));
1135 if (!dont_free)
1136 xfree (lpval);
1142 /* Rebuild system configuration to reflect invoking system. */
1143 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1145 /* Another special case: on NT, the PATH variable is actually named
1146 "Path" although cmd.exe (perhaps NT itself) arranges for
1147 environment variable lookup and setting to be case insensitive.
1148 However, Emacs assumes a fully case sensitive environment, so we
1149 need to change "Path" to "PATH" to match the expectations of
1150 various elisp packages. We do this by the sneaky method of
1151 modifying the string in the C runtime environ entry.
1153 The same applies to COMSPEC. */
1155 char ** envp;
1157 for (envp = environ; *envp; envp++)
1158 if (_strnicmp (*envp, "PATH=", 5) == 0)
1159 memcpy (*envp, "PATH=", 5);
1160 else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
1161 memcpy (*envp, "COMSPEC=", 8);
1164 /* Remember the initial working directory for getwd, then make the
1165 real wd be the location of emacs.exe to avoid conflicts when
1166 renaming or deleting directories. (We also don't call chdir when
1167 running subprocesses for the same reason.) */
1168 if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
1169 abort ();
1172 char *p;
1173 static char modname[MAX_PATH];
1175 if (!GetModuleFileName (NULL, modname, MAX_PATH))
1176 abort ();
1177 if ((p = strrchr (modname, '\\')) == NULL)
1178 abort ();
1179 *p = 0;
1181 SetCurrentDirectory (modname);
1183 /* Ensure argv[0] has the full path to Emacs. */
1184 *p = '\\';
1185 argv[0] = modname;
1188 /* Determine if there is a middle mouse button, to allow parse_button
1189 to decide whether right mouse events should be mouse-2 or
1190 mouse-3. */
1191 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
1193 init_user_info ();
1196 char *
1197 emacs_root_dir (void)
1199 static char root_dir[FILENAME_MAX];
1200 const char *p;
1202 p = getenv ("emacs_dir");
1203 if (p == NULL)
1204 abort ();
1205 strcpy (root_dir, p);
1206 root_dir[parse_root (root_dir, NULL)] = '\0';
1207 dostounix_filename (root_dir);
1208 return root_dir;
1211 /* We don't have scripts to automatically determine the system configuration
1212 for Emacs before it's compiled, and we don't want to have to make the
1213 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1214 routine. */
1216 char *
1217 get_emacs_configuration (void)
1219 char *arch, *oem, *os;
1220 int build_num;
1221 static char configuration_buffer[32];
1223 /* Determine the processor type. */
1224 switch (get_processor_type ())
1227 #ifdef PROCESSOR_INTEL_386
1228 case PROCESSOR_INTEL_386:
1229 case PROCESSOR_INTEL_486:
1230 case PROCESSOR_INTEL_PENTIUM:
1231 arch = "i386";
1232 break;
1233 #endif
1235 #ifdef PROCESSOR_INTEL_860
1236 case PROCESSOR_INTEL_860:
1237 arch = "i860";
1238 break;
1239 #endif
1241 #ifdef PROCESSOR_MIPS_R2000
1242 case PROCESSOR_MIPS_R2000:
1243 case PROCESSOR_MIPS_R3000:
1244 case PROCESSOR_MIPS_R4000:
1245 arch = "mips";
1246 break;
1247 #endif
1249 #ifdef PROCESSOR_ALPHA_21064
1250 case PROCESSOR_ALPHA_21064:
1251 arch = "alpha";
1252 break;
1253 #endif
1255 default:
1256 arch = "unknown";
1257 break;
1260 /* Use the OEM field to reflect the compiler/library combination. */
1261 #ifdef _MSC_VER
1262 #define COMPILER_NAME "msvc"
1263 #else
1264 #ifdef __GNUC__
1265 #define COMPILER_NAME "mingw"
1266 #else
1267 #define COMPILER_NAME "unknown"
1268 #endif
1269 #endif
1270 oem = COMPILER_NAME;
1272 switch (osinfo_cache.dwPlatformId) {
1273 case VER_PLATFORM_WIN32_NT:
1274 os = "nt";
1275 build_num = osinfo_cache.dwBuildNumber;
1276 break;
1277 case VER_PLATFORM_WIN32_WINDOWS:
1278 if (osinfo_cache.dwMinorVersion == 0) {
1279 os = "windows95";
1280 } else {
1281 os = "windows98";
1283 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1284 break;
1285 case VER_PLATFORM_WIN32s:
1286 /* Not supported, should not happen. */
1287 os = "windows32s";
1288 build_num = LOWORD (osinfo_cache.dwBuildNumber);
1289 break;
1290 default:
1291 os = "unknown";
1292 build_num = 0;
1293 break;
1296 if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1297 sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
1298 get_w32_major_version (), get_w32_minor_version (), build_num);
1299 } else {
1300 sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
1303 return configuration_buffer;
1306 char *
1307 get_emacs_configuration_options (void)
1309 static char options_buffer[256];
1311 /* Work out the effective configure options for this build. */
1312 #ifdef _MSC_VER
1313 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1314 #else
1315 #ifdef __GNUC__
1316 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1317 #else
1318 #define COMPILER_VERSION ""
1319 #endif
1320 #endif
1322 sprintf (options_buffer, COMPILER_VERSION);
1323 #ifdef EMACSDEBUG
1324 strcat (options_buffer, " --no-opt");
1325 #endif
1326 #ifdef USER_CFLAGS
1327 strcat (options_buffer, " --cflags");
1328 strcat (options_buffer, USER_CFLAGS);
1329 #endif
1330 #ifdef USER_LDFLAGS
1331 strcat (options_buffer, " --ldflags");
1332 strcat (options_buffer, USER_LDFLAGS);
1333 #endif
1334 return options_buffer;
1338 #include <sys/timeb.h>
1340 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1341 void
1342 gettimeofday (struct timeval *tv, struct timezone *tz)
1344 struct _timeb tb;
1345 _ftime (&tb);
1347 tv->tv_sec = tb.time;
1348 tv->tv_usec = tb.millitm * 1000L;
1349 if (tz)
1351 tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
1352 tz->tz_dsttime = tb.dstflag; /* type of dst correction */
1356 /* ------------------------------------------------------------------------- */
1357 /* IO support and wrapper functions for W32 API. */
1358 /* ------------------------------------------------------------------------- */
1360 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1361 on network directories, so we handle that case here.
1362 (Ulrich Leodolter, 1/11/95). */
1363 char *
1364 sys_ctime (const time_t *t)
1366 char *str = (char *) ctime (t);
1367 return (str ? str : "Sun Jan 01 00:00:00 1970");
1370 /* Emulate sleep...we could have done this with a define, but that
1371 would necessitate including windows.h in the files that used it.
1372 This is much easier. */
1373 void
1374 sys_sleep (int seconds)
1376 Sleep (seconds * 1000);
1379 /* Internal MSVC functions for low-level descriptor munging */
1380 extern int __cdecl _set_osfhnd (int fd, long h);
1381 extern int __cdecl _free_osfhnd (int fd);
1383 /* parallel array of private info on file handles */
1384 filedesc fd_info [ MAXDESC ];
1386 typedef struct volume_info_data {
1387 struct volume_info_data * next;
1389 /* time when info was obtained */
1390 DWORD timestamp;
1392 /* actual volume info */
1393 char * root_dir;
1394 DWORD serialnum;
1395 DWORD maxcomp;
1396 DWORD flags;
1397 char * name;
1398 char * type;
1399 } volume_info_data;
1401 /* Global referenced by various functions. */
1402 static volume_info_data volume_info;
1404 /* Vector to indicate which drives are local and fixed (for which cached
1405 data never expires). */
1406 static BOOL fixed_drives[26];
1408 /* Consider cached volume information to be stale if older than 10s,
1409 at least for non-local drives. Info for fixed drives is never stale. */
1410 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1411 #define VOLINFO_STILL_VALID( root_dir, info ) \
1412 ( ( isalpha (root_dir[0]) && \
1413 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1414 || GetTickCount () - info->timestamp < 10000 )
1416 /* Cache support functions. */
1418 /* Simple linked list with linear search is sufficient. */
1419 static volume_info_data *volume_cache = NULL;
1421 static volume_info_data *
1422 lookup_volume_info (char * root_dir)
1424 volume_info_data * info;
1426 for (info = volume_cache; info; info = info->next)
1427 if (stricmp (info->root_dir, root_dir) == 0)
1428 break;
1429 return info;
1432 static void
1433 add_volume_info (char * root_dir, volume_info_data * info)
1435 info->root_dir = xstrdup (root_dir);
1436 info->next = volume_cache;
1437 volume_cache = info;
1441 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1442 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1443 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1444 volume_info_data *
1445 GetCachedVolumeInformation (char * root_dir)
1447 volume_info_data * info;
1448 char default_root[ MAX_PATH ];
1450 /* NULL for root_dir means use root from current directory. */
1451 if (root_dir == NULL)
1453 if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
1454 return NULL;
1455 parse_root (default_root, &root_dir);
1456 *root_dir = 0;
1457 root_dir = default_root;
1460 /* Local fixed drives can be cached permanently. Removable drives
1461 cannot be cached permanently, since the volume name and serial
1462 number (if nothing else) can change. Remote drives should be
1463 treated as if they are removable, since there is no sure way to
1464 tell whether they are or not. Also, the UNC association of drive
1465 letters mapped to remote volumes can be changed at any time (even
1466 by other processes) without notice.
1468 As a compromise, so we can benefit from caching info for remote
1469 volumes, we use a simple expiry mechanism to invalidate cache
1470 entries that are more than ten seconds old. */
1472 #if 0
1473 /* No point doing this, because WNetGetConnection is even slower than
1474 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1475 GetDriveType is about the only call of this type which does not
1476 involve network access, and so is extremely quick). */
1478 /* Map drive letter to UNC if remote. */
1479 if ( isalpha( root_dir[0] ) && !fixed[ DRIVE_INDEX( root_dir[0] ) ] )
1481 char remote_name[ 256 ];
1482 char drive[3] = { root_dir[0], ':' };
1484 if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
1485 == NO_ERROR)
1486 /* do something */ ;
1488 #endif
1490 info = lookup_volume_info (root_dir);
1492 if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
1494 char name[ 256 ];
1495 DWORD serialnum;
1496 DWORD maxcomp;
1497 DWORD flags;
1498 char type[ 256 ];
1500 /* Info is not cached, or is stale. */
1501 if (!GetVolumeInformation (root_dir,
1502 name, sizeof (name),
1503 &serialnum,
1504 &maxcomp,
1505 &flags,
1506 type, sizeof (type)))
1507 return NULL;
1509 /* Cache the volume information for future use, overwriting existing
1510 entry if present. */
1511 if (info == NULL)
1513 info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
1514 add_volume_info (root_dir, info);
1516 else
1518 xfree (info->name);
1519 xfree (info->type);
1522 info->name = xstrdup (name);
1523 info->serialnum = serialnum;
1524 info->maxcomp = maxcomp;
1525 info->flags = flags;
1526 info->type = xstrdup (type);
1527 info->timestamp = GetTickCount ();
1530 return info;
1533 /* Get information on the volume where name is held; set path pointer to
1534 start of pathname in name (past UNC header\volume header if present). */
1536 get_volume_info (const char * name, const char ** pPath)
1538 char temp[MAX_PATH];
1539 char *rootname = NULL; /* default to current volume */
1540 volume_info_data * info;
1542 if (name == NULL)
1543 return FALSE;
1545 /* find the root name of the volume if given */
1546 if (isalpha (name[0]) && name[1] == ':')
1548 rootname = temp;
1549 temp[0] = *name++;
1550 temp[1] = *name++;
1551 temp[2] = '\\';
1552 temp[3] = 0;
1554 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1556 char *str = temp;
1557 int slashes = 4;
1558 rootname = temp;
1561 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1562 break;
1563 *str++ = *name++;
1565 while ( *name );
1567 *str++ = '\\';
1568 *str = 0;
1571 if (pPath)
1572 *pPath = name;
1574 info = GetCachedVolumeInformation (rootname);
1575 if (info != NULL)
1577 /* Set global referenced by other functions. */
1578 volume_info = *info;
1579 return TRUE;
1581 return FALSE;
1584 /* Determine if volume is FAT format (ie. only supports short 8.3
1585 names); also set path pointer to start of pathname in name. */
1587 is_fat_volume (const char * name, const char ** pPath)
1589 if (get_volume_info (name, pPath))
1590 return (volume_info.maxcomp == 12);
1591 return FALSE;
1594 /* Map filename to a legal 8.3 name if necessary. */
1595 const char *
1596 map_w32_filename (const char * name, const char ** pPath)
1598 static char shortname[MAX_PATH];
1599 char * str = shortname;
1600 char c;
1601 char * path;
1602 const char * save_name = name;
1604 if (strlen (name) >= MAX_PATH)
1606 /* Return a filename which will cause callers to fail. */
1607 strcpy (shortname, "?");
1608 return shortname;
1611 if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
1613 register int left = 8; /* maximum number of chars in part */
1614 register int extn = 0; /* extension added? */
1615 register int dots = 2; /* maximum number of dots allowed */
1617 while (name < path)
1618 *str++ = *name++; /* skip past UNC header */
1620 while ((c = *name++))
1622 switch ( c )
1624 case '\\':
1625 case '/':
1626 *str++ = '\\';
1627 extn = 0; /* reset extension flags */
1628 dots = 2; /* max 2 dots */
1629 left = 8; /* max length 8 for main part */
1630 break;
1631 case ':':
1632 *str++ = ':';
1633 extn = 0; /* reset extension flags */
1634 dots = 2; /* max 2 dots */
1635 left = 8; /* max length 8 for main part */
1636 break;
1637 case '.':
1638 if ( dots )
1640 /* Convert path components of the form .xxx to _xxx,
1641 but leave . and .. as they are. This allows .emacs
1642 to be read as _emacs, for example. */
1644 if (! *name ||
1645 *name == '.' ||
1646 IS_DIRECTORY_SEP (*name))
1648 *str++ = '.';
1649 dots--;
1651 else
1653 *str++ = '_';
1654 left--;
1655 dots = 0;
1658 else if ( !extn )
1660 *str++ = '.';
1661 extn = 1; /* we've got an extension */
1662 left = 3; /* 3 chars in extension */
1664 else
1666 /* any embedded dots after the first are converted to _ */
1667 *str++ = '_';
1669 break;
1670 case '~':
1671 case '#': /* don't lose these, they're important */
1672 if ( ! left )
1673 str[-1] = c; /* replace last character of part */
1674 /* FALLTHRU */
1675 default:
1676 if ( left )
1678 *str++ = tolower (c); /* map to lower case (looks nicer) */
1679 left--;
1680 dots = 0; /* started a path component */
1682 break;
1685 *str = '\0';
1687 else
1689 strcpy (shortname, name);
1690 unixtodos_filename (shortname);
1693 if (pPath)
1694 *pPath = shortname + (path - save_name);
1696 return shortname;
1699 static int
1700 is_exec (const char * name)
1702 char * p = strrchr (name, '.');
1703 return
1704 (p != NULL
1705 && (stricmp (p, ".exe") == 0 ||
1706 stricmp (p, ".com") == 0 ||
1707 stricmp (p, ".bat") == 0 ||
1708 stricmp (p, ".cmd") == 0));
1711 /* Emulate the Unix directory procedures opendir, closedir,
1712 and readdir. We can't use the procedures supplied in sysdep.c,
1713 so we provide them here. */
1715 struct direct dir_static; /* simulated directory contents */
1716 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
1717 static int dir_is_fat;
1718 static char dir_pathname[MAXPATHLEN+1];
1719 static WIN32_FIND_DATA dir_find_data;
1721 /* Support shares on a network resource as subdirectories of a read-only
1722 root directory. */
1723 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
1724 HANDLE open_unc_volume (const char *);
1725 char *read_unc_volume (HANDLE, char *, int);
1726 void close_unc_volume (HANDLE);
1728 DIR *
1729 opendir (char *filename)
1731 DIR *dirp;
1733 /* Opening is done by FindFirstFile. However, a read is inherent to
1734 this operation, so we defer the open until read time. */
1736 if (dir_find_handle != INVALID_HANDLE_VALUE)
1737 return NULL;
1738 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1739 return NULL;
1741 if (is_unc_volume (filename))
1743 wnet_enum_handle = open_unc_volume (filename);
1744 if (wnet_enum_handle == INVALID_HANDLE_VALUE)
1745 return NULL;
1748 if (!(dirp = (DIR *) malloc (sizeof (DIR))))
1749 return NULL;
1751 dirp->dd_fd = 0;
1752 dirp->dd_loc = 0;
1753 dirp->dd_size = 0;
1755 strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
1756 dir_pathname[MAXPATHLEN] = '\0';
1757 dir_is_fat = is_fat_volume (filename, NULL);
1759 return dirp;
1762 void
1763 closedir (DIR *dirp)
1765 /* If we have a find-handle open, close it. */
1766 if (dir_find_handle != INVALID_HANDLE_VALUE)
1768 FindClose (dir_find_handle);
1769 dir_find_handle = INVALID_HANDLE_VALUE;
1771 else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1773 close_unc_volume (wnet_enum_handle);
1774 wnet_enum_handle = INVALID_HANDLE_VALUE;
1776 xfree ((char *) dirp);
1779 struct direct *
1780 readdir (DIR *dirp)
1782 if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1784 if (!read_unc_volume (wnet_enum_handle,
1785 dir_find_data.cFileName,
1786 MAX_PATH))
1787 return NULL;
1789 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1790 else if (dir_find_handle == INVALID_HANDLE_VALUE)
1792 char filename[MAXNAMLEN + 3];
1793 int ln;
1795 strcpy (filename, dir_pathname);
1796 ln = strlen (filename) - 1;
1797 if (!IS_DIRECTORY_SEP (filename[ln]))
1798 strcat (filename, "\\");
1799 strcat (filename, "*");
1801 dir_find_handle = FindFirstFile (filename, &dir_find_data);
1803 if (dir_find_handle == INVALID_HANDLE_VALUE)
1804 return NULL;
1806 else
1808 if (!FindNextFile (dir_find_handle, &dir_find_data))
1809 return NULL;
1812 /* Emacs never uses this value, so don't bother making it match
1813 value returned by stat(). */
1814 dir_static.d_ino = 1;
1816 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
1817 dir_static.d_namlen - dir_static.d_namlen % 4;
1819 dir_static.d_namlen = strlen (dir_find_data.cFileName);
1820 strcpy (dir_static.d_name, dir_find_data.cFileName);
1821 if (dir_is_fat)
1822 _strlwr (dir_static.d_name);
1823 else if (!NILP (Vw32_downcase_file_names))
1825 register char *p;
1826 for (p = dir_static.d_name; *p; p++)
1827 if (*p >= 'a' && *p <= 'z')
1828 break;
1829 if (!*p)
1830 _strlwr (dir_static.d_name);
1833 return &dir_static;
1836 HANDLE
1837 open_unc_volume (const char *path)
1839 NETRESOURCE nr;
1840 HANDLE henum;
1841 int result;
1843 nr.dwScope = RESOURCE_GLOBALNET;
1844 nr.dwType = RESOURCETYPE_DISK;
1845 nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
1846 nr.dwUsage = RESOURCEUSAGE_CONTAINER;
1847 nr.lpLocalName = NULL;
1848 nr.lpRemoteName = (LPSTR)map_w32_filename (path, NULL);
1849 nr.lpComment = NULL;
1850 nr.lpProvider = NULL;
1852 result = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
1853 RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
1855 if (result == NO_ERROR)
1856 return henum;
1857 else
1858 return INVALID_HANDLE_VALUE;
1861 char *
1862 read_unc_volume (HANDLE henum, char *readbuf, int size)
1864 DWORD count;
1865 int result;
1866 DWORD bufsize = 512;
1867 char *buffer;
1868 char *ptr;
1870 count = 1;
1871 buffer = alloca (bufsize);
1872 result = WNetEnumResource (wnet_enum_handle, &count, buffer, &bufsize);
1873 if (result != NO_ERROR)
1874 return NULL;
1876 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1877 ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
1878 ptr += 2;
1879 while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
1880 ptr++;
1882 strncpy (readbuf, ptr, size);
1883 return readbuf;
1886 void
1887 close_unc_volume (HANDLE henum)
1889 if (henum != INVALID_HANDLE_VALUE)
1890 WNetCloseEnum (henum);
1893 DWORD
1894 unc_volume_file_attributes (const char *path)
1896 HANDLE henum;
1897 DWORD attrs;
1899 henum = open_unc_volume (path);
1900 if (henum == INVALID_HANDLE_VALUE)
1901 return -1;
1903 attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
1905 close_unc_volume (henum);
1907 return attrs;
1911 /* Shadow some MSVC runtime functions to map requests for long filenames
1912 to reasonable short names if necessary. This was originally added to
1913 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1914 long file names. */
1917 sys_access (const char * path, int mode)
1919 DWORD attributes;
1921 /* MSVC implementation doesn't recognize D_OK. */
1922 path = map_w32_filename (path, NULL);
1923 if (is_unc_volume (path))
1925 attributes = unc_volume_file_attributes (path);
1926 if (attributes == -1) {
1927 errno = EACCES;
1928 return -1;
1931 else if ((attributes = GetFileAttributes (path)) == -1)
1933 /* Should try mapping GetLastError to errno; for now just indicate
1934 that path doesn't exist. */
1935 errno = EACCES;
1936 return -1;
1938 if ((mode & X_OK) != 0 && !is_exec (path))
1940 errno = EACCES;
1941 return -1;
1943 if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
1945 errno = EACCES;
1946 return -1;
1948 if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
1950 errno = EACCES;
1951 return -1;
1953 return 0;
1957 sys_chdir (const char * path)
1959 return _chdir (map_w32_filename (path, NULL));
1963 sys_chmod (const char * path, int mode)
1965 return _chmod (map_w32_filename (path, NULL), mode);
1969 sys_chown (const char *path, uid_t owner, gid_t group)
1971 if (sys_chmod (path, _S_IREAD) == -1) /* check if file exists */
1972 return -1;
1973 return 0;
1977 sys_creat (const char * path, int mode)
1979 return _creat (map_w32_filename (path, NULL), mode);
1982 FILE *
1983 sys_fopen(const char * path, const char * mode)
1985 int fd;
1986 int oflag;
1987 const char * mode_save = mode;
1989 /* Force all file handles to be non-inheritable. This is necessary to
1990 ensure child processes don't unwittingly inherit handles that might
1991 prevent future file access. */
1993 if (mode[0] == 'r')
1994 oflag = O_RDONLY;
1995 else if (mode[0] == 'w' || mode[0] == 'a')
1996 oflag = O_WRONLY | O_CREAT | O_TRUNC;
1997 else
1998 return NULL;
2000 /* Only do simplistic option parsing. */
2001 while (*++mode)
2002 if (mode[0] == '+')
2004 oflag &= ~(O_RDONLY | O_WRONLY);
2005 oflag |= O_RDWR;
2007 else if (mode[0] == 'b')
2009 oflag &= ~O_TEXT;
2010 oflag |= O_BINARY;
2012 else if (mode[0] == 't')
2014 oflag &= ~O_BINARY;
2015 oflag |= O_TEXT;
2017 else break;
2019 fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
2020 if (fd < 0)
2021 return NULL;
2023 return _fdopen (fd, mode_save);
2026 /* This only works on NTFS volumes, but is useful to have. */
2028 sys_link (const char * old, const char * new)
2030 HANDLE fileh;
2031 int result = -1;
2032 char oldname[MAX_PATH], newname[MAX_PATH];
2034 if (old == NULL || new == NULL)
2036 errno = ENOENT;
2037 return -1;
2040 strcpy (oldname, map_w32_filename (old, NULL));
2041 strcpy (newname, map_w32_filename (new, NULL));
2043 fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
2044 FILE_FLAG_BACKUP_SEMANTICS, NULL);
2045 if (fileh != INVALID_HANDLE_VALUE)
2047 int wlen;
2049 /* Confusingly, the "alternate" stream name field does not apply
2050 when restoring a hard link, and instead contains the actual
2051 stream data for the link (ie. the name of the link to create).
2052 The WIN32_STREAM_ID structure before the cStreamName field is
2053 the stream header, which is then immediately followed by the
2054 stream data. */
2056 struct {
2057 WIN32_STREAM_ID wid;
2058 WCHAR wbuffer[MAX_PATH]; /* extra space for link name */
2059 } data;
2061 wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
2062 data.wid.cStreamName, MAX_PATH);
2063 if (wlen > 0)
2065 LPVOID context = NULL;
2066 DWORD wbytes = 0;
2068 data.wid.dwStreamId = BACKUP_LINK;
2069 data.wid.dwStreamAttributes = 0;
2070 data.wid.Size.LowPart = wlen * sizeof(WCHAR);
2071 data.wid.Size.HighPart = 0;
2072 data.wid.dwStreamNameSize = 0;
2074 if (BackupWrite (fileh, (LPBYTE)&data,
2075 offsetof (WIN32_STREAM_ID, cStreamName)
2076 + data.wid.Size.LowPart,
2077 &wbytes, FALSE, FALSE, &context)
2078 && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
2080 /* succeeded */
2081 result = 0;
2083 else
2085 /* Should try mapping GetLastError to errno; for now just
2086 indicate a general error (eg. links not supported). */
2087 errno = EINVAL; // perhaps EMLINK?
2091 CloseHandle (fileh);
2093 else
2094 errno = ENOENT;
2096 return result;
2100 sys_mkdir (const char * path)
2102 return _mkdir (map_w32_filename (path, NULL));
2105 /* Because of long name mapping issues, we need to implement this
2106 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2107 a unique name, instead of setting the input template to an empty
2108 string.
2110 Standard algorithm seems to be use pid or tid with a letter on the
2111 front (in place of the 6 X's) and cycle through the letters to find a
2112 unique name. We extend that to allow any reasonable character as the
2113 first of the 6 X's. */
2114 char *
2115 sys_mktemp (char * template)
2117 char * p;
2118 int i;
2119 unsigned uid = GetCurrentThreadId ();
2120 static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2122 if (template == NULL)
2123 return NULL;
2124 p = template + strlen (template);
2125 i = 5;
2126 /* replace up to the last 5 X's with uid in decimal */
2127 while (--p >= template && p[0] == 'X' && --i >= 0)
2129 p[0] = '0' + uid % 10;
2130 uid /= 10;
2133 if (i < 0 && p[0] == 'X')
2135 i = 0;
2138 int save_errno = errno;
2139 p[0] = first_char[i];
2140 if (sys_access (template, 0) < 0)
2142 errno = save_errno;
2143 return template;
2146 while (++i < sizeof (first_char));
2149 /* Template is badly formed or else we can't generate a unique name,
2150 so return empty string */
2151 template[0] = 0;
2152 return template;
2156 sys_open (const char * path, int oflag, int mode)
2158 const char* mpath = map_w32_filename (path, NULL);
2159 /* Try to open file without _O_CREAT, to be able to write to hidden
2160 and system files. Force all file handles to be
2161 non-inheritable. */
2162 int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
2163 if (res >= 0)
2164 return res;
2165 return _open (mpath, oflag | _O_NOINHERIT, mode);
2169 sys_rename (const char * oldname, const char * newname)
2171 BOOL result;
2172 char temp[MAX_PATH];
2174 /* MoveFile on Windows 95 doesn't correctly change the short file name
2175 alias in a number of circumstances (it is not easy to predict when
2176 just by looking at oldname and newname, unfortunately). In these
2177 cases, renaming through a temporary name avoids the problem.
2179 A second problem on Windows 95 is that renaming through a temp name when
2180 newname is uppercase fails (the final long name ends up in
2181 lowercase, although the short alias might be uppercase) UNLESS the
2182 long temp name is not 8.3.
2184 So, on Windows 95 we always rename through a temp name, and we make sure
2185 the temp name has a long extension to ensure correct renaming. */
2187 strcpy (temp, map_w32_filename (oldname, NULL));
2189 if (os_subtype == OS_WIN95)
2191 char * o;
2192 char * p;
2193 int i = 0;
2195 oldname = map_w32_filename (oldname, NULL);
2196 if (o = strrchr (oldname, '\\'))
2197 o++;
2198 else
2199 o = (char *) oldname;
2201 if (p = strrchr (temp, '\\'))
2202 p++;
2203 else
2204 p = temp;
2208 /* Force temp name to require a manufactured 8.3 alias - this
2209 seems to make the second rename work properly. */
2210 sprintf (p, "_.%s.%u", o, i);
2211 i++;
2212 result = rename (oldname, temp);
2214 /* This loop must surely terminate! */
2215 while (result < 0 && errno == EEXIST);
2216 if (result < 0)
2217 return -1;
2220 /* Emulate Unix behaviour - newname is deleted if it already exists
2221 (at least if it is a file; don't do this for directories).
2223 Since we mustn't do this if we are just changing the case of the
2224 file name (we would end up deleting the file we are trying to
2225 rename!), we let rename detect if the destination file already
2226 exists - that way we avoid the possible pitfalls of trying to
2227 determine ourselves whether two names really refer to the same
2228 file, which is not always possible in the general case. (Consider
2229 all the permutations of shared or subst'd drives, etc.) */
2231 newname = map_w32_filename (newname, NULL);
2232 result = rename (temp, newname);
2234 if (result < 0
2235 && errno == EEXIST
2236 && _chmod (newname, 0666) == 0
2237 && _unlink (newname) == 0)
2238 result = rename (temp, newname);
2240 return result;
2244 sys_rmdir (const char * path)
2246 return _rmdir (map_w32_filename (path, NULL));
2250 sys_unlink (const char * path)
2252 path = map_w32_filename (path, NULL);
2254 /* On Unix, unlink works without write permission. */
2255 _chmod (path, 0666);
2256 return _unlink (path);
2259 static FILETIME utc_base_ft;
2260 static long double utc_base;
2261 static int init = 0;
2263 static time_t
2264 convert_time (FILETIME ft)
2266 long double ret;
2268 if (!init)
2270 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2271 SYSTEMTIME st;
2273 st.wYear = 1970;
2274 st.wMonth = 1;
2275 st.wDay = 1;
2276 st.wHour = 0;
2277 st.wMinute = 0;
2278 st.wSecond = 0;
2279 st.wMilliseconds = 0;
2281 SystemTimeToFileTime (&st, &utc_base_ft);
2282 utc_base = (long double) utc_base_ft.dwHighDateTime
2283 * 4096.0L * 1024.0L * 1024.0L + utc_base_ft.dwLowDateTime;
2284 init = 1;
2287 if (CompareFileTime (&ft, &utc_base_ft) < 0)
2288 return 0;
2290 ret = (long double) ft.dwHighDateTime
2291 * 4096.0L * 1024.0L * 1024.0L + ft.dwLowDateTime;
2292 ret -= utc_base;
2293 return (time_t) (ret * 1e-7L);
2296 void
2297 convert_from_time_t (time_t time, FILETIME * pft)
2299 long double tmp;
2301 if (!init)
2303 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2304 SYSTEMTIME st;
2306 st.wYear = 1970;
2307 st.wMonth = 1;
2308 st.wDay = 1;
2309 st.wHour = 0;
2310 st.wMinute = 0;
2311 st.wSecond = 0;
2312 st.wMilliseconds = 0;
2314 SystemTimeToFileTime (&st, &utc_base_ft);
2315 utc_base = (long double) utc_base_ft.dwHighDateTime
2316 * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
2317 init = 1;
2320 /* time in 100ns units since 1-Jan-1601 */
2321 tmp = (long double) time * 1e7 + utc_base;
2322 pft->dwHighDateTime = (DWORD) (tmp / (4096.0 * 1024 * 1024));
2323 pft->dwLowDateTime = (DWORD) (tmp - (4096.0 * 1024 * 1024) * pft->dwHighDateTime);
2326 #if 0
2327 /* No reason to keep this; faking inode values either by hashing or even
2328 using the file index from GetInformationByHandle, is not perfect and
2329 so by default Emacs doesn't use the inode values on Windows.
2330 Instead, we now determine file-truename correctly (except for
2331 possible drive aliasing etc). */
2333 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2334 static unsigned
2335 hashval (const unsigned char * str)
2337 unsigned h = 0;
2338 while (*str)
2340 h = (h << 4) + *str++;
2341 h ^= (h >> 28);
2343 return h;
2346 /* Return the hash value of the canonical pathname, excluding the
2347 drive/UNC header, to get a hopefully unique inode number. */
2348 static DWORD
2349 generate_inode_val (const char * name)
2351 char fullname[ MAX_PATH ];
2352 char * p;
2353 unsigned hash;
2355 /* Get the truly canonical filename, if it exists. (Note: this
2356 doesn't resolve aliasing due to subst commands, or recognise hard
2357 links. */
2358 if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
2359 abort ();
2361 parse_root (fullname, &p);
2362 /* Normal W32 filesystems are still case insensitive. */
2363 _strlwr (p);
2364 return hashval (p);
2367 #endif
2369 /* MSVC stat function can't cope with UNC names and has other bugs, so
2370 replace it with our own. This also allows us to calculate consistent
2371 inode values without hacks in the main Emacs code. */
2373 stat (const char * path, struct stat * buf)
2375 char *name, *r;
2376 WIN32_FIND_DATA wfd;
2377 HANDLE fh;
2378 DWORD fake_inode;
2379 int permission;
2380 int len;
2381 int rootdir = FALSE;
2383 if (path == NULL || buf == NULL)
2385 errno = EFAULT;
2386 return -1;
2389 name = (char *) map_w32_filename (path, &path);
2390 /* Must be valid filename, no wild cards or other invalid
2391 characters. We use _mbspbrk to support multibyte strings that
2392 might look to strpbrk as if they included literal *, ?, and other
2393 characters mentioned below that are disallowed by Windows
2394 filesystems. */
2395 if (_mbspbrk (name, "*?|<>\""))
2397 errno = ENOENT;
2398 return -1;
2401 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2402 r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
2403 if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
2405 r[1] = r[2] = '\0';
2408 /* Remove trailing directory separator, unless name is the root
2409 directory of a drive or UNC volume in which case ensure there
2410 is a trailing separator. */
2411 len = strlen (name);
2412 rootdir = (path >= name + len - 1
2413 && (IS_DIRECTORY_SEP (*path) || *path == 0));
2414 name = strcpy (alloca (len + 2), name);
2416 if (is_unc_volume (name))
2418 DWORD attrs = unc_volume_file_attributes (name);
2420 if (attrs == -1)
2421 return -1;
2423 memset (&wfd, 0, sizeof (wfd));
2424 wfd.dwFileAttributes = attrs;
2425 wfd.ftCreationTime = utc_base_ft;
2426 wfd.ftLastAccessTime = utc_base_ft;
2427 wfd.ftLastWriteTime = utc_base_ft;
2428 strcpy (wfd.cFileName, name);
2430 else if (rootdir)
2432 if (!IS_DIRECTORY_SEP (name[len-1]))
2433 strcat (name, "\\");
2434 if (GetDriveType (name) < 2)
2436 errno = ENOENT;
2437 return -1;
2439 memset (&wfd, 0, sizeof (wfd));
2440 wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
2441 wfd.ftCreationTime = utc_base_ft;
2442 wfd.ftLastAccessTime = utc_base_ft;
2443 wfd.ftLastWriteTime = utc_base_ft;
2444 strcpy (wfd.cFileName, name);
2446 else
2448 if (IS_DIRECTORY_SEP (name[len-1]))
2449 name[len - 1] = 0;
2451 /* (This is hacky, but helps when doing file completions on
2452 network drives.) Optimize by using information available from
2453 active readdir if possible. */
2454 len = strlen (dir_pathname);
2455 if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
2456 len--;
2457 if (dir_find_handle != INVALID_HANDLE_VALUE
2458 && strnicmp (name, dir_pathname, len) == 0
2459 && IS_DIRECTORY_SEP (name[len])
2460 && stricmp (name + len + 1, dir_static.d_name) == 0)
2462 /* This was the last entry returned by readdir. */
2463 wfd = dir_find_data;
2465 else
2467 fh = FindFirstFile (name, &wfd);
2468 if (fh == INVALID_HANDLE_VALUE)
2470 errno = ENOENT;
2471 return -1;
2473 FindClose (fh);
2477 if (!NILP (Vw32_get_true_file_attributes)
2478 /* No access rights required to get info. */
2479 && (fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
2480 FILE_FLAG_BACKUP_SEMANTICS, NULL))
2481 != INVALID_HANDLE_VALUE)
2483 /* This is more accurate in terms of gettting the correct number
2484 of links, but is quite slow (it is noticable when Emacs is
2485 making a list of file name completions). */
2486 BY_HANDLE_FILE_INFORMATION info;
2488 if (GetFileInformationByHandle (fh, &info))
2490 buf->st_nlink = info.nNumberOfLinks;
2491 /* Might as well use file index to fake inode values, but this
2492 is not guaranteed to be unique unless we keep a handle open
2493 all the time (even then there are situations where it is
2494 not unique). Reputedly, there are at most 48 bits of info
2495 (on NTFS, presumably less on FAT). */
2496 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
2498 else
2500 buf->st_nlink = 1;
2501 fake_inode = 0;
2504 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2506 buf->st_mode = _S_IFDIR;
2508 else
2510 switch (GetFileType (fh))
2512 case FILE_TYPE_DISK:
2513 buf->st_mode = _S_IFREG;
2514 break;
2515 case FILE_TYPE_PIPE:
2516 buf->st_mode = _S_IFIFO;
2517 break;
2518 case FILE_TYPE_CHAR:
2519 case FILE_TYPE_UNKNOWN:
2520 default:
2521 buf->st_mode = _S_IFCHR;
2524 CloseHandle (fh);
2526 else
2528 /* Don't bother to make this information more accurate. */
2529 buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
2530 _S_IFDIR : _S_IFREG;
2531 buf->st_nlink = 1;
2532 fake_inode = 0;
2535 #if 0
2536 /* Not sure if there is any point in this. */
2537 if (!NILP (Vw32_generate_fake_inodes))
2538 fake_inode = generate_inode_val (name);
2539 else if (fake_inode == 0)
2541 /* For want of something better, try to make everything unique. */
2542 static DWORD gen_num = 0;
2543 fake_inode = ++gen_num;
2545 #endif
2547 /* MSVC defines _ino_t to be short; other libc's might not. */
2548 if (sizeof (buf->st_ino) == 2)
2549 buf->st_ino = fake_inode ^ (fake_inode >> 16);
2550 else
2551 buf->st_ino = fake_inode;
2553 /* consider files to belong to current user */
2554 buf->st_uid = the_passwd.pw_uid;
2555 buf->st_gid = the_passwd.pw_gid;
2557 /* volume_info is set indirectly by map_w32_filename */
2558 buf->st_dev = volume_info.serialnum;
2559 buf->st_rdev = volume_info.serialnum;
2562 buf->st_size = wfd.nFileSizeLow;
2564 /* Convert timestamps to Unix format. */
2565 buf->st_mtime = convert_time (wfd.ftLastWriteTime);
2566 buf->st_atime = convert_time (wfd.ftLastAccessTime);
2567 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
2568 buf->st_ctime = convert_time (wfd.ftCreationTime);
2569 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
2571 /* determine rwx permissions */
2572 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
2573 permission = _S_IREAD;
2574 else
2575 permission = _S_IREAD | _S_IWRITE;
2577 if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2578 permission |= _S_IEXEC;
2579 else if (is_exec (name))
2580 permission |= _S_IEXEC;
2582 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
2584 return 0;
2587 /* Provide fstat and utime as well as stat for consistent handling of
2588 file timestamps. */
2590 fstat (int desc, struct stat * buf)
2592 HANDLE fh = (HANDLE) _get_osfhandle (desc);
2593 BY_HANDLE_FILE_INFORMATION info;
2594 DWORD fake_inode;
2595 int permission;
2597 switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
2599 case FILE_TYPE_DISK:
2600 buf->st_mode = _S_IFREG;
2601 if (!GetFileInformationByHandle (fh, &info))
2603 errno = EACCES;
2604 return -1;
2606 break;
2607 case FILE_TYPE_PIPE:
2608 buf->st_mode = _S_IFIFO;
2609 goto non_disk;
2610 case FILE_TYPE_CHAR:
2611 case FILE_TYPE_UNKNOWN:
2612 default:
2613 buf->st_mode = _S_IFCHR;
2614 non_disk:
2615 memset (&info, 0, sizeof (info));
2616 info.dwFileAttributes = 0;
2617 info.ftCreationTime = utc_base_ft;
2618 info.ftLastAccessTime = utc_base_ft;
2619 info.ftLastWriteTime = utc_base_ft;
2622 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2623 buf->st_mode = _S_IFDIR;
2625 buf->st_nlink = info.nNumberOfLinks;
2626 /* Might as well use file index to fake inode values, but this
2627 is not guaranteed to be unique unless we keep a handle open
2628 all the time (even then there are situations where it is
2629 not unique). Reputedly, there are at most 48 bits of info
2630 (on NTFS, presumably less on FAT). */
2631 fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
2633 /* MSVC defines _ino_t to be short; other libc's might not. */
2634 if (sizeof (buf->st_ino) == 2)
2635 buf->st_ino = fake_inode ^ (fake_inode >> 16);
2636 else
2637 buf->st_ino = fake_inode;
2639 /* consider files to belong to current user */
2640 buf->st_uid = 0;
2641 buf->st_gid = 0;
2643 buf->st_dev = info.dwVolumeSerialNumber;
2644 buf->st_rdev = info.dwVolumeSerialNumber;
2646 buf->st_size = info.nFileSizeLow;
2648 /* Convert timestamps to Unix format. */
2649 buf->st_mtime = convert_time (info.ftLastWriteTime);
2650 buf->st_atime = convert_time (info.ftLastAccessTime);
2651 if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
2652 buf->st_ctime = convert_time (info.ftCreationTime);
2653 if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
2655 /* determine rwx permissions */
2656 if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
2657 permission = _S_IREAD;
2658 else
2659 permission = _S_IREAD | _S_IWRITE;
2661 if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2662 permission |= _S_IEXEC;
2663 else
2665 #if 0 /* no way of knowing the filename */
2666 char * p = strrchr (name, '.');
2667 if (p != NULL &&
2668 (stricmp (p, ".exe") == 0 ||
2669 stricmp (p, ".com") == 0 ||
2670 stricmp (p, ".bat") == 0 ||
2671 stricmp (p, ".cmd") == 0))
2672 permission |= _S_IEXEC;
2673 #endif
2676 buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
2678 return 0;
2682 utime (const char *name, struct utimbuf *times)
2684 struct utimbuf deftime;
2685 HANDLE fh;
2686 FILETIME mtime;
2687 FILETIME atime;
2689 if (times == NULL)
2691 deftime.modtime = deftime.actime = time (NULL);
2692 times = &deftime;
2695 /* Need write access to set times. */
2696 fh = CreateFile (name, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
2697 0, OPEN_EXISTING, 0, NULL);
2698 if (fh)
2700 convert_from_time_t (times->actime, &atime);
2701 convert_from_time_t (times->modtime, &mtime);
2702 if (!SetFileTime (fh, NULL, &atime, &mtime))
2704 CloseHandle (fh);
2705 errno = EACCES;
2706 return -1;
2708 CloseHandle (fh);
2710 else
2712 errno = EINVAL;
2713 return -1;
2715 return 0;
2718 #ifdef HAVE_SOCKETS
2720 /* Wrappers for winsock functions to map between our file descriptors
2721 and winsock's handles; also set h_errno for convenience.
2723 To allow Emacs to run on systems which don't have winsock support
2724 installed, we dynamically link to winsock on startup if present, and
2725 otherwise provide the minimum necessary functionality
2726 (eg. gethostname). */
2728 /* function pointers for relevant socket functions */
2729 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
2730 void (PASCAL *pfn_WSASetLastError) (int iError);
2731 int (PASCAL *pfn_WSAGetLastError) (void);
2732 int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
2733 HANDLE (PASCAL *pfn_WSACreateEvent) (void);
2734 int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
2735 int (PASCAL *pfn_socket) (int af, int type, int protocol);
2736 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
2737 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
2738 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
2739 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
2740 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
2741 int (PASCAL *pfn_closesocket) (SOCKET s);
2742 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
2743 int (PASCAL *pfn_WSACleanup) (void);
2745 u_short (PASCAL *pfn_htons) (u_short hostshort);
2746 u_short (PASCAL *pfn_ntohs) (u_short netshort);
2747 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
2748 int (PASCAL *pfn_gethostname) (char * name, int namelen);
2749 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
2750 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
2751 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
2752 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
2753 const char * optval, int optlen);
2754 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
2755 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
2756 int * namelen);
2757 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
2758 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
2759 struct sockaddr * from, int * fromlen);
2760 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
2761 const struct sockaddr * to, int tolen);
2763 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2764 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
2765 #ifndef HANDLE_FLAG_INHERIT
2766 #define HANDLE_FLAG_INHERIT 1
2767 #endif
2769 HANDLE winsock_lib;
2770 static int winsock_inuse;
2772 BOOL
2773 term_winsock (void)
2775 if (winsock_lib != NULL && winsock_inuse == 0)
2777 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2778 after WSAStartup returns successfully, but it seems reasonable
2779 to allow unloading winsock anyway in that case. */
2780 if (pfn_WSACleanup () == 0 ||
2781 pfn_WSAGetLastError () == WSAENETDOWN)
2783 if (FreeLibrary (winsock_lib))
2784 winsock_lib = NULL;
2785 return TRUE;
2788 return FALSE;
2791 BOOL
2792 init_winsock (int load_now)
2794 WSADATA winsockData;
2796 if (winsock_lib != NULL)
2797 return TRUE;
2799 pfn_SetHandleInformation = NULL;
2800 pfn_SetHandleInformation
2801 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2802 "SetHandleInformation");
2804 winsock_lib = LoadLibrary ("Ws2_32.dll");
2806 if (winsock_lib != NULL)
2808 /* dynamically link to socket functions */
2810 #define LOAD_PROC(fn) \
2811 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2812 goto fail;
2814 LOAD_PROC( WSAStartup );
2815 LOAD_PROC( WSASetLastError );
2816 LOAD_PROC( WSAGetLastError );
2817 LOAD_PROC( WSAEventSelect );
2818 LOAD_PROC( WSACreateEvent );
2819 LOAD_PROC( WSACloseEvent );
2820 LOAD_PROC( socket );
2821 LOAD_PROC( bind );
2822 LOAD_PROC( connect );
2823 LOAD_PROC( ioctlsocket );
2824 LOAD_PROC( recv );
2825 LOAD_PROC( send );
2826 LOAD_PROC( closesocket );
2827 LOAD_PROC( shutdown );
2828 LOAD_PROC( htons );
2829 LOAD_PROC( ntohs );
2830 LOAD_PROC( inet_addr );
2831 LOAD_PROC( gethostname );
2832 LOAD_PROC( gethostbyname );
2833 LOAD_PROC( getservbyname );
2834 LOAD_PROC( getpeername );
2835 LOAD_PROC( WSACleanup );
2836 LOAD_PROC( setsockopt );
2837 LOAD_PROC( listen );
2838 LOAD_PROC( getsockname );
2839 LOAD_PROC( accept );
2840 LOAD_PROC( recvfrom );
2841 LOAD_PROC( sendto );
2842 #undef LOAD_PROC
2844 /* specify version 1.1 of winsock */
2845 if (pfn_WSAStartup (0x101, &winsockData) == 0)
2847 if (winsockData.wVersion != 0x101)
2848 goto fail;
2850 if (!load_now)
2852 /* Report that winsock exists and is usable, but leave
2853 socket functions disabled. I am assuming that calling
2854 WSAStartup does not require any network interaction,
2855 and in particular does not cause or require a dial-up
2856 connection to be established. */
2858 pfn_WSACleanup ();
2859 FreeLibrary (winsock_lib);
2860 winsock_lib = NULL;
2862 winsock_inuse = 0;
2863 return TRUE;
2866 fail:
2867 FreeLibrary (winsock_lib);
2868 winsock_lib = NULL;
2871 return FALSE;
2875 int h_errno = 0;
2877 /* function to set h_errno for compatability; map winsock error codes to
2878 normal system codes where they overlap (non-overlapping definitions
2879 are already in <sys/socket.h> */
2880 static void
2881 set_errno ()
2883 if (winsock_lib == NULL)
2884 h_errno = EINVAL;
2885 else
2886 h_errno = pfn_WSAGetLastError ();
2888 switch (h_errno)
2890 case WSAEACCES: h_errno = EACCES; break;
2891 case WSAEBADF: h_errno = EBADF; break;
2892 case WSAEFAULT: h_errno = EFAULT; break;
2893 case WSAEINTR: h_errno = EINTR; break;
2894 case WSAEINVAL: h_errno = EINVAL; break;
2895 case WSAEMFILE: h_errno = EMFILE; break;
2896 case WSAENAMETOOLONG: h_errno = ENAMETOOLONG; break;
2897 case WSAENOTEMPTY: h_errno = ENOTEMPTY; break;
2899 errno = h_errno;
2902 static void
2903 check_errno ()
2905 if (h_errno == 0 && winsock_lib != NULL)
2906 pfn_WSASetLastError (0);
2909 /* Extend strerror to handle the winsock-specific error codes. */
2910 struct {
2911 int errnum;
2912 char * msg;
2913 } _wsa_errlist[] = {
2914 WSAEINTR , "Interrupted function call",
2915 WSAEBADF , "Bad file descriptor",
2916 WSAEACCES , "Permission denied",
2917 WSAEFAULT , "Bad address",
2918 WSAEINVAL , "Invalid argument",
2919 WSAEMFILE , "Too many open files",
2921 WSAEWOULDBLOCK , "Resource temporarily unavailable",
2922 WSAEINPROGRESS , "Operation now in progress",
2923 WSAEALREADY , "Operation already in progress",
2924 WSAENOTSOCK , "Socket operation on non-socket",
2925 WSAEDESTADDRREQ , "Destination address required",
2926 WSAEMSGSIZE , "Message too long",
2927 WSAEPROTOTYPE , "Protocol wrong type for socket",
2928 WSAENOPROTOOPT , "Bad protocol option",
2929 WSAEPROTONOSUPPORT , "Protocol not supported",
2930 WSAESOCKTNOSUPPORT , "Socket type not supported",
2931 WSAEOPNOTSUPP , "Operation not supported",
2932 WSAEPFNOSUPPORT , "Protocol family not supported",
2933 WSAEAFNOSUPPORT , "Address family not supported by protocol family",
2934 WSAEADDRINUSE , "Address already in use",
2935 WSAEADDRNOTAVAIL , "Cannot assign requested address",
2936 WSAENETDOWN , "Network is down",
2937 WSAENETUNREACH , "Network is unreachable",
2938 WSAENETRESET , "Network dropped connection on reset",
2939 WSAECONNABORTED , "Software caused connection abort",
2940 WSAECONNRESET , "Connection reset by peer",
2941 WSAENOBUFS , "No buffer space available",
2942 WSAEISCONN , "Socket is already connected",
2943 WSAENOTCONN , "Socket is not connected",
2944 WSAESHUTDOWN , "Cannot send after socket shutdown",
2945 WSAETOOMANYREFS , "Too many references", /* not sure */
2946 WSAETIMEDOUT , "Connection timed out",
2947 WSAECONNREFUSED , "Connection refused",
2948 WSAELOOP , "Network loop", /* not sure */
2949 WSAENAMETOOLONG , "Name is too long",
2950 WSAEHOSTDOWN , "Host is down",
2951 WSAEHOSTUNREACH , "No route to host",
2952 WSAENOTEMPTY , "Buffer not empty", /* not sure */
2953 WSAEPROCLIM , "Too many processes",
2954 WSAEUSERS , "Too many users", /* not sure */
2955 WSAEDQUOT , "Double quote in host name", /* really not sure */
2956 WSAESTALE , "Data is stale", /* not sure */
2957 WSAEREMOTE , "Remote error", /* not sure */
2959 WSASYSNOTREADY , "Network subsystem is unavailable",
2960 WSAVERNOTSUPPORTED , "WINSOCK.DLL version out of range",
2961 WSANOTINITIALISED , "Winsock not initialized successfully",
2962 WSAEDISCON , "Graceful shutdown in progress",
2963 #ifdef WSAENOMORE
2964 WSAENOMORE , "No more operations allowed", /* not sure */
2965 WSAECANCELLED , "Operation cancelled", /* not sure */
2966 WSAEINVALIDPROCTABLE , "Invalid procedure table from service provider",
2967 WSAEINVALIDPROVIDER , "Invalid service provider version number",
2968 WSAEPROVIDERFAILEDINIT , "Unable to initialize a service provider",
2969 WSASYSCALLFAILURE , "System call failured",
2970 WSASERVICE_NOT_FOUND , "Service not found", /* not sure */
2971 WSATYPE_NOT_FOUND , "Class type not found",
2972 WSA_E_NO_MORE , "No more resources available", /* really not sure */
2973 WSA_E_CANCELLED , "Operation already cancelled", /* really not sure */
2974 WSAEREFUSED , "Operation refused", /* not sure */
2975 #endif
2977 WSAHOST_NOT_FOUND , "Host not found",
2978 WSATRY_AGAIN , "Authoritative host not found during name lookup",
2979 WSANO_RECOVERY , "Non-recoverable error during name lookup",
2980 WSANO_DATA , "Valid name, no data record of requested type",
2982 -1, NULL
2985 char *
2986 sys_strerror(int error_no)
2988 int i;
2989 static char unknown_msg[40];
2991 if (error_no >= 0 && error_no < sys_nerr)
2992 return sys_errlist[error_no];
2994 for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
2995 if (_wsa_errlist[i].errnum == error_no)
2996 return _wsa_errlist[i].msg;
2998 sprintf(unknown_msg, "Unidentified error: %d", error_no);
2999 return unknown_msg;
3002 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3003 but I believe the method of keeping the socket handle separate (and
3004 insuring it is not inheritable) is the correct one. */
3006 //#define SOCK_REPLACE_HANDLE
3008 #ifdef SOCK_REPLACE_HANDLE
3009 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3010 #else
3011 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3012 #endif
3014 int socket_to_fd (SOCKET s);
3017 sys_socket(int af, int type, int protocol)
3019 SOCKET s;
3021 if (winsock_lib == NULL)
3023 h_errno = ENETDOWN;
3024 return INVALID_SOCKET;
3027 check_errno ();
3029 /* call the real socket function */
3030 s = pfn_socket (af, type, protocol);
3032 if (s != INVALID_SOCKET)
3033 return socket_to_fd (s);
3035 set_errno ();
3036 return -1;
3039 /* Convert a SOCKET to a file descriptor. */
3041 socket_to_fd (SOCKET s)
3043 int fd;
3044 child_process * cp;
3046 /* Although under NT 3.5 _open_osfhandle will accept a socket
3047 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3048 that does not work under NT 3.1. However, we can get the same
3049 effect by using a backdoor function to replace an existing
3050 descriptor handle with the one we want. */
3052 /* allocate a file descriptor (with appropriate flags) */
3053 fd = _open ("NUL:", _O_RDWR);
3054 if (fd >= 0)
3056 #ifdef SOCK_REPLACE_HANDLE
3057 /* now replace handle to NUL with our socket handle */
3058 CloseHandle ((HANDLE) _get_osfhandle (fd));
3059 _free_osfhnd (fd);
3060 _set_osfhnd (fd, s);
3061 /* setmode (fd, _O_BINARY); */
3062 #else
3063 /* Make a non-inheritable copy of the socket handle. Note
3064 that it is possible that sockets aren't actually kernel
3065 handles, which appears to be the case on Windows 9x when
3066 the MS Proxy winsock client is installed. */
3068 /* Apparently there is a bug in NT 3.51 with some service
3069 packs, which prevents using DuplicateHandle to make a
3070 socket handle non-inheritable (causes WSACleanup to
3071 hang). The work-around is to use SetHandleInformation
3072 instead if it is available and implemented. */
3073 if (pfn_SetHandleInformation)
3075 pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
3077 else
3079 HANDLE parent = GetCurrentProcess ();
3080 HANDLE new_s = INVALID_HANDLE_VALUE;
3082 if (DuplicateHandle (parent,
3083 (HANDLE) s,
3084 parent,
3085 &new_s,
3087 FALSE,
3088 DUPLICATE_SAME_ACCESS))
3090 /* It is possible that DuplicateHandle succeeds even
3091 though the socket wasn't really a kernel handle,
3092 because a real handle has the same value. So
3093 test whether the new handle really is a socket. */
3094 long nonblocking = 0;
3095 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
3097 pfn_closesocket (s);
3098 s = (SOCKET) new_s;
3100 else
3102 CloseHandle (new_s);
3107 fd_info[fd].hnd = (HANDLE) s;
3108 #endif
3110 /* set our own internal flags */
3111 fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
3113 cp = new_child ();
3114 if (cp)
3116 cp->fd = fd;
3117 cp->status = STATUS_READ_ACKNOWLEDGED;
3119 /* attach child_process to fd_info */
3120 if (fd_info[ fd ].cp != NULL)
3122 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
3123 abort ();
3126 fd_info[ fd ].cp = cp;
3128 /* success! */
3129 winsock_inuse++; /* count open sockets */
3130 return fd;
3133 /* clean up */
3134 _close (fd);
3136 pfn_closesocket (s);
3137 h_errno = EMFILE;
3138 return -1;
3143 sys_bind (int s, const struct sockaddr * addr, int namelen)
3145 if (winsock_lib == NULL)
3147 h_errno = ENOTSOCK;
3148 return SOCKET_ERROR;
3151 check_errno ();
3152 if (fd_info[s].flags & FILE_SOCKET)
3154 int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
3155 if (rc == SOCKET_ERROR)
3156 set_errno ();
3157 return rc;
3159 h_errno = ENOTSOCK;
3160 return SOCKET_ERROR;
3165 sys_connect (int s, const struct sockaddr * name, int namelen)
3167 if (winsock_lib == NULL)
3169 h_errno = ENOTSOCK;
3170 return SOCKET_ERROR;
3173 check_errno ();
3174 if (fd_info[s].flags & FILE_SOCKET)
3176 int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
3177 if (rc == SOCKET_ERROR)
3178 set_errno ();
3179 return rc;
3181 h_errno = ENOTSOCK;
3182 return SOCKET_ERROR;
3185 u_short
3186 sys_htons (u_short hostshort)
3188 return (winsock_lib != NULL) ?
3189 pfn_htons (hostshort) : hostshort;
3192 u_short
3193 sys_ntohs (u_short netshort)
3195 return (winsock_lib != NULL) ?
3196 pfn_ntohs (netshort) : netshort;
3199 unsigned long
3200 sys_inet_addr (const char * cp)
3202 return (winsock_lib != NULL) ?
3203 pfn_inet_addr (cp) : INADDR_NONE;
3207 sys_gethostname (char * name, int namelen)
3209 if (winsock_lib != NULL)
3210 return pfn_gethostname (name, namelen);
3212 if (namelen > MAX_COMPUTERNAME_LENGTH)
3213 return !GetComputerName (name, (DWORD *)&namelen);
3215 h_errno = EFAULT;
3216 return SOCKET_ERROR;
3219 struct hostent *
3220 sys_gethostbyname(const char * name)
3222 struct hostent * host;
3224 if (winsock_lib == NULL)
3226 h_errno = ENETDOWN;
3227 return NULL;
3230 check_errno ();
3231 host = pfn_gethostbyname (name);
3232 if (!host)
3233 set_errno ();
3234 return host;
3237 struct servent *
3238 sys_getservbyname(const char * name, const char * proto)
3240 struct servent * serv;
3242 if (winsock_lib == NULL)
3244 h_errno = ENETDOWN;
3245 return NULL;
3248 check_errno ();
3249 serv = pfn_getservbyname (name, proto);
3250 if (!serv)
3251 set_errno ();
3252 return serv;
3256 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
3258 if (winsock_lib == NULL)
3260 h_errno = ENETDOWN;
3261 return SOCKET_ERROR;
3264 check_errno ();
3265 if (fd_info[s].flags & FILE_SOCKET)
3267 int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
3268 if (rc == SOCKET_ERROR)
3269 set_errno ();
3270 return rc;
3272 h_errno = ENOTSOCK;
3273 return SOCKET_ERROR;
3278 sys_shutdown (int s, int how)
3280 if (winsock_lib == NULL)
3282 h_errno = ENETDOWN;
3283 return SOCKET_ERROR;
3286 check_errno ();
3287 if (fd_info[s].flags & FILE_SOCKET)
3289 int rc = pfn_shutdown (SOCK_HANDLE (s), how);
3290 if (rc == SOCKET_ERROR)
3291 set_errno ();
3292 return rc;
3294 h_errno = ENOTSOCK;
3295 return SOCKET_ERROR;
3299 sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
3301 if (winsock_lib == NULL)
3303 h_errno = ENETDOWN;
3304 return SOCKET_ERROR;
3307 check_errno ();
3308 if (fd_info[s].flags & FILE_SOCKET)
3310 int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
3311 (const char *)optval, optlen);
3312 if (rc == SOCKET_ERROR)
3313 set_errno ();
3314 return rc;
3316 h_errno = ENOTSOCK;
3317 return SOCKET_ERROR;
3321 sys_listen (int s, int backlog)
3323 if (winsock_lib == NULL)
3325 h_errno = ENETDOWN;
3326 return SOCKET_ERROR;
3329 check_errno ();
3330 if (fd_info[s].flags & FILE_SOCKET)
3332 int rc = pfn_listen (SOCK_HANDLE (s), backlog);
3333 if (rc == SOCKET_ERROR)
3334 set_errno ();
3335 else
3336 fd_info[s].flags |= FILE_LISTEN;
3337 return rc;
3339 h_errno = ENOTSOCK;
3340 return SOCKET_ERROR;
3344 sys_getsockname (int s, struct sockaddr * name, int * namelen)
3346 if (winsock_lib == NULL)
3348 h_errno = ENETDOWN;
3349 return SOCKET_ERROR;
3352 check_errno ();
3353 if (fd_info[s].flags & FILE_SOCKET)
3355 int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
3356 if (rc == SOCKET_ERROR)
3357 set_errno ();
3358 return rc;
3360 h_errno = ENOTSOCK;
3361 return SOCKET_ERROR;
3365 sys_accept (int s, struct sockaddr * addr, int * addrlen)
3367 if (winsock_lib == NULL)
3369 h_errno = ENETDOWN;
3370 return -1;
3373 check_errno ();
3374 if (fd_info[s].flags & FILE_LISTEN)
3376 SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
3377 int fd = -1;
3378 if (t == INVALID_SOCKET)
3379 set_errno ();
3380 else
3381 fd = socket_to_fd (t);
3383 fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
3384 ResetEvent (fd_info[s].cp->char_avail);
3385 return fd;
3387 h_errno = ENOTSOCK;
3388 return -1;
3392 sys_recvfrom (int s, char * buf, int len, int flags,
3393 struct sockaddr * from, int * fromlen)
3395 if (winsock_lib == NULL)
3397 h_errno = ENETDOWN;
3398 return SOCKET_ERROR;
3401 check_errno ();
3402 if (fd_info[s].flags & FILE_SOCKET)
3404 int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
3405 if (rc == SOCKET_ERROR)
3406 set_errno ();
3407 return rc;
3409 h_errno = ENOTSOCK;
3410 return SOCKET_ERROR;
3414 sys_sendto (int s, const char * buf, int len, int flags,
3415 const struct sockaddr * to, int tolen)
3417 if (winsock_lib == NULL)
3419 h_errno = ENETDOWN;
3420 return SOCKET_ERROR;
3423 check_errno ();
3424 if (fd_info[s].flags & FILE_SOCKET)
3426 int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
3427 if (rc == SOCKET_ERROR)
3428 set_errno ();
3429 return rc;
3431 h_errno = ENOTSOCK;
3432 return SOCKET_ERROR;
3435 /* Windows does not have an fcntl function. Provide an implementation
3436 solely for making sockets non-blocking. */
3438 fcntl (int s, int cmd, int options)
3440 if (winsock_lib == NULL)
3442 h_errno = ENETDOWN;
3443 return -1;
3446 check_errno ();
3447 if (fd_info[s].flags & FILE_SOCKET)
3449 if (cmd == F_SETFL && options == O_NDELAY)
3451 unsigned long nblock = 1;
3452 int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
3453 if (rc == SOCKET_ERROR)
3454 set_errno();
3455 /* Keep track of the fact that we set this to non-blocking. */
3456 fd_info[s].flags |= FILE_NDELAY;
3457 return rc;
3459 else
3461 h_errno = EINVAL;
3462 return SOCKET_ERROR;
3465 h_errno = ENOTSOCK;
3466 return SOCKET_ERROR;
3469 #endif /* HAVE_SOCKETS */
3472 /* Shadow main io functions: we need to handle pipes and sockets more
3473 intelligently, and implement non-blocking mode as well. */
3476 sys_close (int fd)
3478 int rc;
3480 if (fd < 0)
3482 errno = EBADF;
3483 return -1;
3486 if (fd < MAXDESC && fd_info[fd].cp)
3488 child_process * cp = fd_info[fd].cp;
3490 fd_info[fd].cp = NULL;
3492 if (CHILD_ACTIVE (cp))
3494 /* if last descriptor to active child_process then cleanup */
3495 int i;
3496 for (i = 0; i < MAXDESC; i++)
3498 if (i == fd)
3499 continue;
3500 if (fd_info[i].cp == cp)
3501 break;
3503 if (i == MAXDESC)
3505 #ifdef HAVE_SOCKETS
3506 if (fd_info[fd].flags & FILE_SOCKET)
3508 #ifndef SOCK_REPLACE_HANDLE
3509 if (winsock_lib == NULL) abort ();
3511 pfn_shutdown (SOCK_HANDLE (fd), 2);
3512 rc = pfn_closesocket (SOCK_HANDLE (fd));
3513 #endif
3514 winsock_inuse--; /* count open sockets */
3516 #endif
3517 delete_child (cp);
3522 /* Note that sockets do not need special treatment here (at least on
3523 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3524 closesocket is equivalent to CloseHandle, which is to be expected
3525 because socket handles are fully fledged kernel handles. */
3526 rc = _close (fd);
3528 if (rc == 0 && fd < MAXDESC)
3529 fd_info[fd].flags = 0;
3531 return rc;
3535 sys_dup (int fd)
3537 int new_fd;
3539 new_fd = _dup (fd);
3540 if (new_fd >= 0 && new_fd < MAXDESC)
3542 /* duplicate our internal info as well */
3543 fd_info[new_fd] = fd_info[fd];
3545 return new_fd;
3550 sys_dup2 (int src, int dst)
3552 int rc;
3554 if (dst < 0 || dst >= MAXDESC)
3556 errno = EBADF;
3557 return -1;
3560 /* make sure we close the destination first if it's a pipe or socket */
3561 if (src != dst && fd_info[dst].flags != 0)
3562 sys_close (dst);
3564 rc = _dup2 (src, dst);
3565 if (rc == 0)
3567 /* duplicate our internal info as well */
3568 fd_info[dst] = fd_info[src];
3570 return rc;
3573 /* Unix pipe() has only one arg */
3575 sys_pipe (int * phandles)
3577 int rc;
3578 unsigned flags;
3580 /* make pipe handles non-inheritable; when we spawn a child, we
3581 replace the relevant handle with an inheritable one. Also put
3582 pipes into binary mode; we will do text mode translation ourselves
3583 if required. */
3584 rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
3586 if (rc == 0)
3588 /* Protect against overflow, since Windows can open more handles than
3589 our fd_info array has room for. */
3590 if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
3592 _close (phandles[0]);
3593 _close (phandles[1]);
3594 rc = -1;
3596 else
3598 flags = FILE_PIPE | FILE_READ | FILE_BINARY;
3599 fd_info[phandles[0]].flags = flags;
3601 flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
3602 fd_info[phandles[1]].flags = flags;
3606 return rc;
3609 /* From ntproc.c */
3610 extern int w32_pipe_read_delay;
3612 /* Function to do blocking read of one byte, needed to implement
3613 select. It is only allowed on sockets and pipes. */
3615 _sys_read_ahead (int fd)
3617 child_process * cp;
3618 int rc;
3620 if (fd < 0 || fd >= MAXDESC)
3621 return STATUS_READ_ERROR;
3623 cp = fd_info[fd].cp;
3625 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
3626 return STATUS_READ_ERROR;
3628 if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
3629 || (fd_info[fd].flags & FILE_READ) == 0)
3631 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd));
3632 abort ();
3635 cp->status = STATUS_READ_IN_PROGRESS;
3637 if (fd_info[fd].flags & FILE_PIPE)
3639 rc = _read (fd, &cp->chr, sizeof (char));
3641 /* Give subprocess time to buffer some more output for us before
3642 reporting that input is available; we need this because Windows 95
3643 connects DOS programs to pipes by making the pipe appear to be
3644 the normal console stdout - as a result most DOS programs will
3645 write to stdout without buffering, ie. one character at a
3646 time. Even some W32 programs do this - "dir" in a command
3647 shell on NT is very slow if we don't do this. */
3648 if (rc > 0)
3650 int wait = w32_pipe_read_delay;
3652 if (wait > 0)
3653 Sleep (wait);
3654 else if (wait < 0)
3655 while (++wait <= 0)
3656 /* Yield remainder of our time slice, effectively giving a
3657 temporary priority boost to the child process. */
3658 Sleep (0);
3661 #ifdef HAVE_SOCKETS
3662 else if (fd_info[fd].flags & FILE_SOCKET)
3664 unsigned long nblock = 0;
3665 /* We always want this to block, so temporarily disable NDELAY. */
3666 if (fd_info[fd].flags & FILE_NDELAY)
3667 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3669 rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
3671 if (fd_info[fd].flags & FILE_NDELAY)
3673 nblock = 1;
3674 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3677 #endif
3679 if (rc == sizeof (char))
3680 cp->status = STATUS_READ_SUCCEEDED;
3681 else
3682 cp->status = STATUS_READ_FAILED;
3684 return cp->status;
3688 _sys_wait_accept (int fd)
3690 HANDLE hEv;
3691 child_process * cp;
3692 int rc;
3694 if (fd < 0 || fd >= MAXDESC)
3695 return STATUS_READ_ERROR;
3697 cp = fd_info[fd].cp;
3699 if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
3700 return STATUS_READ_ERROR;
3702 cp->status = STATUS_READ_FAILED;
3704 hEv = pfn_WSACreateEvent ();
3705 rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
3706 if (rc != SOCKET_ERROR)
3708 rc = WaitForSingleObject (hEv, INFINITE);
3709 pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
3710 if (rc == WAIT_OBJECT_0)
3711 cp->status = STATUS_READ_SUCCEEDED;
3713 pfn_WSACloseEvent (hEv);
3715 return cp->status;
3719 sys_read (int fd, char * buffer, unsigned int count)
3721 int nchars;
3722 int to_read;
3723 DWORD waiting;
3724 char * orig_buffer = buffer;
3726 if (fd < 0)
3728 errno = EBADF;
3729 return -1;
3732 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3734 child_process *cp = fd_info[fd].cp;
3736 if ((fd_info[fd].flags & FILE_READ) == 0)
3738 errno = EBADF;
3739 return -1;
3742 nchars = 0;
3744 /* re-read CR carried over from last read */
3745 if (fd_info[fd].flags & FILE_LAST_CR)
3747 if (fd_info[fd].flags & FILE_BINARY) abort ();
3748 *buffer++ = 0x0d;
3749 count--;
3750 nchars++;
3751 fd_info[fd].flags &= ~FILE_LAST_CR;
3754 /* presence of a child_process structure means we are operating in
3755 non-blocking mode - otherwise we just call _read directly.
3756 Note that the child_process structure might be missing because
3757 reap_subprocess has been called; in this case the pipe is
3758 already broken, so calling _read on it is okay. */
3759 if (cp)
3761 int current_status = cp->status;
3763 switch (current_status)
3765 case STATUS_READ_FAILED:
3766 case STATUS_READ_ERROR:
3767 /* report normal EOF if nothing in buffer */
3768 if (nchars <= 0)
3769 fd_info[fd].flags |= FILE_AT_EOF;
3770 return nchars;
3772 case STATUS_READ_READY:
3773 case STATUS_READ_IN_PROGRESS:
3774 DebPrint (("sys_read called when read is in progress\n"));
3775 errno = EWOULDBLOCK;
3776 return -1;
3778 case STATUS_READ_SUCCEEDED:
3779 /* consume read-ahead char */
3780 *buffer++ = cp->chr;
3781 count--;
3782 nchars++;
3783 cp->status = STATUS_READ_ACKNOWLEDGED;
3784 ResetEvent (cp->char_avail);
3786 case STATUS_READ_ACKNOWLEDGED:
3787 break;
3789 default:
3790 DebPrint (("sys_read: bad status %d\n", current_status));
3791 errno = EBADF;
3792 return -1;
3795 if (fd_info[fd].flags & FILE_PIPE)
3797 PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
3798 to_read = min (waiting, (DWORD) count);
3800 if (to_read > 0)
3801 nchars += _read (fd, buffer, to_read);
3803 #ifdef HAVE_SOCKETS
3804 else /* FILE_SOCKET */
3806 if (winsock_lib == NULL) abort ();
3808 /* do the equivalent of a non-blocking read */
3809 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
3810 if (waiting == 0 && nchars == 0)
3812 h_errno = errno = EWOULDBLOCK;
3813 return -1;
3816 if (waiting)
3818 /* always use binary mode for sockets */
3819 int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
3820 if (res == SOCKET_ERROR)
3822 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3823 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3824 set_errno ();
3825 return -1;
3827 nchars += res;
3830 #endif
3832 else
3834 int nread = _read (fd, buffer, count);
3835 if (nread >= 0)
3836 nchars += nread;
3837 else if (nchars == 0)
3838 nchars = nread;
3841 if (nchars <= 0)
3842 fd_info[fd].flags |= FILE_AT_EOF;
3843 /* Perform text mode translation if required. */
3844 else if ((fd_info[fd].flags & FILE_BINARY) == 0)
3846 nchars = crlf_to_lf (nchars, orig_buffer);
3847 /* If buffer contains only CR, return that. To be absolutely
3848 sure we should attempt to read the next char, but in
3849 practice a CR to be followed by LF would not appear by
3850 itself in the buffer. */
3851 if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
3853 fd_info[fd].flags |= FILE_LAST_CR;
3854 nchars--;
3858 else
3859 nchars = _read (fd, buffer, count);
3861 return nchars;
3864 /* For now, don't bother with a non-blocking mode */
3866 sys_write (int fd, const void * buffer, unsigned int count)
3868 int nchars;
3870 if (fd < 0)
3872 errno = EBADF;
3873 return -1;
3876 if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3878 if ((fd_info[fd].flags & FILE_WRITE) == 0)
3880 errno = EBADF;
3881 return -1;
3884 /* Perform text mode translation if required. */
3885 if ((fd_info[fd].flags & FILE_BINARY) == 0)
3887 char * tmpbuf = alloca (count * 2);
3888 unsigned char * src = (void *)buffer;
3889 unsigned char * dst = tmpbuf;
3890 int nbytes = count;
3892 while (1)
3894 unsigned char *next;
3895 /* copy next line or remaining bytes */
3896 next = _memccpy (dst, src, '\n', nbytes);
3897 if (next)
3899 /* copied one line ending with '\n' */
3900 int copied = next - dst;
3901 nbytes -= copied;
3902 src += copied;
3903 /* insert '\r' before '\n' */
3904 next[-1] = '\r';
3905 next[0] = '\n';
3906 dst = next + 1;
3907 count++;
3909 else
3910 /* copied remaining partial line -> now finished */
3911 break;
3913 buffer = tmpbuf;
3917 #ifdef HAVE_SOCKETS
3918 if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
3920 unsigned long nblock = 0;
3921 if (winsock_lib == NULL) abort ();
3923 /* TODO: implement select() properly so non-blocking I/O works. */
3924 /* For now, make sure the write blocks. */
3925 if (fd_info[fd].flags & FILE_NDELAY)
3926 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3928 nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
3930 /* Set the socket back to non-blocking if it was before,
3931 for other operations that support it. */
3932 if (fd_info[fd].flags & FILE_NDELAY)
3934 nblock = 1;
3935 pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3938 if (nchars == SOCKET_ERROR)
3940 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
3941 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3942 set_errno ();
3945 else
3946 #endif
3947 nchars = _write (fd, buffer, count);
3949 return nchars;
3952 static void
3953 check_windows_init_file ()
3955 extern int noninteractive, inhibit_window_system;
3957 /* A common indication that Emacs is not installed properly is when
3958 it cannot find the Windows installation file. If this file does
3959 not exist in the expected place, tell the user. */
3961 if (!noninteractive && !inhibit_window_system)
3963 extern Lisp_Object Vwindow_system, Vload_path, Qfile_exists_p;
3964 Lisp_Object objs[2];
3965 Lisp_Object full_load_path;
3966 Lisp_Object init_file;
3967 int fd;
3969 objs[0] = Vload_path;
3970 objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3971 full_load_path = Fappend (2, objs);
3972 init_file = build_string ("term/w32-win");
3973 fd = openp (full_load_path, init_file, Fget_load_suffixes (), NULL, Qnil);
3974 if (fd < 0)
3976 Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
3977 char *init_file_name = SDATA (init_file);
3978 char *load_path = SDATA (load_path_print);
3979 char *buffer = alloca (1024
3980 + strlen (init_file_name)
3981 + strlen (load_path));
3983 sprintf (buffer,
3984 "The Emacs Windows initialization file \"%s.el\" "
3985 "could not be found in your Emacs installation. "
3986 "Emacs checked the following directories for this file:\n"
3987 "\n%s\n\n"
3988 "When Emacs cannot find this file, it usually means that it "
3989 "was not installed properly, or its distribution file was "
3990 "not unpacked properly.\nSee the README.W32 file in the "
3991 "top-level Emacs directory for more information.",
3992 init_file_name, load_path);
3993 MessageBox (NULL,
3994 buffer,
3995 "Emacs Abort Dialog",
3996 MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
3997 /* Use the low-level Emacs abort. */
3998 #undef abort
3999 abort ();
4001 else
4003 _close (fd);
4008 void
4009 term_ntproc ()
4011 #ifdef HAVE_SOCKETS
4012 /* shutdown the socket interface if necessary */
4013 term_winsock ();
4014 #endif
4016 term_w32select ();
4019 void
4020 init_ntproc ()
4022 #ifdef HAVE_SOCKETS
4023 /* Initialise the socket interface now if available and requested by
4024 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4025 delayed until open-network-stream is called (w32-has-winsock can
4026 also be used to dynamically load or reload winsock).
4028 Conveniently, init_environment is called before us, so
4029 PRELOAD_WINSOCK can be set in the registry. */
4031 /* Always initialize this correctly. */
4032 winsock_lib = NULL;
4034 if (getenv ("PRELOAD_WINSOCK") != NULL)
4035 init_winsock (TRUE);
4036 #endif
4038 /* Initial preparation for subprocess support: replace our standard
4039 handles with non-inheritable versions. */
4041 HANDLE parent;
4042 HANDLE stdin_save = INVALID_HANDLE_VALUE;
4043 HANDLE stdout_save = INVALID_HANDLE_VALUE;
4044 HANDLE stderr_save = INVALID_HANDLE_VALUE;
4046 parent = GetCurrentProcess ();
4048 /* ignore errors when duplicating and closing; typically the
4049 handles will be invalid when running as a gui program. */
4050 DuplicateHandle (parent,
4051 GetStdHandle (STD_INPUT_HANDLE),
4052 parent,
4053 &stdin_save,
4055 FALSE,
4056 DUPLICATE_SAME_ACCESS);
4058 DuplicateHandle (parent,
4059 GetStdHandle (STD_OUTPUT_HANDLE),
4060 parent,
4061 &stdout_save,
4063 FALSE,
4064 DUPLICATE_SAME_ACCESS);
4066 DuplicateHandle (parent,
4067 GetStdHandle (STD_ERROR_HANDLE),
4068 parent,
4069 &stderr_save,
4071 FALSE,
4072 DUPLICATE_SAME_ACCESS);
4074 fclose (stdin);
4075 fclose (stdout);
4076 fclose (stderr);
4078 if (stdin_save != INVALID_HANDLE_VALUE)
4079 _open_osfhandle ((long) stdin_save, O_TEXT);
4080 else
4081 _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
4082 _fdopen (0, "r");
4084 if (stdout_save != INVALID_HANDLE_VALUE)
4085 _open_osfhandle ((long) stdout_save, O_TEXT);
4086 else
4087 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
4088 _fdopen (1, "w");
4090 if (stderr_save != INVALID_HANDLE_VALUE)
4091 _open_osfhandle ((long) stderr_save, O_TEXT);
4092 else
4093 _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
4094 _fdopen (2, "w");
4097 /* unfortunately, atexit depends on implementation of malloc */
4098 /* atexit (term_ntproc); */
4099 signal (SIGABRT, term_ntproc);
4101 /* determine which drives are fixed, for GetCachedVolumeInformation */
4103 /* GetDriveType must have trailing backslash. */
4104 char drive[] = "A:\\";
4106 /* Loop over all possible drive letters */
4107 while (*drive <= 'Z')
4109 /* Record if this drive letter refers to a fixed drive. */
4110 fixed_drives[DRIVE_INDEX (*drive)] =
4111 (GetDriveType (drive) == DRIVE_FIXED);
4113 (*drive)++;
4116 /* Reset the volume info cache. */
4117 volume_cache = NULL;
4120 /* Check to see if Emacs has been installed correctly. */
4121 check_windows_init_file ();
4125 shutdown_handler ensures that buffers' autosave files are
4126 up to date when the user logs off, or the system shuts down.
4128 BOOL WINAPI shutdown_handler(DWORD type)
4130 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4131 if (type == CTRL_CLOSE_EVENT /* User closes console window. */
4132 || type == CTRL_LOGOFF_EVENT /* User logs off. */
4133 || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown. */
4135 /* Shut down cleanly, making sure autosave files are up to date. */
4136 shut_down_emacs (0, 0, Qnil);
4139 /* Allow other handlers to handle this signal. */
4140 return FALSE;
4144 globals_of_w32 is used to initialize those global variables that
4145 must always be initialized on startup even when the global variable
4146 initialized is non zero (see the function main in emacs.c).
4148 void
4149 globals_of_w32 ()
4151 g_b_init_is_windows_9x = 0;
4152 g_b_init_open_process_token = 0;
4153 g_b_init_get_token_information = 0;
4154 g_b_init_lookup_account_sid = 0;
4155 g_b_init_get_sid_identifier_authority = 0;
4156 /* The following sets a handler for shutdown notifications for
4157 console apps. This actually applies to Emacs in both console and
4158 GUI modes, since we had to fool windows into thinking emacs is a
4159 console application to get console mode to work. */
4160 SetConsoleCtrlHandler(shutdown_handler, TRUE);
4163 /* end of nt.c */
4165 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4166 (do not change this comment) */