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
;
116 /* Initialization states.
118 WARNING: If you add any more such variables for additional APIs,
119 you MUST add initialization for them to globals_of_w32
120 below. This is because these variables might get set
121 to non-NULL values during dumping, but the dumped Emacs
122 cannot reuse those values, because it could be run on a
123 different version of the OS, where API addresses are
125 static BOOL g_b_init_is_windows_9x
;
126 static BOOL g_b_init_open_process_token
;
127 static BOOL g_b_init_get_token_information
;
128 static BOOL g_b_init_lookup_account_sid
;
129 static BOOL g_b_init_get_sid_identifier_authority
;
130 static BOOL g_b_init_get_sid_sub_authority
;
131 static BOOL g_b_init_get_sid_sub_authority_count
;
134 BEGIN: Wrapper functions around OpenProcessToken
135 and other functions in advapi32.dll that are only
136 supported in Windows NT / 2k / XP
138 /* ** Function pointer typedefs ** */
139 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
140 HANDLE ProcessHandle
,
142 PHANDLE TokenHandle
);
143 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
145 TOKEN_INFORMATION_CLASS TokenInformationClass
,
146 LPVOID TokenInformation
,
147 DWORD TokenInformationLength
,
148 PDWORD ReturnLength
);
149 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
150 HANDLE process_handle
,
151 LPFILETIME creation_time
,
152 LPFILETIME exit_time
,
153 LPFILETIME kernel_time
,
154 LPFILETIME user_time
);
156 GetProcessTimes_Proc get_process_times_fn
= NULL
;
159 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
161 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
163 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
164 LPCTSTR lpSystemName
,
169 LPDWORD cbDomainName
,
170 PSID_NAME_USE peUse
);
171 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI
* GetSidIdentifierAuthority_Proc
) (
173 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
176 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
180 /* ** A utility function ** */
184 static BOOL s_b_ret
=0;
185 OSVERSIONINFO os_ver
;
186 if (g_b_init_is_windows_9x
== 0)
188 g_b_init_is_windows_9x
= 1;
189 ZeroMemory(&os_ver
, sizeof(OSVERSIONINFO
));
190 os_ver
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
191 if (GetVersionEx (&os_ver
))
193 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
199 /* Get total user and system times for get-internal-run-time.
200 Returns a list of three integers if the times are provided by the OS
201 (NT derivatives), otherwise it returns the result of current-time. */
203 w32_get_internal_run_time ()
205 if (get_process_times_fn
)
207 FILETIME create
, exit
, kernel
, user
;
208 HANDLE proc
= GetCurrentProcess();
209 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
211 LARGE_INTEGER user_int
, kernel_int
, total
;
213 user_int
.LowPart
= user
.dwLowDateTime
;
214 user_int
.HighPart
= user
.dwHighDateTime
;
215 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
216 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
217 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
218 /* FILETIME is 100 nanosecond increments, Emacs only wants
219 microsecond resolution. */
220 total
.QuadPart
/= 10;
221 microseconds
= total
.QuadPart
% 1000000;
222 total
.QuadPart
/= 1000000;
224 /* Sanity check to make sure we can represent the result. */
225 if (total
.HighPart
== 0)
227 int secs
= total
.LowPart
;
229 return list3 (make_number ((secs
>> 16) & 0xffff),
230 make_number (secs
& 0xffff),
231 make_number (microseconds
));
236 return Fcurrent_time ();
239 /* ** The wrapper functions ** */
241 BOOL WINAPI
open_process_token (
242 HANDLE ProcessHandle
,
246 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
247 HMODULE hm_advapi32
= NULL
;
248 if (is_windows_9x () == TRUE
)
252 if (g_b_init_open_process_token
== 0)
254 g_b_init_open_process_token
= 1;
255 hm_advapi32
= LoadLibrary ("Advapi32.dll");
256 s_pfn_Open_Process_Token
=
257 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
259 if (s_pfn_Open_Process_Token
== NULL
)
264 s_pfn_Open_Process_Token (
271 BOOL WINAPI
get_token_information (
273 TOKEN_INFORMATION_CLASS TokenInformationClass
,
274 LPVOID TokenInformation
,
275 DWORD TokenInformationLength
,
278 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
279 HMODULE hm_advapi32
= NULL
;
280 if (is_windows_9x () == TRUE
)
284 if (g_b_init_get_token_information
== 0)
286 g_b_init_get_token_information
= 1;
287 hm_advapi32
= LoadLibrary ("Advapi32.dll");
288 s_pfn_Get_Token_Information
=
289 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
291 if (s_pfn_Get_Token_Information
== NULL
)
296 s_pfn_Get_Token_Information (
298 TokenInformationClass
,
300 TokenInformationLength
,
305 BOOL WINAPI
lookup_account_sid (
306 LPCTSTR lpSystemName
,
311 LPDWORD cbDomainName
,
314 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
315 HMODULE hm_advapi32
= NULL
;
316 if (is_windows_9x () == TRUE
)
320 if (g_b_init_lookup_account_sid
== 0)
322 g_b_init_lookup_account_sid
= 1;
323 hm_advapi32
= LoadLibrary ("Advapi32.dll");
324 s_pfn_Lookup_Account_Sid
=
325 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
327 if (s_pfn_Lookup_Account_Sid
== NULL
)
332 s_pfn_Lookup_Account_Sid (
343 PSID_IDENTIFIER_AUTHORITY WINAPI
get_sid_identifier_authority (
346 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority
= NULL
;
347 HMODULE hm_advapi32
= NULL
;
348 if (is_windows_9x () == TRUE
)
352 if (g_b_init_get_sid_identifier_authority
== 0)
354 g_b_init_get_sid_identifier_authority
= 1;
355 hm_advapi32
= LoadLibrary ("Advapi32.dll");
356 s_pfn_Get_Sid_Identifier_Authority
=
357 (GetSidIdentifierAuthority_Proc
) GetProcAddress (
358 hm_advapi32
, "GetSidIdentifierAuthority");
360 if (s_pfn_Get_Sid_Identifier_Authority
== NULL
)
364 return (s_pfn_Get_Sid_Identifier_Authority (pSid
));
367 PDWORD WINAPI
get_sid_sub_authority (
371 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
372 static DWORD zero
= 0U;
373 HMODULE hm_advapi32
= NULL
;
374 if (is_windows_9x () == TRUE
)
378 if (g_b_init_get_sid_sub_authority
== 0)
380 g_b_init_get_sid_sub_authority
= 1;
381 hm_advapi32
= LoadLibrary ("Advapi32.dll");
382 s_pfn_Get_Sid_Sub_Authority
=
383 (GetSidSubAuthority_Proc
) GetProcAddress (
384 hm_advapi32
, "GetSidSubAuthority");
386 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
390 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
393 PUCHAR WINAPI
get_sid_sub_authority_count (
396 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
397 static UCHAR zero
= 0U;
398 HMODULE hm_advapi32
= NULL
;
399 if (is_windows_9x () == TRUE
)
403 if (g_b_init_get_sid_sub_authority_count
== 0)
405 g_b_init_get_sid_sub_authority_count
= 1;
406 hm_advapi32
= LoadLibrary ("Advapi32.dll");
407 s_pfn_Get_Sid_Sub_Authority_Count
=
408 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
409 hm_advapi32
, "GetSidSubAuthorityCount");
411 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
415 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
419 END: Wrapper functions around OpenProcessToken
420 and other functions in advapi32.dll that are only
421 supported in Windows NT / 2k / XP
425 /* Equivalent of strerror for W32 error codes. */
427 w32_strerror (int error_no
)
429 static char buf
[500];
432 error_no
= GetLastError ();
435 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
437 0, /* choose most suitable language */
438 buf
, sizeof (buf
), NULL
))
439 sprintf (buf
, "w32 error %u", error_no
);
443 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
444 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
446 This is called from alloc.c:valid_pointer_p. */
448 w32_valid_pointer_p (void *p
, int size
)
451 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
455 unsigned char *buf
= alloca (size
);
456 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
465 static char startup_dir
[MAXPATHLEN
];
467 /* Get the current working directory. */
472 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
476 /* Emacs doesn't actually change directory itself, and we want to
477 force our real wd to be where emacs.exe is to avoid unnecessary
478 conflicts when trying to rename or delete directories. */
479 strcpy (dir
, startup_dir
);
485 /* Emulate gethostname. */
487 gethostname (char *buffer
, int size
)
489 /* NT only allows small host names, so the buffer is
490 certainly large enough. */
491 return !GetComputerName (buffer
, &size
);
493 #endif /* HAVE_SOCKETS */
495 /* Emulate getloadavg. */
497 getloadavg (double loadavg
[], int nelem
)
501 /* A faithful emulation is going to have to be saved for a rainy day. */
502 for (i
= 0; i
< nelem
; i
++)
509 /* Emulate getpwuid, getpwnam and others. */
511 #define PASSWD_FIELD_SIZE 256
513 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
514 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
515 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
516 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
517 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
519 static struct passwd the_passwd
=
531 static struct group the_group
=
533 /* There are no groups on NT, so we just return "root" as the
541 return the_passwd
.pw_uid
;
547 /* I could imagine arguing for checking to see whether the user is
548 in the Administrators group and returning a UID of 0 for that
549 case, but I don't know how wise that would be in the long run. */
556 return the_passwd
.pw_gid
;
568 if (uid
== the_passwd
.pw_uid
)
580 getpwnam (char *name
)
584 pw
= getpwuid (getuid ());
588 if (stricmp (name
, pw
->pw_name
))
597 /* Find the user's real name by opening the process token and
598 looking up the name associated with the user-sid in that token.
600 Use the relative portion of the identifier authority value from
601 the user-sid as the user id value (same for group id using the
602 primary group sid from the process token). */
604 char name
[UNLEN
+1], domain
[1025];
605 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
607 SID_NAME_USE user_type
;
608 unsigned char buf
[1024];
609 TOKEN_USER user_token
;
610 TOKEN_PRIMARY_GROUP group_token
;
612 if (open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
)
613 && get_token_information (token
, TokenUser
,
614 (PVOID
)buf
, sizeof (buf
), &trash
)
615 && (memcpy (&user_token
, buf
, sizeof (user_token
)),
616 lookup_account_sid (NULL
, user_token
.User
.Sid
, name
, &length
,
617 domain
, &dlength
, &user_type
)))
619 strcpy (the_passwd
.pw_name
, name
);
620 /* Determine a reasonable uid value. */
621 if (stricmp ("administrator", name
) == 0)
623 the_passwd
.pw_uid
= 500; /* well-known Administrator uid */
624 the_passwd
.pw_gid
= 513; /* well-known None gid */
628 /* Use the last sub-authority value of the RID, the relative
629 portion of the SID, as user/group ID. */
630 DWORD n_subauthorities
=
631 *get_sid_sub_authority_count (user_token
.User
.Sid
);
633 if (n_subauthorities
< 1)
634 the_passwd
.pw_uid
= 0; /* the "World" RID */
638 *get_sid_sub_authority (user_token
.User
.Sid
,
639 n_subauthorities
- 1);
643 if (get_token_information (token
, TokenPrimaryGroup
,
644 (PVOID
)buf
, sizeof (buf
), &trash
))
646 memcpy (&group_token
, buf
, sizeof (group_token
));
648 *get_sid_sub_authority_count (group_token
.PrimaryGroup
);
650 if (n_subauthorities
< 1)
651 the_passwd
.pw_gid
= 0; /* the "World" RID */
655 *get_sid_sub_authority (group_token
.PrimaryGroup
,
656 n_subauthorities
- 1);
660 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
663 /* If security calls are not supported (presumably because we
664 are running under Windows 95), fallback to this. */
665 else if (GetUserName (name
, &length
))
667 strcpy (the_passwd
.pw_name
, name
);
668 if (stricmp ("administrator", name
) == 0)
669 the_passwd
.pw_uid
= 0;
671 the_passwd
.pw_uid
= 123;
672 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
676 strcpy (the_passwd
.pw_name
, "unknown");
677 the_passwd
.pw_uid
= 123;
678 the_passwd
.pw_gid
= 123;
681 /* Ensure HOME and SHELL are defined. */
682 if (getenv ("HOME") == NULL
)
684 if (getenv ("SHELL") == NULL
)
687 /* Set dir and shell from environment variables. */
688 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
689 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
698 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
699 return ((rand () << 15) | rand ());
709 /* Normalize filename by converting all path separators to
710 the specified separator. Also conditionally convert upper
711 case path name components to lower case. */
714 normalize_filename (fp
, path_sep
)
721 /* Always lower-case drive letters a-z, even if the filesystem
722 preserves case in filenames.
723 This is so filenames can be compared by string comparison
724 functions that are case-sensitive. Even case-preserving filesystems
725 do not distinguish case in drive letters. */
726 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
732 if (NILP (Vw32_downcase_file_names
))
736 if (*fp
== '/' || *fp
== '\\')
743 sep
= path_sep
; /* convert to this path separator */
744 elem
= fp
; /* start of current path element */
747 if (*fp
>= 'a' && *fp
<= 'z')
748 elem
= 0; /* don't convert this element */
750 if (*fp
== 0 || *fp
== ':')
752 sep
= *fp
; /* restore current separator (or 0) */
753 *fp
= '/'; /* after conversion of this element */
756 if (*fp
== '/' || *fp
== '\\')
758 if (elem
&& elem
!= fp
)
760 *fp
= 0; /* temporary end of string */
761 _strlwr (elem
); /* while we convert to lower case */
763 *fp
= sep
; /* convert (or restore) path separator */
764 elem
= fp
+ 1; /* next element starts after separator */
770 /* Destructively turn backslashes into slashes. */
772 dostounix_filename (p
)
775 normalize_filename (p
, '/');
778 /* Destructively turn slashes into backslashes. */
780 unixtodos_filename (p
)
783 normalize_filename (p
, '\\');
786 /* Remove all CR's that are followed by a LF.
787 (From msdos.c...probably should figure out a way to share it,
788 although this code isn't going to ever change.) */
792 register unsigned char *buf
;
794 unsigned char *np
= buf
;
795 unsigned char *startp
= buf
;
796 unsigned char *endp
= buf
+ n
;
800 while (buf
< endp
- 1)
804 if (*(++buf
) != 0x0a)
815 /* Parse the root part of file name, if present. Return length and
816 optionally store pointer to char after root. */
818 parse_root (char * name
, char ** pPath
)
825 /* find the root name of the volume if given */
826 if (isalpha (name
[0]) && name
[1] == ':')
828 /* skip past drive specifier */
830 if (IS_DIRECTORY_SEP (name
[0]))
833 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
839 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
844 if (IS_DIRECTORY_SEP (name
[0]))
854 /* Get long base name for name; name is assumed to be absolute. */
856 get_long_basename (char * name
, char * buf
, int size
)
858 WIN32_FIND_DATA find_data
;
862 /* must be valid filename, no wild cards or other invalid characters */
863 if (_mbspbrk (name
, "*?|<>\""))
866 dir_handle
= FindFirstFile (name
, &find_data
);
867 if (dir_handle
!= INVALID_HANDLE_VALUE
)
869 if ((len
= strlen (find_data
.cFileName
)) < size
)
870 memcpy (buf
, find_data
.cFileName
, len
+ 1);
873 FindClose (dir_handle
);
878 /* Get long name for file, if possible (assumed to be absolute). */
880 w32_get_long_filename (char * name
, char * buf
, int size
)
885 char full
[ MAX_PATH
];
892 /* Use local copy for destructive modification. */
893 memcpy (full
, name
, len
+1);
894 unixtodos_filename (full
);
896 /* Copy root part verbatim. */
897 len
= parse_root (full
, &p
);
898 memcpy (o
, full
, len
);
903 while (p
!= NULL
&& *p
)
906 p
= strchr (q
, '\\');
908 len
= get_long_basename (full
, o
, size
);
931 is_unc_volume (const char *filename
)
933 const char *ptr
= filename
;
935 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
938 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
944 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
947 sigsetmask (int signal_mask
)
971 setpgrp (int pid
, int gid
)
982 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
985 w32_get_resource (key
, lpdwtype
)
990 HKEY hrootkey
= NULL
;
993 /* Check both the current user and the local machine to see if
994 we have any resources. */
996 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1000 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1001 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1002 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1004 RegCloseKey (hrootkey
);
1008 if (lpvalue
) xfree (lpvalue
);
1010 RegCloseKey (hrootkey
);
1013 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1017 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1018 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1019 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1021 RegCloseKey (hrootkey
);
1025 if (lpvalue
) xfree (lpvalue
);
1027 RegCloseKey (hrootkey
);
1033 char *get_emacs_configuration (void);
1034 extern Lisp_Object Vsystem_configuration
;
1037 init_environment (char ** argv
)
1039 static const char * const tempdirs
[] = {
1040 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1045 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1047 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1048 temporary files and assume "/tmp" if $TMPDIR is unset, which
1049 will break on DOS/Windows. Refuse to work if we cannot find
1050 a directory, not even "c:/", usable for that purpose. */
1051 for (i
= 0; i
< imax
; i
++)
1053 const char *tmp
= tempdirs
[i
];
1056 tmp
= getenv (tmp
+ 1);
1057 /* Note that `access' can lie to us if the directory resides on a
1058 read-only filesystem, like CD-ROM or a write-protected floppy.
1059 The only way to be really sure is to actually create a file and
1060 see if it succeeds. But I think that's too much to ask. */
1061 if (tmp
&& _access (tmp
, D_OK
) == 0)
1063 char * var
= alloca (strlen (tmp
) + 8);
1064 sprintf (var
, "TMPDIR=%s", tmp
);
1065 _putenv (strdup (var
));
1072 Fcons (build_string ("no usable temporary directories found!!"),
1074 "While setting TMPDIR: ");
1076 /* Check for environment variables and use registry settings if they
1077 don't exist. Fallback on default values where applicable. */
1082 char locale_name
[32];
1083 struct stat ignored
;
1084 char default_home
[MAX_PATH
];
1086 static const struct env_entry
1093 {"PRELOAD_WINSOCK", NULL
},
1094 {"emacs_dir", "C:/emacs"},
1095 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1096 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1097 {"EMACSDATA", "%emacs_dir%/etc"},
1098 {"EMACSPATH", "%emacs_dir%/bin"},
1099 /* We no longer set INFOPATH because Info-default-directory-list
1101 /* {"INFOPATH", "%emacs_dir%/info"}, */
1102 {"EMACSDOC", "%emacs_dir%/etc"},
1107 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1109 /* We need to copy dflt_envvars[] and work on the copy because we
1110 don't want the dumped Emacs to inherit the values of
1111 environment variables we saw during dumping (which could be on
1112 a different system). The defaults above must be left intact. */
1113 struct env_entry env_vars
[N_ENV_VARS
];
1115 for (i
= 0; i
< N_ENV_VARS
; i
++)
1116 env_vars
[i
] = dflt_envvars
[i
];
1118 /* For backwards compatibility, check if a .emacs file exists in C:/
1119 If not, then we can try to default to the appdata directory under the
1120 user's profile, which is more likely to be writable. */
1121 if (stat ("C:/.emacs", &ignored
) < 0)
1123 HRESULT profile_result
;
1124 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1125 of Windows 95 and NT4 that have not been updated to include
1126 MSIE 5. Also we don't link with shell32.dll by default. */
1127 HMODULE shell32_dll
;
1128 ShGetFolderPath_fn get_folder_path
;
1129 shell32_dll
= GetModuleHandle ("shell32.dll");
1130 get_folder_path
= (ShGetFolderPath_fn
)
1131 GetProcAddress (shell32_dll
, "SHGetFolderPathA");
1133 if (get_folder_path
!= NULL
)
1135 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1138 /* If we can't get the appdata dir, revert to old behaviour. */
1139 if (profile_result
== S_OK
)
1140 env_vars
[0].def_value
= default_home
;
1143 /* Unload shell32.dll, it is not needed anymore. */
1144 FreeLibrary (shell32_dll
);
1147 /* Get default locale info and use it for LANG. */
1148 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1149 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1150 locale_name
, sizeof (locale_name
)))
1152 for (i
= 0; i
< N_ENV_VARS
; i
++)
1154 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1156 env_vars
[i
].def_value
= locale_name
;
1162 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1164 /* Treat emacs_dir specially: set it unconditionally based on our
1165 location, if it appears that we are running from the bin subdir
1166 of a standard installation. */
1169 char modname
[MAX_PATH
];
1171 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1173 if ((p
= strrchr (modname
, '\\')) == NULL
)
1177 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
1179 char buf
[SET_ENV_BUF_SIZE
];
1182 for (p
= modname
; *p
; p
++)
1183 if (*p
== '\\') *p
= '/';
1185 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1186 _putenv (strdup (buf
));
1188 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1190 /* FIXME: should use substring of get_emacs_configuration ().
1191 But I don't think the Windows build supports alpha, mips etc
1192 anymore, so have taken the easy option for now. */
1193 else if (p
&& stricmp (p
, "\\i386") == 0)
1196 p
= strrchr (modname
, '\\');
1200 p
= strrchr (modname
, '\\');
1201 if (p
&& stricmp (p
, "\\src") == 0)
1203 char buf
[SET_ENV_BUF_SIZE
];
1206 for (p
= modname
; *p
; p
++)
1207 if (*p
== '\\') *p
= '/';
1209 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1210 _putenv (strdup (buf
));
1216 for (i
= 0; i
< N_ENV_VARS
; i
++)
1218 if (!getenv (env_vars
[i
].name
))
1222 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1223 /* Also ignore empty environment variables. */
1226 if (lpval
) xfree (lpval
);
1227 lpval
= env_vars
[i
].def_value
;
1228 dwType
= REG_EXPAND_SZ
;
1234 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1236 if (dwType
== REG_EXPAND_SZ
)
1237 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
1238 else if (dwType
== REG_SZ
)
1239 strcpy (buf1
, lpval
);
1240 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1242 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
,
1244 _putenv (strdup (buf2
));
1254 /* Rebuild system configuration to reflect invoking system. */
1255 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1257 /* Another special case: on NT, the PATH variable is actually named
1258 "Path" although cmd.exe (perhaps NT itself) arranges for
1259 environment variable lookup and setting to be case insensitive.
1260 However, Emacs assumes a fully case sensitive environment, so we
1261 need to change "Path" to "PATH" to match the expectations of
1262 various elisp packages. We do this by the sneaky method of
1263 modifying the string in the C runtime environ entry.
1265 The same applies to COMSPEC. */
1269 for (envp
= environ
; *envp
; envp
++)
1270 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1271 memcpy (*envp
, "PATH=", 5);
1272 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1273 memcpy (*envp
, "COMSPEC=", 8);
1276 /* Remember the initial working directory for getwd, then make the
1277 real wd be the location of emacs.exe to avoid conflicts when
1278 renaming or deleting directories. (We also don't call chdir when
1279 running subprocesses for the same reason.) */
1280 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1285 static char modname
[MAX_PATH
];
1287 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1289 if ((p
= strrchr (modname
, '\\')) == NULL
)
1293 SetCurrentDirectory (modname
);
1295 /* Ensure argv[0] has the full path to Emacs. */
1300 /* Determine if there is a middle mouse button, to allow parse_button
1301 to decide whether right mouse events should be mouse-2 or
1303 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1309 emacs_root_dir (void)
1311 static char root_dir
[FILENAME_MAX
];
1314 p
= getenv ("emacs_dir");
1317 strcpy (root_dir
, p
);
1318 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1319 dostounix_filename (root_dir
);
1323 /* We don't have scripts to automatically determine the system configuration
1324 for Emacs before it's compiled, and we don't want to have to make the
1325 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1329 get_emacs_configuration (void)
1331 char *arch
, *oem
, *os
;
1333 static char configuration_buffer
[32];
1335 /* Determine the processor type. */
1336 switch (get_processor_type ())
1339 #ifdef PROCESSOR_INTEL_386
1340 case PROCESSOR_INTEL_386
:
1341 case PROCESSOR_INTEL_486
:
1342 case PROCESSOR_INTEL_PENTIUM
:
1347 #ifdef PROCESSOR_MIPS_R2000
1348 case PROCESSOR_MIPS_R2000
:
1349 case PROCESSOR_MIPS_R3000
:
1350 case PROCESSOR_MIPS_R4000
:
1355 #ifdef PROCESSOR_ALPHA_21064
1356 case PROCESSOR_ALPHA_21064
:
1366 /* Use the OEM field to reflect the compiler/library combination. */
1368 #define COMPILER_NAME "msvc"
1371 #define COMPILER_NAME "mingw"
1373 #define COMPILER_NAME "unknown"
1376 oem
= COMPILER_NAME
;
1378 switch (osinfo_cache
.dwPlatformId
) {
1379 case VER_PLATFORM_WIN32_NT
:
1381 build_num
= osinfo_cache
.dwBuildNumber
;
1383 case VER_PLATFORM_WIN32_WINDOWS
:
1384 if (osinfo_cache
.dwMinorVersion
== 0) {
1389 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1391 case VER_PLATFORM_WIN32s
:
1392 /* Not supported, should not happen. */
1394 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1402 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1403 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1404 get_w32_major_version (), get_w32_minor_version (), build_num
);
1406 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1409 return configuration_buffer
;
1413 get_emacs_configuration_options (void)
1415 static char options_buffer
[256];
1417 /* Work out the effective configure options for this build. */
1419 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1422 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1424 #define COMPILER_VERSION ""
1428 sprintf (options_buffer
, COMPILER_VERSION
);
1430 strcat (options_buffer
, " --no-opt");
1433 strcat (options_buffer
, " --cflags");
1434 strcat (options_buffer
, USER_CFLAGS
);
1437 strcat (options_buffer
, " --ldflags");
1438 strcat (options_buffer
, USER_LDFLAGS
);
1440 return options_buffer
;
1444 #include <sys/timeb.h>
1446 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1448 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1453 tv
->tv_sec
= tb
.time
;
1454 tv
->tv_usec
= tb
.millitm
* 1000L;
1457 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1458 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1462 /* ------------------------------------------------------------------------- */
1463 /* IO support and wrapper functions for W32 API. */
1464 /* ------------------------------------------------------------------------- */
1466 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1467 on network directories, so we handle that case here.
1468 (Ulrich Leodolter, 1/11/95). */
1470 sys_ctime (const time_t *t
)
1472 char *str
= (char *) ctime (t
);
1473 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1476 /* Emulate sleep...we could have done this with a define, but that
1477 would necessitate including windows.h in the files that used it.
1478 This is much easier. */
1480 sys_sleep (int seconds
)
1482 Sleep (seconds
* 1000);
1485 /* Internal MSVC functions for low-level descriptor munging */
1486 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1487 extern int __cdecl
_free_osfhnd (int fd
);
1489 /* parallel array of private info on file handles */
1490 filedesc fd_info
[ MAXDESC
];
1492 typedef struct volume_info_data
{
1493 struct volume_info_data
* next
;
1495 /* time when info was obtained */
1498 /* actual volume info */
1507 /* Global referenced by various functions. */
1508 static volume_info_data volume_info
;
1510 /* Vector to indicate which drives are local and fixed (for which cached
1511 data never expires). */
1512 static BOOL fixed_drives
[26];
1514 /* Consider cached volume information to be stale if older than 10s,
1515 at least for non-local drives. Info for fixed drives is never stale. */
1516 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1517 #define VOLINFO_STILL_VALID( root_dir, info ) \
1518 ( ( isalpha (root_dir[0]) && \
1519 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1520 || GetTickCount () - info->timestamp < 10000 )
1522 /* Cache support functions. */
1524 /* Simple linked list with linear search is sufficient. */
1525 static volume_info_data
*volume_cache
= NULL
;
1527 static volume_info_data
*
1528 lookup_volume_info (char * root_dir
)
1530 volume_info_data
* info
;
1532 for (info
= volume_cache
; info
; info
= info
->next
)
1533 if (stricmp (info
->root_dir
, root_dir
) == 0)
1539 add_volume_info (char * root_dir
, volume_info_data
* info
)
1541 info
->root_dir
= xstrdup (root_dir
);
1542 info
->next
= volume_cache
;
1543 volume_cache
= info
;
1547 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1548 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1549 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1551 GetCachedVolumeInformation (char * root_dir
)
1553 volume_info_data
* info
;
1554 char default_root
[ MAX_PATH
];
1556 /* NULL for root_dir means use root from current directory. */
1557 if (root_dir
== NULL
)
1559 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1561 parse_root (default_root
, &root_dir
);
1563 root_dir
= default_root
;
1566 /* Local fixed drives can be cached permanently. Removable drives
1567 cannot be cached permanently, since the volume name and serial
1568 number (if nothing else) can change. Remote drives should be
1569 treated as if they are removable, since there is no sure way to
1570 tell whether they are or not. Also, the UNC association of drive
1571 letters mapped to remote volumes can be changed at any time (even
1572 by other processes) without notice.
1574 As a compromise, so we can benefit from caching info for remote
1575 volumes, we use a simple expiry mechanism to invalidate cache
1576 entries that are more than ten seconds old. */
1579 /* No point doing this, because WNetGetConnection is even slower than
1580 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1581 GetDriveType is about the only call of this type which does not
1582 involve network access, and so is extremely quick). */
1584 /* Map drive letter to UNC if remote. */
1585 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1587 char remote_name
[ 256 ];
1588 char drive
[3] = { root_dir
[0], ':' };
1590 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1592 /* do something */ ;
1596 info
= lookup_volume_info (root_dir
);
1598 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1606 /* Info is not cached, or is stale. */
1607 if (!GetVolumeInformation (root_dir
,
1608 name
, sizeof (name
),
1612 type
, sizeof (type
)))
1615 /* Cache the volume information for future use, overwriting existing
1616 entry if present. */
1619 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1620 add_volume_info (root_dir
, info
);
1628 info
->name
= xstrdup (name
);
1629 info
->serialnum
= serialnum
;
1630 info
->maxcomp
= maxcomp
;
1631 info
->flags
= flags
;
1632 info
->type
= xstrdup (type
);
1633 info
->timestamp
= GetTickCount ();
1639 /* Get information on the volume where name is held; set path pointer to
1640 start of pathname in name (past UNC header\volume header if present). */
1642 get_volume_info (const char * name
, const char ** pPath
)
1644 char temp
[MAX_PATH
];
1645 char *rootname
= NULL
; /* default to current volume */
1646 volume_info_data
* info
;
1651 /* find the root name of the volume if given */
1652 if (isalpha (name
[0]) && name
[1] == ':')
1660 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1667 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1680 info
= GetCachedVolumeInformation (rootname
);
1683 /* Set global referenced by other functions. */
1684 volume_info
= *info
;
1690 /* Determine if volume is FAT format (ie. only supports short 8.3
1691 names); also set path pointer to start of pathname in name. */
1693 is_fat_volume (const char * name
, const char ** pPath
)
1695 if (get_volume_info (name
, pPath
))
1696 return (volume_info
.maxcomp
== 12);
1700 /* Map filename to a valid 8.3 name if necessary. */
1702 map_w32_filename (const char * name
, const char ** pPath
)
1704 static char shortname
[MAX_PATH
];
1705 char * str
= shortname
;
1708 const char * save_name
= name
;
1710 if (strlen (name
) >= MAX_PATH
)
1712 /* Return a filename which will cause callers to fail. */
1713 strcpy (shortname
, "?");
1717 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1719 register int left
= 8; /* maximum number of chars in part */
1720 register int extn
= 0; /* extension added? */
1721 register int dots
= 2; /* maximum number of dots allowed */
1724 *str
++ = *name
++; /* skip past UNC header */
1726 while ((c
= *name
++))
1733 extn
= 0; /* reset extension flags */
1734 dots
= 2; /* max 2 dots */
1735 left
= 8; /* max length 8 for main part */
1739 extn
= 0; /* reset extension flags */
1740 dots
= 2; /* max 2 dots */
1741 left
= 8; /* max length 8 for main part */
1746 /* Convert path components of the form .xxx to _xxx,
1747 but leave . and .. as they are. This allows .emacs
1748 to be read as _emacs, for example. */
1752 IS_DIRECTORY_SEP (*name
))
1767 extn
= 1; /* we've got an extension */
1768 left
= 3; /* 3 chars in extension */
1772 /* any embedded dots after the first are converted to _ */
1777 case '#': /* don't lose these, they're important */
1779 str
[-1] = c
; /* replace last character of part */
1784 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1786 dots
= 0; /* started a path component */
1795 strcpy (shortname
, name
);
1796 unixtodos_filename (shortname
);
1800 *pPath
= shortname
+ (path
- save_name
);
1806 is_exec (const char * name
)
1808 char * p
= strrchr (name
, '.');
1811 && (stricmp (p
, ".exe") == 0 ||
1812 stricmp (p
, ".com") == 0 ||
1813 stricmp (p
, ".bat") == 0 ||
1814 stricmp (p
, ".cmd") == 0));
1817 /* Emulate the Unix directory procedures opendir, closedir,
1818 and readdir. We can't use the procedures supplied in sysdep.c,
1819 so we provide them here. */
1821 struct direct dir_static
; /* simulated directory contents */
1822 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1823 static int dir_is_fat
;
1824 static char dir_pathname
[MAXPATHLEN
+1];
1825 static WIN32_FIND_DATA dir_find_data
;
1827 /* Support shares on a network resource as subdirectories of a read-only
1829 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1830 HANDLE
open_unc_volume (const char *);
1831 char *read_unc_volume (HANDLE
, char *, int);
1832 void close_unc_volume (HANDLE
);
1835 opendir (char *filename
)
1839 /* Opening is done by FindFirstFile. However, a read is inherent to
1840 this operation, so we defer the open until read time. */
1842 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1844 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1847 if (is_unc_volume (filename
))
1849 wnet_enum_handle
= open_unc_volume (filename
);
1850 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1854 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1861 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1862 dir_pathname
[MAXPATHLEN
] = '\0';
1863 dir_is_fat
= is_fat_volume (filename
, NULL
);
1869 closedir (DIR *dirp
)
1871 /* If we have a find-handle open, close it. */
1872 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1874 FindClose (dir_find_handle
);
1875 dir_find_handle
= INVALID_HANDLE_VALUE
;
1877 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1879 close_unc_volume (wnet_enum_handle
);
1880 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1882 xfree ((char *) dirp
);
1888 int downcase
= !NILP (Vw32_downcase_file_names
);
1890 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1892 if (!read_unc_volume (wnet_enum_handle
,
1893 dir_find_data
.cFileName
,
1897 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1898 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1900 char filename
[MAXNAMLEN
+ 3];
1903 strcpy (filename
, dir_pathname
);
1904 ln
= strlen (filename
) - 1;
1905 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1906 strcat (filename
, "\\");
1907 strcat (filename
, "*");
1909 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1911 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1916 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1920 /* Emacs never uses this value, so don't bother making it match
1921 value returned by stat(). */
1922 dir_static
.d_ino
= 1;
1924 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1926 /* If the file name in cFileName[] includes `?' characters, it means
1927 the original file name used characters that cannot be represented
1928 by the current ANSI codepage. To avoid total lossage, retrieve
1929 the short 8+3 alias of the long file name. */
1930 if (_mbspbrk (dir_static
.d_name
, "?"))
1932 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
1933 downcase
= 1; /* 8+3 aliases are returned in all caps */
1935 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
1936 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1937 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1939 /* If the file name in cFileName[] includes `?' characters, it means
1940 the original file name used characters that cannot be represented
1941 by the current ANSI codepage. To avoid total lossage, retrieve
1942 the short 8+3 alias of the long file name. */
1943 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
1945 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
1946 /* 8+3 aliases are returned in all caps, which could break
1947 various alists that look at filenames' extensions. */
1951 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1952 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
1954 _strlwr (dir_static
.d_name
);
1958 for (p
= dir_static
.d_name
; *p
; p
++)
1959 if (*p
>= 'a' && *p
<= 'z')
1962 _strlwr (dir_static
.d_name
);
1969 open_unc_volume (const char *path
)
1975 nr
.dwScope
= RESOURCE_GLOBALNET
;
1976 nr
.dwType
= RESOURCETYPE_DISK
;
1977 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1978 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1979 nr
.lpLocalName
= NULL
;
1980 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
1981 nr
.lpComment
= NULL
;
1982 nr
.lpProvider
= NULL
;
1984 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1985 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1987 if (result
== NO_ERROR
)
1990 return INVALID_HANDLE_VALUE
;
1994 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1998 DWORD bufsize
= 512;
2003 buffer
= alloca (bufsize
);
2004 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
2005 if (result
!= NO_ERROR
)
2008 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2009 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2011 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2014 strncpy (readbuf
, ptr
, size
);
2019 close_unc_volume (HANDLE henum
)
2021 if (henum
!= INVALID_HANDLE_VALUE
)
2022 WNetCloseEnum (henum
);
2026 unc_volume_file_attributes (const char *path
)
2031 henum
= open_unc_volume (path
);
2032 if (henum
== INVALID_HANDLE_VALUE
)
2035 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2037 close_unc_volume (henum
);
2042 /* Ensure a network connection is authenticated. */
2044 logon_network_drive (const char *path
)
2046 NETRESOURCE resource
;
2047 char share
[MAX_PATH
];
2051 sprintf (drive
, "%c:\\", path
[0]);
2053 /* Only logon to networked drives. */
2054 if ((!IS_DIRECTORY_SEP (path
[0]) || !IS_DIRECTORY_SEP (path
[1]))
2055 && GetDriveType (drive
) != DRIVE_REMOTE
)
2059 strncpy (share
, path
, MAX_PATH
);
2060 /* Truncate to just server and share name. */
2061 for (i
= 2; i
< MAX_PATH
; i
++)
2063 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2070 resource
.dwType
= RESOURCETYPE_DISK
;
2071 resource
.lpLocalName
= NULL
;
2072 resource
.lpRemoteName
= share
;
2073 resource
.lpProvider
= NULL
;
2075 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2078 /* Shadow some MSVC runtime functions to map requests for long filenames
2079 to reasonable short names if necessary. This was originally added to
2080 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2084 sys_access (const char * path
, int mode
)
2088 /* MSVC implementation doesn't recognize D_OK. */
2089 path
= map_w32_filename (path
, NULL
);
2090 if (is_unc_volume (path
))
2092 attributes
= unc_volume_file_attributes (path
);
2093 if (attributes
== -1) {
2098 else if ((attributes
= GetFileAttributes (path
)) == -1)
2100 /* Should try mapping GetLastError to errno; for now just indicate
2101 that path doesn't exist. */
2105 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2110 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2115 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2124 sys_chdir (const char * path
)
2126 return _chdir (map_w32_filename (path
, NULL
));
2130 sys_chmod (const char * path
, int mode
)
2132 return _chmod (map_w32_filename (path
, NULL
), mode
);
2136 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2138 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2144 sys_creat (const char * path
, int mode
)
2146 return _creat (map_w32_filename (path
, NULL
), mode
);
2150 sys_fopen(const char * path
, const char * mode
)
2154 const char * mode_save
= mode
;
2156 /* Force all file handles to be non-inheritable. This is necessary to
2157 ensure child processes don't unwittingly inherit handles that might
2158 prevent future file access. */
2162 else if (mode
[0] == 'w' || mode
[0] == 'a')
2163 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2167 /* Only do simplistic option parsing. */
2171 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2174 else if (mode
[0] == 'b')
2179 else if (mode
[0] == 't')
2186 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2190 return _fdopen (fd
, mode_save
);
2193 /* This only works on NTFS volumes, but is useful to have. */
2195 sys_link (const char * old
, const char * new)
2199 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2201 if (old
== NULL
|| new == NULL
)
2207 strcpy (oldname
, map_w32_filename (old
, NULL
));
2208 strcpy (newname
, map_w32_filename (new, NULL
));
2210 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2211 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2212 if (fileh
!= INVALID_HANDLE_VALUE
)
2216 /* Confusingly, the "alternate" stream name field does not apply
2217 when restoring a hard link, and instead contains the actual
2218 stream data for the link (ie. the name of the link to create).
2219 The WIN32_STREAM_ID structure before the cStreamName field is
2220 the stream header, which is then immediately followed by the
2224 WIN32_STREAM_ID wid
;
2225 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2228 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2229 data
.wid
.cStreamName
, MAX_PATH
);
2232 LPVOID context
= NULL
;
2235 data
.wid
.dwStreamId
= BACKUP_LINK
;
2236 data
.wid
.dwStreamAttributes
= 0;
2237 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
2238 data
.wid
.Size
.HighPart
= 0;
2239 data
.wid
.dwStreamNameSize
= 0;
2241 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2242 offsetof (WIN32_STREAM_ID
, cStreamName
)
2243 + data
.wid
.Size
.LowPart
,
2244 &wbytes
, FALSE
, FALSE
, &context
)
2245 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2252 /* Should try mapping GetLastError to errno; for now just
2253 indicate a general error (eg. links not supported). */
2254 errno
= EINVAL
; // perhaps EMLINK?
2258 CloseHandle (fileh
);
2267 sys_mkdir (const char * path
)
2269 return _mkdir (map_w32_filename (path
, NULL
));
2272 /* Because of long name mapping issues, we need to implement this
2273 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2274 a unique name, instead of setting the input template to an empty
2277 Standard algorithm seems to be use pid or tid with a letter on the
2278 front (in place of the 6 X's) and cycle through the letters to find a
2279 unique name. We extend that to allow any reasonable character as the
2280 first of the 6 X's. */
2282 sys_mktemp (char * template)
2286 unsigned uid
= GetCurrentThreadId ();
2287 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2289 if (template == NULL
)
2291 p
= template + strlen (template);
2293 /* replace up to the last 5 X's with uid in decimal */
2294 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2296 p
[0] = '0' + uid
% 10;
2300 if (i
< 0 && p
[0] == 'X')
2305 int save_errno
= errno
;
2306 p
[0] = first_char
[i
];
2307 if (sys_access (template, 0) < 0)
2313 while (++i
< sizeof (first_char
));
2316 /* Template is badly formed or else we can't generate a unique name,
2317 so return empty string */
2323 sys_open (const char * path
, int oflag
, int mode
)
2325 const char* mpath
= map_w32_filename (path
, NULL
);
2326 /* Try to open file without _O_CREAT, to be able to write to hidden
2327 and system files. Force all file handles to be
2329 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2332 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2336 sys_rename (const char * oldname
, const char * newname
)
2339 char temp
[MAX_PATH
];
2341 /* MoveFile on Windows 95 doesn't correctly change the short file name
2342 alias in a number of circumstances (it is not easy to predict when
2343 just by looking at oldname and newname, unfortunately). In these
2344 cases, renaming through a temporary name avoids the problem.
2346 A second problem on Windows 95 is that renaming through a temp name when
2347 newname is uppercase fails (the final long name ends up in
2348 lowercase, although the short alias might be uppercase) UNLESS the
2349 long temp name is not 8.3.
2351 So, on Windows 95 we always rename through a temp name, and we make sure
2352 the temp name has a long extension to ensure correct renaming. */
2354 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2356 if (os_subtype
== OS_WIN95
)
2362 oldname
= map_w32_filename (oldname
, NULL
);
2363 if (o
= strrchr (oldname
, '\\'))
2366 o
= (char *) oldname
;
2368 if (p
= strrchr (temp
, '\\'))
2375 /* Force temp name to require a manufactured 8.3 alias - this
2376 seems to make the second rename work properly. */
2377 sprintf (p
, "_.%s.%u", o
, i
);
2379 result
= rename (oldname
, temp
);
2381 /* This loop must surely terminate! */
2382 while (result
< 0 && errno
== EEXIST
);
2387 /* Emulate Unix behaviour - newname is deleted if it already exists
2388 (at least if it is a file; don't do this for directories).
2390 Since we mustn't do this if we are just changing the case of the
2391 file name (we would end up deleting the file we are trying to
2392 rename!), we let rename detect if the destination file already
2393 exists - that way we avoid the possible pitfalls of trying to
2394 determine ourselves whether two names really refer to the same
2395 file, which is not always possible in the general case. (Consider
2396 all the permutations of shared or subst'd drives, etc.) */
2398 newname
= map_w32_filename (newname
, NULL
);
2399 result
= rename (temp
, newname
);
2403 && _chmod (newname
, 0666) == 0
2404 && _unlink (newname
) == 0)
2405 result
= rename (temp
, newname
);
2411 sys_rmdir (const char * path
)
2413 return _rmdir (map_w32_filename (path
, NULL
));
2417 sys_unlink (const char * path
)
2419 path
= map_w32_filename (path
, NULL
);
2421 /* On Unix, unlink works without write permission. */
2422 _chmod (path
, 0666);
2423 return _unlink (path
);
2426 static FILETIME utc_base_ft
;
2427 static long double utc_base
;
2428 static int init
= 0;
2431 convert_time (FILETIME ft
)
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.0L * 1024.0L * 1024.0L + utc_base_ft
.dwLowDateTime
;
2454 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2457 ret
= (long double) ft
.dwHighDateTime
2458 * 4096.0L * 1024.0L * 1024.0L + ft
.dwLowDateTime
;
2460 return (time_t) (ret
* 1e-7L);
2464 convert_from_time_t (time_t time
, FILETIME
* pft
)
2470 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2479 st
.wMilliseconds
= 0;
2481 SystemTimeToFileTime (&st
, &utc_base_ft
);
2482 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2483 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2487 /* time in 100ns units since 1-Jan-1601 */
2488 tmp
= (long double) time
* 1e7
+ utc_base
;
2489 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2490 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2494 /* No reason to keep this; faking inode values either by hashing or even
2495 using the file index from GetInformationByHandle, is not perfect and
2496 so by default Emacs doesn't use the inode values on Windows.
2497 Instead, we now determine file-truename correctly (except for
2498 possible drive aliasing etc). */
2500 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2502 hashval (const unsigned char * str
)
2507 h
= (h
<< 4) + *str
++;
2513 /* Return the hash value of the canonical pathname, excluding the
2514 drive/UNC header, to get a hopefully unique inode number. */
2516 generate_inode_val (const char * name
)
2518 char fullname
[ MAX_PATH
];
2522 /* Get the truly canonical filename, if it exists. (Note: this
2523 doesn't resolve aliasing due to subst commands, or recognise hard
2525 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2528 parse_root (fullname
, &p
);
2529 /* Normal W32 filesystems are still case insensitive. */
2536 /* MSVC stat function can't cope with UNC names and has other bugs, so
2537 replace it with our own. This also allows us to calculate consistent
2538 inode values without hacks in the main Emacs code. */
2540 stat (const char * path
, struct stat
* buf
)
2543 WIN32_FIND_DATA wfd
;
2545 unsigned __int64 fake_inode
;
2548 int rootdir
= FALSE
;
2550 if (path
== NULL
|| buf
== NULL
)
2556 name
= (char *) map_w32_filename (path
, &path
);
2557 /* Must be valid filename, no wild cards or other invalid
2558 characters. We use _mbspbrk to support multibyte strings that
2559 might look to strpbrk as if they included literal *, ?, and other
2560 characters mentioned below that are disallowed by Windows
2562 if (_mbspbrk (name
, "*?|<>\""))
2568 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2569 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2570 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2575 /* Remove trailing directory separator, unless name is the root
2576 directory of a drive or UNC volume in which case ensure there
2577 is a trailing separator. */
2578 len
= strlen (name
);
2579 rootdir
= (path
>= name
+ len
- 1
2580 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2581 name
= strcpy (alloca (len
+ 2), name
);
2583 if (is_unc_volume (name
))
2585 DWORD attrs
= unc_volume_file_attributes (name
);
2590 memset (&wfd
, 0, sizeof (wfd
));
2591 wfd
.dwFileAttributes
= attrs
;
2592 wfd
.ftCreationTime
= utc_base_ft
;
2593 wfd
.ftLastAccessTime
= utc_base_ft
;
2594 wfd
.ftLastWriteTime
= utc_base_ft
;
2595 strcpy (wfd
.cFileName
, name
);
2599 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2600 strcat (name
, "\\");
2601 if (GetDriveType (name
) < 2)
2606 memset (&wfd
, 0, sizeof (wfd
));
2607 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2608 wfd
.ftCreationTime
= utc_base_ft
;
2609 wfd
.ftLastAccessTime
= utc_base_ft
;
2610 wfd
.ftLastWriteTime
= utc_base_ft
;
2611 strcpy (wfd
.cFileName
, name
);
2615 if (IS_DIRECTORY_SEP (name
[len
-1]))
2618 /* (This is hacky, but helps when doing file completions on
2619 network drives.) Optimize by using information available from
2620 active readdir if possible. */
2621 len
= strlen (dir_pathname
);
2622 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2624 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2625 && strnicmp (name
, dir_pathname
, len
) == 0
2626 && IS_DIRECTORY_SEP (name
[len
])
2627 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2629 /* This was the last entry returned by readdir. */
2630 wfd
= dir_find_data
;
2634 logon_network_drive (name
);
2636 fh
= FindFirstFile (name
, &wfd
);
2637 if (fh
== INVALID_HANDLE_VALUE
)
2646 if (!NILP (Vw32_get_true_file_attributes
)
2647 /* No access rights required to get info. */
2648 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
2649 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
2650 != INVALID_HANDLE_VALUE
)
2652 /* This is more accurate in terms of gettting the correct number
2653 of links, but is quite slow (it is noticeable when Emacs is
2654 making a list of file name completions). */
2655 BY_HANDLE_FILE_INFORMATION info
;
2657 if (GetFileInformationByHandle (fh
, &info
))
2659 buf
->st_nlink
= info
.nNumberOfLinks
;
2660 /* Might as well use file index to fake inode values, but this
2661 is not guaranteed to be unique unless we keep a handle open
2662 all the time (even then there are situations where it is
2663 not unique). Reputedly, there are at most 48 bits of info
2664 (on NTFS, presumably less on FAT). */
2665 fake_inode
= info
.nFileIndexHigh
;
2667 fake_inode
+= info
.nFileIndexLow
;
2675 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2677 buf
->st_mode
= S_IFDIR
;
2681 switch (GetFileType (fh
))
2683 case FILE_TYPE_DISK
:
2684 buf
->st_mode
= S_IFREG
;
2686 case FILE_TYPE_PIPE
:
2687 buf
->st_mode
= S_IFIFO
;
2689 case FILE_TYPE_CHAR
:
2690 case FILE_TYPE_UNKNOWN
:
2692 buf
->st_mode
= S_IFCHR
;
2699 /* Don't bother to make this information more accurate. */
2700 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
2707 /* Not sure if there is any point in this. */
2708 if (!NILP (Vw32_generate_fake_inodes
))
2709 fake_inode
= generate_inode_val (name
);
2710 else if (fake_inode
== 0)
2712 /* For want of something better, try to make everything unique. */
2713 static DWORD gen_num
= 0;
2714 fake_inode
= ++gen_num
;
2718 /* MSVC defines _ino_t to be short; other libc's might not. */
2719 if (sizeof (buf
->st_ino
) == 2)
2720 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2722 buf
->st_ino
= fake_inode
;
2724 /* consider files to belong to current user */
2725 buf
->st_uid
= the_passwd
.pw_uid
;
2726 buf
->st_gid
= the_passwd
.pw_gid
;
2728 /* volume_info is set indirectly by map_w32_filename */
2729 buf
->st_dev
= volume_info
.serialnum
;
2730 buf
->st_rdev
= volume_info
.serialnum
;
2733 buf
->st_size
= wfd
.nFileSizeLow
;
2735 /* Convert timestamps to Unix format. */
2736 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2737 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2738 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2739 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2740 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2742 /* determine rwx permissions */
2743 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2744 permission
= S_IREAD
;
2746 permission
= S_IREAD
| S_IWRITE
;
2748 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2749 permission
|= S_IEXEC
;
2750 else if (is_exec (name
))
2751 permission
|= S_IEXEC
;
2753 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2758 /* Provide fstat and utime as well as stat for consistent handling of
2761 fstat (int desc
, struct stat
* buf
)
2763 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2764 BY_HANDLE_FILE_INFORMATION info
;
2765 unsigned __int64 fake_inode
;
2768 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2770 case FILE_TYPE_DISK
:
2771 buf
->st_mode
= S_IFREG
;
2772 if (!GetFileInformationByHandle (fh
, &info
))
2778 case FILE_TYPE_PIPE
:
2779 buf
->st_mode
= S_IFIFO
;
2781 case FILE_TYPE_CHAR
:
2782 case FILE_TYPE_UNKNOWN
:
2784 buf
->st_mode
= S_IFCHR
;
2786 memset (&info
, 0, sizeof (info
));
2787 info
.dwFileAttributes
= 0;
2788 info
.ftCreationTime
= utc_base_ft
;
2789 info
.ftLastAccessTime
= utc_base_ft
;
2790 info
.ftLastWriteTime
= utc_base_ft
;
2793 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2794 buf
->st_mode
= S_IFDIR
;
2796 buf
->st_nlink
= info
.nNumberOfLinks
;
2797 /* Might as well use file index to fake inode values, but this
2798 is not guaranteed to be unique unless we keep a handle open
2799 all the time (even then there are situations where it is
2800 not unique). Reputedly, there are at most 48 bits of info
2801 (on NTFS, presumably less on FAT). */
2802 fake_inode
= info
.nFileIndexHigh
;
2804 fake_inode
+= info
.nFileIndexLow
;
2806 /* MSVC defines _ino_t to be short; other libc's might not. */
2807 if (sizeof (buf
->st_ino
) == 2)
2808 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2810 buf
->st_ino
= fake_inode
;
2812 /* consider files to belong to current user */
2813 buf
->st_uid
= the_passwd
.pw_uid
;
2814 buf
->st_gid
= the_passwd
.pw_gid
;
2816 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2817 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2819 buf
->st_size
= info
.nFileSizeLow
;
2821 /* Convert timestamps to Unix format. */
2822 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2823 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2824 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2825 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2826 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2828 /* determine rwx permissions */
2829 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2830 permission
= S_IREAD
;
2832 permission
= S_IREAD
| S_IWRITE
;
2834 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2835 permission
|= S_IEXEC
;
2838 #if 0 /* no way of knowing the filename */
2839 char * p
= strrchr (name
, '.');
2841 (stricmp (p
, ".exe") == 0 ||
2842 stricmp (p
, ".com") == 0 ||
2843 stricmp (p
, ".bat") == 0 ||
2844 stricmp (p
, ".cmd") == 0))
2845 permission
|= S_IEXEC
;
2849 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2855 utime (const char *name
, struct utimbuf
*times
)
2857 struct utimbuf deftime
;
2864 deftime
.modtime
= deftime
.actime
= time (NULL
);
2868 /* Need write access to set times. */
2869 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2870 0, OPEN_EXISTING
, 0, NULL
);
2873 convert_from_time_t (times
->actime
, &atime
);
2874 convert_from_time_t (times
->modtime
, &mtime
);
2875 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2893 /* Wrappers for winsock functions to map between our file descriptors
2894 and winsock's handles; also set h_errno for convenience.
2896 To allow Emacs to run on systems which don't have winsock support
2897 installed, we dynamically link to winsock on startup if present, and
2898 otherwise provide the minimum necessary functionality
2899 (eg. gethostname). */
2901 /* function pointers for relevant socket functions */
2902 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2903 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2904 int (PASCAL
*pfn_WSAGetLastError
) (void);
2905 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
2906 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
2907 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
2908 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2909 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2910 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2911 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2912 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2913 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2914 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2915 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2916 int (PASCAL
*pfn_WSACleanup
) (void);
2918 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2919 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2920 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2921 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2922 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2923 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2924 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
2925 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2926 const char * optval
, int optlen
);
2927 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2928 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2930 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2931 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2932 struct sockaddr
* from
, int * fromlen
);
2933 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2934 const struct sockaddr
* to
, int tolen
);
2936 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2937 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2938 #ifndef HANDLE_FLAG_INHERIT
2939 #define HANDLE_FLAG_INHERIT 1
2943 static int winsock_inuse
;
2948 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2950 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2951 after WSAStartup returns successfully, but it seems reasonable
2952 to allow unloading winsock anyway in that case. */
2953 if (pfn_WSACleanup () == 0 ||
2954 pfn_WSAGetLastError () == WSAENETDOWN
)
2956 if (FreeLibrary (winsock_lib
))
2965 init_winsock (int load_now
)
2967 WSADATA winsockData
;
2969 if (winsock_lib
!= NULL
)
2972 pfn_SetHandleInformation
= NULL
;
2973 pfn_SetHandleInformation
2974 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2975 "SetHandleInformation");
2977 winsock_lib
= LoadLibrary ("Ws2_32.dll");
2979 if (winsock_lib
!= NULL
)
2981 /* dynamically link to socket functions */
2983 #define LOAD_PROC(fn) \
2984 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2987 LOAD_PROC( WSAStartup
);
2988 LOAD_PROC( WSASetLastError
);
2989 LOAD_PROC( WSAGetLastError
);
2990 LOAD_PROC( WSAEventSelect
);
2991 LOAD_PROC( WSACreateEvent
);
2992 LOAD_PROC( WSACloseEvent
);
2993 LOAD_PROC( socket
);
2995 LOAD_PROC( connect
);
2996 LOAD_PROC( ioctlsocket
);
2999 LOAD_PROC( closesocket
);
3000 LOAD_PROC( shutdown
);
3003 LOAD_PROC( inet_addr
);
3004 LOAD_PROC( gethostname
);
3005 LOAD_PROC( gethostbyname
);
3006 LOAD_PROC( getservbyname
);
3007 LOAD_PROC( getpeername
);
3008 LOAD_PROC( WSACleanup
);
3009 LOAD_PROC( setsockopt
);
3010 LOAD_PROC( listen
);
3011 LOAD_PROC( getsockname
);
3012 LOAD_PROC( accept
);
3013 LOAD_PROC( recvfrom
);
3014 LOAD_PROC( sendto
);
3017 /* specify version 1.1 of winsock */
3018 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
3020 if (winsockData
.wVersion
!= 0x101)
3025 /* Report that winsock exists and is usable, but leave
3026 socket functions disabled. I am assuming that calling
3027 WSAStartup does not require any network interaction,
3028 and in particular does not cause or require a dial-up
3029 connection to be established. */
3032 FreeLibrary (winsock_lib
);
3040 FreeLibrary (winsock_lib
);
3050 /* function to set h_errno for compatability; map winsock error codes to
3051 normal system codes where they overlap (non-overlapping definitions
3052 are already in <sys/socket.h> */
3056 if (winsock_lib
== NULL
)
3059 h_errno
= pfn_WSAGetLastError ();
3063 case WSAEACCES
: h_errno
= EACCES
; break;
3064 case WSAEBADF
: h_errno
= EBADF
; break;
3065 case WSAEFAULT
: h_errno
= EFAULT
; break;
3066 case WSAEINTR
: h_errno
= EINTR
; break;
3067 case WSAEINVAL
: h_errno
= EINVAL
; break;
3068 case WSAEMFILE
: h_errno
= EMFILE
; break;
3069 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
3070 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
3078 if (h_errno
== 0 && winsock_lib
!= NULL
)
3079 pfn_WSASetLastError (0);
3082 /* Extend strerror to handle the winsock-specific error codes. */
3086 } _wsa_errlist
[] = {
3087 WSAEINTR
, "Interrupted function call",
3088 WSAEBADF
, "Bad file descriptor",
3089 WSAEACCES
, "Permission denied",
3090 WSAEFAULT
, "Bad address",
3091 WSAEINVAL
, "Invalid argument",
3092 WSAEMFILE
, "Too many open files",
3094 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
3095 WSAEINPROGRESS
, "Operation now in progress",
3096 WSAEALREADY
, "Operation already in progress",
3097 WSAENOTSOCK
, "Socket operation on non-socket",
3098 WSAEDESTADDRREQ
, "Destination address required",
3099 WSAEMSGSIZE
, "Message too long",
3100 WSAEPROTOTYPE
, "Protocol wrong type for socket",
3101 WSAENOPROTOOPT
, "Bad protocol option",
3102 WSAEPROTONOSUPPORT
, "Protocol not supported",
3103 WSAESOCKTNOSUPPORT
, "Socket type not supported",
3104 WSAEOPNOTSUPP
, "Operation not supported",
3105 WSAEPFNOSUPPORT
, "Protocol family not supported",
3106 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
3107 WSAEADDRINUSE
, "Address already in use",
3108 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
3109 WSAENETDOWN
, "Network is down",
3110 WSAENETUNREACH
, "Network is unreachable",
3111 WSAENETRESET
, "Network dropped connection on reset",
3112 WSAECONNABORTED
, "Software caused connection abort",
3113 WSAECONNRESET
, "Connection reset by peer",
3114 WSAENOBUFS
, "No buffer space available",
3115 WSAEISCONN
, "Socket is already connected",
3116 WSAENOTCONN
, "Socket is not connected",
3117 WSAESHUTDOWN
, "Cannot send after socket shutdown",
3118 WSAETOOMANYREFS
, "Too many references", /* not sure */
3119 WSAETIMEDOUT
, "Connection timed out",
3120 WSAECONNREFUSED
, "Connection refused",
3121 WSAELOOP
, "Network loop", /* not sure */
3122 WSAENAMETOOLONG
, "Name is too long",
3123 WSAEHOSTDOWN
, "Host is down",
3124 WSAEHOSTUNREACH
, "No route to host",
3125 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
3126 WSAEPROCLIM
, "Too many processes",
3127 WSAEUSERS
, "Too many users", /* not sure */
3128 WSAEDQUOT
, "Double quote in host name", /* really not sure */
3129 WSAESTALE
, "Data is stale", /* not sure */
3130 WSAEREMOTE
, "Remote error", /* not sure */
3132 WSASYSNOTREADY
, "Network subsystem is unavailable",
3133 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
3134 WSANOTINITIALISED
, "Winsock not initialized successfully",
3135 WSAEDISCON
, "Graceful shutdown in progress",
3137 WSAENOMORE
, "No more operations allowed", /* not sure */
3138 WSAECANCELLED
, "Operation cancelled", /* not sure */
3139 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
3140 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
3141 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
3142 WSASYSCALLFAILURE
, "System call failure",
3143 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
3144 WSATYPE_NOT_FOUND
, "Class type not found",
3145 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
3146 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
3147 WSAEREFUSED
, "Operation refused", /* not sure */
3150 WSAHOST_NOT_FOUND
, "Host not found",
3151 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
3152 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
3153 WSANO_DATA
, "Valid name, no data record of requested type",
3159 sys_strerror(int error_no
)
3162 static char unknown_msg
[40];
3164 if (error_no
>= 0 && error_no
< sys_nerr
)
3165 return sys_errlist
[error_no
];
3167 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
3168 if (_wsa_errlist
[i
].errnum
== error_no
)
3169 return _wsa_errlist
[i
].msg
;
3171 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
3175 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3176 but I believe the method of keeping the socket handle separate (and
3177 insuring it is not inheritable) is the correct one. */
3179 //#define SOCK_REPLACE_HANDLE
3181 #ifdef SOCK_REPLACE_HANDLE
3182 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3184 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3187 int socket_to_fd (SOCKET s
);
3190 sys_socket(int af
, int type
, int protocol
)
3194 if (winsock_lib
== NULL
)
3197 return INVALID_SOCKET
;
3202 /* call the real socket function */
3203 s
= pfn_socket (af
, type
, protocol
);
3205 if (s
!= INVALID_SOCKET
)
3206 return socket_to_fd (s
);
3212 /* Convert a SOCKET to a file descriptor. */
3214 socket_to_fd (SOCKET s
)
3219 /* Although under NT 3.5 _open_osfhandle will accept a socket
3220 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3221 that does not work under NT 3.1. However, we can get the same
3222 effect by using a backdoor function to replace an existing
3223 descriptor handle with the one we want. */
3225 /* allocate a file descriptor (with appropriate flags) */
3226 fd
= _open ("NUL:", _O_RDWR
);
3229 #ifdef SOCK_REPLACE_HANDLE
3230 /* now replace handle to NUL with our socket handle */
3231 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
3233 _set_osfhnd (fd
, s
);
3234 /* setmode (fd, _O_BINARY); */
3236 /* Make a non-inheritable copy of the socket handle. Note
3237 that it is possible that sockets aren't actually kernel
3238 handles, which appears to be the case on Windows 9x when
3239 the MS Proxy winsock client is installed. */
3241 /* Apparently there is a bug in NT 3.51 with some service
3242 packs, which prevents using DuplicateHandle to make a
3243 socket handle non-inheritable (causes WSACleanup to
3244 hang). The work-around is to use SetHandleInformation
3245 instead if it is available and implemented. */
3246 if (pfn_SetHandleInformation
)
3248 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
3252 HANDLE parent
= GetCurrentProcess ();
3253 HANDLE new_s
= INVALID_HANDLE_VALUE
;
3255 if (DuplicateHandle (parent
,
3261 DUPLICATE_SAME_ACCESS
))
3263 /* It is possible that DuplicateHandle succeeds even
3264 though the socket wasn't really a kernel handle,
3265 because a real handle has the same value. So
3266 test whether the new handle really is a socket. */
3267 long nonblocking
= 0;
3268 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
3270 pfn_closesocket (s
);
3275 CloseHandle (new_s
);
3280 fd_info
[fd
].hnd
= (HANDLE
) s
;
3283 /* set our own internal flags */
3284 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
3290 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3292 /* attach child_process to fd_info */
3293 if (fd_info
[ fd
].cp
!= NULL
)
3295 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
3299 fd_info
[ fd
].cp
= cp
;
3302 winsock_inuse
++; /* count open sockets */
3309 pfn_closesocket (s
);
3316 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
3318 if (winsock_lib
== NULL
)
3321 return SOCKET_ERROR
;
3325 if (fd_info
[s
].flags
& FILE_SOCKET
)
3327 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
3328 if (rc
== SOCKET_ERROR
)
3333 return SOCKET_ERROR
;
3338 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
3340 if (winsock_lib
== NULL
)
3343 return SOCKET_ERROR
;
3347 if (fd_info
[s
].flags
& FILE_SOCKET
)
3349 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
3350 if (rc
== SOCKET_ERROR
)
3355 return SOCKET_ERROR
;
3359 sys_htons (u_short hostshort
)
3361 return (winsock_lib
!= NULL
) ?
3362 pfn_htons (hostshort
) : hostshort
;
3366 sys_ntohs (u_short netshort
)
3368 return (winsock_lib
!= NULL
) ?
3369 pfn_ntohs (netshort
) : netshort
;
3373 sys_inet_addr (const char * cp
)
3375 return (winsock_lib
!= NULL
) ?
3376 pfn_inet_addr (cp
) : INADDR_NONE
;
3380 sys_gethostname (char * name
, int namelen
)
3382 if (winsock_lib
!= NULL
)
3383 return pfn_gethostname (name
, namelen
);
3385 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
3386 return !GetComputerName (name
, (DWORD
*)&namelen
);
3389 return SOCKET_ERROR
;
3393 sys_gethostbyname(const char * name
)
3395 struct hostent
* host
;
3397 if (winsock_lib
== NULL
)
3404 host
= pfn_gethostbyname (name
);
3411 sys_getservbyname(const char * name
, const char * proto
)
3413 struct servent
* serv
;
3415 if (winsock_lib
== NULL
)
3422 serv
= pfn_getservbyname (name
, proto
);
3429 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
3431 if (winsock_lib
== NULL
)
3434 return SOCKET_ERROR
;
3438 if (fd_info
[s
].flags
& FILE_SOCKET
)
3440 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
3441 if (rc
== SOCKET_ERROR
)
3446 return SOCKET_ERROR
;
3451 sys_shutdown (int s
, int how
)
3453 if (winsock_lib
== NULL
)
3456 return SOCKET_ERROR
;
3460 if (fd_info
[s
].flags
& FILE_SOCKET
)
3462 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
3463 if (rc
== SOCKET_ERROR
)
3468 return SOCKET_ERROR
;
3472 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
3474 if (winsock_lib
== NULL
)
3477 return SOCKET_ERROR
;
3481 if (fd_info
[s
].flags
& FILE_SOCKET
)
3483 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
3484 (const char *)optval
, optlen
);
3485 if (rc
== SOCKET_ERROR
)
3490 return SOCKET_ERROR
;
3494 sys_listen (int s
, int backlog
)
3496 if (winsock_lib
== NULL
)
3499 return SOCKET_ERROR
;
3503 if (fd_info
[s
].flags
& FILE_SOCKET
)
3505 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
3506 if (rc
== SOCKET_ERROR
)
3509 fd_info
[s
].flags
|= FILE_LISTEN
;
3513 return SOCKET_ERROR
;
3517 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
3519 if (winsock_lib
== NULL
)
3522 return SOCKET_ERROR
;
3526 if (fd_info
[s
].flags
& FILE_SOCKET
)
3528 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3529 if (rc
== SOCKET_ERROR
)
3534 return SOCKET_ERROR
;
3538 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3540 if (winsock_lib
== NULL
)
3547 if (fd_info
[s
].flags
& FILE_LISTEN
)
3549 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3551 if (t
== INVALID_SOCKET
)
3554 fd
= socket_to_fd (t
);
3556 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3557 ResetEvent (fd_info
[s
].cp
->char_avail
);
3565 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3566 struct sockaddr
* from
, int * fromlen
)
3568 if (winsock_lib
== NULL
)
3571 return SOCKET_ERROR
;
3575 if (fd_info
[s
].flags
& FILE_SOCKET
)
3577 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3578 if (rc
== SOCKET_ERROR
)
3583 return SOCKET_ERROR
;
3587 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3588 const struct sockaddr
* to
, int tolen
)
3590 if (winsock_lib
== NULL
)
3593 return SOCKET_ERROR
;
3597 if (fd_info
[s
].flags
& FILE_SOCKET
)
3599 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3600 if (rc
== SOCKET_ERROR
)
3605 return SOCKET_ERROR
;
3608 /* Windows does not have an fcntl function. Provide an implementation
3609 solely for making sockets non-blocking. */
3611 fcntl (int s
, int cmd
, int options
)
3613 if (winsock_lib
== NULL
)
3620 if (fd_info
[s
].flags
& FILE_SOCKET
)
3622 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
3624 unsigned long nblock
= 1;
3625 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
3626 if (rc
== SOCKET_ERROR
)
3628 /* Keep track of the fact that we set this to non-blocking. */
3629 fd_info
[s
].flags
|= FILE_NDELAY
;
3635 return SOCKET_ERROR
;
3639 return SOCKET_ERROR
;
3642 #endif /* HAVE_SOCKETS */
3645 /* Shadow main io functions: we need to handle pipes and sockets more
3646 intelligently, and implement non-blocking mode as well. */
3659 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
3661 child_process
* cp
= fd_info
[fd
].cp
;
3663 fd_info
[fd
].cp
= NULL
;
3665 if (CHILD_ACTIVE (cp
))
3667 /* if last descriptor to active child_process then cleanup */
3669 for (i
= 0; i
< MAXDESC
; i
++)
3673 if (fd_info
[i
].cp
== cp
)
3679 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3681 #ifndef SOCK_REPLACE_HANDLE
3682 if (winsock_lib
== NULL
) abort ();
3684 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3685 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3687 winsock_inuse
--; /* count open sockets */
3695 /* Note that sockets do not need special treatment here (at least on
3696 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3697 closesocket is equivalent to CloseHandle, which is to be expected
3698 because socket handles are fully fledged kernel handles. */
3701 if (rc
== 0 && fd
< MAXDESC
)
3702 fd_info
[fd
].flags
= 0;
3713 if (new_fd
>= 0 && new_fd
< MAXDESC
)
3715 /* duplicate our internal info as well */
3716 fd_info
[new_fd
] = fd_info
[fd
];
3723 sys_dup2 (int src
, int dst
)
3727 if (dst
< 0 || dst
>= MAXDESC
)
3733 /* make sure we close the destination first if it's a pipe or socket */
3734 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3737 rc
= _dup2 (src
, dst
);
3740 /* duplicate our internal info as well */
3741 fd_info
[dst
] = fd_info
[src
];
3746 /* Unix pipe() has only one arg */
3748 sys_pipe (int * phandles
)
3753 /* make pipe handles non-inheritable; when we spawn a child, we
3754 replace the relevant handle with an inheritable one. Also put
3755 pipes into binary mode; we will do text mode translation ourselves
3757 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3761 /* Protect against overflow, since Windows can open more handles than
3762 our fd_info array has room for. */
3763 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
3765 _close (phandles
[0]);
3766 _close (phandles
[1]);
3771 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3772 fd_info
[phandles
[0]].flags
= flags
;
3774 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3775 fd_info
[phandles
[1]].flags
= flags
;
3783 extern int w32_pipe_read_delay
;
3785 /* Function to do blocking read of one byte, needed to implement
3786 select. It is only allowed on sockets and pipes. */
3788 _sys_read_ahead (int fd
)
3793 if (fd
< 0 || fd
>= MAXDESC
)
3794 return STATUS_READ_ERROR
;
3796 cp
= fd_info
[fd
].cp
;
3798 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3799 return STATUS_READ_ERROR
;
3801 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3802 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3804 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3808 cp
->status
= STATUS_READ_IN_PROGRESS
;
3810 if (fd_info
[fd
].flags
& FILE_PIPE
)
3812 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3814 /* Give subprocess time to buffer some more output for us before
3815 reporting that input is available; we need this because Windows 95
3816 connects DOS programs to pipes by making the pipe appear to be
3817 the normal console stdout - as a result most DOS programs will
3818 write to stdout without buffering, ie. one character at a
3819 time. Even some W32 programs do this - "dir" in a command
3820 shell on NT is very slow if we don't do this. */
3823 int wait
= w32_pipe_read_delay
;
3829 /* Yield remainder of our time slice, effectively giving a
3830 temporary priority boost to the child process. */
3835 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3837 unsigned long nblock
= 0;
3838 /* We always want this to block, so temporarily disable NDELAY. */
3839 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3840 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3842 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3844 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3847 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3852 if (rc
== sizeof (char))
3853 cp
->status
= STATUS_READ_SUCCEEDED
;
3855 cp
->status
= STATUS_READ_FAILED
;
3861 _sys_wait_accept (int fd
)
3867 if (fd
< 0 || fd
>= MAXDESC
)
3868 return STATUS_READ_ERROR
;
3870 cp
= fd_info
[fd
].cp
;
3872 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3873 return STATUS_READ_ERROR
;
3875 cp
->status
= STATUS_READ_FAILED
;
3877 hEv
= pfn_WSACreateEvent ();
3878 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
3879 if (rc
!= SOCKET_ERROR
)
3881 rc
= WaitForSingleObject (hEv
, INFINITE
);
3882 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
3883 if (rc
== WAIT_OBJECT_0
)
3884 cp
->status
= STATUS_READ_SUCCEEDED
;
3886 pfn_WSACloseEvent (hEv
);
3892 sys_read (int fd
, char * buffer
, unsigned int count
)
3897 char * orig_buffer
= buffer
;
3905 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3907 child_process
*cp
= fd_info
[fd
].cp
;
3909 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3917 /* re-read CR carried over from last read */
3918 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3920 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3924 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3927 /* presence of a child_process structure means we are operating in
3928 non-blocking mode - otherwise we just call _read directly.
3929 Note that the child_process structure might be missing because
3930 reap_subprocess has been called; in this case the pipe is
3931 already broken, so calling _read on it is okay. */
3934 int current_status
= cp
->status
;
3936 switch (current_status
)
3938 case STATUS_READ_FAILED
:
3939 case STATUS_READ_ERROR
:
3940 /* report normal EOF if nothing in buffer */
3942 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3945 case STATUS_READ_READY
:
3946 case STATUS_READ_IN_PROGRESS
:
3947 DebPrint (("sys_read called when read is in progress\n"));
3948 errno
= EWOULDBLOCK
;
3951 case STATUS_READ_SUCCEEDED
:
3952 /* consume read-ahead char */
3953 *buffer
++ = cp
->chr
;
3956 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3957 ResetEvent (cp
->char_avail
);
3959 case STATUS_READ_ACKNOWLEDGED
:
3963 DebPrint (("sys_read: bad status %d\n", current_status
));
3968 if (fd_info
[fd
].flags
& FILE_PIPE
)
3970 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3971 to_read
= min (waiting
, (DWORD
) count
);
3974 nchars
+= _read (fd
, buffer
, to_read
);
3977 else /* FILE_SOCKET */
3979 if (winsock_lib
== NULL
) abort ();
3981 /* do the equivalent of a non-blocking read */
3982 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3983 if (waiting
== 0 && nchars
== 0)
3985 h_errno
= errno
= EWOULDBLOCK
;
3991 /* always use binary mode for sockets */
3992 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3993 if (res
== SOCKET_ERROR
)
3995 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3996 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
4007 int nread
= _read (fd
, buffer
, count
);
4010 else if (nchars
== 0)
4015 fd_info
[fd
].flags
|= FILE_AT_EOF
;
4016 /* Perform text mode translation if required. */
4017 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
4019 nchars
= crlf_to_lf (nchars
, orig_buffer
);
4020 /* If buffer contains only CR, return that. To be absolutely
4021 sure we should attempt to read the next char, but in
4022 practice a CR to be followed by LF would not appear by
4023 itself in the buffer. */
4024 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
4026 fd_info
[fd
].flags
|= FILE_LAST_CR
;
4032 nchars
= _read (fd
, buffer
, count
);
4037 /* For now, don't bother with a non-blocking mode */
4039 sys_write (int fd
, const void * buffer
, unsigned int count
)
4049 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
4051 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
4057 /* Perform text mode translation if required. */
4058 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
4060 char * tmpbuf
= alloca (count
* 2);
4061 unsigned char * src
= (void *)buffer
;
4062 unsigned char * dst
= tmpbuf
;
4067 unsigned char *next
;
4068 /* copy next line or remaining bytes */
4069 next
= _memccpy (dst
, src
, '\n', nbytes
);
4072 /* copied one line ending with '\n' */
4073 int copied
= next
- dst
;
4076 /* insert '\r' before '\n' */
4083 /* copied remaining partial line -> now finished */
4091 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
4093 unsigned long nblock
= 0;
4094 if (winsock_lib
== NULL
) abort ();
4096 /* TODO: implement select() properly so non-blocking I/O works. */
4097 /* For now, make sure the write blocks. */
4098 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4099 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4101 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
4103 /* Set the socket back to non-blocking if it was before,
4104 for other operations that support it. */
4105 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4108 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4111 if (nchars
== SOCKET_ERROR
)
4113 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
4114 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
4120 nchars
= _write (fd
, buffer
, count
);
4126 check_windows_init_file ()
4128 extern int noninteractive
, inhibit_window_system
;
4130 /* A common indication that Emacs is not installed properly is when
4131 it cannot find the Windows installation file. If this file does
4132 not exist in the expected place, tell the user. */
4134 if (!noninteractive
&& !inhibit_window_system
)
4136 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
4137 Lisp_Object objs
[2];
4138 Lisp_Object full_load_path
;
4139 Lisp_Object init_file
;
4142 objs
[0] = Vload_path
;
4143 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
4144 full_load_path
= Fappend (2, objs
);
4145 init_file
= build_string ("term/w32-win");
4146 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
4149 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
4150 char *init_file_name
= SDATA (init_file
);
4151 char *load_path
= SDATA (load_path_print
);
4152 char *buffer
= alloca (1024
4153 + strlen (init_file_name
)
4154 + strlen (load_path
));
4157 "The Emacs Windows initialization file \"%s.el\" "
4158 "could not be found in your Emacs installation. "
4159 "Emacs checked the following directories for this file:\n"
4161 "When Emacs cannot find this file, it usually means that it "
4162 "was not installed properly, or its distribution file was "
4163 "not unpacked properly.\nSee the README.W32 file in the "
4164 "top-level Emacs directory for more information.",
4165 init_file_name
, load_path
);
4168 "Emacs Abort Dialog",
4169 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
4170 /* Use the low-level Emacs abort. */
4185 /* shutdown the socket interface if necessary */
4196 /* Initialise the socket interface now if available and requested by
4197 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4198 delayed until open-network-stream is called (w32-has-winsock can
4199 also be used to dynamically load or reload winsock).
4201 Conveniently, init_environment is called before us, so
4202 PRELOAD_WINSOCK can be set in the registry. */
4204 /* Always initialize this correctly. */
4207 if (getenv ("PRELOAD_WINSOCK") != NULL
)
4208 init_winsock (TRUE
);
4211 /* Initial preparation for subprocess support: replace our standard
4212 handles with non-inheritable versions. */
4215 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
4216 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
4217 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
4219 parent
= GetCurrentProcess ();
4221 /* ignore errors when duplicating and closing; typically the
4222 handles will be invalid when running as a gui program. */
4223 DuplicateHandle (parent
,
4224 GetStdHandle (STD_INPUT_HANDLE
),
4229 DUPLICATE_SAME_ACCESS
);
4231 DuplicateHandle (parent
,
4232 GetStdHandle (STD_OUTPUT_HANDLE
),
4237 DUPLICATE_SAME_ACCESS
);
4239 DuplicateHandle (parent
,
4240 GetStdHandle (STD_ERROR_HANDLE
),
4245 DUPLICATE_SAME_ACCESS
);
4251 if (stdin_save
!= INVALID_HANDLE_VALUE
)
4252 _open_osfhandle ((long) stdin_save
, O_TEXT
);
4254 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
4257 if (stdout_save
!= INVALID_HANDLE_VALUE
)
4258 _open_osfhandle ((long) stdout_save
, O_TEXT
);
4260 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4263 if (stderr_save
!= INVALID_HANDLE_VALUE
)
4264 _open_osfhandle ((long) stderr_save
, O_TEXT
);
4266 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4270 /* unfortunately, atexit depends on implementation of malloc */
4271 /* atexit (term_ntproc); */
4272 signal (SIGABRT
, term_ntproc
);
4274 /* determine which drives are fixed, for GetCachedVolumeInformation */
4276 /* GetDriveType must have trailing backslash. */
4277 char drive
[] = "A:\\";
4279 /* Loop over all possible drive letters */
4280 while (*drive
<= 'Z')
4282 /* Record if this drive letter refers to a fixed drive. */
4283 fixed_drives
[DRIVE_INDEX (*drive
)] =
4284 (GetDriveType (drive
) == DRIVE_FIXED
);
4289 /* Reset the volume info cache. */
4290 volume_cache
= NULL
;
4293 /* Check to see if Emacs has been installed correctly. */
4294 check_windows_init_file ();
4298 shutdown_handler ensures that buffers' autosave files are
4299 up to date when the user logs off, or the system shuts down.
4301 BOOL WINAPI
shutdown_handler(DWORD type
)
4303 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4304 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
4305 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
4306 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
4308 /* Shut down cleanly, making sure autosave files are up to date. */
4309 shut_down_emacs (0, 0, Qnil
);
4312 /* Allow other handlers to handle this signal. */
4317 globals_of_w32 is used to initialize those global variables that
4318 must always be initialized on startup even when the global variable
4319 initialized is non zero (see the function main in emacs.c).
4324 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
4326 get_process_times_fn
= (GetProcessTimes_Proc
)
4327 GetProcAddress (kernel32
, "GetProcessTimes");
4329 g_b_init_is_windows_9x
= 0;
4330 g_b_init_open_process_token
= 0;
4331 g_b_init_get_token_information
= 0;
4332 g_b_init_lookup_account_sid
= 0;
4333 g_b_init_get_sid_identifier_authority
= 0;
4334 g_b_init_get_sid_sub_authority
= 0;
4335 g_b_init_get_sid_sub_authority_count
= 0;
4336 /* The following sets a handler for shutdown notifications for
4337 console apps. This actually applies to Emacs in both console and
4338 GUI modes, since we had to fool windows into thinking emacs is a
4339 console application to get console mode to work. */
4340 SetConsoleCtrlHandler(shutdown_handler
, TRUE
);
4345 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4346 (do not change this comment) */