1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994, 1995, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
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
;
125 BEGIN: Wrapper functions around OpenProcessToken
126 and other functions in advapi32.dll that are only
127 supported in Windows NT / 2k / XP
129 /* ** Function pointer typedefs ** */
130 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
131 HANDLE ProcessHandle
,
133 PHANDLE TokenHandle
);
134 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
136 TOKEN_INFORMATION_CLASS TokenInformationClass
,
137 LPVOID TokenInformation
,
138 DWORD TokenInformationLength
,
139 PDWORD ReturnLength
);
140 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
141 HANDLE process_handle
,
142 LPFILETIME creation_time
,
143 LPFILETIME exit_time
,
144 LPFILETIME kernel_time
,
145 LPFILETIME user_time
);
147 GetProcessTimes_Proc get_process_times_fn
= NULL
;
150 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
152 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
154 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
155 LPCTSTR lpSystemName
,
160 LPDWORD cbDomainName
,
161 PSID_NAME_USE peUse
);
162 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI
* GetSidIdentifierAuthority_Proc
) (
165 /* ** A utility function ** */
169 static BOOL s_b_ret
=0;
170 OSVERSIONINFO os_ver
;
171 if (g_b_init_is_windows_9x
== 0)
173 g_b_init_is_windows_9x
= 1;
174 ZeroMemory(&os_ver
, sizeof(OSVERSIONINFO
));
175 os_ver
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
176 if (GetVersionEx (&os_ver
))
178 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
184 /* Get total user and system times for get-internal-run-time.
185 Returns a list of three integers if the times are provided by the OS
186 (NT derivatives), otherwise it returns the result of current-time. */
188 w32_get_internal_run_time ()
190 if (get_process_times_fn
)
192 FILETIME create
, exit
, kernel
, user
;
193 HANDLE proc
= GetCurrentProcess();
194 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
196 LARGE_INTEGER user_int
, kernel_int
, total
;
198 user_int
.LowPart
= user
.dwLowDateTime
;
199 user_int
.HighPart
= user
.dwHighDateTime
;
200 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
201 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
202 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
203 /* FILETIME is 100 nanosecond increments, Emacs only wants
204 microsecond resolution. */
205 total
.QuadPart
/= 10;
206 microseconds
= total
.QuadPart
% 1000000;
207 total
.QuadPart
/= 1000000;
209 /* Sanity check to make sure we can represent the result. */
210 if (total
.HighPart
== 0)
212 int secs
= total
.LowPart
;
214 return list3 (make_number ((secs
>> 16) & 0xffff),
215 make_number (secs
& 0xffff),
216 make_number (microseconds
));
221 return Fcurrent_time ();
224 /* ** The wrapper functions ** */
226 BOOL WINAPI
open_process_token (
227 HANDLE ProcessHandle
,
231 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
232 HMODULE hm_advapi32
= NULL
;
233 if (is_windows_9x () == TRUE
)
237 if (g_b_init_open_process_token
== 0)
239 g_b_init_open_process_token
= 1;
240 hm_advapi32
= LoadLibrary ("Advapi32.dll");
241 s_pfn_Open_Process_Token
=
242 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
244 if (s_pfn_Open_Process_Token
== NULL
)
249 s_pfn_Open_Process_Token (
256 BOOL WINAPI
get_token_information (
258 TOKEN_INFORMATION_CLASS TokenInformationClass
,
259 LPVOID TokenInformation
,
260 DWORD TokenInformationLength
,
263 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
264 HMODULE hm_advapi32
= NULL
;
265 if (is_windows_9x () == TRUE
)
269 if (g_b_init_get_token_information
== 0)
271 g_b_init_get_token_information
= 1;
272 hm_advapi32
= LoadLibrary ("Advapi32.dll");
273 s_pfn_Get_Token_Information
=
274 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
276 if (s_pfn_Get_Token_Information
== NULL
)
281 s_pfn_Get_Token_Information (
283 TokenInformationClass
,
285 TokenInformationLength
,
290 BOOL WINAPI
lookup_account_sid (
291 LPCTSTR lpSystemName
,
296 LPDWORD cbDomainName
,
299 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
300 HMODULE hm_advapi32
= NULL
;
301 if (is_windows_9x () == TRUE
)
305 if (g_b_init_lookup_account_sid
== 0)
307 g_b_init_lookup_account_sid
= 1;
308 hm_advapi32
= LoadLibrary ("Advapi32.dll");
309 s_pfn_Lookup_Account_Sid
=
310 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
312 if (s_pfn_Lookup_Account_Sid
== NULL
)
317 s_pfn_Lookup_Account_Sid (
328 PSID_IDENTIFIER_AUTHORITY WINAPI
get_sid_identifier_authority (
331 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority
= NULL
;
332 HMODULE hm_advapi32
= NULL
;
333 if (is_windows_9x () == TRUE
)
337 if (g_b_init_get_sid_identifier_authority
== 0)
339 g_b_init_get_sid_identifier_authority
= 1;
340 hm_advapi32
= LoadLibrary ("Advapi32.dll");
341 s_pfn_Get_Sid_Identifier_Authority
=
342 (GetSidIdentifierAuthority_Proc
) GetProcAddress (
343 hm_advapi32
, "GetSidIdentifierAuthority");
345 if (s_pfn_Get_Sid_Identifier_Authority
== NULL
)
349 return (s_pfn_Get_Sid_Identifier_Authority (pSid
));
353 END: Wrapper functions around OpenProcessToken
354 and other functions in advapi32.dll that are only
355 supported in Windows NT / 2k / XP
359 /* Equivalent of strerror for W32 error codes. */
361 w32_strerror (int error_no
)
363 static char buf
[500];
366 error_no
= GetLastError ();
369 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
371 0, /* choose most suitable language */
372 buf
, sizeof (buf
), NULL
))
373 sprintf (buf
, "w32 error %u", error_no
);
377 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
378 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
380 This is called from alloc.c:valid_pointer_p. */
382 w32_valid_pointer_p (void *p
, int size
)
385 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
389 unsigned char *buf
= alloca (size
);
390 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
399 static char startup_dir
[MAXPATHLEN
];
401 /* Get the current working directory. */
406 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
410 /* Emacs doesn't actually change directory itself, and we want to
411 force our real wd to be where emacs.exe is to avoid unnecessary
412 conflicts when trying to rename or delete directories. */
413 strcpy (dir
, startup_dir
);
419 /* Emulate gethostname. */
421 gethostname (char *buffer
, int size
)
423 /* NT only allows small host names, so the buffer is
424 certainly large enough. */
425 return !GetComputerName (buffer
, &size
);
427 #endif /* HAVE_SOCKETS */
429 /* Emulate getloadavg. */
431 getloadavg (double loadavg
[], int nelem
)
435 /* A faithful emulation is going to have to be saved for a rainy day. */
436 for (i
= 0; i
< nelem
; i
++)
443 /* Emulate getpwuid, getpwnam and others. */
445 #define PASSWD_FIELD_SIZE 256
447 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
448 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
449 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
450 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
451 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
453 static struct passwd the_passwd
=
465 static struct group the_group
=
467 /* There are no groups on NT, so we just return "root" as the
475 return the_passwd
.pw_uid
;
481 /* I could imagine arguing for checking to see whether the user is
482 in the Administrators group and returning a UID of 0 for that
483 case, but I don't know how wise that would be in the long run. */
490 return the_passwd
.pw_gid
;
502 if (uid
== the_passwd
.pw_uid
)
514 getpwnam (char *name
)
518 pw
= getpwuid (getuid ());
522 if (stricmp (name
, pw
->pw_name
))
531 /* Find the user's real name by opening the process token and
532 looking up the name associated with the user-sid in that token.
534 Use the relative portion of the identifier authority value from
535 the user-sid as the user id value (same for group id using the
536 primary group sid from the process token). */
538 char user_sid
[256], name
[256], domain
[256];
539 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
541 SID_NAME_USE user_type
;
543 if (open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
)
544 && get_token_information (token
, TokenUser
,
545 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
546 && lookup_account_sid (NULL
, *((PSID
*) user_sid
), name
, &length
,
547 domain
, &dlength
, &user_type
))
549 strcpy (the_passwd
.pw_name
, name
);
550 /* Determine a reasonable uid value. */
551 if (stricmp ("administrator", name
) == 0)
553 the_passwd
.pw_uid
= 0;
554 the_passwd
.pw_gid
= 0;
558 SID_IDENTIFIER_AUTHORITY
* pSIA
;
560 pSIA
= get_sid_identifier_authority (*((PSID
*) user_sid
));
561 /* I believe the relative portion is the last 4 bytes (of 6)
563 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
564 (pSIA
->Value
[3] << 16) +
565 (pSIA
->Value
[4] << 8) +
566 (pSIA
->Value
[5] << 0));
567 /* restrict to conventional uid range for normal users */
568 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
571 if (get_token_information (token
, TokenPrimaryGroup
,
572 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
574 SID_IDENTIFIER_AUTHORITY
* pSIA
;
576 pSIA
= get_sid_identifier_authority (*((PSID
*) user_sid
));
577 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
578 (pSIA
->Value
[3] << 16) +
579 (pSIA
->Value
[4] << 8) +
580 (pSIA
->Value
[5] << 0));
581 /* I don't know if this is necessary, but for safety... */
582 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
585 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
588 /* If security calls are not supported (presumably because we
589 are running under Windows 95), fallback to this. */
590 else if (GetUserName (name
, &length
))
592 strcpy (the_passwd
.pw_name
, name
);
593 if (stricmp ("administrator", name
) == 0)
594 the_passwd
.pw_uid
= 0;
596 the_passwd
.pw_uid
= 123;
597 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
601 strcpy (the_passwd
.pw_name
, "unknown");
602 the_passwd
.pw_uid
= 123;
603 the_passwd
.pw_gid
= 123;
606 /* Ensure HOME and SHELL are defined. */
607 if (getenv ("HOME") == NULL
)
609 if (getenv ("SHELL") == NULL
)
612 /* Set dir and shell from environment variables. */
613 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
614 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
623 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
624 return ((rand () << 15) | rand ());
634 /* Normalize filename by converting all path separators to
635 the specified separator. Also conditionally convert upper
636 case path name components to lower case. */
639 normalize_filename (fp
, path_sep
)
646 /* Always lower-case drive letters a-z, even if the filesystem
647 preserves case in filenames.
648 This is so filenames can be compared by string comparison
649 functions that are case-sensitive. Even case-preserving filesystems
650 do not distinguish case in drive letters. */
651 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
657 if (NILP (Vw32_downcase_file_names
))
661 if (*fp
== '/' || *fp
== '\\')
668 sep
= path_sep
; /* convert to this path separator */
669 elem
= fp
; /* start of current path element */
672 if (*fp
>= 'a' && *fp
<= 'z')
673 elem
= 0; /* don't convert this element */
675 if (*fp
== 0 || *fp
== ':')
677 sep
= *fp
; /* restore current separator (or 0) */
678 *fp
= '/'; /* after conversion of this element */
681 if (*fp
== '/' || *fp
== '\\')
683 if (elem
&& elem
!= fp
)
685 *fp
= 0; /* temporary end of string */
686 _strlwr (elem
); /* while we convert to lower case */
688 *fp
= sep
; /* convert (or restore) path separator */
689 elem
= fp
+ 1; /* next element starts after separator */
695 /* Destructively turn backslashes into slashes. */
697 dostounix_filename (p
)
700 normalize_filename (p
, '/');
703 /* Destructively turn slashes into backslashes. */
705 unixtodos_filename (p
)
708 normalize_filename (p
, '\\');
711 /* Remove all CR's that are followed by a LF.
712 (From msdos.c...probably should figure out a way to share it,
713 although this code isn't going to ever change.) */
717 register unsigned char *buf
;
719 unsigned char *np
= buf
;
720 unsigned char *startp
= buf
;
721 unsigned char *endp
= buf
+ n
;
725 while (buf
< endp
- 1)
729 if (*(++buf
) != 0x0a)
740 /* Parse the root part of file name, if present. Return length and
741 optionally store pointer to char after root. */
743 parse_root (char * name
, char ** pPath
)
750 /* find the root name of the volume if given */
751 if (isalpha (name
[0]) && name
[1] == ':')
753 /* skip past drive specifier */
755 if (IS_DIRECTORY_SEP (name
[0]))
758 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
764 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
769 if (IS_DIRECTORY_SEP (name
[0]))
779 /* Get long base name for name; name is assumed to be absolute. */
781 get_long_basename (char * name
, char * buf
, int size
)
783 WIN32_FIND_DATA find_data
;
787 /* must be valid filename, no wild cards or other invalid characters */
788 if (_mbspbrk (name
, "*?|<>\""))
791 dir_handle
= FindFirstFile (name
, &find_data
);
792 if (dir_handle
!= INVALID_HANDLE_VALUE
)
794 if ((len
= strlen (find_data
.cFileName
)) < size
)
795 memcpy (buf
, find_data
.cFileName
, len
+ 1);
798 FindClose (dir_handle
);
803 /* Get long name for file, if possible (assumed to be absolute). */
805 w32_get_long_filename (char * name
, char * buf
, int size
)
810 char full
[ MAX_PATH
];
817 /* Use local copy for destructive modification. */
818 memcpy (full
, name
, len
+1);
819 unixtodos_filename (full
);
821 /* Copy root part verbatim. */
822 len
= parse_root (full
, &p
);
823 memcpy (o
, full
, len
);
828 while (p
!= NULL
&& *p
)
831 p
= strchr (q
, '\\');
833 len
= get_long_basename (full
, o
, size
);
856 is_unc_volume (const char *filename
)
858 const char *ptr
= filename
;
860 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
863 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
869 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
872 sigsetmask (int signal_mask
)
896 setpgrp (int pid
, int gid
)
907 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
910 w32_get_resource (key
, lpdwtype
)
915 HKEY hrootkey
= NULL
;
919 /* Check both the current user and the local machine to see if
920 we have any resources. */
922 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
926 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
927 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
928 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
933 if (lpvalue
) xfree (lpvalue
);
935 RegCloseKey (hrootkey
);
938 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
942 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
943 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
944 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
949 if (lpvalue
) xfree (lpvalue
);
951 RegCloseKey (hrootkey
);
957 char *get_emacs_configuration (void);
958 extern Lisp_Object Vsystem_configuration
;
961 init_environment (char ** argv
)
963 static const char * const tempdirs
[] = {
964 "$TMPDIR", "$TEMP", "$TMP", "c:/"
969 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
971 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
972 temporary files and assume "/tmp" if $TMPDIR is unset, which
973 will break on DOS/Windows. Refuse to work if we cannot find
974 a directory, not even "c:/", usable for that purpose. */
975 for (i
= 0; i
< imax
; i
++)
977 const char *tmp
= tempdirs
[i
];
980 tmp
= getenv (tmp
+ 1);
981 /* Note that `access' can lie to us if the directory resides on a
982 read-only filesystem, like CD-ROM or a write-protected floppy.
983 The only way to be really sure is to actually create a file and
984 see if it succeeds. But I think that's too much to ask. */
985 if (tmp
&& _access (tmp
, D_OK
) == 0)
987 char * var
= alloca (strlen (tmp
) + 8);
988 sprintf (var
, "TMPDIR=%s", tmp
);
989 _putenv (strdup (var
));
996 Fcons (build_string ("no usable temporary directories found!!"),
998 "While setting TMPDIR: ");
1000 /* Check for environment variables and use registry settings if they
1001 don't exist. Fallback on default values where applicable. */
1006 char locale_name
[32];
1007 struct stat ignored
;
1008 char default_home
[MAX_PATH
];
1010 static const struct env_entry
1017 {"PRELOAD_WINSOCK", NULL
},
1018 {"emacs_dir", "C:/emacs"},
1019 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
1020 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1021 {"EMACSDATA", "%emacs_dir%/etc"},
1022 {"EMACSPATH", "%emacs_dir%/bin"},
1023 /* We no longer set INFOPATH because Info-default-directory-list
1025 /* {"INFOPATH", "%emacs_dir%/info"}, */
1026 {"EMACSDOC", "%emacs_dir%/etc"},
1031 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
1033 /* We need to copy dflt_envvars[] and work on the copy because we
1034 don't want the dumped Emacs to inherit the values of
1035 environment variables we saw during dumping (which could be on
1036 a different system). The defaults above must be left intact. */
1037 struct env_entry env_vars
[N_ENV_VARS
];
1039 for (i
= 0; i
< N_ENV_VARS
; i
++)
1040 env_vars
[i
] = dflt_envvars
[i
];
1042 /* For backwards compatibility, check if a .emacs file exists in C:/
1043 If not, then we can try to default to the appdata directory under the
1044 user's profile, which is more likely to be writable. */
1045 if (stat ("C:/.emacs", &ignored
) < 0)
1047 HRESULT profile_result
;
1048 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1049 of Windows 95 and NT4 that have not been updated to include
1050 MSIE 5. Also we don't link with shell32.dll by default. */
1051 HMODULE shell32_dll
;
1052 ShGetFolderPath_fn get_folder_path
;
1053 shell32_dll
= GetModuleHandle ("shell32.dll");
1054 get_folder_path
= (ShGetFolderPath_fn
)
1055 GetProcAddress (shell32_dll
, "SHGetFolderPathA");
1057 if (get_folder_path
!= NULL
)
1059 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1062 /* If we can't get the appdata dir, revert to old behaviour. */
1063 if (profile_result
== S_OK
)
1064 env_vars
[0].def_value
= default_home
;
1067 /* Unload shell32.dll, it is not needed anymore. */
1068 FreeLibrary (shell32_dll
);
1071 /* Get default locale info and use it for LANG. */
1072 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1073 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1074 locale_name
, sizeof (locale_name
)))
1076 for (i
= 0; i
< N_ENV_VARS
; i
++)
1078 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1080 env_vars
[i
].def_value
= locale_name
;
1086 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1088 /* Treat emacs_dir specially: set it unconditionally based on our
1089 location, if it appears that we are running from the bin subdir
1090 of a standard installation. */
1093 char modname
[MAX_PATH
];
1095 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1097 if ((p
= strrchr (modname
, '\\')) == NULL
)
1101 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
1103 char buf
[SET_ENV_BUF_SIZE
];
1106 for (p
= modname
; *p
; p
++)
1107 if (*p
== '\\') *p
= '/';
1109 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1110 _putenv (strdup (buf
));
1112 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1114 /* FIXME: should use substring of get_emacs_configuration ().
1115 But I don't think the Windows build supports alpha, mips etc
1116 anymore, so have taken the easy option for now. */
1117 else if (p
&& stricmp (p
, "\\i386") == 0)
1120 p
= strrchr (modname
, '\\');
1124 p
= strrchr (modname
, '\\');
1125 if (p
&& stricmp (p
, "\\src") == 0)
1127 char buf
[SET_ENV_BUF_SIZE
];
1130 for (p
= modname
; *p
; p
++)
1131 if (*p
== '\\') *p
= '/';
1133 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1134 _putenv (strdup (buf
));
1140 for (i
= 0; i
< N_ENV_VARS
; i
++)
1142 if (!getenv (env_vars
[i
].name
))
1146 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1147 /* Also ignore empty environment variables. */
1150 lpval
= env_vars
[i
].def_value
;
1151 dwType
= REG_EXPAND_SZ
;
1157 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1159 if (dwType
== REG_EXPAND_SZ
)
1160 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
1161 else if (dwType
== REG_SZ
)
1162 strcpy (buf1
, lpval
);
1163 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1165 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
,
1167 _putenv (strdup (buf2
));
1177 /* Rebuild system configuration to reflect invoking system. */
1178 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1180 /* Another special case: on NT, the PATH variable is actually named
1181 "Path" although cmd.exe (perhaps NT itself) arranges for
1182 environment variable lookup and setting to be case insensitive.
1183 However, Emacs assumes a fully case sensitive environment, so we
1184 need to change "Path" to "PATH" to match the expectations of
1185 various elisp packages. We do this by the sneaky method of
1186 modifying the string in the C runtime environ entry.
1188 The same applies to COMSPEC. */
1192 for (envp
= environ
; *envp
; envp
++)
1193 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1194 memcpy (*envp
, "PATH=", 5);
1195 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1196 memcpy (*envp
, "COMSPEC=", 8);
1199 /* Remember the initial working directory for getwd, then make the
1200 real wd be the location of emacs.exe to avoid conflicts when
1201 renaming or deleting directories. (We also don't call chdir when
1202 running subprocesses for the same reason.) */
1203 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1208 static char modname
[MAX_PATH
];
1210 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1212 if ((p
= strrchr (modname
, '\\')) == NULL
)
1216 SetCurrentDirectory (modname
);
1218 /* Ensure argv[0] has the full path to Emacs. */
1223 /* Determine if there is a middle mouse button, to allow parse_button
1224 to decide whether right mouse events should be mouse-2 or
1226 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1232 emacs_root_dir (void)
1234 static char root_dir
[FILENAME_MAX
];
1237 p
= getenv ("emacs_dir");
1240 strcpy (root_dir
, p
);
1241 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1242 dostounix_filename (root_dir
);
1246 /* We don't have scripts to automatically determine the system configuration
1247 for Emacs before it's compiled, and we don't want to have to make the
1248 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1252 get_emacs_configuration (void)
1254 char *arch
, *oem
, *os
;
1256 static char configuration_buffer
[32];
1258 /* Determine the processor type. */
1259 switch (get_processor_type ())
1262 #ifdef PROCESSOR_INTEL_386
1263 case PROCESSOR_INTEL_386
:
1264 case PROCESSOR_INTEL_486
:
1265 case PROCESSOR_INTEL_PENTIUM
:
1270 #ifdef PROCESSOR_INTEL_860
1271 case PROCESSOR_INTEL_860
:
1276 #ifdef PROCESSOR_MIPS_R2000
1277 case PROCESSOR_MIPS_R2000
:
1278 case PROCESSOR_MIPS_R3000
:
1279 case PROCESSOR_MIPS_R4000
:
1284 #ifdef PROCESSOR_ALPHA_21064
1285 case PROCESSOR_ALPHA_21064
:
1295 /* Use the OEM field to reflect the compiler/library combination. */
1297 #define COMPILER_NAME "msvc"
1300 #define COMPILER_NAME "mingw"
1302 #define COMPILER_NAME "unknown"
1305 oem
= COMPILER_NAME
;
1307 switch (osinfo_cache
.dwPlatformId
) {
1308 case VER_PLATFORM_WIN32_NT
:
1310 build_num
= osinfo_cache
.dwBuildNumber
;
1312 case VER_PLATFORM_WIN32_WINDOWS
:
1313 if (osinfo_cache
.dwMinorVersion
== 0) {
1318 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1320 case VER_PLATFORM_WIN32s
:
1321 /* Not supported, should not happen. */
1323 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1331 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1332 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1333 get_w32_major_version (), get_w32_minor_version (), build_num
);
1335 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1338 return configuration_buffer
;
1342 get_emacs_configuration_options (void)
1344 static char options_buffer
[256];
1346 /* Work out the effective configure options for this build. */
1348 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1351 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1353 #define COMPILER_VERSION ""
1357 sprintf (options_buffer
, COMPILER_VERSION
);
1359 strcat (options_buffer
, " --no-opt");
1362 strcat (options_buffer
, " --cflags");
1363 strcat (options_buffer
, USER_CFLAGS
);
1366 strcat (options_buffer
, " --ldflags");
1367 strcat (options_buffer
, USER_LDFLAGS
);
1369 return options_buffer
;
1373 #include <sys/timeb.h>
1375 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1377 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1382 tv
->tv_sec
= tb
.time
;
1383 tv
->tv_usec
= tb
.millitm
* 1000L;
1386 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1387 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1391 /* ------------------------------------------------------------------------- */
1392 /* IO support and wrapper functions for W32 API. */
1393 /* ------------------------------------------------------------------------- */
1395 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1396 on network directories, so we handle that case here.
1397 (Ulrich Leodolter, 1/11/95). */
1399 sys_ctime (const time_t *t
)
1401 char *str
= (char *) ctime (t
);
1402 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1405 /* Emulate sleep...we could have done this with a define, but that
1406 would necessitate including windows.h in the files that used it.
1407 This is much easier. */
1409 sys_sleep (int seconds
)
1411 Sleep (seconds
* 1000);
1414 /* Internal MSVC functions for low-level descriptor munging */
1415 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1416 extern int __cdecl
_free_osfhnd (int fd
);
1418 /* parallel array of private info on file handles */
1419 filedesc fd_info
[ MAXDESC
];
1421 typedef struct volume_info_data
{
1422 struct volume_info_data
* next
;
1424 /* time when info was obtained */
1427 /* actual volume info */
1436 /* Global referenced by various functions. */
1437 static volume_info_data volume_info
;
1439 /* Vector to indicate which drives are local and fixed (for which cached
1440 data never expires). */
1441 static BOOL fixed_drives
[26];
1443 /* Consider cached volume information to be stale if older than 10s,
1444 at least for non-local drives. Info for fixed drives is never stale. */
1445 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1446 #define VOLINFO_STILL_VALID( root_dir, info ) \
1447 ( ( isalpha (root_dir[0]) && \
1448 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1449 || GetTickCount () - info->timestamp < 10000 )
1451 /* Cache support functions. */
1453 /* Simple linked list with linear search is sufficient. */
1454 static volume_info_data
*volume_cache
= NULL
;
1456 static volume_info_data
*
1457 lookup_volume_info (char * root_dir
)
1459 volume_info_data
* info
;
1461 for (info
= volume_cache
; info
; info
= info
->next
)
1462 if (stricmp (info
->root_dir
, root_dir
) == 0)
1468 add_volume_info (char * root_dir
, volume_info_data
* info
)
1470 info
->root_dir
= xstrdup (root_dir
);
1471 info
->next
= volume_cache
;
1472 volume_cache
= info
;
1476 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1477 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1478 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1480 GetCachedVolumeInformation (char * root_dir
)
1482 volume_info_data
* info
;
1483 char default_root
[ MAX_PATH
];
1485 /* NULL for root_dir means use root from current directory. */
1486 if (root_dir
== NULL
)
1488 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1490 parse_root (default_root
, &root_dir
);
1492 root_dir
= default_root
;
1495 /* Local fixed drives can be cached permanently. Removable drives
1496 cannot be cached permanently, since the volume name and serial
1497 number (if nothing else) can change. Remote drives should be
1498 treated as if they are removable, since there is no sure way to
1499 tell whether they are or not. Also, the UNC association of drive
1500 letters mapped to remote volumes can be changed at any time (even
1501 by other processes) without notice.
1503 As a compromise, so we can benefit from caching info for remote
1504 volumes, we use a simple expiry mechanism to invalidate cache
1505 entries that are more than ten seconds old. */
1508 /* No point doing this, because WNetGetConnection is even slower than
1509 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1510 GetDriveType is about the only call of this type which does not
1511 involve network access, and so is extremely quick). */
1513 /* Map drive letter to UNC if remote. */
1514 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1516 char remote_name
[ 256 ];
1517 char drive
[3] = { root_dir
[0], ':' };
1519 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1521 /* do something */ ;
1525 info
= lookup_volume_info (root_dir
);
1527 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1535 /* Info is not cached, or is stale. */
1536 if (!GetVolumeInformation (root_dir
,
1537 name
, sizeof (name
),
1541 type
, sizeof (type
)))
1544 /* Cache the volume information for future use, overwriting existing
1545 entry if present. */
1548 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1549 add_volume_info (root_dir
, info
);
1557 info
->name
= xstrdup (name
);
1558 info
->serialnum
= serialnum
;
1559 info
->maxcomp
= maxcomp
;
1560 info
->flags
= flags
;
1561 info
->type
= xstrdup (type
);
1562 info
->timestamp
= GetTickCount ();
1568 /* Get information on the volume where name is held; set path pointer to
1569 start of pathname in name (past UNC header\volume header if present). */
1571 get_volume_info (const char * name
, const char ** pPath
)
1573 char temp
[MAX_PATH
];
1574 char *rootname
= NULL
; /* default to current volume */
1575 volume_info_data
* info
;
1580 /* find the root name of the volume if given */
1581 if (isalpha (name
[0]) && name
[1] == ':')
1589 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1596 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1609 info
= GetCachedVolumeInformation (rootname
);
1612 /* Set global referenced by other functions. */
1613 volume_info
= *info
;
1619 /* Determine if volume is FAT format (ie. only supports short 8.3
1620 names); also set path pointer to start of pathname in name. */
1622 is_fat_volume (const char * name
, const char ** pPath
)
1624 if (get_volume_info (name
, pPath
))
1625 return (volume_info
.maxcomp
== 12);
1629 /* Map filename to a legal 8.3 name if necessary. */
1631 map_w32_filename (const char * name
, const char ** pPath
)
1633 static char shortname
[MAX_PATH
];
1634 char * str
= shortname
;
1637 const char * save_name
= name
;
1639 if (strlen (name
) >= MAX_PATH
)
1641 /* Return a filename which will cause callers to fail. */
1642 strcpy (shortname
, "?");
1646 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1648 register int left
= 8; /* maximum number of chars in part */
1649 register int extn
= 0; /* extension added? */
1650 register int dots
= 2; /* maximum number of dots allowed */
1653 *str
++ = *name
++; /* skip past UNC header */
1655 while ((c
= *name
++))
1662 extn
= 0; /* reset extension flags */
1663 dots
= 2; /* max 2 dots */
1664 left
= 8; /* max length 8 for main part */
1668 extn
= 0; /* reset extension flags */
1669 dots
= 2; /* max 2 dots */
1670 left
= 8; /* max length 8 for main part */
1675 /* Convert path components of the form .xxx to _xxx,
1676 but leave . and .. as they are. This allows .emacs
1677 to be read as _emacs, for example. */
1681 IS_DIRECTORY_SEP (*name
))
1696 extn
= 1; /* we've got an extension */
1697 left
= 3; /* 3 chars in extension */
1701 /* any embedded dots after the first are converted to _ */
1706 case '#': /* don't lose these, they're important */
1708 str
[-1] = c
; /* replace last character of part */
1713 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1715 dots
= 0; /* started a path component */
1724 strcpy (shortname
, name
);
1725 unixtodos_filename (shortname
);
1729 *pPath
= shortname
+ (path
- save_name
);
1735 is_exec (const char * name
)
1737 char * p
= strrchr (name
, '.');
1740 && (stricmp (p
, ".exe") == 0 ||
1741 stricmp (p
, ".com") == 0 ||
1742 stricmp (p
, ".bat") == 0 ||
1743 stricmp (p
, ".cmd") == 0));
1746 /* Emulate the Unix directory procedures opendir, closedir,
1747 and readdir. We can't use the procedures supplied in sysdep.c,
1748 so we provide them here. */
1750 struct direct dir_static
; /* simulated directory contents */
1751 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1752 static int dir_is_fat
;
1753 static char dir_pathname
[MAXPATHLEN
+1];
1754 static WIN32_FIND_DATA dir_find_data
;
1756 /* Support shares on a network resource as subdirectories of a read-only
1758 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1759 HANDLE
open_unc_volume (const char *);
1760 char *read_unc_volume (HANDLE
, char *, int);
1761 void close_unc_volume (HANDLE
);
1764 opendir (char *filename
)
1768 /* Opening is done by FindFirstFile. However, a read is inherent to
1769 this operation, so we defer the open until read time. */
1771 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1773 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1776 if (is_unc_volume (filename
))
1778 wnet_enum_handle
= open_unc_volume (filename
);
1779 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1783 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1790 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1791 dir_pathname
[MAXPATHLEN
] = '\0';
1792 dir_is_fat
= is_fat_volume (filename
, NULL
);
1798 closedir (DIR *dirp
)
1800 /* If we have a find-handle open, close it. */
1801 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1803 FindClose (dir_find_handle
);
1804 dir_find_handle
= INVALID_HANDLE_VALUE
;
1806 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1808 close_unc_volume (wnet_enum_handle
);
1809 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1811 xfree ((char *) dirp
);
1817 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1819 if (!read_unc_volume (wnet_enum_handle
,
1820 dir_find_data
.cFileName
,
1824 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1825 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1827 char filename
[MAXNAMLEN
+ 3];
1830 strcpy (filename
, dir_pathname
);
1831 ln
= strlen (filename
) - 1;
1832 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1833 strcat (filename
, "\\");
1834 strcat (filename
, "*");
1836 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1838 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1843 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1847 /* Emacs never uses this value, so don't bother making it match
1848 value returned by stat(). */
1849 dir_static
.d_ino
= 1;
1851 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1852 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1854 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1855 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1857 _strlwr (dir_static
.d_name
);
1858 else if (!NILP (Vw32_downcase_file_names
))
1861 for (p
= dir_static
.d_name
; *p
; p
++)
1862 if (*p
>= 'a' && *p
<= 'z')
1865 _strlwr (dir_static
.d_name
);
1872 open_unc_volume (const char *path
)
1878 nr
.dwScope
= RESOURCE_GLOBALNET
;
1879 nr
.dwType
= RESOURCETYPE_DISK
;
1880 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1881 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1882 nr
.lpLocalName
= NULL
;
1883 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
1884 nr
.lpComment
= NULL
;
1885 nr
.lpProvider
= NULL
;
1887 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1888 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1890 if (result
== NO_ERROR
)
1893 return INVALID_HANDLE_VALUE
;
1897 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1901 DWORD bufsize
= 512;
1906 buffer
= alloca (bufsize
);
1907 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1908 if (result
!= NO_ERROR
)
1911 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1912 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1914 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1917 strncpy (readbuf
, ptr
, size
);
1922 close_unc_volume (HANDLE henum
)
1924 if (henum
!= INVALID_HANDLE_VALUE
)
1925 WNetCloseEnum (henum
);
1929 unc_volume_file_attributes (const char *path
)
1934 henum
= open_unc_volume (path
);
1935 if (henum
== INVALID_HANDLE_VALUE
)
1938 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1940 close_unc_volume (henum
);
1946 /* Shadow some MSVC runtime functions to map requests for long filenames
1947 to reasonable short names if necessary. This was originally added to
1948 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1952 sys_access (const char * path
, int mode
)
1956 /* MSVC implementation doesn't recognize D_OK. */
1957 path
= map_w32_filename (path
, NULL
);
1958 if (is_unc_volume (path
))
1960 attributes
= unc_volume_file_attributes (path
);
1961 if (attributes
== -1) {
1966 else if ((attributes
= GetFileAttributes (path
)) == -1)
1968 /* Should try mapping GetLastError to errno; for now just indicate
1969 that path doesn't exist. */
1973 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1978 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1983 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1992 sys_chdir (const char * path
)
1994 return _chdir (map_w32_filename (path
, NULL
));
1998 sys_chmod (const char * path
, int mode
)
2000 return _chmod (map_w32_filename (path
, NULL
), mode
);
2004 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2006 if (sys_chmod (path
, _S_IREAD
) == -1) /* check if file exists */
2012 sys_creat (const char * path
, int mode
)
2014 return _creat (map_w32_filename (path
, NULL
), mode
);
2018 sys_fopen(const char * path
, const char * mode
)
2022 const char * mode_save
= mode
;
2024 /* Force all file handles to be non-inheritable. This is necessary to
2025 ensure child processes don't unwittingly inherit handles that might
2026 prevent future file access. */
2030 else if (mode
[0] == 'w' || mode
[0] == 'a')
2031 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2035 /* Only do simplistic option parsing. */
2039 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2042 else if (mode
[0] == 'b')
2047 else if (mode
[0] == 't')
2054 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2058 return _fdopen (fd
, mode_save
);
2061 /* This only works on NTFS volumes, but is useful to have. */
2063 sys_link (const char * old
, const char * new)
2067 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2069 if (old
== NULL
|| new == NULL
)
2075 strcpy (oldname
, map_w32_filename (old
, NULL
));
2076 strcpy (newname
, map_w32_filename (new, NULL
));
2078 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2079 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2080 if (fileh
!= INVALID_HANDLE_VALUE
)
2084 /* Confusingly, the "alternate" stream name field does not apply
2085 when restoring a hard link, and instead contains the actual
2086 stream data for the link (ie. the name of the link to create).
2087 The WIN32_STREAM_ID structure before the cStreamName field is
2088 the stream header, which is then immediately followed by the
2092 WIN32_STREAM_ID wid
;
2093 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2096 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2097 data
.wid
.cStreamName
, MAX_PATH
);
2100 LPVOID context
= NULL
;
2103 data
.wid
.dwStreamId
= BACKUP_LINK
;
2104 data
.wid
.dwStreamAttributes
= 0;
2105 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
2106 data
.wid
.Size
.HighPart
= 0;
2107 data
.wid
.dwStreamNameSize
= 0;
2109 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2110 offsetof (WIN32_STREAM_ID
, cStreamName
)
2111 + data
.wid
.Size
.LowPart
,
2112 &wbytes
, FALSE
, FALSE
, &context
)
2113 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2120 /* Should try mapping GetLastError to errno; for now just
2121 indicate a general error (eg. links not supported). */
2122 errno
= EINVAL
; // perhaps EMLINK?
2126 CloseHandle (fileh
);
2135 sys_mkdir (const char * path
)
2137 return _mkdir (map_w32_filename (path
, NULL
));
2140 /* Because of long name mapping issues, we need to implement this
2141 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2142 a unique name, instead of setting the input template to an empty
2145 Standard algorithm seems to be use pid or tid with a letter on the
2146 front (in place of the 6 X's) and cycle through the letters to find a
2147 unique name. We extend that to allow any reasonable character as the
2148 first of the 6 X's. */
2150 sys_mktemp (char * template)
2154 unsigned uid
= GetCurrentThreadId ();
2155 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2157 if (template == NULL
)
2159 p
= template + strlen (template);
2161 /* replace up to the last 5 X's with uid in decimal */
2162 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2164 p
[0] = '0' + uid
% 10;
2168 if (i
< 0 && p
[0] == 'X')
2173 int save_errno
= errno
;
2174 p
[0] = first_char
[i
];
2175 if (sys_access (template, 0) < 0)
2181 while (++i
< sizeof (first_char
));
2184 /* Template is badly formed or else we can't generate a unique name,
2185 so return empty string */
2191 sys_open (const char * path
, int oflag
, int mode
)
2193 const char* mpath
= map_w32_filename (path
, NULL
);
2194 /* Try to open file without _O_CREAT, to be able to write to hidden
2195 and system files. Force all file handles to be
2197 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2200 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2204 sys_rename (const char * oldname
, const char * newname
)
2207 char temp
[MAX_PATH
];
2209 /* MoveFile on Windows 95 doesn't correctly change the short file name
2210 alias in a number of circumstances (it is not easy to predict when
2211 just by looking at oldname and newname, unfortunately). In these
2212 cases, renaming through a temporary name avoids the problem.
2214 A second problem on Windows 95 is that renaming through a temp name when
2215 newname is uppercase fails (the final long name ends up in
2216 lowercase, although the short alias might be uppercase) UNLESS the
2217 long temp name is not 8.3.
2219 So, on Windows 95 we always rename through a temp name, and we make sure
2220 the temp name has a long extension to ensure correct renaming. */
2222 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2224 if (os_subtype
== OS_WIN95
)
2230 oldname
= map_w32_filename (oldname
, NULL
);
2231 if (o
= strrchr (oldname
, '\\'))
2234 o
= (char *) oldname
;
2236 if (p
= strrchr (temp
, '\\'))
2243 /* Force temp name to require a manufactured 8.3 alias - this
2244 seems to make the second rename work properly. */
2245 sprintf (p
, "_.%s.%u", o
, i
);
2247 result
= rename (oldname
, temp
);
2249 /* This loop must surely terminate! */
2250 while (result
< 0 && errno
== EEXIST
);
2255 /* Emulate Unix behaviour - newname is deleted if it already exists
2256 (at least if it is a file; don't do this for directories).
2258 Since we mustn't do this if we are just changing the case of the
2259 file name (we would end up deleting the file we are trying to
2260 rename!), we let rename detect if the destination file already
2261 exists - that way we avoid the possible pitfalls of trying to
2262 determine ourselves whether two names really refer to the same
2263 file, which is not always possible in the general case. (Consider
2264 all the permutations of shared or subst'd drives, etc.) */
2266 newname
= map_w32_filename (newname
, NULL
);
2267 result
= rename (temp
, newname
);
2271 && _chmod (newname
, 0666) == 0
2272 && _unlink (newname
) == 0)
2273 result
= rename (temp
, newname
);
2279 sys_rmdir (const char * path
)
2281 return _rmdir (map_w32_filename (path
, NULL
));
2285 sys_unlink (const char * path
)
2287 path
= map_w32_filename (path
, NULL
);
2289 /* On Unix, unlink works without write permission. */
2290 _chmod (path
, 0666);
2291 return _unlink (path
);
2294 static FILETIME utc_base_ft
;
2295 static long double utc_base
;
2296 static int init
= 0;
2299 convert_time (FILETIME ft
)
2305 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2314 st
.wMilliseconds
= 0;
2316 SystemTimeToFileTime (&st
, &utc_base_ft
);
2317 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2318 * 4096.0L * 1024.0L * 1024.0L + utc_base_ft
.dwLowDateTime
;
2322 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2325 ret
= (long double) ft
.dwHighDateTime
2326 * 4096.0L * 1024.0L * 1024.0L + ft
.dwLowDateTime
;
2328 return (time_t) (ret
* 1e-7L);
2332 convert_from_time_t (time_t time
, FILETIME
* pft
)
2338 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2347 st
.wMilliseconds
= 0;
2349 SystemTimeToFileTime (&st
, &utc_base_ft
);
2350 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2351 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2355 /* time in 100ns units since 1-Jan-1601 */
2356 tmp
= (long double) time
* 1e7
+ utc_base
;
2357 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2358 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2362 /* No reason to keep this; faking inode values either by hashing or even
2363 using the file index from GetInformationByHandle, is not perfect and
2364 so by default Emacs doesn't use the inode values on Windows.
2365 Instead, we now determine file-truename correctly (except for
2366 possible drive aliasing etc). */
2368 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2370 hashval (const unsigned char * str
)
2375 h
= (h
<< 4) + *str
++;
2381 /* Return the hash value of the canonical pathname, excluding the
2382 drive/UNC header, to get a hopefully unique inode number. */
2384 generate_inode_val (const char * name
)
2386 char fullname
[ MAX_PATH
];
2390 /* Get the truly canonical filename, if it exists. (Note: this
2391 doesn't resolve aliasing due to subst commands, or recognise hard
2393 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2396 parse_root (fullname
, &p
);
2397 /* Normal W32 filesystems are still case insensitive. */
2404 /* MSVC stat function can't cope with UNC names and has other bugs, so
2405 replace it with our own. This also allows us to calculate consistent
2406 inode values without hacks in the main Emacs code. */
2408 stat (const char * path
, struct stat
* buf
)
2411 WIN32_FIND_DATA wfd
;
2416 int rootdir
= FALSE
;
2418 if (path
== NULL
|| buf
== NULL
)
2424 name
= (char *) map_w32_filename (path
, &path
);
2425 /* Must be valid filename, no wild cards or other invalid
2426 characters. We use _mbspbrk to support multibyte strings that
2427 might look to strpbrk as if they included literal *, ?, and other
2428 characters mentioned below that are disallowed by Windows
2430 if (_mbspbrk (name
, "*?|<>\""))
2436 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2437 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2438 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2443 /* Remove trailing directory separator, unless name is the root
2444 directory of a drive or UNC volume in which case ensure there
2445 is a trailing separator. */
2446 len
= strlen (name
);
2447 rootdir
= (path
>= name
+ len
- 1
2448 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2449 name
= strcpy (alloca (len
+ 2), name
);
2451 if (is_unc_volume (name
))
2453 DWORD attrs
= unc_volume_file_attributes (name
);
2458 memset (&wfd
, 0, sizeof (wfd
));
2459 wfd
.dwFileAttributes
= attrs
;
2460 wfd
.ftCreationTime
= utc_base_ft
;
2461 wfd
.ftLastAccessTime
= utc_base_ft
;
2462 wfd
.ftLastWriteTime
= utc_base_ft
;
2463 strcpy (wfd
.cFileName
, name
);
2467 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2468 strcat (name
, "\\");
2469 if (GetDriveType (name
) < 2)
2474 memset (&wfd
, 0, sizeof (wfd
));
2475 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2476 wfd
.ftCreationTime
= utc_base_ft
;
2477 wfd
.ftLastAccessTime
= utc_base_ft
;
2478 wfd
.ftLastWriteTime
= utc_base_ft
;
2479 strcpy (wfd
.cFileName
, name
);
2483 if (IS_DIRECTORY_SEP (name
[len
-1]))
2486 /* (This is hacky, but helps when doing file completions on
2487 network drives.) Optimize by using information available from
2488 active readdir if possible. */
2489 len
= strlen (dir_pathname
);
2490 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2492 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2493 && strnicmp (name
, dir_pathname
, len
) == 0
2494 && IS_DIRECTORY_SEP (name
[len
])
2495 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2497 /* This was the last entry returned by readdir. */
2498 wfd
= dir_find_data
;
2502 fh
= FindFirstFile (name
, &wfd
);
2503 if (fh
== INVALID_HANDLE_VALUE
)
2512 if (!NILP (Vw32_get_true_file_attributes
)
2513 /* No access rights required to get info. */
2514 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
2515 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
2516 != INVALID_HANDLE_VALUE
)
2518 /* This is more accurate in terms of gettting the correct number
2519 of links, but is quite slow (it is noticeable when Emacs is
2520 making a list of file name completions). */
2521 BY_HANDLE_FILE_INFORMATION info
;
2523 if (GetFileInformationByHandle (fh
, &info
))
2525 buf
->st_nlink
= info
.nNumberOfLinks
;
2526 /* Might as well use file index to fake inode values, but this
2527 is not guaranteed to be unique unless we keep a handle open
2528 all the time (even then there are situations where it is
2529 not unique). Reputedly, there are at most 48 bits of info
2530 (on NTFS, presumably less on FAT). */
2531 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2539 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2541 buf
->st_mode
= _S_IFDIR
;
2545 switch (GetFileType (fh
))
2547 case FILE_TYPE_DISK
:
2548 buf
->st_mode
= _S_IFREG
;
2550 case FILE_TYPE_PIPE
:
2551 buf
->st_mode
= _S_IFIFO
;
2553 case FILE_TYPE_CHAR
:
2554 case FILE_TYPE_UNKNOWN
:
2556 buf
->st_mode
= _S_IFCHR
;
2563 /* Don't bother to make this information more accurate. */
2564 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
2565 _S_IFDIR
: _S_IFREG
;
2571 /* Not sure if there is any point in this. */
2572 if (!NILP (Vw32_generate_fake_inodes
))
2573 fake_inode
= generate_inode_val (name
);
2574 else if (fake_inode
== 0)
2576 /* For want of something better, try to make everything unique. */
2577 static DWORD gen_num
= 0;
2578 fake_inode
= ++gen_num
;
2582 /* MSVC defines _ino_t to be short; other libc's might not. */
2583 if (sizeof (buf
->st_ino
) == 2)
2584 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2586 buf
->st_ino
= fake_inode
;
2588 /* consider files to belong to current user */
2589 buf
->st_uid
= the_passwd
.pw_uid
;
2590 buf
->st_gid
= the_passwd
.pw_gid
;
2592 /* volume_info is set indirectly by map_w32_filename */
2593 buf
->st_dev
= volume_info
.serialnum
;
2594 buf
->st_rdev
= volume_info
.serialnum
;
2597 buf
->st_size
= wfd
.nFileSizeLow
;
2599 /* Convert timestamps to Unix format. */
2600 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2601 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2602 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2603 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2604 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2606 /* determine rwx permissions */
2607 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2608 permission
= _S_IREAD
;
2610 permission
= _S_IREAD
| _S_IWRITE
;
2612 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2613 permission
|= _S_IEXEC
;
2614 else if (is_exec (name
))
2615 permission
|= _S_IEXEC
;
2617 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2622 /* Provide fstat and utime as well as stat for consistent handling of
2625 fstat (int desc
, struct stat
* buf
)
2627 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2628 BY_HANDLE_FILE_INFORMATION info
;
2632 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2634 case FILE_TYPE_DISK
:
2635 buf
->st_mode
= _S_IFREG
;
2636 if (!GetFileInformationByHandle (fh
, &info
))
2642 case FILE_TYPE_PIPE
:
2643 buf
->st_mode
= _S_IFIFO
;
2645 case FILE_TYPE_CHAR
:
2646 case FILE_TYPE_UNKNOWN
:
2648 buf
->st_mode
= _S_IFCHR
;
2650 memset (&info
, 0, sizeof (info
));
2651 info
.dwFileAttributes
= 0;
2652 info
.ftCreationTime
= utc_base_ft
;
2653 info
.ftLastAccessTime
= utc_base_ft
;
2654 info
.ftLastWriteTime
= utc_base_ft
;
2657 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2658 buf
->st_mode
= _S_IFDIR
;
2660 buf
->st_nlink
= info
.nNumberOfLinks
;
2661 /* Might as well use file index to fake inode values, but this
2662 is not guaranteed to be unique unless we keep a handle open
2663 all the time (even then there are situations where it is
2664 not unique). Reputedly, there are at most 48 bits of info
2665 (on NTFS, presumably less on FAT). */
2666 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2668 /* MSVC defines _ino_t to be short; other libc's might not. */
2669 if (sizeof (buf
->st_ino
) == 2)
2670 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2672 buf
->st_ino
= fake_inode
;
2674 /* consider files to belong to current user */
2678 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2679 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2681 buf
->st_size
= info
.nFileSizeLow
;
2683 /* Convert timestamps to Unix format. */
2684 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2685 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2686 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2687 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2688 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2690 /* determine rwx permissions */
2691 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2692 permission
= _S_IREAD
;
2694 permission
= _S_IREAD
| _S_IWRITE
;
2696 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2697 permission
|= _S_IEXEC
;
2700 #if 0 /* no way of knowing the filename */
2701 char * p
= strrchr (name
, '.');
2703 (stricmp (p
, ".exe") == 0 ||
2704 stricmp (p
, ".com") == 0 ||
2705 stricmp (p
, ".bat") == 0 ||
2706 stricmp (p
, ".cmd") == 0))
2707 permission
|= _S_IEXEC
;
2711 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2717 utime (const char *name
, struct utimbuf
*times
)
2719 struct utimbuf deftime
;
2726 deftime
.modtime
= deftime
.actime
= time (NULL
);
2730 /* Need write access to set times. */
2731 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2732 0, OPEN_EXISTING
, 0, NULL
);
2735 convert_from_time_t (times
->actime
, &atime
);
2736 convert_from_time_t (times
->modtime
, &mtime
);
2737 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2755 /* Wrappers for winsock functions to map between our file descriptors
2756 and winsock's handles; also set h_errno for convenience.
2758 To allow Emacs to run on systems which don't have winsock support
2759 installed, we dynamically link to winsock on startup if present, and
2760 otherwise provide the minimum necessary functionality
2761 (eg. gethostname). */
2763 /* function pointers for relevant socket functions */
2764 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2765 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2766 int (PASCAL
*pfn_WSAGetLastError
) (void);
2767 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
2768 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
2769 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
2770 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2771 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2772 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2773 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2774 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2775 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2776 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2777 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2778 int (PASCAL
*pfn_WSACleanup
) (void);
2780 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2781 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2782 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2783 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2784 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2785 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2786 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
2787 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2788 const char * optval
, int optlen
);
2789 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2790 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2792 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2793 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2794 struct sockaddr
* from
, int * fromlen
);
2795 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2796 const struct sockaddr
* to
, int tolen
);
2798 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2799 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2800 #ifndef HANDLE_FLAG_INHERIT
2801 #define HANDLE_FLAG_INHERIT 1
2805 static int winsock_inuse
;
2810 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2812 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2813 after WSAStartup returns successfully, but it seems reasonable
2814 to allow unloading winsock anyway in that case. */
2815 if (pfn_WSACleanup () == 0 ||
2816 pfn_WSAGetLastError () == WSAENETDOWN
)
2818 if (FreeLibrary (winsock_lib
))
2827 init_winsock (int load_now
)
2829 WSADATA winsockData
;
2831 if (winsock_lib
!= NULL
)
2834 pfn_SetHandleInformation
= NULL
;
2835 pfn_SetHandleInformation
2836 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2837 "SetHandleInformation");
2839 winsock_lib
= LoadLibrary ("Ws2_32.dll");
2841 if (winsock_lib
!= NULL
)
2843 /* dynamically link to socket functions */
2845 #define LOAD_PROC(fn) \
2846 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2849 LOAD_PROC( WSAStartup
);
2850 LOAD_PROC( WSASetLastError
);
2851 LOAD_PROC( WSAGetLastError
);
2852 LOAD_PROC( WSAEventSelect
);
2853 LOAD_PROC( WSACreateEvent
);
2854 LOAD_PROC( WSACloseEvent
);
2855 LOAD_PROC( socket
);
2857 LOAD_PROC( connect
);
2858 LOAD_PROC( ioctlsocket
);
2861 LOAD_PROC( closesocket
);
2862 LOAD_PROC( shutdown
);
2865 LOAD_PROC( inet_addr
);
2866 LOAD_PROC( gethostname
);
2867 LOAD_PROC( gethostbyname
);
2868 LOAD_PROC( getservbyname
);
2869 LOAD_PROC( getpeername
);
2870 LOAD_PROC( WSACleanup
);
2871 LOAD_PROC( setsockopt
);
2872 LOAD_PROC( listen
);
2873 LOAD_PROC( getsockname
);
2874 LOAD_PROC( accept
);
2875 LOAD_PROC( recvfrom
);
2876 LOAD_PROC( sendto
);
2879 /* specify version 1.1 of winsock */
2880 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2882 if (winsockData
.wVersion
!= 0x101)
2887 /* Report that winsock exists and is usable, but leave
2888 socket functions disabled. I am assuming that calling
2889 WSAStartup does not require any network interaction,
2890 and in particular does not cause or require a dial-up
2891 connection to be established. */
2894 FreeLibrary (winsock_lib
);
2902 FreeLibrary (winsock_lib
);
2912 /* function to set h_errno for compatability; map winsock error codes to
2913 normal system codes where they overlap (non-overlapping definitions
2914 are already in <sys/socket.h> */
2918 if (winsock_lib
== NULL
)
2921 h_errno
= pfn_WSAGetLastError ();
2925 case WSAEACCES
: h_errno
= EACCES
; break;
2926 case WSAEBADF
: h_errno
= EBADF
; break;
2927 case WSAEFAULT
: h_errno
= EFAULT
; break;
2928 case WSAEINTR
: h_errno
= EINTR
; break;
2929 case WSAEINVAL
: h_errno
= EINVAL
; break;
2930 case WSAEMFILE
: h_errno
= EMFILE
; break;
2931 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2932 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2940 if (h_errno
== 0 && winsock_lib
!= NULL
)
2941 pfn_WSASetLastError (0);
2944 /* Extend strerror to handle the winsock-specific error codes. */
2948 } _wsa_errlist
[] = {
2949 WSAEINTR
, "Interrupted function call",
2950 WSAEBADF
, "Bad file descriptor",
2951 WSAEACCES
, "Permission denied",
2952 WSAEFAULT
, "Bad address",
2953 WSAEINVAL
, "Invalid argument",
2954 WSAEMFILE
, "Too many open files",
2956 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2957 WSAEINPROGRESS
, "Operation now in progress",
2958 WSAEALREADY
, "Operation already in progress",
2959 WSAENOTSOCK
, "Socket operation on non-socket",
2960 WSAEDESTADDRREQ
, "Destination address required",
2961 WSAEMSGSIZE
, "Message too long",
2962 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2963 WSAENOPROTOOPT
, "Bad protocol option",
2964 WSAEPROTONOSUPPORT
, "Protocol not supported",
2965 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2966 WSAEOPNOTSUPP
, "Operation not supported",
2967 WSAEPFNOSUPPORT
, "Protocol family not supported",
2968 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2969 WSAEADDRINUSE
, "Address already in use",
2970 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2971 WSAENETDOWN
, "Network is down",
2972 WSAENETUNREACH
, "Network is unreachable",
2973 WSAENETRESET
, "Network dropped connection on reset",
2974 WSAECONNABORTED
, "Software caused connection abort",
2975 WSAECONNRESET
, "Connection reset by peer",
2976 WSAENOBUFS
, "No buffer space available",
2977 WSAEISCONN
, "Socket is already connected",
2978 WSAENOTCONN
, "Socket is not connected",
2979 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2980 WSAETOOMANYREFS
, "Too many references", /* not sure */
2981 WSAETIMEDOUT
, "Connection timed out",
2982 WSAECONNREFUSED
, "Connection refused",
2983 WSAELOOP
, "Network loop", /* not sure */
2984 WSAENAMETOOLONG
, "Name is too long",
2985 WSAEHOSTDOWN
, "Host is down",
2986 WSAEHOSTUNREACH
, "No route to host",
2987 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2988 WSAEPROCLIM
, "Too many processes",
2989 WSAEUSERS
, "Too many users", /* not sure */
2990 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2991 WSAESTALE
, "Data is stale", /* not sure */
2992 WSAEREMOTE
, "Remote error", /* not sure */
2994 WSASYSNOTREADY
, "Network subsystem is unavailable",
2995 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2996 WSANOTINITIALISED
, "Winsock not initialized successfully",
2997 WSAEDISCON
, "Graceful shutdown in progress",
2999 WSAENOMORE
, "No more operations allowed", /* not sure */
3000 WSAECANCELLED
, "Operation cancelled", /* not sure */
3001 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
3002 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
3003 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
3004 WSASYSCALLFAILURE
, "System call failure",
3005 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
3006 WSATYPE_NOT_FOUND
, "Class type not found",
3007 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
3008 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
3009 WSAEREFUSED
, "Operation refused", /* not sure */
3012 WSAHOST_NOT_FOUND
, "Host not found",
3013 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
3014 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
3015 WSANO_DATA
, "Valid name, no data record of requested type",
3021 sys_strerror(int error_no
)
3024 static char unknown_msg
[40];
3026 if (error_no
>= 0 && error_no
< sys_nerr
)
3027 return sys_errlist
[error_no
];
3029 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
3030 if (_wsa_errlist
[i
].errnum
== error_no
)
3031 return _wsa_errlist
[i
].msg
;
3033 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
3037 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3038 but I believe the method of keeping the socket handle separate (and
3039 insuring it is not inheritable) is the correct one. */
3041 //#define SOCK_REPLACE_HANDLE
3043 #ifdef SOCK_REPLACE_HANDLE
3044 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3046 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3049 int socket_to_fd (SOCKET s
);
3052 sys_socket(int af
, int type
, int protocol
)
3056 if (winsock_lib
== NULL
)
3059 return INVALID_SOCKET
;
3064 /* call the real socket function */
3065 s
= pfn_socket (af
, type
, protocol
);
3067 if (s
!= INVALID_SOCKET
)
3068 return socket_to_fd (s
);
3074 /* Convert a SOCKET to a file descriptor. */
3076 socket_to_fd (SOCKET s
)
3081 /* Although under NT 3.5 _open_osfhandle will accept a socket
3082 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3083 that does not work under NT 3.1. However, we can get the same
3084 effect by using a backdoor function to replace an existing
3085 descriptor handle with the one we want. */
3087 /* allocate a file descriptor (with appropriate flags) */
3088 fd
= _open ("NUL:", _O_RDWR
);
3091 #ifdef SOCK_REPLACE_HANDLE
3092 /* now replace handle to NUL with our socket handle */
3093 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
3095 _set_osfhnd (fd
, s
);
3096 /* setmode (fd, _O_BINARY); */
3098 /* Make a non-inheritable copy of the socket handle. Note
3099 that it is possible that sockets aren't actually kernel
3100 handles, which appears to be the case on Windows 9x when
3101 the MS Proxy winsock client is installed. */
3103 /* Apparently there is a bug in NT 3.51 with some service
3104 packs, which prevents using DuplicateHandle to make a
3105 socket handle non-inheritable (causes WSACleanup to
3106 hang). The work-around is to use SetHandleInformation
3107 instead if it is available and implemented. */
3108 if (pfn_SetHandleInformation
)
3110 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
3114 HANDLE parent
= GetCurrentProcess ();
3115 HANDLE new_s
= INVALID_HANDLE_VALUE
;
3117 if (DuplicateHandle (parent
,
3123 DUPLICATE_SAME_ACCESS
))
3125 /* It is possible that DuplicateHandle succeeds even
3126 though the socket wasn't really a kernel handle,
3127 because a real handle has the same value. So
3128 test whether the new handle really is a socket. */
3129 long nonblocking
= 0;
3130 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
3132 pfn_closesocket (s
);
3137 CloseHandle (new_s
);
3142 fd_info
[fd
].hnd
= (HANDLE
) s
;
3145 /* set our own internal flags */
3146 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
3152 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3154 /* attach child_process to fd_info */
3155 if (fd_info
[ fd
].cp
!= NULL
)
3157 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
3161 fd_info
[ fd
].cp
= cp
;
3164 winsock_inuse
++; /* count open sockets */
3171 pfn_closesocket (s
);
3178 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
3180 if (winsock_lib
== NULL
)
3183 return SOCKET_ERROR
;
3187 if (fd_info
[s
].flags
& FILE_SOCKET
)
3189 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
3190 if (rc
== SOCKET_ERROR
)
3195 return SOCKET_ERROR
;
3200 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
3202 if (winsock_lib
== NULL
)
3205 return SOCKET_ERROR
;
3209 if (fd_info
[s
].flags
& FILE_SOCKET
)
3211 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
3212 if (rc
== SOCKET_ERROR
)
3217 return SOCKET_ERROR
;
3221 sys_htons (u_short hostshort
)
3223 return (winsock_lib
!= NULL
) ?
3224 pfn_htons (hostshort
) : hostshort
;
3228 sys_ntohs (u_short netshort
)
3230 return (winsock_lib
!= NULL
) ?
3231 pfn_ntohs (netshort
) : netshort
;
3235 sys_inet_addr (const char * cp
)
3237 return (winsock_lib
!= NULL
) ?
3238 pfn_inet_addr (cp
) : INADDR_NONE
;
3242 sys_gethostname (char * name
, int namelen
)
3244 if (winsock_lib
!= NULL
)
3245 return pfn_gethostname (name
, namelen
);
3247 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
3248 return !GetComputerName (name
, (DWORD
*)&namelen
);
3251 return SOCKET_ERROR
;
3255 sys_gethostbyname(const char * name
)
3257 struct hostent
* host
;
3259 if (winsock_lib
== NULL
)
3266 host
= pfn_gethostbyname (name
);
3273 sys_getservbyname(const char * name
, const char * proto
)
3275 struct servent
* serv
;
3277 if (winsock_lib
== NULL
)
3284 serv
= pfn_getservbyname (name
, proto
);
3291 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
3293 if (winsock_lib
== NULL
)
3296 return SOCKET_ERROR
;
3300 if (fd_info
[s
].flags
& FILE_SOCKET
)
3302 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
3303 if (rc
== SOCKET_ERROR
)
3308 return SOCKET_ERROR
;
3313 sys_shutdown (int s
, int how
)
3315 if (winsock_lib
== NULL
)
3318 return SOCKET_ERROR
;
3322 if (fd_info
[s
].flags
& FILE_SOCKET
)
3324 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
3325 if (rc
== SOCKET_ERROR
)
3330 return SOCKET_ERROR
;
3334 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
3336 if (winsock_lib
== NULL
)
3339 return SOCKET_ERROR
;
3343 if (fd_info
[s
].flags
& FILE_SOCKET
)
3345 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
3346 (const char *)optval
, optlen
);
3347 if (rc
== SOCKET_ERROR
)
3352 return SOCKET_ERROR
;
3356 sys_listen (int s
, int backlog
)
3358 if (winsock_lib
== NULL
)
3361 return SOCKET_ERROR
;
3365 if (fd_info
[s
].flags
& FILE_SOCKET
)
3367 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
3368 if (rc
== SOCKET_ERROR
)
3371 fd_info
[s
].flags
|= FILE_LISTEN
;
3375 return SOCKET_ERROR
;
3379 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
3381 if (winsock_lib
== NULL
)
3384 return SOCKET_ERROR
;
3388 if (fd_info
[s
].flags
& FILE_SOCKET
)
3390 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3391 if (rc
== SOCKET_ERROR
)
3396 return SOCKET_ERROR
;
3400 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3402 if (winsock_lib
== NULL
)
3409 if (fd_info
[s
].flags
& FILE_LISTEN
)
3411 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3413 if (t
== INVALID_SOCKET
)
3416 fd
= socket_to_fd (t
);
3418 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3419 ResetEvent (fd_info
[s
].cp
->char_avail
);
3427 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3428 struct sockaddr
* from
, int * fromlen
)
3430 if (winsock_lib
== NULL
)
3433 return SOCKET_ERROR
;
3437 if (fd_info
[s
].flags
& FILE_SOCKET
)
3439 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3440 if (rc
== SOCKET_ERROR
)
3445 return SOCKET_ERROR
;
3449 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3450 const struct sockaddr
* to
, int tolen
)
3452 if (winsock_lib
== NULL
)
3455 return SOCKET_ERROR
;
3459 if (fd_info
[s
].flags
& FILE_SOCKET
)
3461 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3462 if (rc
== SOCKET_ERROR
)
3467 return SOCKET_ERROR
;
3470 /* Windows does not have an fcntl function. Provide an implementation
3471 solely for making sockets non-blocking. */
3473 fcntl (int s
, int cmd
, int options
)
3475 if (winsock_lib
== NULL
)
3482 if (fd_info
[s
].flags
& FILE_SOCKET
)
3484 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
3486 unsigned long nblock
= 1;
3487 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
3488 if (rc
== SOCKET_ERROR
)
3490 /* Keep track of the fact that we set this to non-blocking. */
3491 fd_info
[s
].flags
|= FILE_NDELAY
;
3497 return SOCKET_ERROR
;
3501 return SOCKET_ERROR
;
3504 #endif /* HAVE_SOCKETS */
3507 /* Shadow main io functions: we need to handle pipes and sockets more
3508 intelligently, and implement non-blocking mode as well. */
3521 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
3523 child_process
* cp
= fd_info
[fd
].cp
;
3525 fd_info
[fd
].cp
= NULL
;
3527 if (CHILD_ACTIVE (cp
))
3529 /* if last descriptor to active child_process then cleanup */
3531 for (i
= 0; i
< MAXDESC
; i
++)
3535 if (fd_info
[i
].cp
== cp
)
3541 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3543 #ifndef SOCK_REPLACE_HANDLE
3544 if (winsock_lib
== NULL
) abort ();
3546 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3547 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3549 winsock_inuse
--; /* count open sockets */
3557 /* Note that sockets do not need special treatment here (at least on
3558 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3559 closesocket is equivalent to CloseHandle, which is to be expected
3560 because socket handles are fully fledged kernel handles. */
3563 if (rc
== 0 && fd
< MAXDESC
)
3564 fd_info
[fd
].flags
= 0;
3575 if (new_fd
>= 0 && new_fd
< MAXDESC
)
3577 /* duplicate our internal info as well */
3578 fd_info
[new_fd
] = fd_info
[fd
];
3585 sys_dup2 (int src
, int dst
)
3589 if (dst
< 0 || dst
>= MAXDESC
)
3595 /* make sure we close the destination first if it's a pipe or socket */
3596 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3599 rc
= _dup2 (src
, dst
);
3602 /* duplicate our internal info as well */
3603 fd_info
[dst
] = fd_info
[src
];
3608 /* Unix pipe() has only one arg */
3610 sys_pipe (int * phandles
)
3615 /* make pipe handles non-inheritable; when we spawn a child, we
3616 replace the relevant handle with an inheritable one. Also put
3617 pipes into binary mode; we will do text mode translation ourselves
3619 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3623 /* Protect against overflow, since Windows can open more handles than
3624 our fd_info array has room for. */
3625 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
3627 _close (phandles
[0]);
3628 _close (phandles
[1]);
3633 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3634 fd_info
[phandles
[0]].flags
= flags
;
3636 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3637 fd_info
[phandles
[1]].flags
= flags
;
3645 extern int w32_pipe_read_delay
;
3647 /* Function to do blocking read of one byte, needed to implement
3648 select. It is only allowed on sockets and pipes. */
3650 _sys_read_ahead (int fd
)
3655 if (fd
< 0 || fd
>= MAXDESC
)
3656 return STATUS_READ_ERROR
;
3658 cp
= fd_info
[fd
].cp
;
3660 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3661 return STATUS_READ_ERROR
;
3663 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3664 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3666 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3670 cp
->status
= STATUS_READ_IN_PROGRESS
;
3672 if (fd_info
[fd
].flags
& FILE_PIPE
)
3674 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3676 /* Give subprocess time to buffer some more output for us before
3677 reporting that input is available; we need this because Windows 95
3678 connects DOS programs to pipes by making the pipe appear to be
3679 the normal console stdout - as a result most DOS programs will
3680 write to stdout without buffering, ie. one character at a
3681 time. Even some W32 programs do this - "dir" in a command
3682 shell on NT is very slow if we don't do this. */
3685 int wait
= w32_pipe_read_delay
;
3691 /* Yield remainder of our time slice, effectively giving a
3692 temporary priority boost to the child process. */
3697 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3699 unsigned long nblock
= 0;
3700 /* We always want this to block, so temporarily disable NDELAY. */
3701 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3702 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3704 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3706 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3709 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3714 if (rc
== sizeof (char))
3715 cp
->status
= STATUS_READ_SUCCEEDED
;
3717 cp
->status
= STATUS_READ_FAILED
;
3723 _sys_wait_accept (int fd
)
3729 if (fd
< 0 || fd
>= MAXDESC
)
3730 return STATUS_READ_ERROR
;
3732 cp
= fd_info
[fd
].cp
;
3734 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3735 return STATUS_READ_ERROR
;
3737 cp
->status
= STATUS_READ_FAILED
;
3739 hEv
= pfn_WSACreateEvent ();
3740 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
3741 if (rc
!= SOCKET_ERROR
)
3743 rc
= WaitForSingleObject (hEv
, INFINITE
);
3744 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
3745 if (rc
== WAIT_OBJECT_0
)
3746 cp
->status
= STATUS_READ_SUCCEEDED
;
3748 pfn_WSACloseEvent (hEv
);
3754 sys_read (int fd
, char * buffer
, unsigned int count
)
3759 char * orig_buffer
= buffer
;
3767 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3769 child_process
*cp
= fd_info
[fd
].cp
;
3771 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3779 /* re-read CR carried over from last read */
3780 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3782 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3786 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3789 /* presence of a child_process structure means we are operating in
3790 non-blocking mode - otherwise we just call _read directly.
3791 Note that the child_process structure might be missing because
3792 reap_subprocess has been called; in this case the pipe is
3793 already broken, so calling _read on it is okay. */
3796 int current_status
= cp
->status
;
3798 switch (current_status
)
3800 case STATUS_READ_FAILED
:
3801 case STATUS_READ_ERROR
:
3802 /* report normal EOF if nothing in buffer */
3804 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3807 case STATUS_READ_READY
:
3808 case STATUS_READ_IN_PROGRESS
:
3809 DebPrint (("sys_read called when read is in progress\n"));
3810 errno
= EWOULDBLOCK
;
3813 case STATUS_READ_SUCCEEDED
:
3814 /* consume read-ahead char */
3815 *buffer
++ = cp
->chr
;
3818 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3819 ResetEvent (cp
->char_avail
);
3821 case STATUS_READ_ACKNOWLEDGED
:
3825 DebPrint (("sys_read: bad status %d\n", current_status
));
3830 if (fd_info
[fd
].flags
& FILE_PIPE
)
3832 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3833 to_read
= min (waiting
, (DWORD
) count
);
3836 nchars
+= _read (fd
, buffer
, to_read
);
3839 else /* FILE_SOCKET */
3841 if (winsock_lib
== NULL
) abort ();
3843 /* do the equivalent of a non-blocking read */
3844 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3845 if (waiting
== 0 && nchars
== 0)
3847 h_errno
= errno
= EWOULDBLOCK
;
3853 /* always use binary mode for sockets */
3854 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3855 if (res
== SOCKET_ERROR
)
3857 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3858 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3869 int nread
= _read (fd
, buffer
, count
);
3872 else if (nchars
== 0)
3877 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3878 /* Perform text mode translation if required. */
3879 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3881 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3882 /* If buffer contains only CR, return that. To be absolutely
3883 sure we should attempt to read the next char, but in
3884 practice a CR to be followed by LF would not appear by
3885 itself in the buffer. */
3886 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3888 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3894 nchars
= _read (fd
, buffer
, count
);
3899 /* For now, don't bother with a non-blocking mode */
3901 sys_write (int fd
, const void * buffer
, unsigned int count
)
3911 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3913 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3919 /* Perform text mode translation if required. */
3920 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3922 char * tmpbuf
= alloca (count
* 2);
3923 unsigned char * src
= (void *)buffer
;
3924 unsigned char * dst
= tmpbuf
;
3929 unsigned char *next
;
3930 /* copy next line or remaining bytes */
3931 next
= _memccpy (dst
, src
, '\n', nbytes
);
3934 /* copied one line ending with '\n' */
3935 int copied
= next
- dst
;
3938 /* insert '\r' before '\n' */
3945 /* copied remaining partial line -> now finished */
3953 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
3955 unsigned long nblock
= 0;
3956 if (winsock_lib
== NULL
) abort ();
3958 /* TODO: implement select() properly so non-blocking I/O works. */
3959 /* For now, make sure the write blocks. */
3960 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3961 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3963 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3965 /* Set the socket back to non-blocking if it was before,
3966 for other operations that support it. */
3967 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3970 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3973 if (nchars
== SOCKET_ERROR
)
3975 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
3976 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3982 nchars
= _write (fd
, buffer
, count
);
3988 check_windows_init_file ()
3990 extern int noninteractive
, inhibit_window_system
;
3992 /* A common indication that Emacs is not installed properly is when
3993 it cannot find the Windows installation file. If this file does
3994 not exist in the expected place, tell the user. */
3996 if (!noninteractive
&& !inhibit_window_system
)
3998 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3999 Lisp_Object objs
[2];
4000 Lisp_Object full_load_path
;
4001 Lisp_Object init_file
;
4004 objs
[0] = Vload_path
;
4005 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
4006 full_load_path
= Fappend (2, objs
);
4007 init_file
= build_string ("term/w32-win");
4008 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
4011 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
4012 char *init_file_name
= SDATA (init_file
);
4013 char *load_path
= SDATA (load_path_print
);
4014 char *buffer
= alloca (1024
4015 + strlen (init_file_name
)
4016 + strlen (load_path
));
4019 "The Emacs Windows initialization file \"%s.el\" "
4020 "could not be found in your Emacs installation. "
4021 "Emacs checked the following directories for this file:\n"
4023 "When Emacs cannot find this file, it usually means that it "
4024 "was not installed properly, or its distribution file was "
4025 "not unpacked properly.\nSee the README.W32 file in the "
4026 "top-level Emacs directory for more information.",
4027 init_file_name
, load_path
);
4030 "Emacs Abort Dialog",
4031 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
4032 /* Use the low-level Emacs abort. */
4047 /* shutdown the socket interface if necessary */
4058 /* Initialise the socket interface now if available and requested by
4059 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4060 delayed until open-network-stream is called (w32-has-winsock can
4061 also be used to dynamically load or reload winsock).
4063 Conveniently, init_environment is called before us, so
4064 PRELOAD_WINSOCK can be set in the registry. */
4066 /* Always initialize this correctly. */
4069 if (getenv ("PRELOAD_WINSOCK") != NULL
)
4070 init_winsock (TRUE
);
4073 /* Initial preparation for subprocess support: replace our standard
4074 handles with non-inheritable versions. */
4077 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
4078 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
4079 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
4081 parent
= GetCurrentProcess ();
4083 /* ignore errors when duplicating and closing; typically the
4084 handles will be invalid when running as a gui program. */
4085 DuplicateHandle (parent
,
4086 GetStdHandle (STD_INPUT_HANDLE
),
4091 DUPLICATE_SAME_ACCESS
);
4093 DuplicateHandle (parent
,
4094 GetStdHandle (STD_OUTPUT_HANDLE
),
4099 DUPLICATE_SAME_ACCESS
);
4101 DuplicateHandle (parent
,
4102 GetStdHandle (STD_ERROR_HANDLE
),
4107 DUPLICATE_SAME_ACCESS
);
4113 if (stdin_save
!= INVALID_HANDLE_VALUE
)
4114 _open_osfhandle ((long) stdin_save
, O_TEXT
);
4116 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
4119 if (stdout_save
!= INVALID_HANDLE_VALUE
)
4120 _open_osfhandle ((long) stdout_save
, O_TEXT
);
4122 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4125 if (stderr_save
!= INVALID_HANDLE_VALUE
)
4126 _open_osfhandle ((long) stderr_save
, O_TEXT
);
4128 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4132 /* unfortunately, atexit depends on implementation of malloc */
4133 /* atexit (term_ntproc); */
4134 signal (SIGABRT
, term_ntproc
);
4136 /* determine which drives are fixed, for GetCachedVolumeInformation */
4138 /* GetDriveType must have trailing backslash. */
4139 char drive
[] = "A:\\";
4141 /* Loop over all possible drive letters */
4142 while (*drive
<= 'Z')
4144 /* Record if this drive letter refers to a fixed drive. */
4145 fixed_drives
[DRIVE_INDEX (*drive
)] =
4146 (GetDriveType (drive
) == DRIVE_FIXED
);
4151 /* Reset the volume info cache. */
4152 volume_cache
= NULL
;
4155 /* Check to see if Emacs has been installed correctly. */
4156 check_windows_init_file ();
4160 shutdown_handler ensures that buffers' autosave files are
4161 up to date when the user logs off, or the system shuts down.
4163 BOOL WINAPI
shutdown_handler(DWORD type
)
4165 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4166 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
4167 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
4168 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
4170 /* Shut down cleanly, making sure autosave files are up to date. */
4171 shut_down_emacs (0, 0, Qnil
);
4174 /* Allow other handlers to handle this signal. */
4179 globals_of_w32 is used to initialize those global variables that
4180 must always be initialized on startup even when the global variable
4181 initialized is non zero (see the function main in emacs.c).
4186 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
4188 get_process_times_fn
= (GetProcessTimes_Proc
)
4189 GetProcAddress (kernel32
, "GetProcessTimes");
4191 g_b_init_is_windows_9x
= 0;
4192 g_b_init_open_process_token
= 0;
4193 g_b_init_get_token_information
= 0;
4194 g_b_init_lookup_account_sid
= 0;
4195 g_b_init_get_sid_identifier_authority
= 0;
4196 /* The following sets a handler for shutdown notifications for
4197 console apps. This actually applies to Emacs in both console and
4198 GUI modes, since we had to fool windows into thinking emacs is a
4199 console application to get console mode to work. */
4200 SetConsoleCtrlHandler(shutdown_handler
, TRUE
);
4205 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4206 (do not change this comment) */