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
78 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
79 #include <sys/socket.h>
104 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
105 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
107 void globals_of_w32 ();
109 extern Lisp_Object Vw32_downcase_file_names
;
110 extern Lisp_Object Vw32_generate_fake_inodes
;
111 extern Lisp_Object Vw32_get_true_file_attributes
;
112 extern int w32_num_mouse_buttons
;
116 Initialization states
118 static BOOL g_b_init_is_windows_9x
;
119 static BOOL g_b_init_open_process_token
;
120 static BOOL g_b_init_get_token_information
;
121 static BOOL g_b_init_lookup_account_sid
;
122 static BOOL g_b_init_get_sid_identifier_authority
;
123 static BOOL g_b_init_get_sid_sub_authority
;
124 static BOOL g_b_init_get_sid_sub_authority_count
;
127 BEGIN: Wrapper functions around OpenProcessToken
128 and other functions in advapi32.dll that are only
129 supported in Windows NT / 2k / XP
131 /* ** Function pointer typedefs ** */
132 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
133 HANDLE ProcessHandle
,
135 PHANDLE TokenHandle
);
136 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
138 TOKEN_INFORMATION_CLASS TokenInformationClass
,
139 LPVOID TokenInformation
,
140 DWORD TokenInformationLength
,
141 PDWORD ReturnLength
);
142 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
143 HANDLE process_handle
,
144 LPFILETIME creation_time
,
145 LPFILETIME exit_time
,
146 LPFILETIME kernel_time
,
147 LPFILETIME user_time
);
149 GetProcessTimes_Proc get_process_times_fn
= NULL
;
152 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
154 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
156 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
157 LPCTSTR lpSystemName
,
162 LPDWORD cbDomainName
,
163 PSID_NAME_USE peUse
);
164 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI
* GetSidIdentifierAuthority_Proc
) (
166 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
169 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
173 /* ** A utility function ** */
177 static BOOL s_b_ret
=0;
178 OSVERSIONINFO os_ver
;
179 if (g_b_init_is_windows_9x
== 0)
181 g_b_init_is_windows_9x
= 1;
182 ZeroMemory(&os_ver
, sizeof(OSVERSIONINFO
));
183 os_ver
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
184 if (GetVersionEx (&os_ver
))
186 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
192 /* Get total user and system times for get-internal-run-time.
193 Returns a list of three integers if the times are provided by the OS
194 (NT derivatives), otherwise it returns the result of current-time. */
196 w32_get_internal_run_time ()
198 if (get_process_times_fn
)
200 FILETIME create
, exit
, kernel
, user
;
201 HANDLE proc
= GetCurrentProcess();
202 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
204 LARGE_INTEGER user_int
, kernel_int
, total
;
206 user_int
.LowPart
= user
.dwLowDateTime
;
207 user_int
.HighPart
= user
.dwHighDateTime
;
208 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
209 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
210 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
211 /* FILETIME is 100 nanosecond increments, Emacs only wants
212 microsecond resolution. */
213 total
.QuadPart
/= 10;
214 microseconds
= total
.QuadPart
% 1000000;
215 total
.QuadPart
/= 1000000;
217 /* Sanity check to make sure we can represent the result. */
218 if (total
.HighPart
== 0)
220 int secs
= total
.LowPart
;
222 return list3 (make_number ((secs
>> 16) & 0xffff),
223 make_number (secs
& 0xffff),
224 make_number (microseconds
));
229 return Fcurrent_time ();
232 /* ** The wrapper functions ** */
234 BOOL WINAPI
open_process_token (
235 HANDLE ProcessHandle
,
239 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
240 HMODULE hm_advapi32
= NULL
;
241 if (is_windows_9x () == TRUE
)
245 if (g_b_init_open_process_token
== 0)
247 g_b_init_open_process_token
= 1;
248 hm_advapi32
= LoadLibrary ("Advapi32.dll");
249 s_pfn_Open_Process_Token
=
250 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
252 if (s_pfn_Open_Process_Token
== NULL
)
257 s_pfn_Open_Process_Token (
264 BOOL WINAPI
get_token_information (
266 TOKEN_INFORMATION_CLASS TokenInformationClass
,
267 LPVOID TokenInformation
,
268 DWORD TokenInformationLength
,
271 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
272 HMODULE hm_advapi32
= NULL
;
273 if (is_windows_9x () == TRUE
)
277 if (g_b_init_get_token_information
== 0)
279 g_b_init_get_token_information
= 1;
280 hm_advapi32
= LoadLibrary ("Advapi32.dll");
281 s_pfn_Get_Token_Information
=
282 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
284 if (s_pfn_Get_Token_Information
== NULL
)
289 s_pfn_Get_Token_Information (
291 TokenInformationClass
,
293 TokenInformationLength
,
298 BOOL WINAPI
lookup_account_sid (
299 LPCTSTR lpSystemName
,
304 LPDWORD cbDomainName
,
307 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
308 HMODULE hm_advapi32
= NULL
;
309 if (is_windows_9x () == TRUE
)
313 if (g_b_init_lookup_account_sid
== 0)
315 g_b_init_lookup_account_sid
= 1;
316 hm_advapi32
= LoadLibrary ("Advapi32.dll");
317 s_pfn_Lookup_Account_Sid
=
318 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
320 if (s_pfn_Lookup_Account_Sid
== NULL
)
325 s_pfn_Lookup_Account_Sid (
336 PSID_IDENTIFIER_AUTHORITY WINAPI
get_sid_identifier_authority (
339 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority
= NULL
;
340 HMODULE hm_advapi32
= NULL
;
341 if (is_windows_9x () == TRUE
)
345 if (g_b_init_get_sid_identifier_authority
== 0)
347 g_b_init_get_sid_identifier_authority
= 1;
348 hm_advapi32
= LoadLibrary ("Advapi32.dll");
349 s_pfn_Get_Sid_Identifier_Authority
=
350 (GetSidIdentifierAuthority_Proc
) GetProcAddress (
351 hm_advapi32
, "GetSidIdentifierAuthority");
353 if (s_pfn_Get_Sid_Identifier_Authority
== NULL
)
357 return (s_pfn_Get_Sid_Identifier_Authority (pSid
));
360 PDWORD WINAPI
get_sid_sub_authority (
364 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
365 HMODULE hm_advapi32
= NULL
;
366 if (is_windows_9x () == TRUE
)
370 if (g_b_init_get_sid_sub_authority
== 0)
372 g_b_init_get_sid_sub_authority
= 1;
373 hm_advapi32
= LoadLibrary ("Advapi32.dll");
374 s_pfn_Get_Sid_Sub_Authority
=
375 (GetSidSubAuthority_Proc
) GetProcAddress (
376 hm_advapi32
, "GetSidSubAuthority");
378 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
382 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
385 PUCHAR WINAPI
get_sid_sub_authority_count (
388 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
389 HMODULE hm_advapi32
= NULL
;
390 if (is_windows_9x () == TRUE
)
394 if (g_b_init_get_sid_sub_authority_count
== 0)
396 g_b_init_get_sid_sub_authority_count
= 1;
397 hm_advapi32
= LoadLibrary ("Advapi32.dll");
398 s_pfn_Get_Sid_Sub_Authority_Count
=
399 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
400 hm_advapi32
, "GetSidSubAuthorityCount");
402 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
406 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
410 END: Wrapper functions around OpenProcessToken
411 and other functions in advapi32.dll that are only
412 supported in Windows NT / 2k / XP
416 /* Equivalent of strerror for W32 error codes. */
418 w32_strerror (int error_no
)
420 static char buf
[500];
423 error_no
= GetLastError ();
426 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
428 0, /* choose most suitable language */
429 buf
, sizeof (buf
), NULL
))
430 sprintf (buf
, "w32 error %u", error_no
);
434 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
435 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
437 This is called from alloc.c:valid_pointer_p. */
439 w32_valid_pointer_p (void *p
, int size
)
442 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
446 unsigned char *buf
= alloca (size
);
447 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
456 static char startup_dir
[MAXPATHLEN
];
458 /* Get the current working directory. */
463 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
467 /* Emacs doesn't actually change directory itself, and we want to
468 force our real wd to be where emacs.exe is to avoid unnecessary
469 conflicts when trying to rename or delete directories. */
470 strcpy (dir
, startup_dir
);
476 /* Emulate gethostname. */
478 gethostname (char *buffer
, int size
)
480 /* NT only allows small host names, so the buffer is
481 certainly large enough. */
482 return !GetComputerName (buffer
, &size
);
484 #endif /* HAVE_SOCKETS */
486 /* Emulate getloadavg. */
488 getloadavg (double loadavg
[], int nelem
)
492 /* A faithful emulation is going to have to be saved for a rainy day. */
493 for (i
= 0; i
< nelem
; i
++)
500 /* Emulate getpwuid, getpwnam and others. */
502 #define PASSWD_FIELD_SIZE 256
504 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
505 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
506 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
507 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
508 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
510 static struct passwd the_passwd
=
522 static struct group the_group
=
524 /* There are no groups on NT, so we just return "root" as the
532 return the_passwd
.pw_uid
;
538 /* I could imagine arguing for checking to see whether the user is
539 in the Administrators group and returning a UID of 0 for that
540 case, but I don't know how wise that would be in the long run. */
547 return the_passwd
.pw_gid
;
559 if (uid
== the_passwd
.pw_uid
)
571 getpwnam (char *name
)
575 pw
= getpwuid (getuid ());
579 if (stricmp (name
, pw
->pw_name
))
588 /* Find the user's real name by opening the process token and
589 looking up the name associated with the user-sid in that token.
591 Use the relative portion of the identifier authority value from
592 the user-sid as the user id value (same for group id using the
593 primary group sid from the process token). */
595 char user_sid
[256], name
[256], domain
[256];
596 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
598 SID_NAME_USE user_type
;
600 if (open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
)
601 && get_token_information (token
, TokenUser
,
602 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
603 && lookup_account_sid (NULL
, *((PSID
*) user_sid
), name
, &length
,
604 domain
, &dlength
, &user_type
))
606 strcpy (the_passwd
.pw_name
, name
);
607 /* Determine a reasonable uid value. */
608 if (stricmp ("administrator", name
) == 0)
610 the_passwd
.pw_uid
= 500; /* well-known Administrator uid */
611 the_passwd
.pw_gid
= 513; /* well-known None gid */
615 /* Use RID, the relative portion of the SID, that is the last
616 sub-authority value of the SID. */
617 DWORD n_subauthorities
=
618 *get_sid_sub_authority_count (*((PSID
*) user_sid
));
620 if (n_subauthorities
< 1)
621 the_passwd
.pw_uid
= 0; /* the "World" RID */
625 *get_sid_sub_authority (*((PSID
*) user_sid
),
626 n_subauthorities
- 1);
627 /* Restrict to conventional uid range for normal users. */
628 the_passwd
.pw_uid
%= 60001;
632 if (get_token_information (token
, TokenPrimaryGroup
,
633 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
636 *get_sid_sub_authority_count (*((PSID
*) user_sid
));
638 if (n_subauthorities
< 1)
639 the_passwd
.pw_gid
= 0; /* the "World" RID */
643 *get_sid_sub_authority (*((PSID
*) user_sid
),
644 n_subauthorities
- 1);
645 /* I don't know if this is necessary, but for safety... */
646 the_passwd
.pw_gid
%= 60001;
650 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
653 /* If security calls are not supported (presumably because we
654 are running under Windows 95), fallback to this. */
655 else if (GetUserName (name
, &length
))
657 strcpy (the_passwd
.pw_name
, name
);
658 if (stricmp ("administrator", name
) == 0)
659 the_passwd
.pw_uid
= 0;
661 the_passwd
.pw_uid
= 123;
662 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
666 strcpy (the_passwd
.pw_name
, "unknown");
667 the_passwd
.pw_uid
= 123;
668 the_passwd
.pw_gid
= 123;
671 /* Ensure HOME and SHELL are defined. */
672 if (getenv ("HOME") == NULL
)
674 if (getenv ("SHELL") == NULL
)
677 /* Set dir and shell from environment variables. */
678 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
679 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
688 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
689 return ((rand () << 15) | rand ());
699 /* Normalize filename by converting all path separators to
700 the specified separator. Also conditionally convert upper
701 case path name components to lower case. */
704 normalize_filename (fp
, path_sep
)
711 /* Always lower-case drive letters a-z, even if the filesystem
712 preserves case in filenames.
713 This is so filenames can be compared by string comparison
714 functions that are case-sensitive. Even case-preserving filesystems
715 do not distinguish case in drive letters. */
716 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
722 if (NILP (Vw32_downcase_file_names
))
726 if (*fp
== '/' || *fp
== '\\')
733 sep
= path_sep
; /* convert to this path separator */
734 elem
= fp
; /* start of current path element */
737 if (*fp
>= 'a' && *fp
<= 'z')
738 elem
= 0; /* don't convert this element */
740 if (*fp
== 0 || *fp
== ':')
742 sep
= *fp
; /* restore current separator (or 0) */
743 *fp
= '/'; /* after conversion of this element */
746 if (*fp
== '/' || *fp
== '\\')
748 if (elem
&& elem
!= fp
)
750 *fp
= 0; /* temporary end of string */
751 _strlwr (elem
); /* while we convert to lower case */
753 *fp
= sep
; /* convert (or restore) path separator */
754 elem
= fp
+ 1; /* next element starts after separator */
760 /* Destructively turn backslashes into slashes. */
762 dostounix_filename (p
)
765 normalize_filename (p
, '/');
768 /* Destructively turn slashes into backslashes. */
770 unixtodos_filename (p
)
773 normalize_filename (p
, '\\');
776 /* Remove all CR's that are followed by a LF.
777 (From msdos.c...probably should figure out a way to share it,
778 although this code isn't going to ever change.) */
782 register unsigned char *buf
;
784 unsigned char *np
= buf
;
785 unsigned char *startp
= buf
;
786 unsigned char *endp
= buf
+ n
;
790 while (buf
< endp
- 1)
794 if (*(++buf
) != 0x0a)
805 /* Parse the root part of file name, if present. Return length and
806 optionally store pointer to char after root. */
808 parse_root (char * name
, char ** pPath
)
815 /* find the root name of the volume if given */
816 if (isalpha (name
[0]) && name
[1] == ':')
818 /* skip past drive specifier */
820 if (IS_DIRECTORY_SEP (name
[0]))
823 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
829 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
834 if (IS_DIRECTORY_SEP (name
[0]))
844 /* Get long base name for name; name is assumed to be absolute. */
846 get_long_basename (char * name
, char * buf
, int size
)
848 WIN32_FIND_DATA find_data
;
852 /* must be valid filename, no wild cards or other invalid characters */
853 if (_mbspbrk (name
, "*?|<>\""))
856 dir_handle
= FindFirstFile (name
, &find_data
);
857 if (dir_handle
!= INVALID_HANDLE_VALUE
)
859 if ((len
= strlen (find_data
.cFileName
)) < size
)
860 memcpy (buf
, find_data
.cFileName
, len
+ 1);
863 FindClose (dir_handle
);
868 /* Get long name for file, if possible (assumed to be absolute). */
870 w32_get_long_filename (char * name
, char * buf
, int size
)
875 char full
[ MAX_PATH
];
882 /* Use local copy for destructive modification. */
883 memcpy (full
, name
, len
+1);
884 unixtodos_filename (full
);
886 /* Copy root part verbatim. */
887 len
= parse_root (full
, &p
);
888 memcpy (o
, full
, len
);
893 while (p
!= NULL
&& *p
)
896 p
= strchr (q
, '\\');
898 len
= get_long_basename (full
, o
, size
);
921 is_unc_volume (const char *filename
)
923 const char *ptr
= filename
;
925 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
928 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
934 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
937 sigsetmask (int signal_mask
)
961 setpgrp (int pid
, int gid
)
972 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
975 w32_get_resource (key
, lpdwtype
)
980 HKEY hrootkey
= NULL
;
983 /* Check both the current user and the local machine to see if
984 we have any resources. */
986 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
990 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
991 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
992 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
994 RegCloseKey (hrootkey
);
998 if (lpvalue
) xfree (lpvalue
);
1000 RegCloseKey (hrootkey
);
1003 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1007 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1008 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
1009 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1011 RegCloseKey (hrootkey
);
1015 if (lpvalue
) xfree (lpvalue
);
1017 RegCloseKey (hrootkey
);
1023 char *get_emacs_configuration (void);
1024 extern Lisp_Object Vsystem_configuration
;
1027 init_environment (char ** argv
)
1029 static const char * const tempdirs
[] = {
1030 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1035 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1037 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1038 temporary files and assume "/tmp" if $TMPDIR is unset, which
1039 will break on DOS/Windows. Refuse to work if we cannot find
1040 a directory, not even "c:/", usable for that purpose. */
1041 for (i
= 0; i
< imax
; i
++)
1043 const char *tmp
= tempdirs
[i
];
1046 tmp
= getenv (tmp
+ 1);
1047 /* Note that `access' can lie to us if the directory resides on a
1048 read-only filesystem, like CD-ROM or a write-protected floppy.
1049 The only way to be really sure is to actually create a file and
1050 see if it succeeds. But I think that's too much to ask. */
1051 if (tmp
&& _access (tmp
, D_OK
) == 0)
1053 char * var
= alloca (strlen (tmp
) + 8);
1054 sprintf (var
, "TMPDIR=%s", tmp
);
1055 _putenv (strdup (var
));
1062 Fcons (build_string ("no usable temporary directories found!!"),
1064 "While setting TMPDIR: ");
1066 /* Check for environment variables and use registry settings if they
1067 don't exist. Fallback on default values where applicable. */
1072 char locale_name
[32];
1073 struct stat ignored
;
1074 char default_home
[MAX_PATH
];
1076 static const struct env_entry
1083 {"PRELOAD_WINSOCK", NULL
},
1084 {"emacs_dir", "C:/emacs"},
1085 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1086 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1087 {"EMACSDATA", "%emacs_dir%/etc"},
1088 {"EMACSPATH", "%emacs_dir%/bin"},
1089 /* We no longer set INFOPATH because Info-default-directory-list
1091 /* {"INFOPATH", "%emacs_dir%/info"}, */
1092 {"EMACSDOC", "%emacs_dir%/etc"},
1097 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1099 /* We need to copy dflt_envvars[] and work on the copy because we
1100 don't want the dumped Emacs to inherit the values of
1101 environment variables we saw during dumping (which could be on
1102 a different system). The defaults above must be left intact. */
1103 struct env_entry env_vars
[N_ENV_VARS
];
1105 for (i
= 0; i
< N_ENV_VARS
; i
++)
1106 env_vars
[i
] = dflt_envvars
[i
];
1108 /* For backwards compatibility, check if a .emacs file exists in C:/
1109 If not, then we can try to default to the appdata directory under the
1110 user's profile, which is more likely to be writable. */
1111 if (stat ("C:/.emacs", &ignored
) < 0)
1113 HRESULT profile_result
;
1114 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1115 of Windows 95 and NT4 that have not been updated to include
1116 MSIE 5. Also we don't link with shell32.dll by default. */
1117 HMODULE shell32_dll
;
1118 ShGetFolderPath_fn get_folder_path
;
1119 shell32_dll
= GetModuleHandle ("shell32.dll");
1120 get_folder_path
= (ShGetFolderPath_fn
)
1121 GetProcAddress (shell32_dll
, "SHGetFolderPathA");
1123 if (get_folder_path
!= NULL
)
1125 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1128 /* If we can't get the appdata dir, revert to old behaviour. */
1129 if (profile_result
== S_OK
)
1130 env_vars
[0].def_value
= default_home
;
1133 /* Unload shell32.dll, it is not needed anymore. */
1134 FreeLibrary (shell32_dll
);
1137 /* Get default locale info and use it for LANG. */
1138 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1139 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1140 locale_name
, sizeof (locale_name
)))
1142 for (i
= 0; i
< N_ENV_VARS
; i
++)
1144 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1146 env_vars
[i
].def_value
= locale_name
;
1152 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1154 /* Treat emacs_dir specially: set it unconditionally based on our
1155 location, if it appears that we are running from the bin subdir
1156 of a standard installation. */
1159 char modname
[MAX_PATH
];
1161 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1163 if ((p
= strrchr (modname
, '\\')) == NULL
)
1167 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
1169 char buf
[SET_ENV_BUF_SIZE
];
1172 for (p
= modname
; *p
; p
++)
1173 if (*p
== '\\') *p
= '/';
1175 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1176 _putenv (strdup (buf
));
1178 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1180 /* FIXME: should use substring of get_emacs_configuration ().
1181 But I don't think the Windows build supports alpha, mips etc
1182 anymore, so have taken the easy option for now. */
1183 else if (p
&& stricmp (p
, "\\i386") == 0)
1186 p
= strrchr (modname
, '\\');
1190 p
= strrchr (modname
, '\\');
1191 if (p
&& stricmp (p
, "\\src") == 0)
1193 char buf
[SET_ENV_BUF_SIZE
];
1196 for (p
= modname
; *p
; p
++)
1197 if (*p
== '\\') *p
= '/';
1199 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1200 _putenv (strdup (buf
));
1206 for (i
= 0; i
< N_ENV_VARS
; i
++)
1208 if (!getenv (env_vars
[i
].name
))
1212 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1213 /* Also ignore empty environment variables. */
1216 if (lpval
) xfree (lpval
);
1217 lpval
= env_vars
[i
].def_value
;
1218 dwType
= REG_EXPAND_SZ
;
1224 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1226 if (dwType
== REG_EXPAND_SZ
)
1227 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
1228 else if (dwType
== REG_SZ
)
1229 strcpy (buf1
, lpval
);
1230 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1232 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
,
1234 _putenv (strdup (buf2
));
1244 /* Rebuild system configuration to reflect invoking system. */
1245 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1247 /* Another special case: on NT, the PATH variable is actually named
1248 "Path" although cmd.exe (perhaps NT itself) arranges for
1249 environment variable lookup and setting to be case insensitive.
1250 However, Emacs assumes a fully case sensitive environment, so we
1251 need to change "Path" to "PATH" to match the expectations of
1252 various elisp packages. We do this by the sneaky method of
1253 modifying the string in the C runtime environ entry.
1255 The same applies to COMSPEC. */
1259 for (envp
= environ
; *envp
; envp
++)
1260 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1261 memcpy (*envp
, "PATH=", 5);
1262 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1263 memcpy (*envp
, "COMSPEC=", 8);
1266 /* Remember the initial working directory for getwd, then make the
1267 real wd be the location of emacs.exe to avoid conflicts when
1268 renaming or deleting directories. (We also don't call chdir when
1269 running subprocesses for the same reason.) */
1270 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1275 static char modname
[MAX_PATH
];
1277 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1279 if ((p
= strrchr (modname
, '\\')) == NULL
)
1283 SetCurrentDirectory (modname
);
1285 /* Ensure argv[0] has the full path to Emacs. */
1290 /* Determine if there is a middle mouse button, to allow parse_button
1291 to decide whether right mouse events should be mouse-2 or
1293 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1299 emacs_root_dir (void)
1301 static char root_dir
[FILENAME_MAX
];
1304 p
= getenv ("emacs_dir");
1307 strcpy (root_dir
, p
);
1308 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1309 dostounix_filename (root_dir
);
1313 /* We don't have scripts to automatically determine the system configuration
1314 for Emacs before it's compiled, and we don't want to have to make the
1315 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1319 get_emacs_configuration (void)
1321 char *arch
, *oem
, *os
;
1323 static char configuration_buffer
[32];
1325 /* Determine the processor type. */
1326 switch (get_processor_type ())
1329 #ifdef PROCESSOR_INTEL_386
1330 case PROCESSOR_INTEL_386
:
1331 case PROCESSOR_INTEL_486
:
1332 case PROCESSOR_INTEL_PENTIUM
:
1337 #ifdef PROCESSOR_MIPS_R2000
1338 case PROCESSOR_MIPS_R2000
:
1339 case PROCESSOR_MIPS_R3000
:
1340 case PROCESSOR_MIPS_R4000
:
1345 #ifdef PROCESSOR_ALPHA_21064
1346 case PROCESSOR_ALPHA_21064
:
1356 /* Use the OEM field to reflect the compiler/library combination. */
1358 #define COMPILER_NAME "msvc"
1361 #define COMPILER_NAME "mingw"
1363 #define COMPILER_NAME "unknown"
1366 oem
= COMPILER_NAME
;
1368 switch (osinfo_cache
.dwPlatformId
) {
1369 case VER_PLATFORM_WIN32_NT
:
1371 build_num
= osinfo_cache
.dwBuildNumber
;
1373 case VER_PLATFORM_WIN32_WINDOWS
:
1374 if (osinfo_cache
.dwMinorVersion
== 0) {
1379 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1381 case VER_PLATFORM_WIN32s
:
1382 /* Not supported, should not happen. */
1384 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1392 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1393 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1394 get_w32_major_version (), get_w32_minor_version (), build_num
);
1396 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1399 return configuration_buffer
;
1403 get_emacs_configuration_options (void)
1405 static char options_buffer
[256];
1407 /* Work out the effective configure options for this build. */
1409 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1412 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1414 #define COMPILER_VERSION ""
1418 sprintf (options_buffer
, COMPILER_VERSION
);
1420 strcat (options_buffer
, " --no-opt");
1423 strcat (options_buffer
, " --cflags");
1424 strcat (options_buffer
, USER_CFLAGS
);
1427 strcat (options_buffer
, " --ldflags");
1428 strcat (options_buffer
, USER_LDFLAGS
);
1430 return options_buffer
;
1434 #include <sys/timeb.h>
1436 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1438 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1443 tv
->tv_sec
= tb
.time
;
1444 tv
->tv_usec
= tb
.millitm
* 1000L;
1447 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1448 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1452 /* ------------------------------------------------------------------------- */
1453 /* IO support and wrapper functions for W32 API. */
1454 /* ------------------------------------------------------------------------- */
1456 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1457 on network directories, so we handle that case here.
1458 (Ulrich Leodolter, 1/11/95). */
1460 sys_ctime (const time_t *t
)
1462 char *str
= (char *) ctime (t
);
1463 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1466 /* Emulate sleep...we could have done this with a define, but that
1467 would necessitate including windows.h in the files that used it.
1468 This is much easier. */
1470 sys_sleep (int seconds
)
1472 Sleep (seconds
* 1000);
1475 /* Internal MSVC functions for low-level descriptor munging */
1476 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1477 extern int __cdecl
_free_osfhnd (int fd
);
1479 /* parallel array of private info on file handles */
1480 filedesc fd_info
[ MAXDESC
];
1482 typedef struct volume_info_data
{
1483 struct volume_info_data
* next
;
1485 /* time when info was obtained */
1488 /* actual volume info */
1497 /* Global referenced by various functions. */
1498 static volume_info_data volume_info
;
1500 /* Vector to indicate which drives are local and fixed (for which cached
1501 data never expires). */
1502 static BOOL fixed_drives
[26];
1504 /* Consider cached volume information to be stale if older than 10s,
1505 at least for non-local drives. Info for fixed drives is never stale. */
1506 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1507 #define VOLINFO_STILL_VALID( root_dir, info ) \
1508 ( ( isalpha (root_dir[0]) && \
1509 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1510 || GetTickCount () - info->timestamp < 10000 )
1512 /* Cache support functions. */
1514 /* Simple linked list with linear search is sufficient. */
1515 static volume_info_data
*volume_cache
= NULL
;
1517 static volume_info_data
*
1518 lookup_volume_info (char * root_dir
)
1520 volume_info_data
* info
;
1522 for (info
= volume_cache
; info
; info
= info
->next
)
1523 if (stricmp (info
->root_dir
, root_dir
) == 0)
1529 add_volume_info (char * root_dir
, volume_info_data
* info
)
1531 info
->root_dir
= xstrdup (root_dir
);
1532 info
->next
= volume_cache
;
1533 volume_cache
= info
;
1537 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1538 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1539 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1541 GetCachedVolumeInformation (char * root_dir
)
1543 volume_info_data
* info
;
1544 char default_root
[ MAX_PATH
];
1546 /* NULL for root_dir means use root from current directory. */
1547 if (root_dir
== NULL
)
1549 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1551 parse_root (default_root
, &root_dir
);
1553 root_dir
= default_root
;
1556 /* Local fixed drives can be cached permanently. Removable drives
1557 cannot be cached permanently, since the volume name and serial
1558 number (if nothing else) can change. Remote drives should be
1559 treated as if they are removable, since there is no sure way to
1560 tell whether they are or not. Also, the UNC association of drive
1561 letters mapped to remote volumes can be changed at any time (even
1562 by other processes) without notice.
1564 As a compromise, so we can benefit from caching info for remote
1565 volumes, we use a simple expiry mechanism to invalidate cache
1566 entries that are more than ten seconds old. */
1569 /* No point doing this, because WNetGetConnection is even slower than
1570 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1571 GetDriveType is about the only call of this type which does not
1572 involve network access, and so is extremely quick). */
1574 /* Map drive letter to UNC if remote. */
1575 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1577 char remote_name
[ 256 ];
1578 char drive
[3] = { root_dir
[0], ':' };
1580 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1582 /* do something */ ;
1586 info
= lookup_volume_info (root_dir
);
1588 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1596 /* Info is not cached, or is stale. */
1597 if (!GetVolumeInformation (root_dir
,
1598 name
, sizeof (name
),
1602 type
, sizeof (type
)))
1605 /* Cache the volume information for future use, overwriting existing
1606 entry if present. */
1609 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1610 add_volume_info (root_dir
, info
);
1618 info
->name
= xstrdup (name
);
1619 info
->serialnum
= serialnum
;
1620 info
->maxcomp
= maxcomp
;
1621 info
->flags
= flags
;
1622 info
->type
= xstrdup (type
);
1623 info
->timestamp
= GetTickCount ();
1629 /* Get information on the volume where name is held; set path pointer to
1630 start of pathname in name (past UNC header\volume header if present). */
1632 get_volume_info (const char * name
, const char ** pPath
)
1634 char temp
[MAX_PATH
];
1635 char *rootname
= NULL
; /* default to current volume */
1636 volume_info_data
* info
;
1641 /* find the root name of the volume if given */
1642 if (isalpha (name
[0]) && name
[1] == ':')
1650 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1657 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1670 info
= GetCachedVolumeInformation (rootname
);
1673 /* Set global referenced by other functions. */
1674 volume_info
= *info
;
1680 /* Determine if volume is FAT format (ie. only supports short 8.3
1681 names); also set path pointer to start of pathname in name. */
1683 is_fat_volume (const char * name
, const char ** pPath
)
1685 if (get_volume_info (name
, pPath
))
1686 return (volume_info
.maxcomp
== 12);
1690 /* Map filename to a legal 8.3 name if necessary. */
1692 map_w32_filename (const char * name
, const char ** pPath
)
1694 static char shortname
[MAX_PATH
];
1695 char * str
= shortname
;
1698 const char * save_name
= name
;
1700 if (strlen (name
) >= MAX_PATH
)
1702 /* Return a filename which will cause callers to fail. */
1703 strcpy (shortname
, "?");
1707 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1709 register int left
= 8; /* maximum number of chars in part */
1710 register int extn
= 0; /* extension added? */
1711 register int dots
= 2; /* maximum number of dots allowed */
1714 *str
++ = *name
++; /* skip past UNC header */
1716 while ((c
= *name
++))
1723 extn
= 0; /* reset extension flags */
1724 dots
= 2; /* max 2 dots */
1725 left
= 8; /* max length 8 for main part */
1729 extn
= 0; /* reset extension flags */
1730 dots
= 2; /* max 2 dots */
1731 left
= 8; /* max length 8 for main part */
1736 /* Convert path components of the form .xxx to _xxx,
1737 but leave . and .. as they are. This allows .emacs
1738 to be read as _emacs, for example. */
1742 IS_DIRECTORY_SEP (*name
))
1757 extn
= 1; /* we've got an extension */
1758 left
= 3; /* 3 chars in extension */
1762 /* any embedded dots after the first are converted to _ */
1767 case '#': /* don't lose these, they're important */
1769 str
[-1] = c
; /* replace last character of part */
1774 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1776 dots
= 0; /* started a path component */
1785 strcpy (shortname
, name
);
1786 unixtodos_filename (shortname
);
1790 *pPath
= shortname
+ (path
- save_name
);
1796 is_exec (const char * name
)
1798 char * p
= strrchr (name
, '.');
1801 && (stricmp (p
, ".exe") == 0 ||
1802 stricmp (p
, ".com") == 0 ||
1803 stricmp (p
, ".bat") == 0 ||
1804 stricmp (p
, ".cmd") == 0));
1807 /* Emulate the Unix directory procedures opendir, closedir,
1808 and readdir. We can't use the procedures supplied in sysdep.c,
1809 so we provide them here. */
1811 struct direct dir_static
; /* simulated directory contents */
1812 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1813 static int dir_is_fat
;
1814 static char dir_pathname
[MAXPATHLEN
+1];
1815 static WIN32_FIND_DATA dir_find_data
;
1817 /* Support shares on a network resource as subdirectories of a read-only
1819 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1820 HANDLE
open_unc_volume (const char *);
1821 char *read_unc_volume (HANDLE
, char *, int);
1822 void close_unc_volume (HANDLE
);
1825 opendir (char *filename
)
1829 /* Opening is done by FindFirstFile. However, a read is inherent to
1830 this operation, so we defer the open until read time. */
1832 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1834 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1837 if (is_unc_volume (filename
))
1839 wnet_enum_handle
= open_unc_volume (filename
);
1840 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1844 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1851 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1852 dir_pathname
[MAXPATHLEN
] = '\0';
1853 dir_is_fat
= is_fat_volume (filename
, NULL
);
1859 closedir (DIR *dirp
)
1861 /* If we have a find-handle open, close it. */
1862 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1864 FindClose (dir_find_handle
);
1865 dir_find_handle
= INVALID_HANDLE_VALUE
;
1867 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1869 close_unc_volume (wnet_enum_handle
);
1870 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1872 xfree ((char *) dirp
);
1878 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1880 if (!read_unc_volume (wnet_enum_handle
,
1881 dir_find_data
.cFileName
,
1885 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1886 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1888 char filename
[MAXNAMLEN
+ 3];
1891 strcpy (filename
, dir_pathname
);
1892 ln
= strlen (filename
) - 1;
1893 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1894 strcat (filename
, "\\");
1895 strcat (filename
, "*");
1897 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1899 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1904 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1908 /* Emacs never uses this value, so don't bother making it match
1909 value returned by stat(). */
1910 dir_static
.d_ino
= 1;
1912 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1913 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1915 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1916 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1918 _strlwr (dir_static
.d_name
);
1919 else if (!NILP (Vw32_downcase_file_names
))
1922 for (p
= dir_static
.d_name
; *p
; p
++)
1923 if (*p
>= 'a' && *p
<= 'z')
1926 _strlwr (dir_static
.d_name
);
1933 open_unc_volume (const char *path
)
1939 nr
.dwScope
= RESOURCE_GLOBALNET
;
1940 nr
.dwType
= RESOURCETYPE_DISK
;
1941 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1942 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1943 nr
.lpLocalName
= NULL
;
1944 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
1945 nr
.lpComment
= NULL
;
1946 nr
.lpProvider
= NULL
;
1948 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1949 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1951 if (result
== NO_ERROR
)
1954 return INVALID_HANDLE_VALUE
;
1958 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1962 DWORD bufsize
= 512;
1967 buffer
= alloca (bufsize
);
1968 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1969 if (result
!= NO_ERROR
)
1972 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1973 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1975 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1978 strncpy (readbuf
, ptr
, size
);
1983 close_unc_volume (HANDLE henum
)
1985 if (henum
!= INVALID_HANDLE_VALUE
)
1986 WNetCloseEnum (henum
);
1990 unc_volume_file_attributes (const char *path
)
1995 henum
= open_unc_volume (path
);
1996 if (henum
== INVALID_HANDLE_VALUE
)
1999 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2001 close_unc_volume (henum
);
2006 /* Ensure a network connection is authenticated. */
2008 logon_network_drive (const char *path
)
2010 NETRESOURCE resource
;
2011 char share
[MAX_PATH
];
2014 /* Only logon to networked drives. */
2015 if (!IS_DIRECTORY_SEP (path
[0]) || !IS_DIRECTORY_SEP (path
[1]))
2018 strncpy (share
, path
, MAX_PATH
);
2019 /* Truncate to just server and share name. */
2020 for (i
= 2; i
< MAX_PATH
; i
++)
2022 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2029 resource
.dwType
= RESOURCETYPE_DISK
;
2030 resource
.lpLocalName
= NULL
;
2031 resource
.lpRemoteName
= share
;
2032 resource
.lpProvider
= NULL
;
2034 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2037 /* Shadow some MSVC runtime functions to map requests for long filenames
2038 to reasonable short names if necessary. This was originally added to
2039 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2043 sys_access (const char * path
, int mode
)
2047 /* MSVC implementation doesn't recognize D_OK. */
2048 path
= map_w32_filename (path
, NULL
);
2049 if (is_unc_volume (path
))
2051 attributes
= unc_volume_file_attributes (path
);
2052 if (attributes
== -1) {
2057 else if ((attributes
= GetFileAttributes (path
)) == -1)
2059 /* Should try mapping GetLastError to errno; for now just indicate
2060 that path doesn't exist. */
2064 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2069 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2074 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2083 sys_chdir (const char * path
)
2085 return _chdir (map_w32_filename (path
, NULL
));
2089 sys_chmod (const char * path
, int mode
)
2091 return _chmod (map_w32_filename (path
, NULL
), mode
);
2095 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2097 if (sys_chmod (path
, _S_IREAD
) == -1) /* check if file exists */
2103 sys_creat (const char * path
, int mode
)
2105 return _creat (map_w32_filename (path
, NULL
), mode
);
2109 sys_fopen(const char * path
, const char * mode
)
2113 const char * mode_save
= mode
;
2115 /* Force all file handles to be non-inheritable. This is necessary to
2116 ensure child processes don't unwittingly inherit handles that might
2117 prevent future file access. */
2121 else if (mode
[0] == 'w' || mode
[0] == 'a')
2122 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2126 /* Only do simplistic option parsing. */
2130 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2133 else if (mode
[0] == 'b')
2138 else if (mode
[0] == 't')
2145 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2149 return _fdopen (fd
, mode_save
);
2152 /* This only works on NTFS volumes, but is useful to have. */
2154 sys_link (const char * old
, const char * new)
2158 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2160 if (old
== NULL
|| new == NULL
)
2166 strcpy (oldname
, map_w32_filename (old
, NULL
));
2167 strcpy (newname
, map_w32_filename (new, NULL
));
2169 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2170 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2171 if (fileh
!= INVALID_HANDLE_VALUE
)
2175 /* Confusingly, the "alternate" stream name field does not apply
2176 when restoring a hard link, and instead contains the actual
2177 stream data for the link (ie. the name of the link to create).
2178 The WIN32_STREAM_ID structure before the cStreamName field is
2179 the stream header, which is then immediately followed by the
2183 WIN32_STREAM_ID wid
;
2184 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2187 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2188 data
.wid
.cStreamName
, MAX_PATH
);
2191 LPVOID context
= NULL
;
2194 data
.wid
.dwStreamId
= BACKUP_LINK
;
2195 data
.wid
.dwStreamAttributes
= 0;
2196 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
2197 data
.wid
.Size
.HighPart
= 0;
2198 data
.wid
.dwStreamNameSize
= 0;
2200 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2201 offsetof (WIN32_STREAM_ID
, cStreamName
)
2202 + data
.wid
.Size
.LowPart
,
2203 &wbytes
, FALSE
, FALSE
, &context
)
2204 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2211 /* Should try mapping GetLastError to errno; for now just
2212 indicate a general error (eg. links not supported). */
2213 errno
= EINVAL
; // perhaps EMLINK?
2217 CloseHandle (fileh
);
2226 sys_mkdir (const char * path
)
2228 return _mkdir (map_w32_filename (path
, NULL
));
2231 /* Because of long name mapping issues, we need to implement this
2232 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2233 a unique name, instead of setting the input template to an empty
2236 Standard algorithm seems to be use pid or tid with a letter on the
2237 front (in place of the 6 X's) and cycle through the letters to find a
2238 unique name. We extend that to allow any reasonable character as the
2239 first of the 6 X's. */
2241 sys_mktemp (char * template)
2245 unsigned uid
= GetCurrentThreadId ();
2246 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2248 if (template == NULL
)
2250 p
= template + strlen (template);
2252 /* replace up to the last 5 X's with uid in decimal */
2253 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2255 p
[0] = '0' + uid
% 10;
2259 if (i
< 0 && p
[0] == 'X')
2264 int save_errno
= errno
;
2265 p
[0] = first_char
[i
];
2266 if (sys_access (template, 0) < 0)
2272 while (++i
< sizeof (first_char
));
2275 /* Template is badly formed or else we can't generate a unique name,
2276 so return empty string */
2282 sys_open (const char * path
, int oflag
, int mode
)
2284 const char* mpath
= map_w32_filename (path
, NULL
);
2285 /* Try to open file without _O_CREAT, to be able to write to hidden
2286 and system files. Force all file handles to be
2288 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2291 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2295 sys_rename (const char * oldname
, const char * newname
)
2298 char temp
[MAX_PATH
];
2300 /* MoveFile on Windows 95 doesn't correctly change the short file name
2301 alias in a number of circumstances (it is not easy to predict when
2302 just by looking at oldname and newname, unfortunately). In these
2303 cases, renaming through a temporary name avoids the problem.
2305 A second problem on Windows 95 is that renaming through a temp name when
2306 newname is uppercase fails (the final long name ends up in
2307 lowercase, although the short alias might be uppercase) UNLESS the
2308 long temp name is not 8.3.
2310 So, on Windows 95 we always rename through a temp name, and we make sure
2311 the temp name has a long extension to ensure correct renaming. */
2313 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2315 if (os_subtype
== OS_WIN95
)
2321 oldname
= map_w32_filename (oldname
, NULL
);
2322 if (o
= strrchr (oldname
, '\\'))
2325 o
= (char *) oldname
;
2327 if (p
= strrchr (temp
, '\\'))
2334 /* Force temp name to require a manufactured 8.3 alias - this
2335 seems to make the second rename work properly. */
2336 sprintf (p
, "_.%s.%u", o
, i
);
2338 result
= rename (oldname
, temp
);
2340 /* This loop must surely terminate! */
2341 while (result
< 0 && errno
== EEXIST
);
2346 /* Emulate Unix behaviour - newname is deleted if it already exists
2347 (at least if it is a file; don't do this for directories).
2349 Since we mustn't do this if we are just changing the case of the
2350 file name (we would end up deleting the file we are trying to
2351 rename!), we let rename detect if the destination file already
2352 exists - that way we avoid the possible pitfalls of trying to
2353 determine ourselves whether two names really refer to the same
2354 file, which is not always possible in the general case. (Consider
2355 all the permutations of shared or subst'd drives, etc.) */
2357 newname
= map_w32_filename (newname
, NULL
);
2358 result
= rename (temp
, newname
);
2362 && _chmod (newname
, 0666) == 0
2363 && _unlink (newname
) == 0)
2364 result
= rename (temp
, newname
);
2370 sys_rmdir (const char * path
)
2372 return _rmdir (map_w32_filename (path
, NULL
));
2376 sys_unlink (const char * path
)
2378 path
= map_w32_filename (path
, NULL
);
2380 /* On Unix, unlink works without write permission. */
2381 _chmod (path
, 0666);
2382 return _unlink (path
);
2385 static FILETIME utc_base_ft
;
2386 static long double utc_base
;
2387 static int init
= 0;
2390 convert_time (FILETIME ft
)
2396 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2405 st
.wMilliseconds
= 0;
2407 SystemTimeToFileTime (&st
, &utc_base_ft
);
2408 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2409 * 4096.0L * 1024.0L * 1024.0L + utc_base_ft
.dwLowDateTime
;
2413 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2416 ret
= (long double) ft
.dwHighDateTime
2417 * 4096.0L * 1024.0L * 1024.0L + ft
.dwLowDateTime
;
2419 return (time_t) (ret
* 1e-7L);
2423 convert_from_time_t (time_t time
, FILETIME
* pft
)
2429 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2438 st
.wMilliseconds
= 0;
2440 SystemTimeToFileTime (&st
, &utc_base_ft
);
2441 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2442 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2446 /* time in 100ns units since 1-Jan-1601 */
2447 tmp
= (long double) time
* 1e7
+ utc_base
;
2448 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2449 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2453 /* No reason to keep this; faking inode values either by hashing or even
2454 using the file index from GetInformationByHandle, is not perfect and
2455 so by default Emacs doesn't use the inode values on Windows.
2456 Instead, we now determine file-truename correctly (except for
2457 possible drive aliasing etc). */
2459 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2461 hashval (const unsigned char * str
)
2466 h
= (h
<< 4) + *str
++;
2472 /* Return the hash value of the canonical pathname, excluding the
2473 drive/UNC header, to get a hopefully unique inode number. */
2475 generate_inode_val (const char * name
)
2477 char fullname
[ MAX_PATH
];
2481 /* Get the truly canonical filename, if it exists. (Note: this
2482 doesn't resolve aliasing due to subst commands, or recognise hard
2484 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2487 parse_root (fullname
, &p
);
2488 /* Normal W32 filesystems are still case insensitive. */
2495 /* MSVC stat function can't cope with UNC names and has other bugs, so
2496 replace it with our own. This also allows us to calculate consistent
2497 inode values without hacks in the main Emacs code. */
2499 stat (const char * path
, struct stat
* buf
)
2502 WIN32_FIND_DATA wfd
;
2507 int rootdir
= FALSE
;
2509 if (path
== NULL
|| buf
== NULL
)
2515 name
= (char *) map_w32_filename (path
, &path
);
2516 /* Must be valid filename, no wild cards or other invalid
2517 characters. We use _mbspbrk to support multibyte strings that
2518 might look to strpbrk as if they included literal *, ?, and other
2519 characters mentioned below that are disallowed by Windows
2521 if (_mbspbrk (name
, "*?|<>\""))
2527 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2528 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2529 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2534 /* Remove trailing directory separator, unless name is the root
2535 directory of a drive or UNC volume in which case ensure there
2536 is a trailing separator. */
2537 len
= strlen (name
);
2538 rootdir
= (path
>= name
+ len
- 1
2539 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2540 name
= strcpy (alloca (len
+ 2), name
);
2542 if (is_unc_volume (name
))
2544 DWORD attrs
= unc_volume_file_attributes (name
);
2549 memset (&wfd
, 0, sizeof (wfd
));
2550 wfd
.dwFileAttributes
= attrs
;
2551 wfd
.ftCreationTime
= utc_base_ft
;
2552 wfd
.ftLastAccessTime
= utc_base_ft
;
2553 wfd
.ftLastWriteTime
= utc_base_ft
;
2554 strcpy (wfd
.cFileName
, name
);
2558 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2559 strcat (name
, "\\");
2560 if (GetDriveType (name
) < 2)
2565 memset (&wfd
, 0, sizeof (wfd
));
2566 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2567 wfd
.ftCreationTime
= utc_base_ft
;
2568 wfd
.ftLastAccessTime
= utc_base_ft
;
2569 wfd
.ftLastWriteTime
= utc_base_ft
;
2570 strcpy (wfd
.cFileName
, name
);
2574 if (IS_DIRECTORY_SEP (name
[len
-1]))
2577 /* (This is hacky, but helps when doing file completions on
2578 network drives.) Optimize by using information available from
2579 active readdir if possible. */
2580 len
= strlen (dir_pathname
);
2581 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2583 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2584 && strnicmp (name
, dir_pathname
, len
) == 0
2585 && IS_DIRECTORY_SEP (name
[len
])
2586 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2588 /* This was the last entry returned by readdir. */
2589 wfd
= dir_find_data
;
2593 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2594 logon_network_drive (name
);
2596 fh
= FindFirstFile (name
, &wfd
);
2597 if (fh
== INVALID_HANDLE_VALUE
)
2606 if (!NILP (Vw32_get_true_file_attributes
)
2607 /* No access rights required to get info. */
2608 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
2609 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
2610 != INVALID_HANDLE_VALUE
)
2612 /* This is more accurate in terms of gettting the correct number
2613 of links, but is quite slow (it is noticeable when Emacs is
2614 making a list of file name completions). */
2615 BY_HANDLE_FILE_INFORMATION info
;
2617 if (GetFileInformationByHandle (fh
, &info
))
2619 buf
->st_nlink
= info
.nNumberOfLinks
;
2620 /* Might as well use file index to fake inode values, but this
2621 is not guaranteed to be unique unless we keep a handle open
2622 all the time (even then there are situations where it is
2623 not unique). Reputedly, there are at most 48 bits of info
2624 (on NTFS, presumably less on FAT). */
2625 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2633 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2635 buf
->st_mode
= _S_IFDIR
;
2639 switch (GetFileType (fh
))
2641 case FILE_TYPE_DISK
:
2642 buf
->st_mode
= _S_IFREG
;
2644 case FILE_TYPE_PIPE
:
2645 buf
->st_mode
= _S_IFIFO
;
2647 case FILE_TYPE_CHAR
:
2648 case FILE_TYPE_UNKNOWN
:
2650 buf
->st_mode
= _S_IFCHR
;
2657 /* Don't bother to make this information more accurate. */
2658 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
2659 _S_IFDIR
: _S_IFREG
;
2665 /* Not sure if there is any point in this. */
2666 if (!NILP (Vw32_generate_fake_inodes
))
2667 fake_inode
= generate_inode_val (name
);
2668 else if (fake_inode
== 0)
2670 /* For want of something better, try to make everything unique. */
2671 static DWORD gen_num
= 0;
2672 fake_inode
= ++gen_num
;
2676 /* MSVC defines _ino_t to be short; other libc's might not. */
2677 if (sizeof (buf
->st_ino
) == 2)
2678 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2680 buf
->st_ino
= fake_inode
;
2682 /* consider files to belong to current user */
2683 buf
->st_uid
= the_passwd
.pw_uid
;
2684 buf
->st_gid
= the_passwd
.pw_gid
;
2686 /* volume_info is set indirectly by map_w32_filename */
2687 buf
->st_dev
= volume_info
.serialnum
;
2688 buf
->st_rdev
= volume_info
.serialnum
;
2691 buf
->st_size
= wfd
.nFileSizeLow
;
2693 /* Convert timestamps to Unix format. */
2694 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2695 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2696 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2697 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2698 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2700 /* determine rwx permissions */
2701 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2702 permission
= _S_IREAD
;
2704 permission
= _S_IREAD
| _S_IWRITE
;
2706 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2707 permission
|= _S_IEXEC
;
2708 else if (is_exec (name
))
2709 permission
|= _S_IEXEC
;
2711 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2716 /* Provide fstat and utime as well as stat for consistent handling of
2719 fstat (int desc
, struct stat
* buf
)
2721 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2722 BY_HANDLE_FILE_INFORMATION info
;
2726 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2728 case FILE_TYPE_DISK
:
2729 buf
->st_mode
= _S_IFREG
;
2730 if (!GetFileInformationByHandle (fh
, &info
))
2736 case FILE_TYPE_PIPE
:
2737 buf
->st_mode
= _S_IFIFO
;
2739 case FILE_TYPE_CHAR
:
2740 case FILE_TYPE_UNKNOWN
:
2742 buf
->st_mode
= _S_IFCHR
;
2744 memset (&info
, 0, sizeof (info
));
2745 info
.dwFileAttributes
= 0;
2746 info
.ftCreationTime
= utc_base_ft
;
2747 info
.ftLastAccessTime
= utc_base_ft
;
2748 info
.ftLastWriteTime
= utc_base_ft
;
2751 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2752 buf
->st_mode
= _S_IFDIR
;
2754 buf
->st_nlink
= info
.nNumberOfLinks
;
2755 /* Might as well use file index to fake inode values, but this
2756 is not guaranteed to be unique unless we keep a handle open
2757 all the time (even then there are situations where it is
2758 not unique). Reputedly, there are at most 48 bits of info
2759 (on NTFS, presumably less on FAT). */
2760 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2762 /* MSVC defines _ino_t to be short; other libc's might not. */
2763 if (sizeof (buf
->st_ino
) == 2)
2764 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2766 buf
->st_ino
= fake_inode
;
2768 /* consider files to belong to current user */
2772 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2773 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2775 buf
->st_size
= info
.nFileSizeLow
;
2777 /* Convert timestamps to Unix format. */
2778 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2779 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2780 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2781 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2782 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2784 /* determine rwx permissions */
2785 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2786 permission
= _S_IREAD
;
2788 permission
= _S_IREAD
| _S_IWRITE
;
2790 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2791 permission
|= _S_IEXEC
;
2794 #if 0 /* no way of knowing the filename */
2795 char * p
= strrchr (name
, '.');
2797 (stricmp (p
, ".exe") == 0 ||
2798 stricmp (p
, ".com") == 0 ||
2799 stricmp (p
, ".bat") == 0 ||
2800 stricmp (p
, ".cmd") == 0))
2801 permission
|= _S_IEXEC
;
2805 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2811 utime (const char *name
, struct utimbuf
*times
)
2813 struct utimbuf deftime
;
2820 deftime
.modtime
= deftime
.actime
= time (NULL
);
2824 /* Need write access to set times. */
2825 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2826 0, OPEN_EXISTING
, 0, NULL
);
2829 convert_from_time_t (times
->actime
, &atime
);
2830 convert_from_time_t (times
->modtime
, &mtime
);
2831 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2849 /* Wrappers for winsock functions to map between our file descriptors
2850 and winsock's handles; also set h_errno for convenience.
2852 To allow Emacs to run on systems which don't have winsock support
2853 installed, we dynamically link to winsock on startup if present, and
2854 otherwise provide the minimum necessary functionality
2855 (eg. gethostname). */
2857 /* function pointers for relevant socket functions */
2858 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2859 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2860 int (PASCAL
*pfn_WSAGetLastError
) (void);
2861 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
2862 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
2863 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
2864 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2865 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2866 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2867 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2868 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2869 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2870 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2871 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2872 int (PASCAL
*pfn_WSACleanup
) (void);
2874 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2875 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2876 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2877 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2878 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2879 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2880 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
2881 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2882 const char * optval
, int optlen
);
2883 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2884 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2886 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2887 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2888 struct sockaddr
* from
, int * fromlen
);
2889 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2890 const struct sockaddr
* to
, int tolen
);
2892 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2893 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2894 #ifndef HANDLE_FLAG_INHERIT
2895 #define HANDLE_FLAG_INHERIT 1
2899 static int winsock_inuse
;
2904 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2906 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2907 after WSAStartup returns successfully, but it seems reasonable
2908 to allow unloading winsock anyway in that case. */
2909 if (pfn_WSACleanup () == 0 ||
2910 pfn_WSAGetLastError () == WSAENETDOWN
)
2912 if (FreeLibrary (winsock_lib
))
2921 init_winsock (int load_now
)
2923 WSADATA winsockData
;
2925 if (winsock_lib
!= NULL
)
2928 pfn_SetHandleInformation
= NULL
;
2929 pfn_SetHandleInformation
2930 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2931 "SetHandleInformation");
2933 winsock_lib
= LoadLibrary ("Ws2_32.dll");
2935 if (winsock_lib
!= NULL
)
2937 /* dynamically link to socket functions */
2939 #define LOAD_PROC(fn) \
2940 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2943 LOAD_PROC( WSAStartup
);
2944 LOAD_PROC( WSASetLastError
);
2945 LOAD_PROC( WSAGetLastError
);
2946 LOAD_PROC( WSAEventSelect
);
2947 LOAD_PROC( WSACreateEvent
);
2948 LOAD_PROC( WSACloseEvent
);
2949 LOAD_PROC( socket
);
2951 LOAD_PROC( connect
);
2952 LOAD_PROC( ioctlsocket
);
2955 LOAD_PROC( closesocket
);
2956 LOAD_PROC( shutdown
);
2959 LOAD_PROC( inet_addr
);
2960 LOAD_PROC( gethostname
);
2961 LOAD_PROC( gethostbyname
);
2962 LOAD_PROC( getservbyname
);
2963 LOAD_PROC( getpeername
);
2964 LOAD_PROC( WSACleanup
);
2965 LOAD_PROC( setsockopt
);
2966 LOAD_PROC( listen
);
2967 LOAD_PROC( getsockname
);
2968 LOAD_PROC( accept
);
2969 LOAD_PROC( recvfrom
);
2970 LOAD_PROC( sendto
);
2973 /* specify version 1.1 of winsock */
2974 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2976 if (winsockData
.wVersion
!= 0x101)
2981 /* Report that winsock exists and is usable, but leave
2982 socket functions disabled. I am assuming that calling
2983 WSAStartup does not require any network interaction,
2984 and in particular does not cause or require a dial-up
2985 connection to be established. */
2988 FreeLibrary (winsock_lib
);
2996 FreeLibrary (winsock_lib
);
3006 /* function to set h_errno for compatability; map winsock error codes to
3007 normal system codes where they overlap (non-overlapping definitions
3008 are already in <sys/socket.h> */
3012 if (winsock_lib
== NULL
)
3015 h_errno
= pfn_WSAGetLastError ();
3019 case WSAEACCES
: h_errno
= EACCES
; break;
3020 case WSAEBADF
: h_errno
= EBADF
; break;
3021 case WSAEFAULT
: h_errno
= EFAULT
; break;
3022 case WSAEINTR
: h_errno
= EINTR
; break;
3023 case WSAEINVAL
: h_errno
= EINVAL
; break;
3024 case WSAEMFILE
: h_errno
= EMFILE
; break;
3025 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
3026 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
3034 if (h_errno
== 0 && winsock_lib
!= NULL
)
3035 pfn_WSASetLastError (0);
3038 /* Extend strerror to handle the winsock-specific error codes. */
3042 } _wsa_errlist
[] = {
3043 WSAEINTR
, "Interrupted function call",
3044 WSAEBADF
, "Bad file descriptor",
3045 WSAEACCES
, "Permission denied",
3046 WSAEFAULT
, "Bad address",
3047 WSAEINVAL
, "Invalid argument",
3048 WSAEMFILE
, "Too many open files",
3050 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
3051 WSAEINPROGRESS
, "Operation now in progress",
3052 WSAEALREADY
, "Operation already in progress",
3053 WSAENOTSOCK
, "Socket operation on non-socket",
3054 WSAEDESTADDRREQ
, "Destination address required",
3055 WSAEMSGSIZE
, "Message too long",
3056 WSAEPROTOTYPE
, "Protocol wrong type for socket",
3057 WSAENOPROTOOPT
, "Bad protocol option",
3058 WSAEPROTONOSUPPORT
, "Protocol not supported",
3059 WSAESOCKTNOSUPPORT
, "Socket type not supported",
3060 WSAEOPNOTSUPP
, "Operation not supported",
3061 WSAEPFNOSUPPORT
, "Protocol family not supported",
3062 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
3063 WSAEADDRINUSE
, "Address already in use",
3064 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
3065 WSAENETDOWN
, "Network is down",
3066 WSAENETUNREACH
, "Network is unreachable",
3067 WSAENETRESET
, "Network dropped connection on reset",
3068 WSAECONNABORTED
, "Software caused connection abort",
3069 WSAECONNRESET
, "Connection reset by peer",
3070 WSAENOBUFS
, "No buffer space available",
3071 WSAEISCONN
, "Socket is already connected",
3072 WSAENOTCONN
, "Socket is not connected",
3073 WSAESHUTDOWN
, "Cannot send after socket shutdown",
3074 WSAETOOMANYREFS
, "Too many references", /* not sure */
3075 WSAETIMEDOUT
, "Connection timed out",
3076 WSAECONNREFUSED
, "Connection refused",
3077 WSAELOOP
, "Network loop", /* not sure */
3078 WSAENAMETOOLONG
, "Name is too long",
3079 WSAEHOSTDOWN
, "Host is down",
3080 WSAEHOSTUNREACH
, "No route to host",
3081 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
3082 WSAEPROCLIM
, "Too many processes",
3083 WSAEUSERS
, "Too many users", /* not sure */
3084 WSAEDQUOT
, "Double quote in host name", /* really not sure */
3085 WSAESTALE
, "Data is stale", /* not sure */
3086 WSAEREMOTE
, "Remote error", /* not sure */
3088 WSASYSNOTREADY
, "Network subsystem is unavailable",
3089 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
3090 WSANOTINITIALISED
, "Winsock not initialized successfully",
3091 WSAEDISCON
, "Graceful shutdown in progress",
3093 WSAENOMORE
, "No more operations allowed", /* not sure */
3094 WSAECANCELLED
, "Operation cancelled", /* not sure */
3095 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
3096 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
3097 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
3098 WSASYSCALLFAILURE
, "System call failure",
3099 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
3100 WSATYPE_NOT_FOUND
, "Class type not found",
3101 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
3102 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
3103 WSAEREFUSED
, "Operation refused", /* not sure */
3106 WSAHOST_NOT_FOUND
, "Host not found",
3107 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
3108 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
3109 WSANO_DATA
, "Valid name, no data record of requested type",
3115 sys_strerror(int error_no
)
3118 static char unknown_msg
[40];
3120 if (error_no
>= 0 && error_no
< sys_nerr
)
3121 return sys_errlist
[error_no
];
3123 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
3124 if (_wsa_errlist
[i
].errnum
== error_no
)
3125 return _wsa_errlist
[i
].msg
;
3127 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
3131 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3132 but I believe the method of keeping the socket handle separate (and
3133 insuring it is not inheritable) is the correct one. */
3135 //#define SOCK_REPLACE_HANDLE
3137 #ifdef SOCK_REPLACE_HANDLE
3138 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3140 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3143 int socket_to_fd (SOCKET s
);
3146 sys_socket(int af
, int type
, int protocol
)
3150 if (winsock_lib
== NULL
)
3153 return INVALID_SOCKET
;
3158 /* call the real socket function */
3159 s
= pfn_socket (af
, type
, protocol
);
3161 if (s
!= INVALID_SOCKET
)
3162 return socket_to_fd (s
);
3168 /* Convert a SOCKET to a file descriptor. */
3170 socket_to_fd (SOCKET s
)
3175 /* Although under NT 3.5 _open_osfhandle will accept a socket
3176 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3177 that does not work under NT 3.1. However, we can get the same
3178 effect by using a backdoor function to replace an existing
3179 descriptor handle with the one we want. */
3181 /* allocate a file descriptor (with appropriate flags) */
3182 fd
= _open ("NUL:", _O_RDWR
);
3185 #ifdef SOCK_REPLACE_HANDLE
3186 /* now replace handle to NUL with our socket handle */
3187 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
3189 _set_osfhnd (fd
, s
);
3190 /* setmode (fd, _O_BINARY); */
3192 /* Make a non-inheritable copy of the socket handle. Note
3193 that it is possible that sockets aren't actually kernel
3194 handles, which appears to be the case on Windows 9x when
3195 the MS Proxy winsock client is installed. */
3197 /* Apparently there is a bug in NT 3.51 with some service
3198 packs, which prevents using DuplicateHandle to make a
3199 socket handle non-inheritable (causes WSACleanup to
3200 hang). The work-around is to use SetHandleInformation
3201 instead if it is available and implemented. */
3202 if (pfn_SetHandleInformation
)
3204 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
3208 HANDLE parent
= GetCurrentProcess ();
3209 HANDLE new_s
= INVALID_HANDLE_VALUE
;
3211 if (DuplicateHandle (parent
,
3217 DUPLICATE_SAME_ACCESS
))
3219 /* It is possible that DuplicateHandle succeeds even
3220 though the socket wasn't really a kernel handle,
3221 because a real handle has the same value. So
3222 test whether the new handle really is a socket. */
3223 long nonblocking
= 0;
3224 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
3226 pfn_closesocket (s
);
3231 CloseHandle (new_s
);
3236 fd_info
[fd
].hnd
= (HANDLE
) s
;
3239 /* set our own internal flags */
3240 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
3246 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3248 /* attach child_process to fd_info */
3249 if (fd_info
[ fd
].cp
!= NULL
)
3251 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
3255 fd_info
[ fd
].cp
= cp
;
3258 winsock_inuse
++; /* count open sockets */
3265 pfn_closesocket (s
);
3272 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
3274 if (winsock_lib
== NULL
)
3277 return SOCKET_ERROR
;
3281 if (fd_info
[s
].flags
& FILE_SOCKET
)
3283 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
3284 if (rc
== SOCKET_ERROR
)
3289 return SOCKET_ERROR
;
3294 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
3296 if (winsock_lib
== NULL
)
3299 return SOCKET_ERROR
;
3303 if (fd_info
[s
].flags
& FILE_SOCKET
)
3305 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
3306 if (rc
== SOCKET_ERROR
)
3311 return SOCKET_ERROR
;
3315 sys_htons (u_short hostshort
)
3317 return (winsock_lib
!= NULL
) ?
3318 pfn_htons (hostshort
) : hostshort
;
3322 sys_ntohs (u_short netshort
)
3324 return (winsock_lib
!= NULL
) ?
3325 pfn_ntohs (netshort
) : netshort
;
3329 sys_inet_addr (const char * cp
)
3331 return (winsock_lib
!= NULL
) ?
3332 pfn_inet_addr (cp
) : INADDR_NONE
;
3336 sys_gethostname (char * name
, int namelen
)
3338 if (winsock_lib
!= NULL
)
3339 return pfn_gethostname (name
, namelen
);
3341 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
3342 return !GetComputerName (name
, (DWORD
*)&namelen
);
3345 return SOCKET_ERROR
;
3349 sys_gethostbyname(const char * name
)
3351 struct hostent
* host
;
3353 if (winsock_lib
== NULL
)
3360 host
= pfn_gethostbyname (name
);
3367 sys_getservbyname(const char * name
, const char * proto
)
3369 struct servent
* serv
;
3371 if (winsock_lib
== NULL
)
3378 serv
= pfn_getservbyname (name
, proto
);
3385 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
3387 if (winsock_lib
== NULL
)
3390 return SOCKET_ERROR
;
3394 if (fd_info
[s
].flags
& FILE_SOCKET
)
3396 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
3397 if (rc
== SOCKET_ERROR
)
3402 return SOCKET_ERROR
;
3407 sys_shutdown (int s
, int how
)
3409 if (winsock_lib
== NULL
)
3412 return SOCKET_ERROR
;
3416 if (fd_info
[s
].flags
& FILE_SOCKET
)
3418 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
3419 if (rc
== SOCKET_ERROR
)
3424 return SOCKET_ERROR
;
3428 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
3430 if (winsock_lib
== NULL
)
3433 return SOCKET_ERROR
;
3437 if (fd_info
[s
].flags
& FILE_SOCKET
)
3439 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
3440 (const char *)optval
, optlen
);
3441 if (rc
== SOCKET_ERROR
)
3446 return SOCKET_ERROR
;
3450 sys_listen (int s
, int backlog
)
3452 if (winsock_lib
== NULL
)
3455 return SOCKET_ERROR
;
3459 if (fd_info
[s
].flags
& FILE_SOCKET
)
3461 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
3462 if (rc
== SOCKET_ERROR
)
3465 fd_info
[s
].flags
|= FILE_LISTEN
;
3469 return SOCKET_ERROR
;
3473 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
3475 if (winsock_lib
== NULL
)
3478 return SOCKET_ERROR
;
3482 if (fd_info
[s
].flags
& FILE_SOCKET
)
3484 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3485 if (rc
== SOCKET_ERROR
)
3490 return SOCKET_ERROR
;
3494 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3496 if (winsock_lib
== NULL
)
3503 if (fd_info
[s
].flags
& FILE_LISTEN
)
3505 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3507 if (t
== INVALID_SOCKET
)
3510 fd
= socket_to_fd (t
);
3512 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3513 ResetEvent (fd_info
[s
].cp
->char_avail
);
3521 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3522 struct sockaddr
* from
, int * fromlen
)
3524 if (winsock_lib
== NULL
)
3527 return SOCKET_ERROR
;
3531 if (fd_info
[s
].flags
& FILE_SOCKET
)
3533 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3534 if (rc
== SOCKET_ERROR
)
3539 return SOCKET_ERROR
;
3543 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3544 const struct sockaddr
* to
, int tolen
)
3546 if (winsock_lib
== NULL
)
3549 return SOCKET_ERROR
;
3553 if (fd_info
[s
].flags
& FILE_SOCKET
)
3555 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3556 if (rc
== SOCKET_ERROR
)
3561 return SOCKET_ERROR
;
3564 /* Windows does not have an fcntl function. Provide an implementation
3565 solely for making sockets non-blocking. */
3567 fcntl (int s
, int cmd
, int options
)
3569 if (winsock_lib
== NULL
)
3576 if (fd_info
[s
].flags
& FILE_SOCKET
)
3578 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
3580 unsigned long nblock
= 1;
3581 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
3582 if (rc
== SOCKET_ERROR
)
3584 /* Keep track of the fact that we set this to non-blocking. */
3585 fd_info
[s
].flags
|= FILE_NDELAY
;
3591 return SOCKET_ERROR
;
3595 return SOCKET_ERROR
;
3598 #endif /* HAVE_SOCKETS */
3601 /* Shadow main io functions: we need to handle pipes and sockets more
3602 intelligently, and implement non-blocking mode as well. */
3615 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
3617 child_process
* cp
= fd_info
[fd
].cp
;
3619 fd_info
[fd
].cp
= NULL
;
3621 if (CHILD_ACTIVE (cp
))
3623 /* if last descriptor to active child_process then cleanup */
3625 for (i
= 0; i
< MAXDESC
; i
++)
3629 if (fd_info
[i
].cp
== cp
)
3635 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3637 #ifndef SOCK_REPLACE_HANDLE
3638 if (winsock_lib
== NULL
) abort ();
3640 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3641 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3643 winsock_inuse
--; /* count open sockets */
3651 /* Note that sockets do not need special treatment here (at least on
3652 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3653 closesocket is equivalent to CloseHandle, which is to be expected
3654 because socket handles are fully fledged kernel handles. */
3657 if (rc
== 0 && fd
< MAXDESC
)
3658 fd_info
[fd
].flags
= 0;
3669 if (new_fd
>= 0 && new_fd
< MAXDESC
)
3671 /* duplicate our internal info as well */
3672 fd_info
[new_fd
] = fd_info
[fd
];
3679 sys_dup2 (int src
, int dst
)
3683 if (dst
< 0 || dst
>= MAXDESC
)
3689 /* make sure we close the destination first if it's a pipe or socket */
3690 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3693 rc
= _dup2 (src
, dst
);
3696 /* duplicate our internal info as well */
3697 fd_info
[dst
] = fd_info
[src
];
3702 /* Unix pipe() has only one arg */
3704 sys_pipe (int * phandles
)
3709 /* make pipe handles non-inheritable; when we spawn a child, we
3710 replace the relevant handle with an inheritable one. Also put
3711 pipes into binary mode; we will do text mode translation ourselves
3713 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3717 /* Protect against overflow, since Windows can open more handles than
3718 our fd_info array has room for. */
3719 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
3721 _close (phandles
[0]);
3722 _close (phandles
[1]);
3727 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3728 fd_info
[phandles
[0]].flags
= flags
;
3730 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3731 fd_info
[phandles
[1]].flags
= flags
;
3739 extern int w32_pipe_read_delay
;
3741 /* Function to do blocking read of one byte, needed to implement
3742 select. It is only allowed on sockets and pipes. */
3744 _sys_read_ahead (int fd
)
3749 if (fd
< 0 || fd
>= MAXDESC
)
3750 return STATUS_READ_ERROR
;
3752 cp
= fd_info
[fd
].cp
;
3754 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3755 return STATUS_READ_ERROR
;
3757 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3758 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3760 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3764 cp
->status
= STATUS_READ_IN_PROGRESS
;
3766 if (fd_info
[fd
].flags
& FILE_PIPE
)
3768 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3770 /* Give subprocess time to buffer some more output for us before
3771 reporting that input is available; we need this because Windows 95
3772 connects DOS programs to pipes by making the pipe appear to be
3773 the normal console stdout - as a result most DOS programs will
3774 write to stdout without buffering, ie. one character at a
3775 time. Even some W32 programs do this - "dir" in a command
3776 shell on NT is very slow if we don't do this. */
3779 int wait
= w32_pipe_read_delay
;
3785 /* Yield remainder of our time slice, effectively giving a
3786 temporary priority boost to the child process. */
3791 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3793 unsigned long nblock
= 0;
3794 /* We always want this to block, so temporarily disable NDELAY. */
3795 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3796 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3798 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3800 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3803 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3808 if (rc
== sizeof (char))
3809 cp
->status
= STATUS_READ_SUCCEEDED
;
3811 cp
->status
= STATUS_READ_FAILED
;
3817 _sys_wait_accept (int fd
)
3823 if (fd
< 0 || fd
>= MAXDESC
)
3824 return STATUS_READ_ERROR
;
3826 cp
= fd_info
[fd
].cp
;
3828 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3829 return STATUS_READ_ERROR
;
3831 cp
->status
= STATUS_READ_FAILED
;
3833 hEv
= pfn_WSACreateEvent ();
3834 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
3835 if (rc
!= SOCKET_ERROR
)
3837 rc
= WaitForSingleObject (hEv
, INFINITE
);
3838 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
3839 if (rc
== WAIT_OBJECT_0
)
3840 cp
->status
= STATUS_READ_SUCCEEDED
;
3842 pfn_WSACloseEvent (hEv
);
3848 sys_read (int fd
, char * buffer
, unsigned int count
)
3853 char * orig_buffer
= buffer
;
3861 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3863 child_process
*cp
= fd_info
[fd
].cp
;
3865 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3873 /* re-read CR carried over from last read */
3874 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3876 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3880 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3883 /* presence of a child_process structure means we are operating in
3884 non-blocking mode - otherwise we just call _read directly.
3885 Note that the child_process structure might be missing because
3886 reap_subprocess has been called; in this case the pipe is
3887 already broken, so calling _read on it is okay. */
3890 int current_status
= cp
->status
;
3892 switch (current_status
)
3894 case STATUS_READ_FAILED
:
3895 case STATUS_READ_ERROR
:
3896 /* report normal EOF if nothing in buffer */
3898 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3901 case STATUS_READ_READY
:
3902 case STATUS_READ_IN_PROGRESS
:
3903 DebPrint (("sys_read called when read is in progress\n"));
3904 errno
= EWOULDBLOCK
;
3907 case STATUS_READ_SUCCEEDED
:
3908 /* consume read-ahead char */
3909 *buffer
++ = cp
->chr
;
3912 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3913 ResetEvent (cp
->char_avail
);
3915 case STATUS_READ_ACKNOWLEDGED
:
3919 DebPrint (("sys_read: bad status %d\n", current_status
));
3924 if (fd_info
[fd
].flags
& FILE_PIPE
)
3926 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3927 to_read
= min (waiting
, (DWORD
) count
);
3930 nchars
+= _read (fd
, buffer
, to_read
);
3933 else /* FILE_SOCKET */
3935 if (winsock_lib
== NULL
) abort ();
3937 /* do the equivalent of a non-blocking read */
3938 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3939 if (waiting
== 0 && nchars
== 0)
3941 h_errno
= errno
= EWOULDBLOCK
;
3947 /* always use binary mode for sockets */
3948 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3949 if (res
== SOCKET_ERROR
)
3951 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3952 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3963 int nread
= _read (fd
, buffer
, count
);
3966 else if (nchars
== 0)
3971 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3972 /* Perform text mode translation if required. */
3973 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3975 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3976 /* If buffer contains only CR, return that. To be absolutely
3977 sure we should attempt to read the next char, but in
3978 practice a CR to be followed by LF would not appear by
3979 itself in the buffer. */
3980 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3982 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3988 nchars
= _read (fd
, buffer
, count
);
3993 /* For now, don't bother with a non-blocking mode */
3995 sys_write (int fd
, const void * buffer
, unsigned int count
)
4005 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
4007 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
4013 /* Perform text mode translation if required. */
4014 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
4016 char * tmpbuf
= alloca (count
* 2);
4017 unsigned char * src
= (void *)buffer
;
4018 unsigned char * dst
= tmpbuf
;
4023 unsigned char *next
;
4024 /* copy next line or remaining bytes */
4025 next
= _memccpy (dst
, src
, '\n', nbytes
);
4028 /* copied one line ending with '\n' */
4029 int copied
= next
- dst
;
4032 /* insert '\r' before '\n' */
4039 /* copied remaining partial line -> now finished */
4047 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
4049 unsigned long nblock
= 0;
4050 if (winsock_lib
== NULL
) abort ();
4052 /* TODO: implement select() properly so non-blocking I/O works. */
4053 /* For now, make sure the write blocks. */
4054 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4055 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4057 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
4059 /* Set the socket back to non-blocking if it was before,
4060 for other operations that support it. */
4061 if (fd_info
[fd
].flags
& FILE_NDELAY
)
4064 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
4067 if (nchars
== SOCKET_ERROR
)
4069 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
4070 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
4076 nchars
= _write (fd
, buffer
, count
);
4082 check_windows_init_file ()
4084 extern int noninteractive
, inhibit_window_system
;
4086 /* A common indication that Emacs is not installed properly is when
4087 it cannot find the Windows installation file. If this file does
4088 not exist in the expected place, tell the user. */
4090 if (!noninteractive
&& !inhibit_window_system
)
4092 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
4093 Lisp_Object objs
[2];
4094 Lisp_Object full_load_path
;
4095 Lisp_Object init_file
;
4098 objs
[0] = Vload_path
;
4099 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
4100 full_load_path
= Fappend (2, objs
);
4101 init_file
= build_string ("term/w32-win");
4102 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
4105 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
4106 char *init_file_name
= SDATA (init_file
);
4107 char *load_path
= SDATA (load_path_print
);
4108 char *buffer
= alloca (1024
4109 + strlen (init_file_name
)
4110 + strlen (load_path
));
4113 "The Emacs Windows initialization file \"%s.el\" "
4114 "could not be found in your Emacs installation. "
4115 "Emacs checked the following directories for this file:\n"
4117 "When Emacs cannot find this file, it usually means that it "
4118 "was not installed properly, or its distribution file was "
4119 "not unpacked properly.\nSee the README.W32 file in the "
4120 "top-level Emacs directory for more information.",
4121 init_file_name
, load_path
);
4124 "Emacs Abort Dialog",
4125 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
4126 /* Use the low-level Emacs abort. */
4141 /* shutdown the socket interface if necessary */
4152 /* Initialise the socket interface now if available and requested by
4153 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4154 delayed until open-network-stream is called (w32-has-winsock can
4155 also be used to dynamically load or reload winsock).
4157 Conveniently, init_environment is called before us, so
4158 PRELOAD_WINSOCK can be set in the registry. */
4160 /* Always initialize this correctly. */
4163 if (getenv ("PRELOAD_WINSOCK") != NULL
)
4164 init_winsock (TRUE
);
4167 /* Initial preparation for subprocess support: replace our standard
4168 handles with non-inheritable versions. */
4171 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
4172 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
4173 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
4175 parent
= GetCurrentProcess ();
4177 /* ignore errors when duplicating and closing; typically the
4178 handles will be invalid when running as a gui program. */
4179 DuplicateHandle (parent
,
4180 GetStdHandle (STD_INPUT_HANDLE
),
4185 DUPLICATE_SAME_ACCESS
);
4187 DuplicateHandle (parent
,
4188 GetStdHandle (STD_OUTPUT_HANDLE
),
4193 DUPLICATE_SAME_ACCESS
);
4195 DuplicateHandle (parent
,
4196 GetStdHandle (STD_ERROR_HANDLE
),
4201 DUPLICATE_SAME_ACCESS
);
4207 if (stdin_save
!= INVALID_HANDLE_VALUE
)
4208 _open_osfhandle ((long) stdin_save
, O_TEXT
);
4210 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
4213 if (stdout_save
!= INVALID_HANDLE_VALUE
)
4214 _open_osfhandle ((long) stdout_save
, O_TEXT
);
4216 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4219 if (stderr_save
!= INVALID_HANDLE_VALUE
)
4220 _open_osfhandle ((long) stderr_save
, O_TEXT
);
4222 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4226 /* unfortunately, atexit depends on implementation of malloc */
4227 /* atexit (term_ntproc); */
4228 signal (SIGABRT
, term_ntproc
);
4230 /* determine which drives are fixed, for GetCachedVolumeInformation */
4232 /* GetDriveType must have trailing backslash. */
4233 char drive
[] = "A:\\";
4235 /* Loop over all possible drive letters */
4236 while (*drive
<= 'Z')
4238 /* Record if this drive letter refers to a fixed drive. */
4239 fixed_drives
[DRIVE_INDEX (*drive
)] =
4240 (GetDriveType (drive
) == DRIVE_FIXED
);
4245 /* Reset the volume info cache. */
4246 volume_cache
= NULL
;
4249 /* Check to see if Emacs has been installed correctly. */
4250 check_windows_init_file ();
4254 shutdown_handler ensures that buffers' autosave files are
4255 up to date when the user logs off, or the system shuts down.
4257 BOOL WINAPI
shutdown_handler(DWORD type
)
4259 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4260 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
4261 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
4262 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
4264 /* Shut down cleanly, making sure autosave files are up to date. */
4265 shut_down_emacs (0, 0, Qnil
);
4268 /* Allow other handlers to handle this signal. */
4273 globals_of_w32 is used to initialize those global variables that
4274 must always be initialized on startup even when the global variable
4275 initialized is non zero (see the function main in emacs.c).
4280 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
4282 get_process_times_fn
= (GetProcessTimes_Proc
)
4283 GetProcAddress (kernel32
, "GetProcessTimes");
4285 g_b_init_is_windows_9x
= 0;
4286 g_b_init_open_process_token
= 0;
4287 g_b_init_get_token_information
= 0;
4288 g_b_init_lookup_account_sid
= 0;
4289 g_b_init_get_sid_identifier_authority
= 0;
4290 /* The following sets a handler for shutdown notifications for
4291 console apps. This actually applies to Emacs in both console and
4292 GUI modes, since we had to fool windows into thinking emacs is a
4293 console application to get console mode to work. */
4294 SetConsoleCtrlHandler(shutdown_handler
, TRUE
);
4299 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4300 (do not change this comment) */