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);
640 /* Restrict to conventional uid range for normal users. */
641 the_passwd
.pw_uid
%= 60001;
645 if (get_token_information (token
, TokenPrimaryGroup
,
646 (PVOID
)buf
, sizeof (buf
), &trash
))
648 memcpy (&group_token
, buf
, sizeof (group_token
));
650 *get_sid_sub_authority_count (group_token
.PrimaryGroup
);
652 if (n_subauthorities
< 1)
653 the_passwd
.pw_gid
= 0; /* the "World" RID */
657 *get_sid_sub_authority (group_token
.PrimaryGroup
,
658 n_subauthorities
- 1);
659 /* I don't know if this is necessary, but for safety... */
660 the_passwd
.pw_gid
%= 60001;
664 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
667 /* If security calls are not supported (presumably because we
668 are running under Windows 95), fallback to this. */
669 else if (GetUserName (name
, &length
))
671 strcpy (the_passwd
.pw_name
, name
);
672 if (stricmp ("administrator", name
) == 0)
673 the_passwd
.pw_uid
= 0;
675 the_passwd
.pw_uid
= 123;
676 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
680 strcpy (the_passwd
.pw_name
, "unknown");
681 the_passwd
.pw_uid
= 123;
682 the_passwd
.pw_gid
= 123;
685 /* Ensure HOME and SHELL are defined. */
686 if (getenv ("HOME") == NULL
)
688 if (getenv ("SHELL") == NULL
)
691 /* Set dir and shell from environment variables. */
692 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
693 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
702 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
703 return ((rand () << 15) | rand ());
713 /* Normalize filename by converting all path separators to
714 the specified separator. Also conditionally convert upper
715 case path name components to lower case. */
718 normalize_filename (fp
, path_sep
)
725 /* Always lower-case drive letters a-z, even if the filesystem
726 preserves case in filenames.
727 This is so filenames can be compared by string comparison
728 functions that are case-sensitive. Even case-preserving filesystems
729 do not distinguish case in drive letters. */
730 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
736 if (NILP (Vw32_downcase_file_names
))
740 if (*fp
== '/' || *fp
== '\\')
747 sep
= path_sep
; /* convert to this path separator */
748 elem
= fp
; /* start of current path element */
751 if (*fp
>= 'a' && *fp
<= 'z')
752 elem
= 0; /* don't convert this element */
754 if (*fp
== 0 || *fp
== ':')
756 sep
= *fp
; /* restore current separator (or 0) */
757 *fp
= '/'; /* after conversion of this element */
760 if (*fp
== '/' || *fp
== '\\')
762 if (elem
&& elem
!= fp
)
764 *fp
= 0; /* temporary end of string */
765 _strlwr (elem
); /* while we convert to lower case */
767 *fp
= sep
; /* convert (or restore) path separator */
768 elem
= fp
+ 1; /* next element starts after separator */
774 /* Destructively turn backslashes into slashes. */
776 dostounix_filename (p
)
779 normalize_filename (p
, '/');
782 /* Destructively turn slashes into backslashes. */
784 unixtodos_filename (p
)
787 normalize_filename (p
, '\\');
790 /* Remove all CR's that are followed by a LF.
791 (From msdos.c...probably should figure out a way to share it,
792 although this code isn't going to ever change.) */
796 register unsigned char *buf
;
798 unsigned char *np
= buf
;
799 unsigned char *startp
= buf
;
800 unsigned char *endp
= buf
+ n
;
804 while (buf
< endp
- 1)
808 if (*(++buf
) != 0x0a)
819 /* Parse the root part of file name, if present. Return length and
820 optionally store pointer to char after root. */
822 parse_root (char * name
, char ** pPath
)
829 /* find the root name of the volume if given */
830 if (isalpha (name
[0]) && name
[1] == ':')
832 /* skip past drive specifier */
834 if (IS_DIRECTORY_SEP (name
[0]))
837 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
843 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
848 if (IS_DIRECTORY_SEP (name
[0]))
858 /* Get long base name for name; name is assumed to be absolute. */
860 get_long_basename (char * name
, char * buf
, int size
)
862 WIN32_FIND_DATA find_data
;
866 /* must be valid filename, no wild cards or other invalid characters */
867 if (_mbspbrk (name
, "*?|<>\""))
870 dir_handle
= FindFirstFile (name
, &find_data
);
871 if (dir_handle
!= INVALID_HANDLE_VALUE
)
873 if ((len
= strlen (find_data
.cFileName
)) < size
)
874 memcpy (buf
, find_data
.cFileName
, len
+ 1);
877 FindClose (dir_handle
);
882 /* Get long name for file, if possible (assumed to be absolute). */
884 w32_get_long_filename (char * name
, char * buf
, int size
)
889 char full
[ MAX_PATH
];
896 /* Use local copy for destructive modification. */
897 memcpy (full
, name
, len
+1);
898 unixtodos_filename (full
);
900 /* Copy root part verbatim. */
901 len
= parse_root (full
, &p
);
902 memcpy (o
, full
, len
);
907 while (p
!= NULL
&& *p
)
910 p
= strchr (q
, '\\');
912 len
= get_long_basename (full
, o
, size
);
935 is_unc_volume (const char *filename
)
937 const char *ptr
= filename
;
939 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
942 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
948 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
951 sigsetmask (int signal_mask
)
975 setpgrp (int pid
, int gid
)
986 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
989 w32_get_resource (key
, lpdwtype
)
994 HKEY hrootkey
= NULL
;
997 /* Check both the current user and the local machine to see if
998 we have any resources. */
1000 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1004 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1005 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1006 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1008 RegCloseKey (hrootkey
);
1012 if (lpvalue
) xfree (lpvalue
);
1014 RegCloseKey (hrootkey
);
1017 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1021 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1022 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1023 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1025 RegCloseKey (hrootkey
);
1029 if (lpvalue
) xfree (lpvalue
);
1031 RegCloseKey (hrootkey
);
1037 char *get_emacs_configuration (void);
1038 extern Lisp_Object Vsystem_configuration
;
1041 init_environment (char ** argv
)
1043 static const char * const tempdirs
[] = {
1044 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1049 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1051 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1052 temporary files and assume "/tmp" if $TMPDIR is unset, which
1053 will break on DOS/Windows. Refuse to work if we cannot find
1054 a directory, not even "c:/", usable for that purpose. */
1055 for (i
= 0; i
< imax
; i
++)
1057 const char *tmp
= tempdirs
[i
];
1060 tmp
= getenv (tmp
+ 1);
1061 /* Note that `access' can lie to us if the directory resides on a
1062 read-only filesystem, like CD-ROM or a write-protected floppy.
1063 The only way to be really sure is to actually create a file and
1064 see if it succeeds. But I think that's too much to ask. */
1065 if (tmp
&& _access (tmp
, D_OK
) == 0)
1067 char * var
= alloca (strlen (tmp
) + 8);
1068 sprintf (var
, "TMPDIR=%s", tmp
);
1069 _putenv (strdup (var
));
1076 Fcons (build_string ("no usable temporary directories found!!"),
1078 "While setting TMPDIR: ");
1080 /* Check for environment variables and use registry settings if they
1081 don't exist. Fallback on default values where applicable. */
1086 char locale_name
[32];
1087 struct stat ignored
;
1088 char default_home
[MAX_PATH
];
1090 static const struct env_entry
1097 {"PRELOAD_WINSOCK", NULL
},
1098 {"emacs_dir", "C:/emacs"},
1099 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1100 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1101 {"EMACSDATA", "%emacs_dir%/etc"},
1102 {"EMACSPATH", "%emacs_dir%/bin"},
1103 /* We no longer set INFOPATH because Info-default-directory-list
1105 /* {"INFOPATH", "%emacs_dir%/info"}, */
1106 {"EMACSDOC", "%emacs_dir%/etc"},
1111 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1113 /* We need to copy dflt_envvars[] and work on the copy because we
1114 don't want the dumped Emacs to inherit the values of
1115 environment variables we saw during dumping (which could be on
1116 a different system). The defaults above must be left intact. */
1117 struct env_entry env_vars
[N_ENV_VARS
];
1119 for (i
= 0; i
< N_ENV_VARS
; i
++)
1120 env_vars
[i
] = dflt_envvars
[i
];
1122 /* For backwards compatibility, check if a .emacs file exists in C:/
1123 If not, then we can try to default to the appdata directory under the
1124 user's profile, which is more likely to be writable. */
1125 if (stat ("C:/.emacs", &ignored
) < 0)
1127 HRESULT profile_result
;
1128 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1129 of Windows 95 and NT4 that have not been updated to include
1130 MSIE 5. Also we don't link with shell32.dll by default. */
1131 HMODULE shell32_dll
;
1132 ShGetFolderPath_fn get_folder_path
;
1133 shell32_dll
= GetModuleHandle ("shell32.dll");
1134 get_folder_path
= (ShGetFolderPath_fn
)
1135 GetProcAddress (shell32_dll
, "SHGetFolderPathA");
1137 if (get_folder_path
!= NULL
)
1139 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1142 /* If we can't get the appdata dir, revert to old behaviour. */
1143 if (profile_result
== S_OK
)
1144 env_vars
[0].def_value
= default_home
;
1147 /* Unload shell32.dll, it is not needed anymore. */
1148 FreeLibrary (shell32_dll
);
1151 /* Get default locale info and use it for LANG. */
1152 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1153 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1154 locale_name
, sizeof (locale_name
)))
1156 for (i
= 0; i
< N_ENV_VARS
; i
++)
1158 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1160 env_vars
[i
].def_value
= locale_name
;
1166 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1168 /* Treat emacs_dir specially: set it unconditionally based on our
1169 location, if it appears that we are running from the bin subdir
1170 of a standard installation. */
1173 char modname
[MAX_PATH
];
1175 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1177 if ((p
= strrchr (modname
, '\\')) == NULL
)
1181 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
1183 char buf
[SET_ENV_BUF_SIZE
];
1186 for (p
= modname
; *p
; p
++)
1187 if (*p
== '\\') *p
= '/';
1189 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1190 _putenv (strdup (buf
));
1192 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1194 /* FIXME: should use substring of get_emacs_configuration ().
1195 But I don't think the Windows build supports alpha, mips etc
1196 anymore, so have taken the easy option for now. */
1197 else if (p
&& stricmp (p
, "\\i386") == 0)
1200 p
= strrchr (modname
, '\\');
1204 p
= strrchr (modname
, '\\');
1205 if (p
&& stricmp (p
, "\\src") == 0)
1207 char buf
[SET_ENV_BUF_SIZE
];
1210 for (p
= modname
; *p
; p
++)
1211 if (*p
== '\\') *p
= '/';
1213 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1214 _putenv (strdup (buf
));
1220 for (i
= 0; i
< N_ENV_VARS
; i
++)
1222 if (!getenv (env_vars
[i
].name
))
1226 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1227 /* Also ignore empty environment variables. */
1230 if (lpval
) xfree (lpval
);
1231 lpval
= env_vars
[i
].def_value
;
1232 dwType
= REG_EXPAND_SZ
;
1238 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1240 if (dwType
== REG_EXPAND_SZ
)
1241 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
1242 else if (dwType
== REG_SZ
)
1243 strcpy (buf1
, lpval
);
1244 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1246 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
,
1248 _putenv (strdup (buf2
));
1258 /* Rebuild system configuration to reflect invoking system. */
1259 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1261 /* Another special case: on NT, the PATH variable is actually named
1262 "Path" although cmd.exe (perhaps NT itself) arranges for
1263 environment variable lookup and setting to be case insensitive.
1264 However, Emacs assumes a fully case sensitive environment, so we
1265 need to change "Path" to "PATH" to match the expectations of
1266 various elisp packages. We do this by the sneaky method of
1267 modifying the string in the C runtime environ entry.
1269 The same applies to COMSPEC. */
1273 for (envp
= environ
; *envp
; envp
++)
1274 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1275 memcpy (*envp
, "PATH=", 5);
1276 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1277 memcpy (*envp
, "COMSPEC=", 8);
1280 /* Remember the initial working directory for getwd, then make the
1281 real wd be the location of emacs.exe to avoid conflicts when
1282 renaming or deleting directories. (We also don't call chdir when
1283 running subprocesses for the same reason.) */
1284 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1289 static char modname
[MAX_PATH
];
1291 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1293 if ((p
= strrchr (modname
, '\\')) == NULL
)
1297 SetCurrentDirectory (modname
);
1299 /* Ensure argv[0] has the full path to Emacs. */
1304 /* Determine if there is a middle mouse button, to allow parse_button
1305 to decide whether right mouse events should be mouse-2 or
1307 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1313 emacs_root_dir (void)
1315 static char root_dir
[FILENAME_MAX
];
1318 p
= getenv ("emacs_dir");
1321 strcpy (root_dir
, p
);
1322 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1323 dostounix_filename (root_dir
);
1327 /* We don't have scripts to automatically determine the system configuration
1328 for Emacs before it's compiled, and we don't want to have to make the
1329 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1333 get_emacs_configuration (void)
1335 char *arch
, *oem
, *os
;
1337 static char configuration_buffer
[32];
1339 /* Determine the processor type. */
1340 switch (get_processor_type ())
1343 #ifdef PROCESSOR_INTEL_386
1344 case PROCESSOR_INTEL_386
:
1345 case PROCESSOR_INTEL_486
:
1346 case PROCESSOR_INTEL_PENTIUM
:
1351 #ifdef PROCESSOR_MIPS_R2000
1352 case PROCESSOR_MIPS_R2000
:
1353 case PROCESSOR_MIPS_R3000
:
1354 case PROCESSOR_MIPS_R4000
:
1359 #ifdef PROCESSOR_ALPHA_21064
1360 case PROCESSOR_ALPHA_21064
:
1370 /* Use the OEM field to reflect the compiler/library combination. */
1372 #define COMPILER_NAME "msvc"
1375 #define COMPILER_NAME "mingw"
1377 #define COMPILER_NAME "unknown"
1380 oem
= COMPILER_NAME
;
1382 switch (osinfo_cache
.dwPlatformId
) {
1383 case VER_PLATFORM_WIN32_NT
:
1385 build_num
= osinfo_cache
.dwBuildNumber
;
1387 case VER_PLATFORM_WIN32_WINDOWS
:
1388 if (osinfo_cache
.dwMinorVersion
== 0) {
1393 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1395 case VER_PLATFORM_WIN32s
:
1396 /* Not supported, should not happen. */
1398 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1406 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1407 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1408 get_w32_major_version (), get_w32_minor_version (), build_num
);
1410 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1413 return configuration_buffer
;
1417 get_emacs_configuration_options (void)
1419 static char options_buffer
[256];
1421 /* Work out the effective configure options for this build. */
1423 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1426 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1428 #define COMPILER_VERSION ""
1432 sprintf (options_buffer
, COMPILER_VERSION
);
1434 strcat (options_buffer
, " --no-opt");
1437 strcat (options_buffer
, " --cflags");
1438 strcat (options_buffer
, USER_CFLAGS
);
1441 strcat (options_buffer
, " --ldflags");
1442 strcat (options_buffer
, USER_LDFLAGS
);
1444 return options_buffer
;
1448 #include <sys/timeb.h>
1450 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1452 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1457 tv
->tv_sec
= tb
.time
;
1458 tv
->tv_usec
= tb
.millitm
* 1000L;
1461 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1462 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1466 /* ------------------------------------------------------------------------- */
1467 /* IO support and wrapper functions for W32 API. */
1468 /* ------------------------------------------------------------------------- */
1470 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1471 on network directories, so we handle that case here.
1472 (Ulrich Leodolter, 1/11/95). */
1474 sys_ctime (const time_t *t
)
1476 char *str
= (char *) ctime (t
);
1477 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1480 /* Emulate sleep...we could have done this with a define, but that
1481 would necessitate including windows.h in the files that used it.
1482 This is much easier. */
1484 sys_sleep (int seconds
)
1486 Sleep (seconds
* 1000);
1489 /* Internal MSVC functions for low-level descriptor munging */
1490 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1491 extern int __cdecl
_free_osfhnd (int fd
);
1493 /* parallel array of private info on file handles */
1494 filedesc fd_info
[ MAXDESC
];
1496 typedef struct volume_info_data
{
1497 struct volume_info_data
* next
;
1499 /* time when info was obtained */
1502 /* actual volume info */
1511 /* Global referenced by various functions. */
1512 static volume_info_data volume_info
;
1514 /* Vector to indicate which drives are local and fixed (for which cached
1515 data never expires). */
1516 static BOOL fixed_drives
[26];
1518 /* Consider cached volume information to be stale if older than 10s,
1519 at least for non-local drives. Info for fixed drives is never stale. */
1520 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1521 #define VOLINFO_STILL_VALID( root_dir, info ) \
1522 ( ( isalpha (root_dir[0]) && \
1523 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1524 || GetTickCount () - info->timestamp < 10000 )
1526 /* Cache support functions. */
1528 /* Simple linked list with linear search is sufficient. */
1529 static volume_info_data
*volume_cache
= NULL
;
1531 static volume_info_data
*
1532 lookup_volume_info (char * root_dir
)
1534 volume_info_data
* info
;
1536 for (info
= volume_cache
; info
; info
= info
->next
)
1537 if (stricmp (info
->root_dir
, root_dir
) == 0)
1543 add_volume_info (char * root_dir
, volume_info_data
* info
)
1545 info
->root_dir
= xstrdup (root_dir
);
1546 info
->next
= volume_cache
;
1547 volume_cache
= info
;
1551 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1552 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1553 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1555 GetCachedVolumeInformation (char * root_dir
)
1557 volume_info_data
* info
;
1558 char default_root
[ MAX_PATH
];
1560 /* NULL for root_dir means use root from current directory. */
1561 if (root_dir
== NULL
)
1563 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1565 parse_root (default_root
, &root_dir
);
1567 root_dir
= default_root
;
1570 /* Local fixed drives can be cached permanently. Removable drives
1571 cannot be cached permanently, since the volume name and serial
1572 number (if nothing else) can change. Remote drives should be
1573 treated as if they are removable, since there is no sure way to
1574 tell whether they are or not. Also, the UNC association of drive
1575 letters mapped to remote volumes can be changed at any time (even
1576 by other processes) without notice.
1578 As a compromise, so we can benefit from caching info for remote
1579 volumes, we use a simple expiry mechanism to invalidate cache
1580 entries that are more than ten seconds old. */
1583 /* No point doing this, because WNetGetConnection is even slower than
1584 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1585 GetDriveType is about the only call of this type which does not
1586 involve network access, and so is extremely quick). */
1588 /* Map drive letter to UNC if remote. */
1589 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1591 char remote_name
[ 256 ];
1592 char drive
[3] = { root_dir
[0], ':' };
1594 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1596 /* do something */ ;
1600 info
= lookup_volume_info (root_dir
);
1602 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1610 /* Info is not cached, or is stale. */
1611 if (!GetVolumeInformation (root_dir
,
1612 name
, sizeof (name
),
1616 type
, sizeof (type
)))
1619 /* Cache the volume information for future use, overwriting existing
1620 entry if present. */
1623 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1624 add_volume_info (root_dir
, info
);
1632 info
->name
= xstrdup (name
);
1633 info
->serialnum
= serialnum
;
1634 info
->maxcomp
= maxcomp
;
1635 info
->flags
= flags
;
1636 info
->type
= xstrdup (type
);
1637 info
->timestamp
= GetTickCount ();
1643 /* Get information on the volume where name is held; set path pointer to
1644 start of pathname in name (past UNC header\volume header if present). */
1646 get_volume_info (const char * name
, const char ** pPath
)
1648 char temp
[MAX_PATH
];
1649 char *rootname
= NULL
; /* default to current volume */
1650 volume_info_data
* info
;
1655 /* find the root name of the volume if given */
1656 if (isalpha (name
[0]) && name
[1] == ':')
1664 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1671 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1684 info
= GetCachedVolumeInformation (rootname
);
1687 /* Set global referenced by other functions. */
1688 volume_info
= *info
;
1694 /* Determine if volume is FAT format (ie. only supports short 8.3
1695 names); also set path pointer to start of pathname in name. */
1697 is_fat_volume (const char * name
, const char ** pPath
)
1699 if (get_volume_info (name
, pPath
))
1700 return (volume_info
.maxcomp
== 12);
1704 /* Map filename to a valid 8.3 name if necessary. */
1706 map_w32_filename (const char * name
, const char ** pPath
)
1708 static char shortname
[MAX_PATH
];
1709 char * str
= shortname
;
1712 const char * save_name
= name
;
1714 if (strlen (name
) >= MAX_PATH
)
1716 /* Return a filename which will cause callers to fail. */
1717 strcpy (shortname
, "?");
1721 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1723 register int left
= 8; /* maximum number of chars in part */
1724 register int extn
= 0; /* extension added? */
1725 register int dots
= 2; /* maximum number of dots allowed */
1728 *str
++ = *name
++; /* skip past UNC header */
1730 while ((c
= *name
++))
1737 extn
= 0; /* reset extension flags */
1738 dots
= 2; /* max 2 dots */
1739 left
= 8; /* max length 8 for main part */
1743 extn
= 0; /* reset extension flags */
1744 dots
= 2; /* max 2 dots */
1745 left
= 8; /* max length 8 for main part */
1750 /* Convert path components of the form .xxx to _xxx,
1751 but leave . and .. as they are. This allows .emacs
1752 to be read as _emacs, for example. */
1756 IS_DIRECTORY_SEP (*name
))
1771 extn
= 1; /* we've got an extension */
1772 left
= 3; /* 3 chars in extension */
1776 /* any embedded dots after the first are converted to _ */
1781 case '#': /* don't lose these, they're important */
1783 str
[-1] = c
; /* replace last character of part */
1788 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1790 dots
= 0; /* started a path component */
1799 strcpy (shortname
, name
);
1800 unixtodos_filename (shortname
);
1804 *pPath
= shortname
+ (path
- save_name
);
1810 is_exec (const char * name
)
1812 char * p
= strrchr (name
, '.');
1815 && (stricmp (p
, ".exe") == 0 ||
1816 stricmp (p
, ".com") == 0 ||
1817 stricmp (p
, ".bat") == 0 ||
1818 stricmp (p
, ".cmd") == 0));
1821 /* Emulate the Unix directory procedures opendir, closedir,
1822 and readdir. We can't use the procedures supplied in sysdep.c,
1823 so we provide them here. */
1825 struct direct dir_static
; /* simulated directory contents */
1826 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1827 static int dir_is_fat
;
1828 static char dir_pathname
[MAXPATHLEN
+1];
1829 static WIN32_FIND_DATA dir_find_data
;
1831 /* Support shares on a network resource as subdirectories of a read-only
1833 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1834 HANDLE
open_unc_volume (const char *);
1835 char *read_unc_volume (HANDLE
, char *, int);
1836 void close_unc_volume (HANDLE
);
1839 opendir (char *filename
)
1843 /* Opening is done by FindFirstFile. However, a read is inherent to
1844 this operation, so we defer the open until read time. */
1846 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1848 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1851 if (is_unc_volume (filename
))
1853 wnet_enum_handle
= open_unc_volume (filename
);
1854 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1858 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1865 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1866 dir_pathname
[MAXPATHLEN
] = '\0';
1867 dir_is_fat
= is_fat_volume (filename
, NULL
);
1873 closedir (DIR *dirp
)
1875 /* If we have a find-handle open, close it. */
1876 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1878 FindClose (dir_find_handle
);
1879 dir_find_handle
= INVALID_HANDLE_VALUE
;
1881 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1883 close_unc_volume (wnet_enum_handle
);
1884 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1886 xfree ((char *) dirp
);
1892 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1894 if (!read_unc_volume (wnet_enum_handle
,
1895 dir_find_data
.cFileName
,
1899 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1900 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1902 char filename
[MAXNAMLEN
+ 3];
1905 strcpy (filename
, dir_pathname
);
1906 ln
= strlen (filename
) - 1;
1907 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1908 strcat (filename
, "\\");
1909 strcat (filename
, "*");
1911 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1913 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1918 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1922 /* Emacs never uses this value, so don't bother making it match
1923 value returned by stat(). */
1924 dir_static
.d_ino
= 1;
1926 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1927 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1929 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1930 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1932 _strlwr (dir_static
.d_name
);
1933 else if (!NILP (Vw32_downcase_file_names
))
1936 for (p
= dir_static
.d_name
; *p
; p
++)
1937 if (*p
>= 'a' && *p
<= 'z')
1940 _strlwr (dir_static
.d_name
);
1947 open_unc_volume (const char *path
)
1953 nr
.dwScope
= RESOURCE_GLOBALNET
;
1954 nr
.dwType
= RESOURCETYPE_DISK
;
1955 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1956 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1957 nr
.lpLocalName
= NULL
;
1958 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
1959 nr
.lpComment
= NULL
;
1960 nr
.lpProvider
= NULL
;
1962 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1963 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1965 if (result
== NO_ERROR
)
1968 return INVALID_HANDLE_VALUE
;
1972 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1976 DWORD bufsize
= 512;
1981 buffer
= alloca (bufsize
);
1982 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1983 if (result
!= NO_ERROR
)
1986 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1987 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1989 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1992 strncpy (readbuf
, ptr
, size
);
1997 close_unc_volume (HANDLE henum
)
1999 if (henum
!= INVALID_HANDLE_VALUE
)
2000 WNetCloseEnum (henum
);
2004 unc_volume_file_attributes (const char *path
)
2009 henum
= open_unc_volume (path
);
2010 if (henum
== INVALID_HANDLE_VALUE
)
2013 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2015 close_unc_volume (henum
);
2020 /* Ensure a network connection is authenticated. */
2022 logon_network_drive (const char *path
)
2024 NETRESOURCE resource
;
2025 char share
[MAX_PATH
];
2028 /* Only logon to networked drives. */
2029 if (!IS_DIRECTORY_SEP (path
[0]) || !IS_DIRECTORY_SEP (path
[1]))
2032 strncpy (share
, path
, MAX_PATH
);
2033 /* Truncate to just server and share name. */
2034 for (i
= 2; i
< MAX_PATH
; i
++)
2036 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2043 resource
.dwType
= RESOURCETYPE_DISK
;
2044 resource
.lpLocalName
= NULL
;
2045 resource
.lpRemoteName
= share
;
2046 resource
.lpProvider
= NULL
;
2048 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2051 /* Shadow some MSVC runtime functions to map requests for long filenames
2052 to reasonable short names if necessary. This was originally added to
2053 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2057 sys_access (const char * path
, int mode
)
2061 /* MSVC implementation doesn't recognize D_OK. */
2062 path
= map_w32_filename (path
, NULL
);
2063 if (is_unc_volume (path
))
2065 attributes
= unc_volume_file_attributes (path
);
2066 if (attributes
== -1) {
2071 else if ((attributes
= GetFileAttributes (path
)) == -1)
2073 /* Should try mapping GetLastError to errno; for now just indicate
2074 that path doesn't exist. */
2078 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2083 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2088 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2097 sys_chdir (const char * path
)
2099 return _chdir (map_w32_filename (path
, NULL
));
2103 sys_chmod (const char * path
, int mode
)
2105 return _chmod (map_w32_filename (path
, NULL
), mode
);
2109 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2111 if (sys_chmod (path
, _S_IREAD
) == -1) /* check if file exists */
2117 sys_creat (const char * path
, int mode
)
2119 return _creat (map_w32_filename (path
, NULL
), mode
);
2123 sys_fopen(const char * path
, const char * mode
)
2127 const char * mode_save
= mode
;
2129 /* Force all file handles to be non-inheritable. This is necessary to
2130 ensure child processes don't unwittingly inherit handles that might
2131 prevent future file access. */
2135 else if (mode
[0] == 'w' || mode
[0] == 'a')
2136 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2140 /* Only do simplistic option parsing. */
2144 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2147 else if (mode
[0] == 'b')
2152 else if (mode
[0] == 't')
2159 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2163 return _fdopen (fd
, mode_save
);
2166 /* This only works on NTFS volumes, but is useful to have. */
2168 sys_link (const char * old
, const char * new)
2172 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2174 if (old
== NULL
|| new == NULL
)
2180 strcpy (oldname
, map_w32_filename (old
, NULL
));
2181 strcpy (newname
, map_w32_filename (new, NULL
));
2183 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2184 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2185 if (fileh
!= INVALID_HANDLE_VALUE
)
2189 /* Confusingly, the "alternate" stream name field does not apply
2190 when restoring a hard link, and instead contains the actual
2191 stream data for the link (ie. the name of the link to create).
2192 The WIN32_STREAM_ID structure before the cStreamName field is
2193 the stream header, which is then immediately followed by the
2197 WIN32_STREAM_ID wid
;
2198 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2201 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2202 data
.wid
.cStreamName
, MAX_PATH
);
2205 LPVOID context
= NULL
;
2208 data
.wid
.dwStreamId
= BACKUP_LINK
;
2209 data
.wid
.dwStreamAttributes
= 0;
2210 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
2211 data
.wid
.Size
.HighPart
= 0;
2212 data
.wid
.dwStreamNameSize
= 0;
2214 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2215 offsetof (WIN32_STREAM_ID
, cStreamName
)
2216 + data
.wid
.Size
.LowPart
,
2217 &wbytes
, FALSE
, FALSE
, &context
)
2218 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2225 /* Should try mapping GetLastError to errno; for now just
2226 indicate a general error (eg. links not supported). */
2227 errno
= EINVAL
; // perhaps EMLINK?
2231 CloseHandle (fileh
);
2240 sys_mkdir (const char * path
)
2242 return _mkdir (map_w32_filename (path
, NULL
));
2245 /* Because of long name mapping issues, we need to implement this
2246 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2247 a unique name, instead of setting the input template to an empty
2250 Standard algorithm seems to be use pid or tid with a letter on the
2251 front (in place of the 6 X's) and cycle through the letters to find a
2252 unique name. We extend that to allow any reasonable character as the
2253 first of the 6 X's. */
2255 sys_mktemp (char * template)
2259 unsigned uid
= GetCurrentThreadId ();
2260 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2262 if (template == NULL
)
2264 p
= template + strlen (template);
2266 /* replace up to the last 5 X's with uid in decimal */
2267 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2269 p
[0] = '0' + uid
% 10;
2273 if (i
< 0 && p
[0] == 'X')
2278 int save_errno
= errno
;
2279 p
[0] = first_char
[i
];
2280 if (sys_access (template, 0) < 0)
2286 while (++i
< sizeof (first_char
));
2289 /* Template is badly formed or else we can't generate a unique name,
2290 so return empty string */
2296 sys_open (const char * path
, int oflag
, int mode
)
2298 const char* mpath
= map_w32_filename (path
, NULL
);
2299 /* Try to open file without _O_CREAT, to be able to write to hidden
2300 and system files. Force all file handles to be
2302 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2305 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2309 sys_rename (const char * oldname
, const char * newname
)
2312 char temp
[MAX_PATH
];
2314 /* MoveFile on Windows 95 doesn't correctly change the short file name
2315 alias in a number of circumstances (it is not easy to predict when
2316 just by looking at oldname and newname, unfortunately). In these
2317 cases, renaming through a temporary name avoids the problem.
2319 A second problem on Windows 95 is that renaming through a temp name when
2320 newname is uppercase fails (the final long name ends up in
2321 lowercase, although the short alias might be uppercase) UNLESS the
2322 long temp name is not 8.3.
2324 So, on Windows 95 we always rename through a temp name, and we make sure
2325 the temp name has a long extension to ensure correct renaming. */
2327 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2329 if (os_subtype
== OS_WIN95
)
2335 oldname
= map_w32_filename (oldname
, NULL
);
2336 if (o
= strrchr (oldname
, '\\'))
2339 o
= (char *) oldname
;
2341 if (p
= strrchr (temp
, '\\'))
2348 /* Force temp name to require a manufactured 8.3 alias - this
2349 seems to make the second rename work properly. */
2350 sprintf (p
, "_.%s.%u", o
, i
);
2352 result
= rename (oldname
, temp
);
2354 /* This loop must surely terminate! */
2355 while (result
< 0 && errno
== EEXIST
);
2360 /* Emulate Unix behaviour - newname is deleted if it already exists
2361 (at least if it is a file; don't do this for directories).
2363 Since we mustn't do this if we are just changing the case of the
2364 file name (we would end up deleting the file we are trying to
2365 rename!), we let rename detect if the destination file already
2366 exists - that way we avoid the possible pitfalls of trying to
2367 determine ourselves whether two names really refer to the same
2368 file, which is not always possible in the general case. (Consider
2369 all the permutations of shared or subst'd drives, etc.) */
2371 newname
= map_w32_filename (newname
, NULL
);
2372 result
= rename (temp
, newname
);
2376 && _chmod (newname
, 0666) == 0
2377 && _unlink (newname
) == 0)
2378 result
= rename (temp
, newname
);
2384 sys_rmdir (const char * path
)
2386 return _rmdir (map_w32_filename (path
, NULL
));
2390 sys_unlink (const char * path
)
2392 path
= map_w32_filename (path
, NULL
);
2394 /* On Unix, unlink works without write permission. */
2395 _chmod (path
, 0666);
2396 return _unlink (path
);
2399 static FILETIME utc_base_ft
;
2400 static long double utc_base
;
2401 static int init
= 0;
2404 convert_time (FILETIME ft
)
2410 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2419 st
.wMilliseconds
= 0;
2421 SystemTimeToFileTime (&st
, &utc_base_ft
);
2422 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2423 * 4096.0L * 1024.0L * 1024.0L + utc_base_ft
.dwLowDateTime
;
2427 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2430 ret
= (long double) ft
.dwHighDateTime
2431 * 4096.0L * 1024.0L * 1024.0L + ft
.dwLowDateTime
;
2433 return (time_t) (ret
* 1e-7L);
2437 convert_from_time_t (time_t time
, FILETIME
* pft
)
2443 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2452 st
.wMilliseconds
= 0;
2454 SystemTimeToFileTime (&st
, &utc_base_ft
);
2455 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2456 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2460 /* time in 100ns units since 1-Jan-1601 */
2461 tmp
= (long double) time
* 1e7
+ utc_base
;
2462 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2463 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2467 /* No reason to keep this; faking inode values either by hashing or even
2468 using the file index from GetInformationByHandle, is not perfect and
2469 so by default Emacs doesn't use the inode values on Windows.
2470 Instead, we now determine file-truename correctly (except for
2471 possible drive aliasing etc). */
2473 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2475 hashval (const unsigned char * str
)
2480 h
= (h
<< 4) + *str
++;
2486 /* Return the hash value of the canonical pathname, excluding the
2487 drive/UNC header, to get a hopefully unique inode number. */
2489 generate_inode_val (const char * name
)
2491 char fullname
[ MAX_PATH
];
2495 /* Get the truly canonical filename, if it exists. (Note: this
2496 doesn't resolve aliasing due to subst commands, or recognise hard
2498 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2501 parse_root (fullname
, &p
);
2502 /* Normal W32 filesystems are still case insensitive. */
2509 /* MSVC stat function can't cope with UNC names and has other bugs, so
2510 replace it with our own. This also allows us to calculate consistent
2511 inode values without hacks in the main Emacs code. */
2513 stat (const char * path
, struct stat
* buf
)
2516 WIN32_FIND_DATA wfd
;
2521 int rootdir
= FALSE
;
2523 if (path
== NULL
|| buf
== NULL
)
2529 name
= (char *) map_w32_filename (path
, &path
);
2530 /* Must be valid filename, no wild cards or other invalid
2531 characters. We use _mbspbrk to support multibyte strings that
2532 might look to strpbrk as if they included literal *, ?, and other
2533 characters mentioned below that are disallowed by Windows
2535 if (_mbspbrk (name
, "*?|<>\""))
2541 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2542 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2543 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2548 /* Remove trailing directory separator, unless name is the root
2549 directory of a drive or UNC volume in which case ensure there
2550 is a trailing separator. */
2551 len
= strlen (name
);
2552 rootdir
= (path
>= name
+ len
- 1
2553 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2554 name
= strcpy (alloca (len
+ 2), name
);
2556 if (is_unc_volume (name
))
2558 DWORD attrs
= unc_volume_file_attributes (name
);
2563 memset (&wfd
, 0, sizeof (wfd
));
2564 wfd
.dwFileAttributes
= attrs
;
2565 wfd
.ftCreationTime
= utc_base_ft
;
2566 wfd
.ftLastAccessTime
= utc_base_ft
;
2567 wfd
.ftLastWriteTime
= utc_base_ft
;
2568 strcpy (wfd
.cFileName
, name
);
2572 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2573 strcat (name
, "\\");
2574 if (GetDriveType (name
) < 2)
2579 memset (&wfd
, 0, sizeof (wfd
));
2580 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2581 wfd
.ftCreationTime
= utc_base_ft
;
2582 wfd
.ftLastAccessTime
= utc_base_ft
;
2583 wfd
.ftLastWriteTime
= utc_base_ft
;
2584 strcpy (wfd
.cFileName
, name
);
2588 if (IS_DIRECTORY_SEP (name
[len
-1]))
2591 /* (This is hacky, but helps when doing file completions on
2592 network drives.) Optimize by using information available from
2593 active readdir if possible. */
2594 len
= strlen (dir_pathname
);
2595 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2597 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2598 && strnicmp (name
, dir_pathname
, len
) == 0
2599 && IS_DIRECTORY_SEP (name
[len
])
2600 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2602 /* This was the last entry returned by readdir. */
2603 wfd
= dir_find_data
;
2607 logon_network_drive (name
);
2609 fh
= FindFirstFile (name
, &wfd
);
2610 if (fh
== INVALID_HANDLE_VALUE
)
2619 if (!NILP (Vw32_get_true_file_attributes
)
2620 /* No access rights required to get info. */
2621 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
2622 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
2623 != INVALID_HANDLE_VALUE
)
2625 /* This is more accurate in terms of gettting the correct number
2626 of links, but is quite slow (it is noticeable when Emacs is
2627 making a list of file name completions). */
2628 BY_HANDLE_FILE_INFORMATION info
;
2630 if (GetFileInformationByHandle (fh
, &info
))
2632 buf
->st_nlink
= info
.nNumberOfLinks
;
2633 /* Might as well use file index to fake inode values, but this
2634 is not guaranteed to be unique unless we keep a handle open
2635 all the time (even then there are situations where it is
2636 not unique). Reputedly, there are at most 48 bits of info
2637 (on NTFS, presumably less on FAT). */
2638 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2646 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2648 buf
->st_mode
= _S_IFDIR
;
2652 switch (GetFileType (fh
))
2654 case FILE_TYPE_DISK
:
2655 buf
->st_mode
= _S_IFREG
;
2657 case FILE_TYPE_PIPE
:
2658 buf
->st_mode
= _S_IFIFO
;
2660 case FILE_TYPE_CHAR
:
2661 case FILE_TYPE_UNKNOWN
:
2663 buf
->st_mode
= _S_IFCHR
;
2670 /* Don't bother to make this information more accurate. */
2671 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
2672 _S_IFDIR
: _S_IFREG
;
2678 /* Not sure if there is any point in this. */
2679 if (!NILP (Vw32_generate_fake_inodes
))
2680 fake_inode
= generate_inode_val (name
);
2681 else if (fake_inode
== 0)
2683 /* For want of something better, try to make everything unique. */
2684 static DWORD gen_num
= 0;
2685 fake_inode
= ++gen_num
;
2689 /* MSVC defines _ino_t to be short; other libc's might not. */
2690 if (sizeof (buf
->st_ino
) == 2)
2691 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2693 buf
->st_ino
= fake_inode
;
2695 /* consider files to belong to current user */
2696 buf
->st_uid
= the_passwd
.pw_uid
;
2697 buf
->st_gid
= the_passwd
.pw_gid
;
2699 /* volume_info is set indirectly by map_w32_filename */
2700 buf
->st_dev
= volume_info
.serialnum
;
2701 buf
->st_rdev
= volume_info
.serialnum
;
2704 buf
->st_size
= wfd
.nFileSizeLow
;
2706 /* Convert timestamps to Unix format. */
2707 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2708 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2709 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2710 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2711 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2713 /* determine rwx permissions */
2714 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2715 permission
= _S_IREAD
;
2717 permission
= _S_IREAD
| _S_IWRITE
;
2719 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2720 permission
|= _S_IEXEC
;
2721 else if (is_exec (name
))
2722 permission
|= _S_IEXEC
;
2724 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2729 /* Provide fstat and utime as well as stat for consistent handling of
2732 fstat (int desc
, struct stat
* buf
)
2734 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2735 BY_HANDLE_FILE_INFORMATION info
;
2739 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2741 case FILE_TYPE_DISK
:
2742 buf
->st_mode
= _S_IFREG
;
2743 if (!GetFileInformationByHandle (fh
, &info
))
2749 case FILE_TYPE_PIPE
:
2750 buf
->st_mode
= _S_IFIFO
;
2752 case FILE_TYPE_CHAR
:
2753 case FILE_TYPE_UNKNOWN
:
2755 buf
->st_mode
= _S_IFCHR
;
2757 memset (&info
, 0, sizeof (info
));
2758 info
.dwFileAttributes
= 0;
2759 info
.ftCreationTime
= utc_base_ft
;
2760 info
.ftLastAccessTime
= utc_base_ft
;
2761 info
.ftLastWriteTime
= utc_base_ft
;
2764 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2765 buf
->st_mode
= _S_IFDIR
;
2767 buf
->st_nlink
= info
.nNumberOfLinks
;
2768 /* Might as well use file index to fake inode values, but this
2769 is not guaranteed to be unique unless we keep a handle open
2770 all the time (even then there are situations where it is
2771 not unique). Reputedly, there are at most 48 bits of info
2772 (on NTFS, presumably less on FAT). */
2773 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2775 /* MSVC defines _ino_t to be short; other libc's might not. */
2776 if (sizeof (buf
->st_ino
) == 2)
2777 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2779 buf
->st_ino
= fake_inode
;
2781 /* consider files to belong to current user */
2782 buf
->st_uid
= the_passwd
.pw_uid
;
2783 buf
->st_gid
= the_passwd
.pw_gid
;
2785 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2786 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2788 buf
->st_size
= info
.nFileSizeLow
;
2790 /* Convert timestamps to Unix format. */
2791 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2792 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2793 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2794 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2795 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2797 /* determine rwx permissions */
2798 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2799 permission
= _S_IREAD
;
2801 permission
= _S_IREAD
| _S_IWRITE
;
2803 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2804 permission
|= _S_IEXEC
;
2807 #if 0 /* no way of knowing the filename */
2808 char * p
= strrchr (name
, '.');
2810 (stricmp (p
, ".exe") == 0 ||
2811 stricmp (p
, ".com") == 0 ||
2812 stricmp (p
, ".bat") == 0 ||
2813 stricmp (p
, ".cmd") == 0))
2814 permission
|= _S_IEXEC
;
2818 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2824 utime (const char *name
, struct utimbuf
*times
)
2826 struct utimbuf deftime
;
2833 deftime
.modtime
= deftime
.actime
= time (NULL
);
2837 /* Need write access to set times. */
2838 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2839 0, OPEN_EXISTING
, 0, NULL
);
2842 convert_from_time_t (times
->actime
, &atime
);
2843 convert_from_time_t (times
->modtime
, &mtime
);
2844 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2862 /* Wrappers for winsock functions to map between our file descriptors
2863 and winsock's handles; also set h_errno for convenience.
2865 To allow Emacs to run on systems which don't have winsock support
2866 installed, we dynamically link to winsock on startup if present, and
2867 otherwise provide the minimum necessary functionality
2868 (eg. gethostname). */
2870 /* function pointers for relevant socket functions */
2871 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2872 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2873 int (PASCAL
*pfn_WSAGetLastError
) (void);
2874 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
2875 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
2876 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
2877 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2878 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2879 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2880 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2881 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2882 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2883 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2884 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2885 int (PASCAL
*pfn_WSACleanup
) (void);
2887 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2888 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2889 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2890 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2891 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2892 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2893 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
2894 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2895 const char * optval
, int optlen
);
2896 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2897 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2899 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2900 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2901 struct sockaddr
* from
, int * fromlen
);
2902 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2903 const struct sockaddr
* to
, int tolen
);
2905 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2906 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2907 #ifndef HANDLE_FLAG_INHERIT
2908 #define HANDLE_FLAG_INHERIT 1
2912 static int winsock_inuse
;
2917 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2919 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2920 after WSAStartup returns successfully, but it seems reasonable
2921 to allow unloading winsock anyway in that case. */
2922 if (pfn_WSACleanup () == 0 ||
2923 pfn_WSAGetLastError () == WSAENETDOWN
)
2925 if (FreeLibrary (winsock_lib
))
2934 init_winsock (int load_now
)
2936 WSADATA winsockData
;
2938 if (winsock_lib
!= NULL
)
2941 pfn_SetHandleInformation
= NULL
;
2942 pfn_SetHandleInformation
2943 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2944 "SetHandleInformation");
2946 winsock_lib
= LoadLibrary ("Ws2_32.dll");
2948 if (winsock_lib
!= NULL
)
2950 /* dynamically link to socket functions */
2952 #define LOAD_PROC(fn) \
2953 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2956 LOAD_PROC( WSAStartup
);
2957 LOAD_PROC( WSASetLastError
);
2958 LOAD_PROC( WSAGetLastError
);
2959 LOAD_PROC( WSAEventSelect
);
2960 LOAD_PROC( WSACreateEvent
);
2961 LOAD_PROC( WSACloseEvent
);
2962 LOAD_PROC( socket
);
2964 LOAD_PROC( connect
);
2965 LOAD_PROC( ioctlsocket
);
2968 LOAD_PROC( closesocket
);
2969 LOAD_PROC( shutdown
);
2972 LOAD_PROC( inet_addr
);
2973 LOAD_PROC( gethostname
);
2974 LOAD_PROC( gethostbyname
);
2975 LOAD_PROC( getservbyname
);
2976 LOAD_PROC( getpeername
);
2977 LOAD_PROC( WSACleanup
);
2978 LOAD_PROC( setsockopt
);
2979 LOAD_PROC( listen
);
2980 LOAD_PROC( getsockname
);
2981 LOAD_PROC( accept
);
2982 LOAD_PROC( recvfrom
);
2983 LOAD_PROC( sendto
);
2986 /* specify version 1.1 of winsock */
2987 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2989 if (winsockData
.wVersion
!= 0x101)
2994 /* Report that winsock exists and is usable, but leave
2995 socket functions disabled. I am assuming that calling
2996 WSAStartup does not require any network interaction,
2997 and in particular does not cause or require a dial-up
2998 connection to be established. */
3001 FreeLibrary (winsock_lib
);
3009 FreeLibrary (winsock_lib
);
3019 /* function to set h_errno for compatability; map winsock error codes to
3020 normal system codes where they overlap (non-overlapping definitions
3021 are already in <sys/socket.h> */
3025 if (winsock_lib
== NULL
)
3028 h_errno
= pfn_WSAGetLastError ();
3032 case WSAEACCES
: h_errno
= EACCES
; break;
3033 case WSAEBADF
: h_errno
= EBADF
; break;
3034 case WSAEFAULT
: h_errno
= EFAULT
; break;
3035 case WSAEINTR
: h_errno
= EINTR
; break;
3036 case WSAEINVAL
: h_errno
= EINVAL
; break;
3037 case WSAEMFILE
: h_errno
= EMFILE
; break;
3038 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
3039 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
3047 if (h_errno
== 0 && winsock_lib
!= NULL
)
3048 pfn_WSASetLastError (0);
3051 /* Extend strerror to handle the winsock-specific error codes. */
3055 } _wsa_errlist
[] = {
3056 WSAEINTR
, "Interrupted function call",
3057 WSAEBADF
, "Bad file descriptor",
3058 WSAEACCES
, "Permission denied",
3059 WSAEFAULT
, "Bad address",
3060 WSAEINVAL
, "Invalid argument",
3061 WSAEMFILE
, "Too many open files",
3063 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
3064 WSAEINPROGRESS
, "Operation now in progress",
3065 WSAEALREADY
, "Operation already in progress",
3066 WSAENOTSOCK
, "Socket operation on non-socket",
3067 WSAEDESTADDRREQ
, "Destination address required",
3068 WSAEMSGSIZE
, "Message too long",
3069 WSAEPROTOTYPE
, "Protocol wrong type for socket",
3070 WSAENOPROTOOPT
, "Bad protocol option",
3071 WSAEPROTONOSUPPORT
, "Protocol not supported",
3072 WSAESOCKTNOSUPPORT
, "Socket type not supported",
3073 WSAEOPNOTSUPP
, "Operation not supported",
3074 WSAEPFNOSUPPORT
, "Protocol family not supported",
3075 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
3076 WSAEADDRINUSE
, "Address already in use",
3077 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
3078 WSAENETDOWN
, "Network is down",
3079 WSAENETUNREACH
, "Network is unreachable",
3080 WSAENETRESET
, "Network dropped connection on reset",
3081 WSAECONNABORTED
, "Software caused connection abort",
3082 WSAECONNRESET
, "Connection reset by peer",
3083 WSAENOBUFS
, "No buffer space available",
3084 WSAEISCONN
, "Socket is already connected",
3085 WSAENOTCONN
, "Socket is not connected",
3086 WSAESHUTDOWN
, "Cannot send after socket shutdown",
3087 WSAETOOMANYREFS
, "Too many references", /* not sure */
3088 WSAETIMEDOUT
, "Connection timed out",
3089 WSAECONNREFUSED
, "Connection refused",
3090 WSAELOOP
, "Network loop", /* not sure */
3091 WSAENAMETOOLONG
, "Name is too long",
3092 WSAEHOSTDOWN
, "Host is down",
3093 WSAEHOSTUNREACH
, "No route to host",
3094 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
3095 WSAEPROCLIM
, "Too many processes",
3096 WSAEUSERS
, "Too many users", /* not sure */
3097 WSAEDQUOT
, "Double quote in host name", /* really not sure */
3098 WSAESTALE
, "Data is stale", /* not sure */
3099 WSAEREMOTE
, "Remote error", /* not sure */
3101 WSASYSNOTREADY
, "Network subsystem is unavailable",
3102 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
3103 WSANOTINITIALISED
, "Winsock not initialized successfully",
3104 WSAEDISCON
, "Graceful shutdown in progress",
3106 WSAENOMORE
, "No more operations allowed", /* not sure */
3107 WSAECANCELLED
, "Operation cancelled", /* not sure */
3108 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
3109 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
3110 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
3111 WSASYSCALLFAILURE
, "System call failure",
3112 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
3113 WSATYPE_NOT_FOUND
, "Class type not found",
3114 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
3115 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
3116 WSAEREFUSED
, "Operation refused", /* not sure */
3119 WSAHOST_NOT_FOUND
, "Host not found",
3120 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
3121 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
3122 WSANO_DATA
, "Valid name, no data record of requested type",
3128 sys_strerror(int error_no
)
3131 static char unknown_msg
[40];
3133 if (error_no
>= 0 && error_no
< sys_nerr
)
3134 return sys_errlist
[error_no
];
3136 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
3137 if (_wsa_errlist
[i
].errnum
== error_no
)
3138 return _wsa_errlist
[i
].msg
;
3140 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
3144 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3145 but I believe the method of keeping the socket handle separate (and
3146 insuring it is not inheritable) is the correct one. */
3148 //#define SOCK_REPLACE_HANDLE
3150 #ifdef SOCK_REPLACE_HANDLE
3151 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3153 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3156 int socket_to_fd (SOCKET s
);
3159 sys_socket(int af
, int type
, int protocol
)
3163 if (winsock_lib
== NULL
)
3166 return INVALID_SOCKET
;
3171 /* call the real socket function */
3172 s
= pfn_socket (af
, type
, protocol
);
3174 if (s
!= INVALID_SOCKET
)
3175 return socket_to_fd (s
);
3181 /* Convert a SOCKET to a file descriptor. */
3183 socket_to_fd (SOCKET s
)
3188 /* Although under NT 3.5 _open_osfhandle will accept a socket
3189 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3190 that does not work under NT 3.1. However, we can get the same
3191 effect by using a backdoor function to replace an existing
3192 descriptor handle with the one we want. */
3194 /* allocate a file descriptor (with appropriate flags) */
3195 fd
= _open ("NUL:", _O_RDWR
);
3198 #ifdef SOCK_REPLACE_HANDLE
3199 /* now replace handle to NUL with our socket handle */
3200 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
3202 _set_osfhnd (fd
, s
);
3203 /* setmode (fd, _O_BINARY); */
3205 /* Make a non-inheritable copy of the socket handle. Note
3206 that it is possible that sockets aren't actually kernel
3207 handles, which appears to be the case on Windows 9x when
3208 the MS Proxy winsock client is installed. */
3210 /* Apparently there is a bug in NT 3.51 with some service
3211 packs, which prevents using DuplicateHandle to make a
3212 socket handle non-inheritable (causes WSACleanup to
3213 hang). The work-around is to use SetHandleInformation
3214 instead if it is available and implemented. */
3215 if (pfn_SetHandleInformation
)
3217 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
3221 HANDLE parent
= GetCurrentProcess ();
3222 HANDLE new_s
= INVALID_HANDLE_VALUE
;
3224 if (DuplicateHandle (parent
,
3230 DUPLICATE_SAME_ACCESS
))
3232 /* It is possible that DuplicateHandle succeeds even
3233 though the socket wasn't really a kernel handle,
3234 because a real handle has the same value. So
3235 test whether the new handle really is a socket. */
3236 long nonblocking
= 0;
3237 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
3239 pfn_closesocket (s
);
3244 CloseHandle (new_s
);
3249 fd_info
[fd
].hnd
= (HANDLE
) s
;
3252 /* set our own internal flags */
3253 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
3259 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3261 /* attach child_process to fd_info */
3262 if (fd_info
[ fd
].cp
!= NULL
)
3264 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
3268 fd_info
[ fd
].cp
= cp
;
3271 winsock_inuse
++; /* count open sockets */
3278 pfn_closesocket (s
);
3285 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
3287 if (winsock_lib
== NULL
)
3290 return SOCKET_ERROR
;
3294 if (fd_info
[s
].flags
& FILE_SOCKET
)
3296 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
3297 if (rc
== SOCKET_ERROR
)
3302 return SOCKET_ERROR
;
3307 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
3309 if (winsock_lib
== NULL
)
3312 return SOCKET_ERROR
;
3316 if (fd_info
[s
].flags
& FILE_SOCKET
)
3318 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
3319 if (rc
== SOCKET_ERROR
)
3324 return SOCKET_ERROR
;
3328 sys_htons (u_short hostshort
)
3330 return (winsock_lib
!= NULL
) ?
3331 pfn_htons (hostshort
) : hostshort
;
3335 sys_ntohs (u_short netshort
)
3337 return (winsock_lib
!= NULL
) ?
3338 pfn_ntohs (netshort
) : netshort
;
3342 sys_inet_addr (const char * cp
)
3344 return (winsock_lib
!= NULL
) ?
3345 pfn_inet_addr (cp
) : INADDR_NONE
;
3349 sys_gethostname (char * name
, int namelen
)
3351 if (winsock_lib
!= NULL
)
3352 return pfn_gethostname (name
, namelen
);
3354 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
3355 return !GetComputerName (name
, (DWORD
*)&namelen
);
3358 return SOCKET_ERROR
;
3362 sys_gethostbyname(const char * name
)
3364 struct hostent
* host
;
3366 if (winsock_lib
== NULL
)
3373 host
= pfn_gethostbyname (name
);
3380 sys_getservbyname(const char * name
, const char * proto
)
3382 struct servent
* serv
;
3384 if (winsock_lib
== NULL
)
3391 serv
= pfn_getservbyname (name
, proto
);
3398 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
3400 if (winsock_lib
== NULL
)
3403 return SOCKET_ERROR
;
3407 if (fd_info
[s
].flags
& FILE_SOCKET
)
3409 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
3410 if (rc
== SOCKET_ERROR
)
3415 return SOCKET_ERROR
;
3420 sys_shutdown (int s
, int how
)
3422 if (winsock_lib
== NULL
)
3425 return SOCKET_ERROR
;
3429 if (fd_info
[s
].flags
& FILE_SOCKET
)
3431 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
3432 if (rc
== SOCKET_ERROR
)
3437 return SOCKET_ERROR
;
3441 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
3443 if (winsock_lib
== NULL
)
3446 return SOCKET_ERROR
;
3450 if (fd_info
[s
].flags
& FILE_SOCKET
)
3452 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
3453 (const char *)optval
, optlen
);
3454 if (rc
== SOCKET_ERROR
)
3459 return SOCKET_ERROR
;
3463 sys_listen (int s
, int backlog
)
3465 if (winsock_lib
== NULL
)
3468 return SOCKET_ERROR
;
3472 if (fd_info
[s
].flags
& FILE_SOCKET
)
3474 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
3475 if (rc
== SOCKET_ERROR
)
3478 fd_info
[s
].flags
|= FILE_LISTEN
;
3482 return SOCKET_ERROR
;
3486 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
3488 if (winsock_lib
== NULL
)
3491 return SOCKET_ERROR
;
3495 if (fd_info
[s
].flags
& FILE_SOCKET
)
3497 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3498 if (rc
== SOCKET_ERROR
)
3503 return SOCKET_ERROR
;
3507 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3509 if (winsock_lib
== NULL
)
3516 if (fd_info
[s
].flags
& FILE_LISTEN
)
3518 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3520 if (t
== INVALID_SOCKET
)
3523 fd
= socket_to_fd (t
);
3525 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3526 ResetEvent (fd_info
[s
].cp
->char_avail
);
3534 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3535 struct sockaddr
* from
, int * fromlen
)
3537 if (winsock_lib
== NULL
)
3540 return SOCKET_ERROR
;
3544 if (fd_info
[s
].flags
& FILE_SOCKET
)
3546 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3547 if (rc
== SOCKET_ERROR
)
3552 return SOCKET_ERROR
;
3556 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3557 const struct sockaddr
* to
, int tolen
)
3559 if (winsock_lib
== NULL
)
3562 return SOCKET_ERROR
;
3566 if (fd_info
[s
].flags
& FILE_SOCKET
)
3568 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3569 if (rc
== SOCKET_ERROR
)
3574 return SOCKET_ERROR
;
3577 /* Windows does not have an fcntl function. Provide an implementation
3578 solely for making sockets non-blocking. */
3580 fcntl (int s
, int cmd
, int options
)
3582 if (winsock_lib
== NULL
)
3589 if (fd_info
[s
].flags
& FILE_SOCKET
)
3591 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
3593 unsigned long nblock
= 1;
3594 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
3595 if (rc
== SOCKET_ERROR
)
3597 /* Keep track of the fact that we set this to non-blocking. */
3598 fd_info
[s
].flags
|= FILE_NDELAY
;
3604 return SOCKET_ERROR
;
3608 return SOCKET_ERROR
;
3611 #endif /* HAVE_SOCKETS */
3614 /* Shadow main io functions: we need to handle pipes and sockets more
3615 intelligently, and implement non-blocking mode as well. */
3628 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
3630 child_process
* cp
= fd_info
[fd
].cp
;
3632 fd_info
[fd
].cp
= NULL
;
3634 if (CHILD_ACTIVE (cp
))
3636 /* if last descriptor to active child_process then cleanup */
3638 for (i
= 0; i
< MAXDESC
; i
++)
3642 if (fd_info
[i
].cp
== cp
)
3648 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3650 #ifndef SOCK_REPLACE_HANDLE
3651 if (winsock_lib
== NULL
) abort ();
3653 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3654 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3656 winsock_inuse
--; /* count open sockets */
3664 /* Note that sockets do not need special treatment here (at least on
3665 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3666 closesocket is equivalent to CloseHandle, which is to be expected
3667 because socket handles are fully fledged kernel handles. */
3670 if (rc
== 0 && fd
< MAXDESC
)
3671 fd_info
[fd
].flags
= 0;
3682 if (new_fd
>= 0 && new_fd
< MAXDESC
)
3684 /* duplicate our internal info as well */
3685 fd_info
[new_fd
] = fd_info
[fd
];
3692 sys_dup2 (int src
, int dst
)
3696 if (dst
< 0 || dst
>= MAXDESC
)
3702 /* make sure we close the destination first if it's a pipe or socket */
3703 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3706 rc
= _dup2 (src
, dst
);
3709 /* duplicate our internal info as well */
3710 fd_info
[dst
] = fd_info
[src
];
3715 /* Unix pipe() has only one arg */
3717 sys_pipe (int * phandles
)
3722 /* make pipe handles non-inheritable; when we spawn a child, we
3723 replace the relevant handle with an inheritable one. Also put
3724 pipes into binary mode; we will do text mode translation ourselves
3726 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3730 /* Protect against overflow, since Windows can open more handles than
3731 our fd_info array has room for. */
3732 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
3734 _close (phandles
[0]);
3735 _close (phandles
[1]);
3740 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3741 fd_info
[phandles
[0]].flags
= flags
;
3743 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3744 fd_info
[phandles
[1]].flags
= flags
;
3752 extern int w32_pipe_read_delay
;
3754 /* Function to do blocking read of one byte, needed to implement
3755 select. It is only allowed on sockets and pipes. */
3757 _sys_read_ahead (int fd
)
3762 if (fd
< 0 || fd
>= MAXDESC
)
3763 return STATUS_READ_ERROR
;
3765 cp
= fd_info
[fd
].cp
;
3767 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3768 return STATUS_READ_ERROR
;
3770 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3771 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3773 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3777 cp
->status
= STATUS_READ_IN_PROGRESS
;
3779 if (fd_info
[fd
].flags
& FILE_PIPE
)
3781 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3783 /* Give subprocess time to buffer some more output for us before
3784 reporting that input is available; we need this because Windows 95
3785 connects DOS programs to pipes by making the pipe appear to be
3786 the normal console stdout - as a result most DOS programs will
3787 write to stdout without buffering, ie. one character at a
3788 time. Even some W32 programs do this - "dir" in a command
3789 shell on NT is very slow if we don't do this. */
3792 int wait
= w32_pipe_read_delay
;
3798 /* Yield remainder of our time slice, effectively giving a
3799 temporary priority boost to the child process. */
3804 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3806 unsigned long nblock
= 0;
3807 /* We always want this to block, so temporarily disable NDELAY. */
3808 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3809 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3811 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3813 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3816 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3821 if (rc
== sizeof (char))
3822 cp
->status
= STATUS_READ_SUCCEEDED
;
3824 cp
->status
= STATUS_READ_FAILED
;
3830 _sys_wait_accept (int fd
)
3836 if (fd
< 0 || fd
>= MAXDESC
)
3837 return STATUS_READ_ERROR
;
3839 cp
= fd_info
[fd
].cp
;
3841 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3842 return STATUS_READ_ERROR
;
3844 cp
->status
= STATUS_READ_FAILED
;
3846 hEv
= pfn_WSACreateEvent ();
3847 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
3848 if (rc
!= SOCKET_ERROR
)
3850 rc
= WaitForSingleObject (hEv
, INFINITE
);
3851 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
3852 if (rc
== WAIT_OBJECT_0
)
3853 cp
->status
= STATUS_READ_SUCCEEDED
;
3855 pfn_WSACloseEvent (hEv
);
3861 sys_read (int fd
, char * buffer
, unsigned int count
)
3866 char * orig_buffer
= buffer
;
3874 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3876 child_process
*cp
= fd_info
[fd
].cp
;
3878 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3886 /* re-read CR carried over from last read */
3887 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3889 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3893 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3896 /* presence of a child_process structure means we are operating in
3897 non-blocking mode - otherwise we just call _read directly.
3898 Note that the child_process structure might be missing because
3899 reap_subprocess has been called; in this case the pipe is
3900 already broken, so calling _read on it is okay. */
3903 int current_status
= cp
->status
;
3905 switch (current_status
)
3907 case STATUS_READ_FAILED
:
3908 case STATUS_READ_ERROR
:
3909 /* report normal EOF if nothing in buffer */
3911 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3914 case STATUS_READ_READY
:
3915 case STATUS_READ_IN_PROGRESS
:
3916 DebPrint (("sys_read called when read is in progress\n"));
3917 errno
= EWOULDBLOCK
;
3920 case STATUS_READ_SUCCEEDED
:
3921 /* consume read-ahead char */
3922 *buffer
++ = cp
->chr
;
3925 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3926 ResetEvent (cp
->char_avail
);
3928 case STATUS_READ_ACKNOWLEDGED
:
3932 DebPrint (("sys_read: bad status %d\n", current_status
));
3937 if (fd_info
[fd
].flags
& FILE_PIPE
)
3939 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3940 to_read
= min (waiting
, (DWORD
) count
);
3943 nchars
+= _read (fd
, buffer
, to_read
);
3946 else /* FILE_SOCKET */
3948 if (winsock_lib
== NULL
) abort ();
3950 /* do the equivalent of a non-blocking read */
3951 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3952 if (waiting
== 0 && nchars
== 0)
3954 h_errno
= errno
= EWOULDBLOCK
;
3960 /* always use binary mode for sockets */
3961 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3962 if (res
== SOCKET_ERROR
)
3964 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3965 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3976 int nread
= _read (fd
, buffer
, count
);
3979 else if (nchars
== 0)
3984 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3985 /* Perform text mode translation if required. */
3986 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3988 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3989 /* If buffer contains only CR, return that. To be absolutely
3990 sure we should attempt to read the next char, but in
3991 practice a CR to be followed by LF would not appear by
3992 itself in the buffer. */
3993 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3995 fd_info
[fd
].flags
|= FILE_LAST_CR
;
4001 nchars
= _read (fd
, buffer
, count
);
4006 /* For now, don't bother with a non-blocking mode */
4008 sys_write (int fd
, const void * buffer
, unsigned int count
)
4018 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
4020 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
4026 /* Perform text mode translation if required. */
4027 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
4029 char * tmpbuf
= alloca (count
* 2);
4030 unsigned char * src
= (void *)buffer
;
4031 unsigned char * dst
= tmpbuf
;
4036 unsigned char *next
;
4037 /* copy next line or remaining bytes */
4038 next
= _memccpy (dst
, src
, '\n', nbytes
);
4041 /* copied one line ending with '\n' */
4042 int copied
= next
- dst
;
4045 /* insert '\r' before '\n' */
4052 /* copied remaining partial line -> now finished */
4060 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
4062 unsigned long nblock
= 0;
4063 if (winsock_lib
== NULL
) abort ();
4065 /* TODO: implement select() properly so non-blocking I/O works. */
4066 /* For now, make sure the write blocks. */
4067 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4068 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4070 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
4072 /* Set the socket back to non-blocking if it was before,
4073 for other operations that support it. */
4074 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4077 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4080 if (nchars
== SOCKET_ERROR
)
4082 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
4083 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
4089 nchars
= _write (fd
, buffer
, count
);
4095 check_windows_init_file ()
4097 extern int noninteractive
, inhibit_window_system
;
4099 /* A common indication that Emacs is not installed properly is when
4100 it cannot find the Windows installation file. If this file does
4101 not exist in the expected place, tell the user. */
4103 if (!noninteractive
&& !inhibit_window_system
)
4105 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
4106 Lisp_Object objs
[2];
4107 Lisp_Object full_load_path
;
4108 Lisp_Object init_file
;
4111 objs
[0] = Vload_path
;
4112 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
4113 full_load_path
= Fappend (2, objs
);
4114 init_file
= build_string ("term/w32-win");
4115 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
4118 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
4119 char *init_file_name
= SDATA (init_file
);
4120 char *load_path
= SDATA (load_path_print
);
4121 char *buffer
= alloca (1024
4122 + strlen (init_file_name
)
4123 + strlen (load_path
));
4126 "The Emacs Windows initialization file \"%s.el\" "
4127 "could not be found in your Emacs installation. "
4128 "Emacs checked the following directories for this file:\n"
4130 "When Emacs cannot find this file, it usually means that it "
4131 "was not installed properly, or its distribution file was "
4132 "not unpacked properly.\nSee the README.W32 file in the "
4133 "top-level Emacs directory for more information.",
4134 init_file_name
, load_path
);
4137 "Emacs Abort Dialog",
4138 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
4139 /* Use the low-level Emacs abort. */
4154 /* shutdown the socket interface if necessary */
4165 /* Initialise the socket interface now if available and requested by
4166 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4167 delayed until open-network-stream is called (w32-has-winsock can
4168 also be used to dynamically load or reload winsock).
4170 Conveniently, init_environment is called before us, so
4171 PRELOAD_WINSOCK can be set in the registry. */
4173 /* Always initialize this correctly. */
4176 if (getenv ("PRELOAD_WINSOCK") != NULL
)
4177 init_winsock (TRUE
);
4180 /* Initial preparation for subprocess support: replace our standard
4181 handles with non-inheritable versions. */
4184 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
4185 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
4186 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
4188 parent
= GetCurrentProcess ();
4190 /* ignore errors when duplicating and closing; typically the
4191 handles will be invalid when running as a gui program. */
4192 DuplicateHandle (parent
,
4193 GetStdHandle (STD_INPUT_HANDLE
),
4198 DUPLICATE_SAME_ACCESS
);
4200 DuplicateHandle (parent
,
4201 GetStdHandle (STD_OUTPUT_HANDLE
),
4206 DUPLICATE_SAME_ACCESS
);
4208 DuplicateHandle (parent
,
4209 GetStdHandle (STD_ERROR_HANDLE
),
4214 DUPLICATE_SAME_ACCESS
);
4220 if (stdin_save
!= INVALID_HANDLE_VALUE
)
4221 _open_osfhandle ((long) stdin_save
, O_TEXT
);
4223 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
4226 if (stdout_save
!= INVALID_HANDLE_VALUE
)
4227 _open_osfhandle ((long) stdout_save
, O_TEXT
);
4229 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4232 if (stderr_save
!= INVALID_HANDLE_VALUE
)
4233 _open_osfhandle ((long) stderr_save
, O_TEXT
);
4235 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4239 /* unfortunately, atexit depends on implementation of malloc */
4240 /* atexit (term_ntproc); */
4241 signal (SIGABRT
, term_ntproc
);
4243 /* determine which drives are fixed, for GetCachedVolumeInformation */
4245 /* GetDriveType must have trailing backslash. */
4246 char drive
[] = "A:\\";
4248 /* Loop over all possible drive letters */
4249 while (*drive
<= 'Z')
4251 /* Record if this drive letter refers to a fixed drive. */
4252 fixed_drives
[DRIVE_INDEX (*drive
)] =
4253 (GetDriveType (drive
) == DRIVE_FIXED
);
4258 /* Reset the volume info cache. */
4259 volume_cache
= NULL
;
4262 /* Check to see if Emacs has been installed correctly. */
4263 check_windows_init_file ();
4267 shutdown_handler ensures that buffers' autosave files are
4268 up to date when the user logs off, or the system shuts down.
4270 BOOL WINAPI
shutdown_handler(DWORD type
)
4272 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4273 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
4274 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
4275 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
4277 /* Shut down cleanly, making sure autosave files are up to date. */
4278 shut_down_emacs (0, 0, Qnil
);
4281 /* Allow other handlers to handle this signal. */
4286 globals_of_w32 is used to initialize those global variables that
4287 must always be initialized on startup even when the global variable
4288 initialized is non zero (see the function main in emacs.c).
4293 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
4295 get_process_times_fn
= (GetProcessTimes_Proc
)
4296 GetProcAddress (kernel32
, "GetProcessTimes");
4298 g_b_init_is_windows_9x
= 0;
4299 g_b_init_open_process_token
= 0;
4300 g_b_init_get_token_information
= 0;
4301 g_b_init_lookup_account_sid
= 0;
4302 g_b_init_get_sid_identifier_authority
= 0;
4303 g_b_init_get_sid_sub_authority
= 0;
4304 g_b_init_get_sid_sub_authority_count
= 0;
4305 /* The following sets a handler for shutdown notifications for
4306 console apps. This actually applies to Emacs in both console and
4307 GUI modes, since we had to fool windows into thinking emacs is a
4308 console application to get console mode to work. */
4309 SetConsoleCtrlHandler(shutdown_handler
, TRUE
);
4314 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4315 (do not change this comment) */