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, 2008 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 3, or (at your option)
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 */
34 #include <sys/utime.h>
35 #include <mbstring.h> /* for _mbspbrk */
37 /* must include CRT headers *before* config.h */
72 #define _ANONYMOUS_UNION
73 #define _ANONYMOUS_STRUCT
79 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
80 #include <sys/socket.h>
105 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
106 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
108 void globals_of_w32 ();
110 extern Lisp_Object Vw32_downcase_file_names
;
111 extern Lisp_Object Vw32_generate_fake_inodes
;
112 extern Lisp_Object Vw32_get_true_file_attributes
;
113 extern int w32_num_mouse_buttons
;
117 Initialization states
119 static BOOL g_b_init_is_windows_9x
;
120 static BOOL g_b_init_open_process_token
;
121 static BOOL g_b_init_get_token_information
;
122 static BOOL g_b_init_lookup_account_sid
;
123 static BOOL g_b_init_get_sid_identifier_authority
;
124 static BOOL g_b_init_get_sid_sub_authority
;
125 static BOOL g_b_init_get_sid_sub_authority_count
;
128 BEGIN: Wrapper functions around OpenProcessToken
129 and other functions in advapi32.dll that are only
130 supported in Windows NT / 2k / XP
132 /* ** Function pointer typedefs ** */
133 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
134 HANDLE ProcessHandle
,
136 PHANDLE TokenHandle
);
137 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
139 TOKEN_INFORMATION_CLASS TokenInformationClass
,
140 LPVOID TokenInformation
,
141 DWORD TokenInformationLength
,
142 PDWORD ReturnLength
);
143 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
144 HANDLE process_handle
,
145 LPFILETIME creation_time
,
146 LPFILETIME exit_time
,
147 LPFILETIME kernel_time
,
148 LPFILETIME user_time
);
150 GetProcessTimes_Proc get_process_times_fn
= NULL
;
153 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
155 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
157 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
158 LPCTSTR lpSystemName
,
163 LPDWORD cbDomainName
,
164 PSID_NAME_USE peUse
);
165 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI
* GetSidIdentifierAuthority_Proc
) (
167 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
170 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
174 /* ** A utility function ** */
178 static BOOL s_b_ret
=0;
179 OSVERSIONINFO os_ver
;
180 if (g_b_init_is_windows_9x
== 0)
182 g_b_init_is_windows_9x
= 1;
183 ZeroMemory(&os_ver
, sizeof(OSVERSIONINFO
));
184 os_ver
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
185 if (GetVersionEx (&os_ver
))
187 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
193 /* Get total user and system times for get-internal-run-time.
194 Returns a list of three integers if the times are provided by the OS
195 (NT derivatives), otherwise it returns the result of current-time. */
197 w32_get_internal_run_time ()
199 if (get_process_times_fn
)
201 FILETIME create
, exit
, kernel
, user
;
202 HANDLE proc
= GetCurrentProcess();
203 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
205 LARGE_INTEGER user_int
, kernel_int
, total
;
207 user_int
.LowPart
= user
.dwLowDateTime
;
208 user_int
.HighPart
= user
.dwHighDateTime
;
209 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
210 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
211 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
212 /* FILETIME is 100 nanosecond increments, Emacs only wants
213 microsecond resolution. */
214 total
.QuadPart
/= 10;
215 microseconds
= total
.QuadPart
% 1000000;
216 total
.QuadPart
/= 1000000;
218 /* Sanity check to make sure we can represent the result. */
219 if (total
.HighPart
== 0)
221 int secs
= total
.LowPart
;
223 return list3 (make_number ((secs
>> 16) & 0xffff),
224 make_number (secs
& 0xffff),
225 make_number (microseconds
));
230 return Fcurrent_time ();
233 /* ** The wrapper functions ** */
235 BOOL WINAPI
open_process_token (
236 HANDLE ProcessHandle
,
240 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
241 HMODULE hm_advapi32
= NULL
;
242 if (is_windows_9x () == TRUE
)
246 if (g_b_init_open_process_token
== 0)
248 g_b_init_open_process_token
= 1;
249 hm_advapi32
= LoadLibrary ("Advapi32.dll");
250 s_pfn_Open_Process_Token
=
251 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
253 if (s_pfn_Open_Process_Token
== NULL
)
258 s_pfn_Open_Process_Token (
265 BOOL WINAPI
get_token_information (
267 TOKEN_INFORMATION_CLASS TokenInformationClass
,
268 LPVOID TokenInformation
,
269 DWORD TokenInformationLength
,
272 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
273 HMODULE hm_advapi32
= NULL
;
274 if (is_windows_9x () == TRUE
)
278 if (g_b_init_get_token_information
== 0)
280 g_b_init_get_token_information
= 1;
281 hm_advapi32
= LoadLibrary ("Advapi32.dll");
282 s_pfn_Get_Token_Information
=
283 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
285 if (s_pfn_Get_Token_Information
== NULL
)
290 s_pfn_Get_Token_Information (
292 TokenInformationClass
,
294 TokenInformationLength
,
299 BOOL WINAPI
lookup_account_sid (
300 LPCTSTR lpSystemName
,
305 LPDWORD cbDomainName
,
308 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
309 HMODULE hm_advapi32
= NULL
;
310 if (is_windows_9x () == TRUE
)
314 if (g_b_init_lookup_account_sid
== 0)
316 g_b_init_lookup_account_sid
= 1;
317 hm_advapi32
= LoadLibrary ("Advapi32.dll");
318 s_pfn_Lookup_Account_Sid
=
319 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
321 if (s_pfn_Lookup_Account_Sid
== NULL
)
326 s_pfn_Lookup_Account_Sid (
337 PSID_IDENTIFIER_AUTHORITY WINAPI
get_sid_identifier_authority (
340 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority
= NULL
;
341 HMODULE hm_advapi32
= NULL
;
342 if (is_windows_9x () == TRUE
)
346 if (g_b_init_get_sid_identifier_authority
== 0)
348 g_b_init_get_sid_identifier_authority
= 1;
349 hm_advapi32
= LoadLibrary ("Advapi32.dll");
350 s_pfn_Get_Sid_Identifier_Authority
=
351 (GetSidIdentifierAuthority_Proc
) GetProcAddress (
352 hm_advapi32
, "GetSidIdentifierAuthority");
354 if (s_pfn_Get_Sid_Identifier_Authority
== NULL
)
358 return (s_pfn_Get_Sid_Identifier_Authority (pSid
));
361 PDWORD WINAPI
get_sid_sub_authority (
365 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
366 static DWORD zero
= 0U;
367 HMODULE hm_advapi32
= NULL
;
368 if (is_windows_9x () == TRUE
)
372 if (g_b_init_get_sid_sub_authority
== 0)
374 g_b_init_get_sid_sub_authority
= 1;
375 hm_advapi32
= LoadLibrary ("Advapi32.dll");
376 s_pfn_Get_Sid_Sub_Authority
=
377 (GetSidSubAuthority_Proc
) GetProcAddress (
378 hm_advapi32
, "GetSidSubAuthority");
380 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
384 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
387 PUCHAR WINAPI
get_sid_sub_authority_count (
390 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
391 static UCHAR zero
= 0U;
392 HMODULE hm_advapi32
= NULL
;
393 if (is_windows_9x () == TRUE
)
397 if (g_b_init_get_sid_sub_authority_count
== 0)
399 g_b_init_get_sid_sub_authority_count
= 1;
400 hm_advapi32
= LoadLibrary ("Advapi32.dll");
401 s_pfn_Get_Sid_Sub_Authority_Count
=
402 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
403 hm_advapi32
, "GetSidSubAuthorityCount");
405 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
409 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
413 END: Wrapper functions around OpenProcessToken
414 and other functions in advapi32.dll that are only
415 supported in Windows NT / 2k / XP
419 /* Equivalent of strerror for W32 error codes. */
421 w32_strerror (int error_no
)
423 static char buf
[500];
426 error_no
= GetLastError ();
429 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
431 0, /* choose most suitable language */
432 buf
, sizeof (buf
), NULL
))
433 sprintf (buf
, "w32 error %u", error_no
);
437 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
438 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
440 This is called from alloc.c:valid_pointer_p. */
442 w32_valid_pointer_p (void *p
, int size
)
445 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
449 unsigned char *buf
= alloca (size
);
450 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
459 static char startup_dir
[MAXPATHLEN
];
461 /* Get the current working directory. */
466 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
470 /* Emacs doesn't actually change directory itself, and we want to
471 force our real wd to be where emacs.exe is to avoid unnecessary
472 conflicts when trying to rename or delete directories. */
473 strcpy (dir
, startup_dir
);
479 /* Emulate gethostname. */
481 gethostname (char *buffer
, int size
)
483 /* NT only allows small host names, so the buffer is
484 certainly large enough. */
485 return !GetComputerName (buffer
, &size
);
487 #endif /* HAVE_SOCKETS */
489 /* Emulate getloadavg. */
491 getloadavg (double loadavg
[], int nelem
)
495 /* A faithful emulation is going to have to be saved for a rainy day. */
496 for (i
= 0; i
< nelem
; i
++)
503 /* Emulate getpwuid, getpwnam and others. */
505 #define PASSWD_FIELD_SIZE 256
507 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
508 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
509 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
510 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
511 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
513 static struct passwd the_passwd
=
525 static struct group the_group
=
527 /* There are no groups on NT, so we just return "root" as the
535 return the_passwd
.pw_uid
;
541 /* I could imagine arguing for checking to see whether the user is
542 in the Administrators group and returning a UID of 0 for that
543 case, but I don't know how wise that would be in the long run. */
550 return the_passwd
.pw_gid
;
562 if (uid
== the_passwd
.pw_uid
)
574 getpwnam (char *name
)
578 pw
= getpwuid (getuid ());
582 if (stricmp (name
, pw
->pw_name
))
591 /* Find the user's real name by opening the process token and
592 looking up the name associated with the user-sid in that token.
594 Use the relative portion of the identifier authority value from
595 the user-sid as the user id value (same for group id using the
596 primary group sid from the process token). */
598 char name
[UNLEN
+1], domain
[1025];
599 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
601 SID_NAME_USE user_type
;
602 unsigned char buf
[1024];
603 TOKEN_USER user_token
;
604 TOKEN_PRIMARY_GROUP group_token
;
606 if (open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
)
607 && get_token_information (token
, TokenUser
,
608 (PVOID
)buf
, sizeof (buf
), &trash
)
609 && (memcpy (&user_token
, buf
, sizeof (user_token
)),
610 lookup_account_sid (NULL
, user_token
.User
.Sid
, name
, &length
,
611 domain
, &dlength
, &user_type
)))
613 strcpy (the_passwd
.pw_name
, name
);
614 /* Determine a reasonable uid value. */
615 if (stricmp ("administrator", name
) == 0)
617 the_passwd
.pw_uid
= 500; /* well-known Administrator uid */
618 the_passwd
.pw_gid
= 513; /* well-known None gid */
622 /* Use the last sub-authority value of the RID, the relative
623 portion of the SID, as user/group ID. */
624 DWORD n_subauthorities
=
625 *get_sid_sub_authority_count (user_token
.User
.Sid
);
627 if (n_subauthorities
< 1)
628 the_passwd
.pw_uid
= 0; /* the "World" RID */
632 *get_sid_sub_authority (user_token
.User
.Sid
,
633 n_subauthorities
- 1);
634 /* Restrict to conventional uid range for normal users. */
635 the_passwd
.pw_uid
%= 60001;
639 if (get_token_information (token
, TokenPrimaryGroup
,
640 (PVOID
)buf
, sizeof (buf
), &trash
))
642 memcpy (&group_token
, buf
, sizeof (group_token
));
644 *get_sid_sub_authority_count (group_token
.PrimaryGroup
);
646 if (n_subauthorities
< 1)
647 the_passwd
.pw_gid
= 0; /* the "World" RID */
651 *get_sid_sub_authority (group_token
.PrimaryGroup
,
652 n_subauthorities
- 1);
653 /* I don't know if this is necessary, but for safety... */
654 the_passwd
.pw_gid
%= 60001;
658 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
661 /* If security calls are not supported (presumably because we
662 are running under Windows 95), fallback to this. */
663 else if (GetUserName (name
, &length
))
665 strcpy (the_passwd
.pw_name
, name
);
666 if (stricmp ("administrator", name
) == 0)
667 the_passwd
.pw_uid
= 0;
669 the_passwd
.pw_uid
= 123;
670 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
674 strcpy (the_passwd
.pw_name
, "unknown");
675 the_passwd
.pw_uid
= 123;
676 the_passwd
.pw_gid
= 123;
679 /* Ensure HOME and SHELL are defined. */
680 if (getenv ("HOME") == NULL
)
682 if (getenv ("SHELL") == NULL
)
685 /* Set dir and shell from environment variables. */
686 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
687 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
696 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
697 return ((rand () << 15) | rand ());
707 /* Normalize filename by converting all path separators to
708 the specified separator. Also conditionally convert upper
709 case path name components to lower case. */
712 normalize_filename (fp
, path_sep
)
719 /* Always lower-case drive letters a-z, even if the filesystem
720 preserves case in filenames.
721 This is so filenames can be compared by string comparison
722 functions that are case-sensitive. Even case-preserving filesystems
723 do not distinguish case in drive letters. */
724 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
730 if (NILP (Vw32_downcase_file_names
))
734 if (*fp
== '/' || *fp
== '\\')
741 sep
= path_sep
; /* convert to this path separator */
742 elem
= fp
; /* start of current path element */
745 if (*fp
>= 'a' && *fp
<= 'z')
746 elem
= 0; /* don't convert this element */
748 if (*fp
== 0 || *fp
== ':')
750 sep
= *fp
; /* restore current separator (or 0) */
751 *fp
= '/'; /* after conversion of this element */
754 if (*fp
== '/' || *fp
== '\\')
756 if (elem
&& elem
!= fp
)
758 *fp
= 0; /* temporary end of string */
759 _strlwr (elem
); /* while we convert to lower case */
761 *fp
= sep
; /* convert (or restore) path separator */
762 elem
= fp
+ 1; /* next element starts after separator */
768 /* Destructively turn backslashes into slashes. */
770 dostounix_filename (p
)
773 normalize_filename (p
, '/');
776 /* Destructively turn slashes into backslashes. */
778 unixtodos_filename (p
)
781 normalize_filename (p
, '\\');
784 /* Remove all CR's that are followed by a LF.
785 (From msdos.c...probably should figure out a way to share it,
786 although this code isn't going to ever change.) */
790 register unsigned char *buf
;
792 unsigned char *np
= buf
;
793 unsigned char *startp
= buf
;
794 unsigned char *endp
= buf
+ n
;
798 while (buf
< endp
- 1)
802 if (*(++buf
) != 0x0a)
813 /* Parse the root part of file name, if present. Return length and
814 optionally store pointer to char after root. */
816 parse_root (char * name
, char ** pPath
)
823 /* find the root name of the volume if given */
824 if (isalpha (name
[0]) && name
[1] == ':')
826 /* skip past drive specifier */
828 if (IS_DIRECTORY_SEP (name
[0]))
831 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
837 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
842 if (IS_DIRECTORY_SEP (name
[0]))
852 /* Get long base name for name; name is assumed to be absolute. */
854 get_long_basename (char * name
, char * buf
, int size
)
856 WIN32_FIND_DATA find_data
;
860 /* must be valid filename, no wild cards or other invalid characters */
861 if (_mbspbrk (name
, "*?|<>\""))
864 dir_handle
= FindFirstFile (name
, &find_data
);
865 if (dir_handle
!= INVALID_HANDLE_VALUE
)
867 if ((len
= strlen (find_data
.cFileName
)) < size
)
868 memcpy (buf
, find_data
.cFileName
, len
+ 1);
871 FindClose (dir_handle
);
876 /* Get long name for file, if possible (assumed to be absolute). */
878 w32_get_long_filename (char * name
, char * buf
, int size
)
883 char full
[ MAX_PATH
];
890 /* Use local copy for destructive modification. */
891 memcpy (full
, name
, len
+1);
892 unixtodos_filename (full
);
894 /* Copy root part verbatim. */
895 len
= parse_root (full
, &p
);
896 memcpy (o
, full
, len
);
901 while (p
!= NULL
&& *p
)
904 p
= strchr (q
, '\\');
906 len
= get_long_basename (full
, o
, size
);
929 is_unc_volume (const char *filename
)
931 const char *ptr
= filename
;
933 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
936 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
942 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
945 sigsetmask (int signal_mask
)
969 setpgrp (int pid
, int gid
)
980 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
983 w32_get_resource (key
, lpdwtype
)
988 HKEY hrootkey
= NULL
;
991 /* Check both the current user and the local machine to see if
992 we have any resources. */
994 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
998 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
999 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1000 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1002 RegCloseKey (hrootkey
);
1006 if (lpvalue
) xfree (lpvalue
);
1008 RegCloseKey (hrootkey
);
1011 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1015 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1016 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1017 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1019 RegCloseKey (hrootkey
);
1023 if (lpvalue
) xfree (lpvalue
);
1025 RegCloseKey (hrootkey
);
1031 char *get_emacs_configuration (void);
1032 extern Lisp_Object Vsystem_configuration
;
1035 init_environment (char ** argv
)
1037 static const char * const tempdirs
[] = {
1038 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1043 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1045 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1046 temporary files and assume "/tmp" if $TMPDIR is unset, which
1047 will break on DOS/Windows. Refuse to work if we cannot find
1048 a directory, not even "c:/", usable for that purpose. */
1049 for (i
= 0; i
< imax
; i
++)
1051 const char *tmp
= tempdirs
[i
];
1054 tmp
= getenv (tmp
+ 1);
1055 /* Note that `access' can lie to us if the directory resides on a
1056 read-only filesystem, like CD-ROM or a write-protected floppy.
1057 The only way to be really sure is to actually create a file and
1058 see if it succeeds. But I think that's too much to ask. */
1059 if (tmp
&& _access (tmp
, D_OK
) == 0)
1061 char * var
= alloca (strlen (tmp
) + 8);
1062 sprintf (var
, "TMPDIR=%s", tmp
);
1063 _putenv (strdup (var
));
1070 Fcons (build_string ("no usable temporary directories found!!"),
1072 "While setting TMPDIR: ");
1074 /* Check for environment variables and use registry settings if they
1075 don't exist. Fallback on default values where applicable. */
1080 char locale_name
[32];
1081 struct stat ignored
;
1082 char default_home
[MAX_PATH
];
1084 static const struct env_entry
1091 {"PRELOAD_WINSOCK", NULL
},
1092 {"emacs_dir", "C:/emacs"},
1093 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1094 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1095 {"EMACSDATA", "%emacs_dir%/etc"},
1096 {"EMACSPATH", "%emacs_dir%/bin"},
1097 /* We no longer set INFOPATH because Info-default-directory-list
1099 /* {"INFOPATH", "%emacs_dir%/info"}, */
1100 {"EMACSDOC", "%emacs_dir%/etc"},
1105 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1107 /* We need to copy dflt_envvars[] and work on the copy because we
1108 don't want the dumped Emacs to inherit the values of
1109 environment variables we saw during dumping (which could be on
1110 a different system). The defaults above must be left intact. */
1111 struct env_entry env_vars
[N_ENV_VARS
];
1113 for (i
= 0; i
< N_ENV_VARS
; i
++)
1114 env_vars
[i
] = dflt_envvars
[i
];
1116 /* For backwards compatibility, check if a .emacs file exists in C:/
1117 If not, then we can try to default to the appdata directory under the
1118 user's profile, which is more likely to be writable. */
1119 if (stat ("C:/.emacs", &ignored
) < 0)
1121 HRESULT profile_result
;
1122 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1123 of Windows 95 and NT4 that have not been updated to include
1124 MSIE 5. Also we don't link with shell32.dll by default. */
1125 HMODULE shell32_dll
;
1126 ShGetFolderPath_fn get_folder_path
;
1127 shell32_dll
= GetModuleHandle ("shell32.dll");
1128 get_folder_path
= (ShGetFolderPath_fn
)
1129 GetProcAddress (shell32_dll
, "SHGetFolderPathA");
1131 if (get_folder_path
!= NULL
)
1133 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1136 /* If we can't get the appdata dir, revert to old behaviour. */
1137 if (profile_result
== S_OK
)
1138 env_vars
[0].def_value
= default_home
;
1141 /* Unload shell32.dll, it is not needed anymore. */
1142 FreeLibrary (shell32_dll
);
1145 /* Get default locale info and use it for LANG. */
1146 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1147 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1148 locale_name
, sizeof (locale_name
)))
1150 for (i
= 0; i
< N_ENV_VARS
; i
++)
1152 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1154 env_vars
[i
].def_value
= locale_name
;
1160 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1162 /* Treat emacs_dir specially: set it unconditionally based on our
1163 location, if it appears that we are running from the bin subdir
1164 of a standard installation. */
1167 char modname
[MAX_PATH
];
1169 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1171 if ((p
= strrchr (modname
, '\\')) == NULL
)
1175 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
1177 char buf
[SET_ENV_BUF_SIZE
];
1180 for (p
= modname
; *p
; p
++)
1181 if (*p
== '\\') *p
= '/';
1183 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1184 _putenv (strdup (buf
));
1186 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1188 /* FIXME: should use substring of get_emacs_configuration ().
1189 But I don't think the Windows build supports alpha, mips etc
1190 anymore, so have taken the easy option for now. */
1191 else if (p
&& stricmp (p
, "\\i386") == 0)
1194 p
= strrchr (modname
, '\\');
1198 p
= strrchr (modname
, '\\');
1199 if (p
&& stricmp (p
, "\\src") == 0)
1201 char buf
[SET_ENV_BUF_SIZE
];
1204 for (p
= modname
; *p
; p
++)
1205 if (*p
== '\\') *p
= '/';
1207 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1208 _putenv (strdup (buf
));
1214 for (i
= 0; i
< N_ENV_VARS
; i
++)
1216 if (!getenv (env_vars
[i
].name
))
1220 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1221 /* Also ignore empty environment variables. */
1224 if (lpval
) xfree (lpval
);
1225 lpval
= env_vars
[i
].def_value
;
1226 dwType
= REG_EXPAND_SZ
;
1232 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1234 if (dwType
== REG_EXPAND_SZ
)
1235 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
1236 else if (dwType
== REG_SZ
)
1237 strcpy (buf1
, lpval
);
1238 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1240 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
,
1242 _putenv (strdup (buf2
));
1252 /* Rebuild system configuration to reflect invoking system. */
1253 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1255 /* Another special case: on NT, the PATH variable is actually named
1256 "Path" although cmd.exe (perhaps NT itself) arranges for
1257 environment variable lookup and setting to be case insensitive.
1258 However, Emacs assumes a fully case sensitive environment, so we
1259 need to change "Path" to "PATH" to match the expectations of
1260 various elisp packages. We do this by the sneaky method of
1261 modifying the string in the C runtime environ entry.
1263 The same applies to COMSPEC. */
1267 for (envp
= environ
; *envp
; envp
++)
1268 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1269 memcpy (*envp
, "PATH=", 5);
1270 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1271 memcpy (*envp
, "COMSPEC=", 8);
1274 /* Remember the initial working directory for getwd, then make the
1275 real wd be the location of emacs.exe to avoid conflicts when
1276 renaming or deleting directories. (We also don't call chdir when
1277 running subprocesses for the same reason.) */
1278 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1283 static char modname
[MAX_PATH
];
1285 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1287 if ((p
= strrchr (modname
, '\\')) == NULL
)
1291 SetCurrentDirectory (modname
);
1293 /* Ensure argv[0] has the full path to Emacs. */
1298 /* Determine if there is a middle mouse button, to allow parse_button
1299 to decide whether right mouse events should be mouse-2 or
1301 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1307 emacs_root_dir (void)
1309 static char root_dir
[FILENAME_MAX
];
1312 p
= getenv ("emacs_dir");
1315 strcpy (root_dir
, p
);
1316 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1317 dostounix_filename (root_dir
);
1321 /* We don't have scripts to automatically determine the system configuration
1322 for Emacs before it's compiled, and we don't want to have to make the
1323 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1327 get_emacs_configuration (void)
1329 char *arch
, *oem
, *os
;
1331 static char configuration_buffer
[32];
1333 /* Determine the processor type. */
1334 switch (get_processor_type ())
1337 #ifdef PROCESSOR_INTEL_386
1338 case PROCESSOR_INTEL_386
:
1339 case PROCESSOR_INTEL_486
:
1340 case PROCESSOR_INTEL_PENTIUM
:
1345 #ifdef PROCESSOR_MIPS_R2000
1346 case PROCESSOR_MIPS_R2000
:
1347 case PROCESSOR_MIPS_R3000
:
1348 case PROCESSOR_MIPS_R4000
:
1353 #ifdef PROCESSOR_ALPHA_21064
1354 case PROCESSOR_ALPHA_21064
:
1364 /* Use the OEM field to reflect the compiler/library combination. */
1366 #define COMPILER_NAME "msvc"
1369 #define COMPILER_NAME "mingw"
1371 #define COMPILER_NAME "unknown"
1374 oem
= COMPILER_NAME
;
1376 switch (osinfo_cache
.dwPlatformId
) {
1377 case VER_PLATFORM_WIN32_NT
:
1379 build_num
= osinfo_cache
.dwBuildNumber
;
1381 case VER_PLATFORM_WIN32_WINDOWS
:
1382 if (osinfo_cache
.dwMinorVersion
== 0) {
1387 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1389 case VER_PLATFORM_WIN32s
:
1390 /* Not supported, should not happen. */
1392 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1400 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1401 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1402 get_w32_major_version (), get_w32_minor_version (), build_num
);
1404 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1407 return configuration_buffer
;
1411 get_emacs_configuration_options (void)
1413 static char options_buffer
[256];
1415 /* Work out the effective configure options for this build. */
1417 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1420 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1422 #define COMPILER_VERSION ""
1426 sprintf (options_buffer
, COMPILER_VERSION
);
1428 strcat (options_buffer
, " --no-opt");
1431 strcat (options_buffer
, " --cflags");
1432 strcat (options_buffer
, USER_CFLAGS
);
1435 strcat (options_buffer
, " --ldflags");
1436 strcat (options_buffer
, USER_LDFLAGS
);
1438 return options_buffer
;
1442 #include <sys/timeb.h>
1444 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1446 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1451 tv
->tv_sec
= tb
.time
;
1452 tv
->tv_usec
= tb
.millitm
* 1000L;
1455 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1456 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1460 /* ------------------------------------------------------------------------- */
1461 /* IO support and wrapper functions for W32 API. */
1462 /* ------------------------------------------------------------------------- */
1464 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1465 on network directories, so we handle that case here.
1466 (Ulrich Leodolter, 1/11/95). */
1468 sys_ctime (const time_t *t
)
1470 char *str
= (char *) ctime (t
);
1471 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1474 /* Emulate sleep...we could have done this with a define, but that
1475 would necessitate including windows.h in the files that used it.
1476 This is much easier. */
1478 sys_sleep (int seconds
)
1480 Sleep (seconds
* 1000);
1483 /* Internal MSVC functions for low-level descriptor munging */
1484 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1485 extern int __cdecl
_free_osfhnd (int fd
);
1487 /* parallel array of private info on file handles */
1488 filedesc fd_info
[ MAXDESC
];
1490 typedef struct volume_info_data
{
1491 struct volume_info_data
* next
;
1493 /* time when info was obtained */
1496 /* actual volume info */
1505 /* Global referenced by various functions. */
1506 static volume_info_data volume_info
;
1508 /* Vector to indicate which drives are local and fixed (for which cached
1509 data never expires). */
1510 static BOOL fixed_drives
[26];
1512 /* Consider cached volume information to be stale if older than 10s,
1513 at least for non-local drives. Info for fixed drives is never stale. */
1514 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1515 #define VOLINFO_STILL_VALID( root_dir, info ) \
1516 ( ( isalpha (root_dir[0]) && \
1517 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1518 || GetTickCount () - info->timestamp < 10000 )
1520 /* Cache support functions. */
1522 /* Simple linked list with linear search is sufficient. */
1523 static volume_info_data
*volume_cache
= NULL
;
1525 static volume_info_data
*
1526 lookup_volume_info (char * root_dir
)
1528 volume_info_data
* info
;
1530 for (info
= volume_cache
; info
; info
= info
->next
)
1531 if (stricmp (info
->root_dir
, root_dir
) == 0)
1537 add_volume_info (char * root_dir
, volume_info_data
* info
)
1539 info
->root_dir
= xstrdup (root_dir
);
1540 info
->next
= volume_cache
;
1541 volume_cache
= info
;
1545 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1546 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1547 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1549 GetCachedVolumeInformation (char * root_dir
)
1551 volume_info_data
* info
;
1552 char default_root
[ MAX_PATH
];
1554 /* NULL for root_dir means use root from current directory. */
1555 if (root_dir
== NULL
)
1557 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1559 parse_root (default_root
, &root_dir
);
1561 root_dir
= default_root
;
1564 /* Local fixed drives can be cached permanently. Removable drives
1565 cannot be cached permanently, since the volume name and serial
1566 number (if nothing else) can change. Remote drives should be
1567 treated as if they are removable, since there is no sure way to
1568 tell whether they are or not. Also, the UNC association of drive
1569 letters mapped to remote volumes can be changed at any time (even
1570 by other processes) without notice.
1572 As a compromise, so we can benefit from caching info for remote
1573 volumes, we use a simple expiry mechanism to invalidate cache
1574 entries that are more than ten seconds old. */
1577 /* No point doing this, because WNetGetConnection is even slower than
1578 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1579 GetDriveType is about the only call of this type which does not
1580 involve network access, and so is extremely quick). */
1582 /* Map drive letter to UNC if remote. */
1583 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1585 char remote_name
[ 256 ];
1586 char drive
[3] = { root_dir
[0], ':' };
1588 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1590 /* do something */ ;
1594 info
= lookup_volume_info (root_dir
);
1596 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1604 /* Info is not cached, or is stale. */
1605 if (!GetVolumeInformation (root_dir
,
1606 name
, sizeof (name
),
1610 type
, sizeof (type
)))
1613 /* Cache the volume information for future use, overwriting existing
1614 entry if present. */
1617 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1618 add_volume_info (root_dir
, info
);
1626 info
->name
= xstrdup (name
);
1627 info
->serialnum
= serialnum
;
1628 info
->maxcomp
= maxcomp
;
1629 info
->flags
= flags
;
1630 info
->type
= xstrdup (type
);
1631 info
->timestamp
= GetTickCount ();
1637 /* Get information on the volume where name is held; set path pointer to
1638 start of pathname in name (past UNC header\volume header if present). */
1640 get_volume_info (const char * name
, const char ** pPath
)
1642 char temp
[MAX_PATH
];
1643 char *rootname
= NULL
; /* default to current volume */
1644 volume_info_data
* info
;
1649 /* find the root name of the volume if given */
1650 if (isalpha (name
[0]) && name
[1] == ':')
1658 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1665 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1678 info
= GetCachedVolumeInformation (rootname
);
1681 /* Set global referenced by other functions. */
1682 volume_info
= *info
;
1688 /* Determine if volume is FAT format (ie. only supports short 8.3
1689 names); also set path pointer to start of pathname in name. */
1691 is_fat_volume (const char * name
, const char ** pPath
)
1693 if (get_volume_info (name
, pPath
))
1694 return (volume_info
.maxcomp
== 12);
1698 /* Map filename to a legal 8.3 name if necessary. */
1700 map_w32_filename (const char * name
, const char ** pPath
)
1702 static char shortname
[MAX_PATH
];
1703 char * str
= shortname
;
1706 const char * save_name
= name
;
1708 if (strlen (name
) >= MAX_PATH
)
1710 /* Return a filename which will cause callers to fail. */
1711 strcpy (shortname
, "?");
1715 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1717 register int left
= 8; /* maximum number of chars in part */
1718 register int extn
= 0; /* extension added? */
1719 register int dots
= 2; /* maximum number of dots allowed */
1722 *str
++ = *name
++; /* skip past UNC header */
1724 while ((c
= *name
++))
1731 extn
= 0; /* reset extension flags */
1732 dots
= 2; /* max 2 dots */
1733 left
= 8; /* max length 8 for main part */
1737 extn
= 0; /* reset extension flags */
1738 dots
= 2; /* max 2 dots */
1739 left
= 8; /* max length 8 for main part */
1744 /* Convert path components of the form .xxx to _xxx,
1745 but leave . and .. as they are. This allows .emacs
1746 to be read as _emacs, for example. */
1750 IS_DIRECTORY_SEP (*name
))
1765 extn
= 1; /* we've got an extension */
1766 left
= 3; /* 3 chars in extension */
1770 /* any embedded dots after the first are converted to _ */
1775 case '#': /* don't lose these, they're important */
1777 str
[-1] = c
; /* replace last character of part */
1782 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1784 dots
= 0; /* started a path component */
1793 strcpy (shortname
, name
);
1794 unixtodos_filename (shortname
);
1798 *pPath
= shortname
+ (path
- save_name
);
1804 is_exec (const char * name
)
1806 char * p
= strrchr (name
, '.');
1809 && (stricmp (p
, ".exe") == 0 ||
1810 stricmp (p
, ".com") == 0 ||
1811 stricmp (p
, ".bat") == 0 ||
1812 stricmp (p
, ".cmd") == 0));
1815 /* Emulate the Unix directory procedures opendir, closedir,
1816 and readdir. We can't use the procedures supplied in sysdep.c,
1817 so we provide them here. */
1819 struct direct dir_static
; /* simulated directory contents */
1820 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1821 static int dir_is_fat
;
1822 static char dir_pathname
[MAXPATHLEN
+1];
1823 static WIN32_FIND_DATA dir_find_data
;
1825 /* Support shares on a network resource as subdirectories of a read-only
1827 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1828 HANDLE
open_unc_volume (const char *);
1829 char *read_unc_volume (HANDLE
, char *, int);
1830 void close_unc_volume (HANDLE
);
1833 opendir (char *filename
)
1837 /* Opening is done by FindFirstFile. However, a read is inherent to
1838 this operation, so we defer the open until read time. */
1840 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1842 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1845 if (is_unc_volume (filename
))
1847 wnet_enum_handle
= open_unc_volume (filename
);
1848 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1852 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1859 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1860 dir_pathname
[MAXPATHLEN
] = '\0';
1861 dir_is_fat
= is_fat_volume (filename
, NULL
);
1867 closedir (DIR *dirp
)
1869 /* If we have a find-handle open, close it. */
1870 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1872 FindClose (dir_find_handle
);
1873 dir_find_handle
= INVALID_HANDLE_VALUE
;
1875 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1877 close_unc_volume (wnet_enum_handle
);
1878 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1880 xfree ((char *) dirp
);
1886 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1888 if (!read_unc_volume (wnet_enum_handle
,
1889 dir_find_data
.cFileName
,
1893 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1894 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1896 char filename
[MAXNAMLEN
+ 3];
1899 strcpy (filename
, dir_pathname
);
1900 ln
= strlen (filename
) - 1;
1901 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1902 strcat (filename
, "\\");
1903 strcat (filename
, "*");
1905 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1907 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1912 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1916 /* Emacs never uses this value, so don't bother making it match
1917 value returned by stat(). */
1918 dir_static
.d_ino
= 1;
1920 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1921 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1923 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1924 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1926 _strlwr (dir_static
.d_name
);
1927 else if (!NILP (Vw32_downcase_file_names
))
1930 for (p
= dir_static
.d_name
; *p
; p
++)
1931 if (*p
>= 'a' && *p
<= 'z')
1934 _strlwr (dir_static
.d_name
);
1941 open_unc_volume (const char *path
)
1947 nr
.dwScope
= RESOURCE_GLOBALNET
;
1948 nr
.dwType
= RESOURCETYPE_DISK
;
1949 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1950 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1951 nr
.lpLocalName
= NULL
;
1952 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
1953 nr
.lpComment
= NULL
;
1954 nr
.lpProvider
= NULL
;
1956 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1957 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1959 if (result
== NO_ERROR
)
1962 return INVALID_HANDLE_VALUE
;
1966 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1970 DWORD bufsize
= 512;
1975 buffer
= alloca (bufsize
);
1976 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1977 if (result
!= NO_ERROR
)
1980 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1981 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1983 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1986 strncpy (readbuf
, ptr
, size
);
1991 close_unc_volume (HANDLE henum
)
1993 if (henum
!= INVALID_HANDLE_VALUE
)
1994 WNetCloseEnum (henum
);
1998 unc_volume_file_attributes (const char *path
)
2003 henum
= open_unc_volume (path
);
2004 if (henum
== INVALID_HANDLE_VALUE
)
2007 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2009 close_unc_volume (henum
);
2014 /* Ensure a network connection is authenticated. */
2016 logon_network_drive (const char *path
)
2018 NETRESOURCE resource
;
2019 char share
[MAX_PATH
];
2022 /* Only logon to networked drives. */
2023 if (!IS_DIRECTORY_SEP (path
[0]) || !IS_DIRECTORY_SEP (path
[1]))
2026 strncpy (share
, path
, MAX_PATH
);
2027 /* Truncate to just server and share name. */
2028 for (i
= 2; i
< MAX_PATH
; i
++)
2030 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2037 resource
.dwType
= RESOURCETYPE_DISK
;
2038 resource
.lpLocalName
= NULL
;
2039 resource
.lpRemoteName
= share
;
2040 resource
.lpProvider
= NULL
;
2042 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2045 /* Shadow some MSVC runtime functions to map requests for long filenames
2046 to reasonable short names if necessary. This was originally added to
2047 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2051 sys_access (const char * path
, int mode
)
2055 /* MSVC implementation doesn't recognize D_OK. */
2056 path
= map_w32_filename (path
, NULL
);
2057 if (is_unc_volume (path
))
2059 attributes
= unc_volume_file_attributes (path
);
2060 if (attributes
== -1) {
2065 else if ((attributes
= GetFileAttributes (path
)) == -1)
2067 /* Should try mapping GetLastError to errno; for now just indicate
2068 that path doesn't exist. */
2072 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2077 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2082 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2091 sys_chdir (const char * path
)
2093 return _chdir (map_w32_filename (path
, NULL
));
2097 sys_chmod (const char * path
, int mode
)
2099 return _chmod (map_w32_filename (path
, NULL
), mode
);
2103 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2105 if (sys_chmod (path
, _S_IREAD
) == -1) /* check if file exists */
2111 sys_creat (const char * path
, int mode
)
2113 return _creat (map_w32_filename (path
, NULL
), mode
);
2117 sys_fopen(const char * path
, const char * mode
)
2121 const char * mode_save
= mode
;
2123 /* Force all file handles to be non-inheritable. This is necessary to
2124 ensure child processes don't unwittingly inherit handles that might
2125 prevent future file access. */
2129 else if (mode
[0] == 'w' || mode
[0] == 'a')
2130 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2134 /* Only do simplistic option parsing. */
2138 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2141 else if (mode
[0] == 'b')
2146 else if (mode
[0] == 't')
2153 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2157 return _fdopen (fd
, mode_save
);
2160 /* This only works on NTFS volumes, but is useful to have. */
2162 sys_link (const char * old
, const char * new)
2166 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2168 if (old
== NULL
|| new == NULL
)
2174 strcpy (oldname
, map_w32_filename (old
, NULL
));
2175 strcpy (newname
, map_w32_filename (new, NULL
));
2177 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2178 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2179 if (fileh
!= INVALID_HANDLE_VALUE
)
2183 /* Confusingly, the "alternate" stream name field does not apply
2184 when restoring a hard link, and instead contains the actual
2185 stream data for the link (ie. the name of the link to create).
2186 The WIN32_STREAM_ID structure before the cStreamName field is
2187 the stream header, which is then immediately followed by the
2191 WIN32_STREAM_ID wid
;
2192 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2195 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2196 data
.wid
.cStreamName
, MAX_PATH
);
2199 LPVOID context
= NULL
;
2202 data
.wid
.dwStreamId
= BACKUP_LINK
;
2203 data
.wid
.dwStreamAttributes
= 0;
2204 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
2205 data
.wid
.Size
.HighPart
= 0;
2206 data
.wid
.dwStreamNameSize
= 0;
2208 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2209 offsetof (WIN32_STREAM_ID
, cStreamName
)
2210 + data
.wid
.Size
.LowPart
,
2211 &wbytes
, FALSE
, FALSE
, &context
)
2212 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2219 /* Should try mapping GetLastError to errno; for now just
2220 indicate a general error (eg. links not supported). */
2221 errno
= EINVAL
; // perhaps EMLINK?
2225 CloseHandle (fileh
);
2234 sys_mkdir (const char * path
)
2236 return _mkdir (map_w32_filename (path
, NULL
));
2239 /* Because of long name mapping issues, we need to implement this
2240 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2241 a unique name, instead of setting the input template to an empty
2244 Standard algorithm seems to be use pid or tid with a letter on the
2245 front (in place of the 6 X's) and cycle through the letters to find a
2246 unique name. We extend that to allow any reasonable character as the
2247 first of the 6 X's. */
2249 sys_mktemp (char * template)
2253 unsigned uid
= GetCurrentThreadId ();
2254 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2256 if (template == NULL
)
2258 p
= template + strlen (template);
2260 /* replace up to the last 5 X's with uid in decimal */
2261 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2263 p
[0] = '0' + uid
% 10;
2267 if (i
< 0 && p
[0] == 'X')
2272 int save_errno
= errno
;
2273 p
[0] = first_char
[i
];
2274 if (sys_access (template, 0) < 0)
2280 while (++i
< sizeof (first_char
));
2283 /* Template is badly formed or else we can't generate a unique name,
2284 so return empty string */
2290 sys_open (const char * path
, int oflag
, int mode
)
2292 const char* mpath
= map_w32_filename (path
, NULL
);
2293 /* Try to open file without _O_CREAT, to be able to write to hidden
2294 and system files. Force all file handles to be
2296 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2299 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2303 sys_rename (const char * oldname
, const char * newname
)
2306 char temp
[MAX_PATH
];
2308 /* MoveFile on Windows 95 doesn't correctly change the short file name
2309 alias in a number of circumstances (it is not easy to predict when
2310 just by looking at oldname and newname, unfortunately). In these
2311 cases, renaming through a temporary name avoids the problem.
2313 A second problem on Windows 95 is that renaming through a temp name when
2314 newname is uppercase fails (the final long name ends up in
2315 lowercase, although the short alias might be uppercase) UNLESS the
2316 long temp name is not 8.3.
2318 So, on Windows 95 we always rename through a temp name, and we make sure
2319 the temp name has a long extension to ensure correct renaming. */
2321 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2323 if (os_subtype
== OS_WIN95
)
2329 oldname
= map_w32_filename (oldname
, NULL
);
2330 if (o
= strrchr (oldname
, '\\'))
2333 o
= (char *) oldname
;
2335 if (p
= strrchr (temp
, '\\'))
2342 /* Force temp name to require a manufactured 8.3 alias - this
2343 seems to make the second rename work properly. */
2344 sprintf (p
, "_.%s.%u", o
, i
);
2346 result
= rename (oldname
, temp
);
2348 /* This loop must surely terminate! */
2349 while (result
< 0 && errno
== EEXIST
);
2354 /* Emulate Unix behaviour - newname is deleted if it already exists
2355 (at least if it is a file; don't do this for directories).
2357 Since we mustn't do this if we are just changing the case of the
2358 file name (we would end up deleting the file we are trying to
2359 rename!), we let rename detect if the destination file already
2360 exists - that way we avoid the possible pitfalls of trying to
2361 determine ourselves whether two names really refer to the same
2362 file, which is not always possible in the general case. (Consider
2363 all the permutations of shared or subst'd drives, etc.) */
2365 newname
= map_w32_filename (newname
, NULL
);
2366 result
= rename (temp
, newname
);
2370 && _chmod (newname
, 0666) == 0
2371 && _unlink (newname
) == 0)
2372 result
= rename (temp
, newname
);
2378 sys_rmdir (const char * path
)
2380 return _rmdir (map_w32_filename (path
, NULL
));
2384 sys_unlink (const char * path
)
2386 path
= map_w32_filename (path
, NULL
);
2388 /* On Unix, unlink works without write permission. */
2389 _chmod (path
, 0666);
2390 return _unlink (path
);
2393 static FILETIME utc_base_ft
;
2394 static long double utc_base
;
2395 static int init
= 0;
2398 convert_time (FILETIME ft
)
2404 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2413 st
.wMilliseconds
= 0;
2415 SystemTimeToFileTime (&st
, &utc_base_ft
);
2416 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2417 * 4096.0L * 1024.0L * 1024.0L + utc_base_ft
.dwLowDateTime
;
2421 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2424 ret
= (long double) ft
.dwHighDateTime
2425 * 4096.0L * 1024.0L * 1024.0L + ft
.dwLowDateTime
;
2427 return (time_t) (ret
* 1e-7L);
2431 convert_from_time_t (time_t time
, FILETIME
* pft
)
2437 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2446 st
.wMilliseconds
= 0;
2448 SystemTimeToFileTime (&st
, &utc_base_ft
);
2449 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2450 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2454 /* time in 100ns units since 1-Jan-1601 */
2455 tmp
= (long double) time
* 1e7
+ utc_base
;
2456 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2457 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2461 /* No reason to keep this; faking inode values either by hashing or even
2462 using the file index from GetInformationByHandle, is not perfect and
2463 so by default Emacs doesn't use the inode values on Windows.
2464 Instead, we now determine file-truename correctly (except for
2465 possible drive aliasing etc). */
2467 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2469 hashval (const unsigned char * str
)
2474 h
= (h
<< 4) + *str
++;
2480 /* Return the hash value of the canonical pathname, excluding the
2481 drive/UNC header, to get a hopefully unique inode number. */
2483 generate_inode_val (const char * name
)
2485 char fullname
[ MAX_PATH
];
2489 /* Get the truly canonical filename, if it exists. (Note: this
2490 doesn't resolve aliasing due to subst commands, or recognise hard
2492 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2495 parse_root (fullname
, &p
);
2496 /* Normal W32 filesystems are still case insensitive. */
2503 /* MSVC stat function can't cope with UNC names and has other bugs, so
2504 replace it with our own. This also allows us to calculate consistent
2505 inode values without hacks in the main Emacs code. */
2507 stat (const char * path
, struct stat
* buf
)
2510 WIN32_FIND_DATA wfd
;
2515 int rootdir
= FALSE
;
2517 if (path
== NULL
|| buf
== NULL
)
2523 name
= (char *) map_w32_filename (path
, &path
);
2524 /* Must be valid filename, no wild cards or other invalid
2525 characters. We use _mbspbrk to support multibyte strings that
2526 might look to strpbrk as if they included literal *, ?, and other
2527 characters mentioned below that are disallowed by Windows
2529 if (_mbspbrk (name
, "*?|<>\""))
2535 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2536 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2537 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2542 /* Remove trailing directory separator, unless name is the root
2543 directory of a drive or UNC volume in which case ensure there
2544 is a trailing separator. */
2545 len
= strlen (name
);
2546 rootdir
= (path
>= name
+ len
- 1
2547 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2548 name
= strcpy (alloca (len
+ 2), name
);
2550 if (is_unc_volume (name
))
2552 DWORD attrs
= unc_volume_file_attributes (name
);
2557 memset (&wfd
, 0, sizeof (wfd
));
2558 wfd
.dwFileAttributes
= attrs
;
2559 wfd
.ftCreationTime
= utc_base_ft
;
2560 wfd
.ftLastAccessTime
= utc_base_ft
;
2561 wfd
.ftLastWriteTime
= utc_base_ft
;
2562 strcpy (wfd
.cFileName
, name
);
2566 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2567 strcat (name
, "\\");
2568 if (GetDriveType (name
) < 2)
2573 memset (&wfd
, 0, sizeof (wfd
));
2574 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2575 wfd
.ftCreationTime
= utc_base_ft
;
2576 wfd
.ftLastAccessTime
= utc_base_ft
;
2577 wfd
.ftLastWriteTime
= utc_base_ft
;
2578 strcpy (wfd
.cFileName
, name
);
2582 if (IS_DIRECTORY_SEP (name
[len
-1]))
2585 /* (This is hacky, but helps when doing file completions on
2586 network drives.) Optimize by using information available from
2587 active readdir if possible. */
2588 len
= strlen (dir_pathname
);
2589 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2591 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2592 && strnicmp (name
, dir_pathname
, len
) == 0
2593 && IS_DIRECTORY_SEP (name
[len
])
2594 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2596 /* This was the last entry returned by readdir. */
2597 wfd
= dir_find_data
;
2601 logon_network_drive (name
);
2603 fh
= FindFirstFile (name
, &wfd
);
2604 if (fh
== INVALID_HANDLE_VALUE
)
2613 if (!NILP (Vw32_get_true_file_attributes
)
2614 /* No access rights required to get info. */
2615 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
2616 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
2617 != INVALID_HANDLE_VALUE
)
2619 /* This is more accurate in terms of gettting the correct number
2620 of links, but is quite slow (it is noticeable when Emacs is
2621 making a list of file name completions). */
2622 BY_HANDLE_FILE_INFORMATION info
;
2624 if (GetFileInformationByHandle (fh
, &info
))
2626 buf
->st_nlink
= info
.nNumberOfLinks
;
2627 /* Might as well use file index to fake inode values, but this
2628 is not guaranteed to be unique unless we keep a handle open
2629 all the time (even then there are situations where it is
2630 not unique). Reputedly, there are at most 48 bits of info
2631 (on NTFS, presumably less on FAT). */
2632 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2640 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2642 buf
->st_mode
= _S_IFDIR
;
2646 switch (GetFileType (fh
))
2648 case FILE_TYPE_DISK
:
2649 buf
->st_mode
= _S_IFREG
;
2651 case FILE_TYPE_PIPE
:
2652 buf
->st_mode
= _S_IFIFO
;
2654 case FILE_TYPE_CHAR
:
2655 case FILE_TYPE_UNKNOWN
:
2657 buf
->st_mode
= _S_IFCHR
;
2664 /* Don't bother to make this information more accurate. */
2665 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
2666 _S_IFDIR
: _S_IFREG
;
2672 /* Not sure if there is any point in this. */
2673 if (!NILP (Vw32_generate_fake_inodes
))
2674 fake_inode
= generate_inode_val (name
);
2675 else if (fake_inode
== 0)
2677 /* For want of something better, try to make everything unique. */
2678 static DWORD gen_num
= 0;
2679 fake_inode
= ++gen_num
;
2683 /* MSVC defines _ino_t to be short; other libc's might not. */
2684 if (sizeof (buf
->st_ino
) == 2)
2685 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2687 buf
->st_ino
= fake_inode
;
2689 /* consider files to belong to current user */
2690 buf
->st_uid
= the_passwd
.pw_uid
;
2691 buf
->st_gid
= the_passwd
.pw_gid
;
2693 /* volume_info is set indirectly by map_w32_filename */
2694 buf
->st_dev
= volume_info
.serialnum
;
2695 buf
->st_rdev
= volume_info
.serialnum
;
2698 buf
->st_size
= wfd
.nFileSizeLow
;
2700 /* Convert timestamps to Unix format. */
2701 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2702 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2703 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2704 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2705 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2707 /* determine rwx permissions */
2708 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2709 permission
= _S_IREAD
;
2711 permission
= _S_IREAD
| _S_IWRITE
;
2713 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2714 permission
|= _S_IEXEC
;
2715 else if (is_exec (name
))
2716 permission
|= _S_IEXEC
;
2718 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2723 /* Provide fstat and utime as well as stat for consistent handling of
2726 fstat (int desc
, struct stat
* buf
)
2728 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2729 BY_HANDLE_FILE_INFORMATION info
;
2733 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2735 case FILE_TYPE_DISK
:
2736 buf
->st_mode
= _S_IFREG
;
2737 if (!GetFileInformationByHandle (fh
, &info
))
2743 case FILE_TYPE_PIPE
:
2744 buf
->st_mode
= _S_IFIFO
;
2746 case FILE_TYPE_CHAR
:
2747 case FILE_TYPE_UNKNOWN
:
2749 buf
->st_mode
= _S_IFCHR
;
2751 memset (&info
, 0, sizeof (info
));
2752 info
.dwFileAttributes
= 0;
2753 info
.ftCreationTime
= utc_base_ft
;
2754 info
.ftLastAccessTime
= utc_base_ft
;
2755 info
.ftLastWriteTime
= utc_base_ft
;
2758 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2759 buf
->st_mode
= _S_IFDIR
;
2761 buf
->st_nlink
= info
.nNumberOfLinks
;
2762 /* Might as well use file index to fake inode values, but this
2763 is not guaranteed to be unique unless we keep a handle open
2764 all the time (even then there are situations where it is
2765 not unique). Reputedly, there are at most 48 bits of info
2766 (on NTFS, presumably less on FAT). */
2767 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2769 /* MSVC defines _ino_t to be short; other libc's might not. */
2770 if (sizeof (buf
->st_ino
) == 2)
2771 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2773 buf
->st_ino
= fake_inode
;
2775 /* consider files to belong to current user */
2776 buf
->st_uid
= the_passwd
.pw_uid
;
2777 buf
->st_gid
= the_passwd
.pw_gid
;
2779 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2780 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2782 buf
->st_size
= info
.nFileSizeLow
;
2784 /* Convert timestamps to Unix format. */
2785 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2786 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2787 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2788 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2789 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2791 /* determine rwx permissions */
2792 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2793 permission
= _S_IREAD
;
2795 permission
= _S_IREAD
| _S_IWRITE
;
2797 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2798 permission
|= _S_IEXEC
;
2801 #if 0 /* no way of knowing the filename */
2802 char * p
= strrchr (name
, '.');
2804 (stricmp (p
, ".exe") == 0 ||
2805 stricmp (p
, ".com") == 0 ||
2806 stricmp (p
, ".bat") == 0 ||
2807 stricmp (p
, ".cmd") == 0))
2808 permission
|= _S_IEXEC
;
2812 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2818 utime (const char *name
, struct utimbuf
*times
)
2820 struct utimbuf deftime
;
2827 deftime
.modtime
= deftime
.actime
= time (NULL
);
2831 /* Need write access to set times. */
2832 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2833 0, OPEN_EXISTING
, 0, NULL
);
2836 convert_from_time_t (times
->actime
, &atime
);
2837 convert_from_time_t (times
->modtime
, &mtime
);
2838 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2856 /* Wrappers for winsock functions to map between our file descriptors
2857 and winsock's handles; also set h_errno for convenience.
2859 To allow Emacs to run on systems which don't have winsock support
2860 installed, we dynamically link to winsock on startup if present, and
2861 otherwise provide the minimum necessary functionality
2862 (eg. gethostname). */
2864 /* function pointers for relevant socket functions */
2865 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2866 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2867 int (PASCAL
*pfn_WSAGetLastError
) (void);
2868 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
2869 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
2870 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
2871 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2872 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2873 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2874 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2875 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2876 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2877 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2878 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2879 int (PASCAL
*pfn_WSACleanup
) (void);
2881 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2882 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2883 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2884 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2885 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2886 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2887 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
2888 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2889 const char * optval
, int optlen
);
2890 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2891 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2893 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2894 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2895 struct sockaddr
* from
, int * fromlen
);
2896 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2897 const struct sockaddr
* to
, int tolen
);
2899 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2900 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2901 #ifndef HANDLE_FLAG_INHERIT
2902 #define HANDLE_FLAG_INHERIT 1
2906 static int winsock_inuse
;
2911 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2913 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2914 after WSAStartup returns successfully, but it seems reasonable
2915 to allow unloading winsock anyway in that case. */
2916 if (pfn_WSACleanup () == 0 ||
2917 pfn_WSAGetLastError () == WSAENETDOWN
)
2919 if (FreeLibrary (winsock_lib
))
2928 init_winsock (int load_now
)
2930 WSADATA winsockData
;
2932 if (winsock_lib
!= NULL
)
2935 pfn_SetHandleInformation
= NULL
;
2936 pfn_SetHandleInformation
2937 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2938 "SetHandleInformation");
2940 winsock_lib
= LoadLibrary ("Ws2_32.dll");
2942 if (winsock_lib
!= NULL
)
2944 /* dynamically link to socket functions */
2946 #define LOAD_PROC(fn) \
2947 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2950 LOAD_PROC( WSAStartup
);
2951 LOAD_PROC( WSASetLastError
);
2952 LOAD_PROC( WSAGetLastError
);
2953 LOAD_PROC( WSAEventSelect
);
2954 LOAD_PROC( WSACreateEvent
);
2955 LOAD_PROC( WSACloseEvent
);
2956 LOAD_PROC( socket
);
2958 LOAD_PROC( connect
);
2959 LOAD_PROC( ioctlsocket
);
2962 LOAD_PROC( closesocket
);
2963 LOAD_PROC( shutdown
);
2966 LOAD_PROC( inet_addr
);
2967 LOAD_PROC( gethostname
);
2968 LOAD_PROC( gethostbyname
);
2969 LOAD_PROC( getservbyname
);
2970 LOAD_PROC( getpeername
);
2971 LOAD_PROC( WSACleanup
);
2972 LOAD_PROC( setsockopt
);
2973 LOAD_PROC( listen
);
2974 LOAD_PROC( getsockname
);
2975 LOAD_PROC( accept
);
2976 LOAD_PROC( recvfrom
);
2977 LOAD_PROC( sendto
);
2980 /* specify version 1.1 of winsock */
2981 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2983 if (winsockData
.wVersion
!= 0x101)
2988 /* Report that winsock exists and is usable, but leave
2989 socket functions disabled. I am assuming that calling
2990 WSAStartup does not require any network interaction,
2991 and in particular does not cause or require a dial-up
2992 connection to be established. */
2995 FreeLibrary (winsock_lib
);
3003 FreeLibrary (winsock_lib
);
3013 /* function to set h_errno for compatability; map winsock error codes to
3014 normal system codes where they overlap (non-overlapping definitions
3015 are already in <sys/socket.h> */
3019 if (winsock_lib
== NULL
)
3022 h_errno
= pfn_WSAGetLastError ();
3026 case WSAEACCES
: h_errno
= EACCES
; break;
3027 case WSAEBADF
: h_errno
= EBADF
; break;
3028 case WSAEFAULT
: h_errno
= EFAULT
; break;
3029 case WSAEINTR
: h_errno
= EINTR
; break;
3030 case WSAEINVAL
: h_errno
= EINVAL
; break;
3031 case WSAEMFILE
: h_errno
= EMFILE
; break;
3032 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
3033 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
3041 if (h_errno
== 0 && winsock_lib
!= NULL
)
3042 pfn_WSASetLastError (0);
3045 /* Extend strerror to handle the winsock-specific error codes. */
3049 } _wsa_errlist
[] = {
3050 WSAEINTR
, "Interrupted function call",
3051 WSAEBADF
, "Bad file descriptor",
3052 WSAEACCES
, "Permission denied",
3053 WSAEFAULT
, "Bad address",
3054 WSAEINVAL
, "Invalid argument",
3055 WSAEMFILE
, "Too many open files",
3057 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
3058 WSAEINPROGRESS
, "Operation now in progress",
3059 WSAEALREADY
, "Operation already in progress",
3060 WSAENOTSOCK
, "Socket operation on non-socket",
3061 WSAEDESTADDRREQ
, "Destination address required",
3062 WSAEMSGSIZE
, "Message too long",
3063 WSAEPROTOTYPE
, "Protocol wrong type for socket",
3064 WSAENOPROTOOPT
, "Bad protocol option",
3065 WSAEPROTONOSUPPORT
, "Protocol not supported",
3066 WSAESOCKTNOSUPPORT
, "Socket type not supported",
3067 WSAEOPNOTSUPP
, "Operation not supported",
3068 WSAEPFNOSUPPORT
, "Protocol family not supported",
3069 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
3070 WSAEADDRINUSE
, "Address already in use",
3071 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
3072 WSAENETDOWN
, "Network is down",
3073 WSAENETUNREACH
, "Network is unreachable",
3074 WSAENETRESET
, "Network dropped connection on reset",
3075 WSAECONNABORTED
, "Software caused connection abort",
3076 WSAECONNRESET
, "Connection reset by peer",
3077 WSAENOBUFS
, "No buffer space available",
3078 WSAEISCONN
, "Socket is already connected",
3079 WSAENOTCONN
, "Socket is not connected",
3080 WSAESHUTDOWN
, "Cannot send after socket shutdown",
3081 WSAETOOMANYREFS
, "Too many references", /* not sure */
3082 WSAETIMEDOUT
, "Connection timed out",
3083 WSAECONNREFUSED
, "Connection refused",
3084 WSAELOOP
, "Network loop", /* not sure */
3085 WSAENAMETOOLONG
, "Name is too long",
3086 WSAEHOSTDOWN
, "Host is down",
3087 WSAEHOSTUNREACH
, "No route to host",
3088 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
3089 WSAEPROCLIM
, "Too many processes",
3090 WSAEUSERS
, "Too many users", /* not sure */
3091 WSAEDQUOT
, "Double quote in host name", /* really not sure */
3092 WSAESTALE
, "Data is stale", /* not sure */
3093 WSAEREMOTE
, "Remote error", /* not sure */
3095 WSASYSNOTREADY
, "Network subsystem is unavailable",
3096 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
3097 WSANOTINITIALISED
, "Winsock not initialized successfully",
3098 WSAEDISCON
, "Graceful shutdown in progress",
3100 WSAENOMORE
, "No more operations allowed", /* not sure */
3101 WSAECANCELLED
, "Operation cancelled", /* not sure */
3102 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
3103 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
3104 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
3105 WSASYSCALLFAILURE
, "System call failure",
3106 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
3107 WSATYPE_NOT_FOUND
, "Class type not found",
3108 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
3109 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
3110 WSAEREFUSED
, "Operation refused", /* not sure */
3113 WSAHOST_NOT_FOUND
, "Host not found",
3114 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
3115 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
3116 WSANO_DATA
, "Valid name, no data record of requested type",
3122 sys_strerror(int error_no
)
3125 static char unknown_msg
[40];
3127 if (error_no
>= 0 && error_no
< sys_nerr
)
3128 return sys_errlist
[error_no
];
3130 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
3131 if (_wsa_errlist
[i
].errnum
== error_no
)
3132 return _wsa_errlist
[i
].msg
;
3134 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
3138 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3139 but I believe the method of keeping the socket handle separate (and
3140 insuring it is not inheritable) is the correct one. */
3142 //#define SOCK_REPLACE_HANDLE
3144 #ifdef SOCK_REPLACE_HANDLE
3145 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3147 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3150 int socket_to_fd (SOCKET s
);
3153 sys_socket(int af
, int type
, int protocol
)
3157 if (winsock_lib
== NULL
)
3160 return INVALID_SOCKET
;
3165 /* call the real socket function */
3166 s
= pfn_socket (af
, type
, protocol
);
3168 if (s
!= INVALID_SOCKET
)
3169 return socket_to_fd (s
);
3175 /* Convert a SOCKET to a file descriptor. */
3177 socket_to_fd (SOCKET s
)
3182 /* Although under NT 3.5 _open_osfhandle will accept a socket
3183 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3184 that does not work under NT 3.1. However, we can get the same
3185 effect by using a backdoor function to replace an existing
3186 descriptor handle with the one we want. */
3188 /* allocate a file descriptor (with appropriate flags) */
3189 fd
= _open ("NUL:", _O_RDWR
);
3192 #ifdef SOCK_REPLACE_HANDLE
3193 /* now replace handle to NUL with our socket handle */
3194 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
3196 _set_osfhnd (fd
, s
);
3197 /* setmode (fd, _O_BINARY); */
3199 /* Make a non-inheritable copy of the socket handle. Note
3200 that it is possible that sockets aren't actually kernel
3201 handles, which appears to be the case on Windows 9x when
3202 the MS Proxy winsock client is installed. */
3204 /* Apparently there is a bug in NT 3.51 with some service
3205 packs, which prevents using DuplicateHandle to make a
3206 socket handle non-inheritable (causes WSACleanup to
3207 hang). The work-around is to use SetHandleInformation
3208 instead if it is available and implemented. */
3209 if (pfn_SetHandleInformation
)
3211 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
3215 HANDLE parent
= GetCurrentProcess ();
3216 HANDLE new_s
= INVALID_HANDLE_VALUE
;
3218 if (DuplicateHandle (parent
,
3224 DUPLICATE_SAME_ACCESS
))
3226 /* It is possible that DuplicateHandle succeeds even
3227 though the socket wasn't really a kernel handle,
3228 because a real handle has the same value. So
3229 test whether the new handle really is a socket. */
3230 long nonblocking
= 0;
3231 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
3233 pfn_closesocket (s
);
3238 CloseHandle (new_s
);
3243 fd_info
[fd
].hnd
= (HANDLE
) s
;
3246 /* set our own internal flags */
3247 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
3253 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3255 /* attach child_process to fd_info */
3256 if (fd_info
[ fd
].cp
!= NULL
)
3258 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
3262 fd_info
[ fd
].cp
= cp
;
3265 winsock_inuse
++; /* count open sockets */
3272 pfn_closesocket (s
);
3279 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
3281 if (winsock_lib
== NULL
)
3284 return SOCKET_ERROR
;
3288 if (fd_info
[s
].flags
& FILE_SOCKET
)
3290 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
3291 if (rc
== SOCKET_ERROR
)
3296 return SOCKET_ERROR
;
3301 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
3303 if (winsock_lib
== NULL
)
3306 return SOCKET_ERROR
;
3310 if (fd_info
[s
].flags
& FILE_SOCKET
)
3312 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
3313 if (rc
== SOCKET_ERROR
)
3318 return SOCKET_ERROR
;
3322 sys_htons (u_short hostshort
)
3324 return (winsock_lib
!= NULL
) ?
3325 pfn_htons (hostshort
) : hostshort
;
3329 sys_ntohs (u_short netshort
)
3331 return (winsock_lib
!= NULL
) ?
3332 pfn_ntohs (netshort
) : netshort
;
3336 sys_inet_addr (const char * cp
)
3338 return (winsock_lib
!= NULL
) ?
3339 pfn_inet_addr (cp
) : INADDR_NONE
;
3343 sys_gethostname (char * name
, int namelen
)
3345 if (winsock_lib
!= NULL
)
3346 return pfn_gethostname (name
, namelen
);
3348 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
3349 return !GetComputerName (name
, (DWORD
*)&namelen
);
3352 return SOCKET_ERROR
;
3356 sys_gethostbyname(const char * name
)
3358 struct hostent
* host
;
3360 if (winsock_lib
== NULL
)
3367 host
= pfn_gethostbyname (name
);
3374 sys_getservbyname(const char * name
, const char * proto
)
3376 struct servent
* serv
;
3378 if (winsock_lib
== NULL
)
3385 serv
= pfn_getservbyname (name
, proto
);
3392 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
3394 if (winsock_lib
== NULL
)
3397 return SOCKET_ERROR
;
3401 if (fd_info
[s
].flags
& FILE_SOCKET
)
3403 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
3404 if (rc
== SOCKET_ERROR
)
3409 return SOCKET_ERROR
;
3414 sys_shutdown (int s
, int how
)
3416 if (winsock_lib
== NULL
)
3419 return SOCKET_ERROR
;
3423 if (fd_info
[s
].flags
& FILE_SOCKET
)
3425 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
3426 if (rc
== SOCKET_ERROR
)
3431 return SOCKET_ERROR
;
3435 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
3437 if (winsock_lib
== NULL
)
3440 return SOCKET_ERROR
;
3444 if (fd_info
[s
].flags
& FILE_SOCKET
)
3446 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
3447 (const char *)optval
, optlen
);
3448 if (rc
== SOCKET_ERROR
)
3453 return SOCKET_ERROR
;
3457 sys_listen (int s
, int backlog
)
3459 if (winsock_lib
== NULL
)
3462 return SOCKET_ERROR
;
3466 if (fd_info
[s
].flags
& FILE_SOCKET
)
3468 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
3469 if (rc
== SOCKET_ERROR
)
3472 fd_info
[s
].flags
|= FILE_LISTEN
;
3476 return SOCKET_ERROR
;
3480 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
3482 if (winsock_lib
== NULL
)
3485 return SOCKET_ERROR
;
3489 if (fd_info
[s
].flags
& FILE_SOCKET
)
3491 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3492 if (rc
== SOCKET_ERROR
)
3497 return SOCKET_ERROR
;
3501 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3503 if (winsock_lib
== NULL
)
3510 if (fd_info
[s
].flags
& FILE_LISTEN
)
3512 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3514 if (t
== INVALID_SOCKET
)
3517 fd
= socket_to_fd (t
);
3519 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3520 ResetEvent (fd_info
[s
].cp
->char_avail
);
3528 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3529 struct sockaddr
* from
, int * fromlen
)
3531 if (winsock_lib
== NULL
)
3534 return SOCKET_ERROR
;
3538 if (fd_info
[s
].flags
& FILE_SOCKET
)
3540 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3541 if (rc
== SOCKET_ERROR
)
3546 return SOCKET_ERROR
;
3550 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3551 const struct sockaddr
* to
, int tolen
)
3553 if (winsock_lib
== NULL
)
3556 return SOCKET_ERROR
;
3560 if (fd_info
[s
].flags
& FILE_SOCKET
)
3562 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3563 if (rc
== SOCKET_ERROR
)
3568 return SOCKET_ERROR
;
3571 /* Windows does not have an fcntl function. Provide an implementation
3572 solely for making sockets non-blocking. */
3574 fcntl (int s
, int cmd
, int options
)
3576 if (winsock_lib
== NULL
)
3583 if (fd_info
[s
].flags
& FILE_SOCKET
)
3585 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
3587 unsigned long nblock
= 1;
3588 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
3589 if (rc
== SOCKET_ERROR
)
3591 /* Keep track of the fact that we set this to non-blocking. */
3592 fd_info
[s
].flags
|= FILE_NDELAY
;
3598 return SOCKET_ERROR
;
3602 return SOCKET_ERROR
;
3605 #endif /* HAVE_SOCKETS */
3608 /* Shadow main io functions: we need to handle pipes and sockets more
3609 intelligently, and implement non-blocking mode as well. */
3622 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
3624 child_process
* cp
= fd_info
[fd
].cp
;
3626 fd_info
[fd
].cp
= NULL
;
3628 if (CHILD_ACTIVE (cp
))
3630 /* if last descriptor to active child_process then cleanup */
3632 for (i
= 0; i
< MAXDESC
; i
++)
3636 if (fd_info
[i
].cp
== cp
)
3642 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3644 #ifndef SOCK_REPLACE_HANDLE
3645 if (winsock_lib
== NULL
) abort ();
3647 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3648 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3650 winsock_inuse
--; /* count open sockets */
3658 /* Note that sockets do not need special treatment here (at least on
3659 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3660 closesocket is equivalent to CloseHandle, which is to be expected
3661 because socket handles are fully fledged kernel handles. */
3664 if (rc
== 0 && fd
< MAXDESC
)
3665 fd_info
[fd
].flags
= 0;
3676 if (new_fd
>= 0 && new_fd
< MAXDESC
)
3678 /* duplicate our internal info as well */
3679 fd_info
[new_fd
] = fd_info
[fd
];
3686 sys_dup2 (int src
, int dst
)
3690 if (dst
< 0 || dst
>= MAXDESC
)
3696 /* make sure we close the destination first if it's a pipe or socket */
3697 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3700 rc
= _dup2 (src
, dst
);
3703 /* duplicate our internal info as well */
3704 fd_info
[dst
] = fd_info
[src
];
3709 /* Unix pipe() has only one arg */
3711 sys_pipe (int * phandles
)
3716 /* make pipe handles non-inheritable; when we spawn a child, we
3717 replace the relevant handle with an inheritable one. Also put
3718 pipes into binary mode; we will do text mode translation ourselves
3720 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3724 /* Protect against overflow, since Windows can open more handles than
3725 our fd_info array has room for. */
3726 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
3728 _close (phandles
[0]);
3729 _close (phandles
[1]);
3734 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3735 fd_info
[phandles
[0]].flags
= flags
;
3737 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3738 fd_info
[phandles
[1]].flags
= flags
;
3746 extern int w32_pipe_read_delay
;
3748 /* Function to do blocking read of one byte, needed to implement
3749 select. It is only allowed on sockets and pipes. */
3751 _sys_read_ahead (int fd
)
3756 if (fd
< 0 || fd
>= MAXDESC
)
3757 return STATUS_READ_ERROR
;
3759 cp
= fd_info
[fd
].cp
;
3761 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3762 return STATUS_READ_ERROR
;
3764 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3765 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3767 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3771 cp
->status
= STATUS_READ_IN_PROGRESS
;
3773 if (fd_info
[fd
].flags
& FILE_PIPE
)
3775 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3777 /* Give subprocess time to buffer some more output for us before
3778 reporting that input is available; we need this because Windows 95
3779 connects DOS programs to pipes by making the pipe appear to be
3780 the normal console stdout - as a result most DOS programs will
3781 write to stdout without buffering, ie. one character at a
3782 time. Even some W32 programs do this - "dir" in a command
3783 shell on NT is very slow if we don't do this. */
3786 int wait
= w32_pipe_read_delay
;
3792 /* Yield remainder of our time slice, effectively giving a
3793 temporary priority boost to the child process. */
3798 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3800 unsigned long nblock
= 0;
3801 /* We always want this to block, so temporarily disable NDELAY. */
3802 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3803 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3805 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3807 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3810 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3815 if (rc
== sizeof (char))
3816 cp
->status
= STATUS_READ_SUCCEEDED
;
3818 cp
->status
= STATUS_READ_FAILED
;
3824 _sys_wait_accept (int fd
)
3830 if (fd
< 0 || fd
>= MAXDESC
)
3831 return STATUS_READ_ERROR
;
3833 cp
= fd_info
[fd
].cp
;
3835 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3836 return STATUS_READ_ERROR
;
3838 cp
->status
= STATUS_READ_FAILED
;
3840 hEv
= pfn_WSACreateEvent ();
3841 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
3842 if (rc
!= SOCKET_ERROR
)
3844 rc
= WaitForSingleObject (hEv
, INFINITE
);
3845 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
3846 if (rc
== WAIT_OBJECT_0
)
3847 cp
->status
= STATUS_READ_SUCCEEDED
;
3849 pfn_WSACloseEvent (hEv
);
3855 sys_read (int fd
, char * buffer
, unsigned int count
)
3860 char * orig_buffer
= buffer
;
3868 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3870 child_process
*cp
= fd_info
[fd
].cp
;
3872 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3880 /* re-read CR carried over from last read */
3881 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3883 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3887 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3890 /* presence of a child_process structure means we are operating in
3891 non-blocking mode - otherwise we just call _read directly.
3892 Note that the child_process structure might be missing because
3893 reap_subprocess has been called; in this case the pipe is
3894 already broken, so calling _read on it is okay. */
3897 int current_status
= cp
->status
;
3899 switch (current_status
)
3901 case STATUS_READ_FAILED
:
3902 case STATUS_READ_ERROR
:
3903 /* report normal EOF if nothing in buffer */
3905 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3908 case STATUS_READ_READY
:
3909 case STATUS_READ_IN_PROGRESS
:
3910 DebPrint (("sys_read called when read is in progress\n"));
3911 errno
= EWOULDBLOCK
;
3914 case STATUS_READ_SUCCEEDED
:
3915 /* consume read-ahead char */
3916 *buffer
++ = cp
->chr
;
3919 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3920 ResetEvent (cp
->char_avail
);
3922 case STATUS_READ_ACKNOWLEDGED
:
3926 DebPrint (("sys_read: bad status %d\n", current_status
));
3931 if (fd_info
[fd
].flags
& FILE_PIPE
)
3933 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3934 to_read
= min (waiting
, (DWORD
) count
);
3937 nchars
+= _read (fd
, buffer
, to_read
);
3940 else /* FILE_SOCKET */
3942 if (winsock_lib
== NULL
) abort ();
3944 /* do the equivalent of a non-blocking read */
3945 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3946 if (waiting
== 0 && nchars
== 0)
3948 h_errno
= errno
= EWOULDBLOCK
;
3954 /* always use binary mode for sockets */
3955 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3956 if (res
== SOCKET_ERROR
)
3958 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3959 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3970 int nread
= _read (fd
, buffer
, count
);
3973 else if (nchars
== 0)
3978 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3979 /* Perform text mode translation if required. */
3980 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3982 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3983 /* If buffer contains only CR, return that. To be absolutely
3984 sure we should attempt to read the next char, but in
3985 practice a CR to be followed by LF would not appear by
3986 itself in the buffer. */
3987 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3989 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3995 nchars
= _read (fd
, buffer
, count
);
4000 /* For now, don't bother with a non-blocking mode */
4002 sys_write (int fd
, const void * buffer
, unsigned int count
)
4012 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
4014 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
4020 /* Perform text mode translation if required. */
4021 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
4023 char * tmpbuf
= alloca (count
* 2);
4024 unsigned char * src
= (void *)buffer
;
4025 unsigned char * dst
= tmpbuf
;
4030 unsigned char *next
;
4031 /* copy next line or remaining bytes */
4032 next
= _memccpy (dst
, src
, '\n', nbytes
);
4035 /* copied one line ending with '\n' */
4036 int copied
= next
- dst
;
4039 /* insert '\r' before '\n' */
4046 /* copied remaining partial line -> now finished */
4054 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
4056 unsigned long nblock
= 0;
4057 if (winsock_lib
== NULL
) abort ();
4059 /* TODO: implement select() properly so non-blocking I/O works. */
4060 /* For now, make sure the write blocks. */
4061 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4062 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4064 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
4066 /* Set the socket back to non-blocking if it was before,
4067 for other operations that support it. */
4068 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4071 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4074 if (nchars
== SOCKET_ERROR
)
4076 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
4077 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
4083 nchars
= _write (fd
, buffer
, count
);
4089 check_windows_init_file ()
4091 extern int noninteractive
, inhibit_window_system
;
4093 /* A common indication that Emacs is not installed properly is when
4094 it cannot find the Windows installation file. If this file does
4095 not exist in the expected place, tell the user. */
4097 if (!noninteractive
&& !inhibit_window_system
)
4099 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
4100 Lisp_Object objs
[2];
4101 Lisp_Object full_load_path
;
4102 Lisp_Object init_file
;
4105 objs
[0] = Vload_path
;
4106 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
4107 full_load_path
= Fappend (2, objs
);
4108 init_file
= build_string ("term/w32-win");
4109 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
4112 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
4113 char *init_file_name
= SDATA (init_file
);
4114 char *load_path
= SDATA (load_path_print
);
4115 char *buffer
= alloca (1024
4116 + strlen (init_file_name
)
4117 + strlen (load_path
));
4120 "The Emacs Windows initialization file \"%s.el\" "
4121 "could not be found in your Emacs installation. "
4122 "Emacs checked the following directories for this file:\n"
4124 "When Emacs cannot find this file, it usually means that it "
4125 "was not installed properly, or its distribution file was "
4126 "not unpacked properly.\nSee the README.W32 file in the "
4127 "top-level Emacs directory for more information.",
4128 init_file_name
, load_path
);
4131 "Emacs Abort Dialog",
4132 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
4133 /* Use the low-level Emacs abort. */
4148 /* shutdown the socket interface if necessary */
4159 /* Initialise the socket interface now if available and requested by
4160 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4161 delayed until open-network-stream is called (w32-has-winsock can
4162 also be used to dynamically load or reload winsock).
4164 Conveniently, init_environment is called before us, so
4165 PRELOAD_WINSOCK can be set in the registry. */
4167 /* Always initialize this correctly. */
4170 if (getenv ("PRELOAD_WINSOCK") != NULL
)
4171 init_winsock (TRUE
);
4174 /* Initial preparation for subprocess support: replace our standard
4175 handles with non-inheritable versions. */
4178 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
4179 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
4180 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
4182 parent
= GetCurrentProcess ();
4184 /* ignore errors when duplicating and closing; typically the
4185 handles will be invalid when running as a gui program. */
4186 DuplicateHandle (parent
,
4187 GetStdHandle (STD_INPUT_HANDLE
),
4192 DUPLICATE_SAME_ACCESS
);
4194 DuplicateHandle (parent
,
4195 GetStdHandle (STD_OUTPUT_HANDLE
),
4200 DUPLICATE_SAME_ACCESS
);
4202 DuplicateHandle (parent
,
4203 GetStdHandle (STD_ERROR_HANDLE
),
4208 DUPLICATE_SAME_ACCESS
);
4214 if (stdin_save
!= INVALID_HANDLE_VALUE
)
4215 _open_osfhandle ((long) stdin_save
, O_TEXT
);
4217 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
4220 if (stdout_save
!= INVALID_HANDLE_VALUE
)
4221 _open_osfhandle ((long) stdout_save
, O_TEXT
);
4223 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4226 if (stderr_save
!= INVALID_HANDLE_VALUE
)
4227 _open_osfhandle ((long) stderr_save
, O_TEXT
);
4229 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4233 /* unfortunately, atexit depends on implementation of malloc */
4234 /* atexit (term_ntproc); */
4235 signal (SIGABRT
, term_ntproc
);
4237 /* determine which drives are fixed, for GetCachedVolumeInformation */
4239 /* GetDriveType must have trailing backslash. */
4240 char drive
[] = "A:\\";
4242 /* Loop over all possible drive letters */
4243 while (*drive
<= 'Z')
4245 /* Record if this drive letter refers to a fixed drive. */
4246 fixed_drives
[DRIVE_INDEX (*drive
)] =
4247 (GetDriveType (drive
) == DRIVE_FIXED
);
4252 /* Reset the volume info cache. */
4253 volume_cache
= NULL
;
4256 /* Check to see if Emacs has been installed correctly. */
4257 check_windows_init_file ();
4261 shutdown_handler ensures that buffers' autosave files are
4262 up to date when the user logs off, or the system shuts down.
4264 BOOL WINAPI
shutdown_handler(DWORD type
)
4266 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4267 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
4268 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
4269 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
4271 /* Shut down cleanly, making sure autosave files are up to date. */
4272 shut_down_emacs (0, 0, Qnil
);
4275 /* Allow other handlers to handle this signal. */
4280 globals_of_w32 is used to initialize those global variables that
4281 must always be initialized on startup even when the global variable
4282 initialized is non zero (see the function main in emacs.c).
4287 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
4289 get_process_times_fn
= (GetProcessTimes_Proc
)
4290 GetProcAddress (kernel32
, "GetProcessTimes");
4292 g_b_init_is_windows_9x
= 0;
4293 g_b_init_open_process_token
= 0;
4294 g_b_init_get_token_information
= 0;
4295 g_b_init_lookup_account_sid
= 0;
4296 g_b_init_get_sid_identifier_authority
= 0;
4297 /* The following sets a handler for shutdown notifications for
4298 console apps. This actually applies to Emacs in both console and
4299 GUI modes, since we had to fool windows into thinking emacs is a
4300 console application to get console mode to work. */
4301 SetConsoleCtrlHandler(shutdown_handler
, TRUE
);
4306 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4307 (do not change this comment) */