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 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
;
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
);
141 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
143 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
145 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
146 LPCTSTR lpSystemName
,
151 LPDWORD cbDomainName
,
152 PSID_NAME_USE peUse
);
153 typedef PSID_IDENTIFIER_AUTHORITY (WINAPI
* GetSidIdentifierAuthority_Proc
) (
156 /* ** A utility function ** */
160 static BOOL s_b_ret
=0;
161 OSVERSIONINFO os_ver
;
162 if (g_b_init_is_windows_9x
== 0)
164 g_b_init_is_windows_9x
= 1;
165 ZeroMemory(&os_ver
, sizeof(OSVERSIONINFO
));
166 os_ver
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
167 if (GetVersionEx (&os_ver
))
169 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
175 /* ** The wrapper functions ** */
177 BOOL WINAPI
open_process_token (
178 HANDLE ProcessHandle
,
182 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
183 HMODULE hm_advapi32
= NULL
;
184 if (is_windows_9x () == TRUE
)
188 if (g_b_init_open_process_token
== 0)
190 g_b_init_open_process_token
= 1;
191 hm_advapi32
= LoadLibrary ("Advapi32.dll");
192 s_pfn_Open_Process_Token
=
193 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
195 if (s_pfn_Open_Process_Token
== NULL
)
200 s_pfn_Open_Process_Token (
207 BOOL WINAPI
get_token_information (
209 TOKEN_INFORMATION_CLASS TokenInformationClass
,
210 LPVOID TokenInformation
,
211 DWORD TokenInformationLength
,
214 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
215 HMODULE hm_advapi32
= NULL
;
216 if (is_windows_9x () == TRUE
)
220 if (g_b_init_get_token_information
== 0)
222 g_b_init_get_token_information
= 1;
223 hm_advapi32
= LoadLibrary ("Advapi32.dll");
224 s_pfn_Get_Token_Information
=
225 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
227 if (s_pfn_Get_Token_Information
== NULL
)
232 s_pfn_Get_Token_Information (
234 TokenInformationClass
,
236 TokenInformationLength
,
241 BOOL WINAPI
lookup_account_sid (
242 LPCTSTR lpSystemName
,
247 LPDWORD cbDomainName
,
250 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
251 HMODULE hm_advapi32
= NULL
;
252 if (is_windows_9x () == TRUE
)
256 if (g_b_init_lookup_account_sid
== 0)
258 g_b_init_lookup_account_sid
= 1;
259 hm_advapi32
= LoadLibrary ("Advapi32.dll");
260 s_pfn_Lookup_Account_Sid
=
261 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
263 if (s_pfn_Lookup_Account_Sid
== NULL
)
268 s_pfn_Lookup_Account_Sid (
279 PSID_IDENTIFIER_AUTHORITY WINAPI
get_sid_identifier_authority (
282 static GetSidIdentifierAuthority_Proc s_pfn_Get_Sid_Identifier_Authority
= NULL
;
283 HMODULE hm_advapi32
= NULL
;
284 if (is_windows_9x () == TRUE
)
288 if (g_b_init_get_sid_identifier_authority
== 0)
290 g_b_init_get_sid_identifier_authority
= 1;
291 hm_advapi32
= LoadLibrary ("Advapi32.dll");
292 s_pfn_Get_Sid_Identifier_Authority
=
293 (GetSidIdentifierAuthority_Proc
) GetProcAddress (
294 hm_advapi32
, "GetSidIdentifierAuthority");
296 if (s_pfn_Get_Sid_Identifier_Authority
== NULL
)
300 return (s_pfn_Get_Sid_Identifier_Authority (pSid
));
304 END: Wrapper functions around OpenProcessToken
305 and other functions in advapi32.dll that are only
306 supported in Windows NT / 2k / XP
310 /* Equivalent of strerror for W32 error codes. */
312 w32_strerror (int error_no
)
314 static char buf
[500];
317 error_no
= GetLastError ();
320 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
322 0, /* choose most suitable language */
323 buf
, sizeof (buf
), NULL
))
324 sprintf (buf
, "w32 error %u", error_no
);
328 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
329 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
331 This is called from alloc.c:valid_pointer_p. */
333 w32_valid_pointer_p (void *p
, int size
)
336 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
340 unsigned char *buf
= alloca (size
);
341 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
350 static char startup_dir
[MAXPATHLEN
];
352 /* Get the current working directory. */
357 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
361 /* Emacs doesn't actually change directory itself, and we want to
362 force our real wd to be where emacs.exe is to avoid unnecessary
363 conflicts when trying to rename or delete directories. */
364 strcpy (dir
, startup_dir
);
370 /* Emulate gethostname. */
372 gethostname (char *buffer
, int size
)
374 /* NT only allows small host names, so the buffer is
375 certainly large enough. */
376 return !GetComputerName (buffer
, &size
);
378 #endif /* HAVE_SOCKETS */
380 /* Emulate getloadavg. */
382 getloadavg (double loadavg
[], int nelem
)
386 /* A faithful emulation is going to have to be saved for a rainy day. */
387 for (i
= 0; i
< nelem
; i
++)
394 /* Emulate getpwuid, getpwnam and others. */
396 #define PASSWD_FIELD_SIZE 256
398 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
399 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
400 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
401 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
402 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
404 static struct passwd the_passwd
=
416 static struct group the_group
=
418 /* There are no groups on NT, so we just return "root" as the
426 return the_passwd
.pw_uid
;
432 /* I could imagine arguing for checking to see whether the user is
433 in the Administrators group and returning a UID of 0 for that
434 case, but I don't know how wise that would be in the long run. */
441 return the_passwd
.pw_gid
;
453 if (uid
== the_passwd
.pw_uid
)
465 getpwnam (char *name
)
469 pw
= getpwuid (getuid ());
473 if (stricmp (name
, pw
->pw_name
))
482 /* Find the user's real name by opening the process token and
483 looking up the name associated with the user-sid in that token.
485 Use the relative portion of the identifier authority value from
486 the user-sid as the user id value (same for group id using the
487 primary group sid from the process token). */
489 char user_sid
[256], name
[256], domain
[256];
490 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
492 SID_NAME_USE user_type
;
494 if (open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
)
495 && get_token_information (token
, TokenUser
,
496 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
497 && lookup_account_sid (NULL
, *((PSID
*) user_sid
), name
, &length
,
498 domain
, &dlength
, &user_type
))
500 strcpy (the_passwd
.pw_name
, name
);
501 /* Determine a reasonable uid value. */
502 if (stricmp ("administrator", name
) == 0)
504 the_passwd
.pw_uid
= 0;
505 the_passwd
.pw_gid
= 0;
509 SID_IDENTIFIER_AUTHORITY
* pSIA
;
511 pSIA
= get_sid_identifier_authority (*((PSID
*) user_sid
));
512 /* I believe the relative portion is the last 4 bytes (of 6)
514 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
515 (pSIA
->Value
[3] << 16) +
516 (pSIA
->Value
[4] << 8) +
517 (pSIA
->Value
[5] << 0));
518 /* restrict to conventional uid range for normal users */
519 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
522 if (get_token_information (token
, TokenPrimaryGroup
,
523 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
525 SID_IDENTIFIER_AUTHORITY
* pSIA
;
527 pSIA
= get_sid_identifier_authority (*((PSID
*) user_sid
));
528 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
529 (pSIA
->Value
[3] << 16) +
530 (pSIA
->Value
[4] << 8) +
531 (pSIA
->Value
[5] << 0));
532 /* I don't know if this is necessary, but for safety... */
533 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
536 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
539 /* If security calls are not supported (presumably because we
540 are running under Windows 95), fallback to this. */
541 else if (GetUserName (name
, &length
))
543 strcpy (the_passwd
.pw_name
, name
);
544 if (stricmp ("administrator", name
) == 0)
545 the_passwd
.pw_uid
= 0;
547 the_passwd
.pw_uid
= 123;
548 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
552 strcpy (the_passwd
.pw_name
, "unknown");
553 the_passwd
.pw_uid
= 123;
554 the_passwd
.pw_gid
= 123;
557 /* Ensure HOME and SHELL are defined. */
558 if (getenv ("HOME") == NULL
)
560 if (getenv ("SHELL") == NULL
)
563 /* Set dir and shell from environment variables. */
564 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
565 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
574 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
575 return ((rand () << 15) | rand ());
585 /* Normalize filename by converting all path separators to
586 the specified separator. Also conditionally convert upper
587 case path name components to lower case. */
590 normalize_filename (fp
, path_sep
)
597 /* Always lower-case drive letters a-z, even if the filesystem
598 preserves case in filenames.
599 This is so filenames can be compared by string comparison
600 functions that are case-sensitive. Even case-preserving filesystems
601 do not distinguish case in drive letters. */
602 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
608 if (NILP (Vw32_downcase_file_names
))
612 if (*fp
== '/' || *fp
== '\\')
619 sep
= path_sep
; /* convert to this path separator */
620 elem
= fp
; /* start of current path element */
623 if (*fp
>= 'a' && *fp
<= 'z')
624 elem
= 0; /* don't convert this element */
626 if (*fp
== 0 || *fp
== ':')
628 sep
= *fp
; /* restore current separator (or 0) */
629 *fp
= '/'; /* after conversion of this element */
632 if (*fp
== '/' || *fp
== '\\')
634 if (elem
&& elem
!= fp
)
636 *fp
= 0; /* temporary end of string */
637 _strlwr (elem
); /* while we convert to lower case */
639 *fp
= sep
; /* convert (or restore) path separator */
640 elem
= fp
+ 1; /* next element starts after separator */
646 /* Destructively turn backslashes into slashes. */
648 dostounix_filename (p
)
651 normalize_filename (p
, '/');
654 /* Destructively turn slashes into backslashes. */
656 unixtodos_filename (p
)
659 normalize_filename (p
, '\\');
662 /* Remove all CR's that are followed by a LF.
663 (From msdos.c...probably should figure out a way to share it,
664 although this code isn't going to ever change.) */
668 register unsigned char *buf
;
670 unsigned char *np
= buf
;
671 unsigned char *startp
= buf
;
672 unsigned char *endp
= buf
+ n
;
676 while (buf
< endp
- 1)
680 if (*(++buf
) != 0x0a)
691 /* Parse the root part of file name, if present. Return length and
692 optionally store pointer to char after root. */
694 parse_root (char * name
, char ** pPath
)
701 /* find the root name of the volume if given */
702 if (isalpha (name
[0]) && name
[1] == ':')
704 /* skip past drive specifier */
706 if (IS_DIRECTORY_SEP (name
[0]))
709 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
715 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
720 if (IS_DIRECTORY_SEP (name
[0]))
730 /* Get long base name for name; name is assumed to be absolute. */
732 get_long_basename (char * name
, char * buf
, int size
)
734 WIN32_FIND_DATA find_data
;
738 /* must be valid filename, no wild cards or other invalid characters */
739 if (_mbspbrk (name
, "*?|<>\""))
742 dir_handle
= FindFirstFile (name
, &find_data
);
743 if (dir_handle
!= INVALID_HANDLE_VALUE
)
745 if ((len
= strlen (find_data
.cFileName
)) < size
)
746 memcpy (buf
, find_data
.cFileName
, len
+ 1);
749 FindClose (dir_handle
);
754 /* Get long name for file, if possible (assumed to be absolute). */
756 w32_get_long_filename (char * name
, char * buf
, int size
)
761 char full
[ MAX_PATH
];
768 /* Use local copy for destructive modification. */
769 memcpy (full
, name
, len
+1);
770 unixtodos_filename (full
);
772 /* Copy root part verbatim. */
773 len
= parse_root (full
, &p
);
774 memcpy (o
, full
, len
);
779 while (p
!= NULL
&& *p
)
782 p
= strchr (q
, '\\');
784 len
= get_long_basename (full
, o
, size
);
807 is_unc_volume (const char *filename
)
809 const char *ptr
= filename
;
811 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
814 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
820 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
823 sigsetmask (int signal_mask
)
847 setpgrp (int pid
, int gid
)
859 unrequest_sigio (void)
870 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
873 w32_get_resource (key
, lpdwtype
)
878 HKEY hrootkey
= NULL
;
882 /* Check both the current user and the local machine to see if
883 we have any resources. */
885 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
889 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
890 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
891 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
896 if (lpvalue
) xfree (lpvalue
);
898 RegCloseKey (hrootkey
);
901 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
905 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
906 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
907 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
912 if (lpvalue
) xfree (lpvalue
);
914 RegCloseKey (hrootkey
);
920 char *get_emacs_configuration (void);
921 extern Lisp_Object Vsystem_configuration
;
924 init_environment (char ** argv
)
926 static const char * const tempdirs
[] = {
927 "$TMPDIR", "$TEMP", "$TMP", "c:/"
932 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
934 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
935 temporary files and assume "/tmp" if $TMPDIR is unset, which
936 will break on DOS/Windows. Refuse to work if we cannot find
937 a directory, not even "c:/", usable for that purpose. */
938 for (i
= 0; i
< imax
; i
++)
940 const char *tmp
= tempdirs
[i
];
943 tmp
= getenv (tmp
+ 1);
944 /* Note that `access' can lie to us if the directory resides on a
945 read-only filesystem, like CD-ROM or a write-protected floppy.
946 The only way to be really sure is to actually create a file and
947 see if it succeeds. But I think that's too much to ask. */
948 if (tmp
&& _access (tmp
, D_OK
) == 0)
950 char * var
= alloca (strlen (tmp
) + 8);
951 sprintf (var
, "TMPDIR=%s", tmp
);
952 _putenv (strdup (var
));
959 Fcons (build_string ("no usable temporary directories found!!"),
961 "While setting TMPDIR: ");
963 /* Check for environment variables and use registry settings if they
964 don't exist. Fallback on default values where applicable. */
969 char locale_name
[32];
971 char default_home
[MAX_PATH
];
973 static const struct env_entry
980 {"PRELOAD_WINSOCK", NULL
},
981 {"emacs_dir", "C:/emacs"},
982 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
983 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
984 {"EMACSDATA", "%emacs_dir%/etc"},
985 {"EMACSPATH", "%emacs_dir%/bin"},
986 /* We no longer set INFOPATH because Info-default-directory-list
988 /* {"INFOPATH", "%emacs_dir%/info"}, */
989 {"EMACSDOC", "%emacs_dir%/etc"},
994 #define N_ENV_VARS sizeof(dflt_envvars)/sizeof(dflt_envvars[0])
996 /* We need to copy dflt_envvars[] and work on the copy because we
997 don't want the dumped Emacs to inherit the values of
998 environment variables we saw during dumping (which could be on
999 a different system). The defaults above must be left intact. */
1000 struct env_entry env_vars
[N_ENV_VARS
];
1002 for (i
= 0; i
< N_ENV_VARS
; i
++)
1003 env_vars
[i
] = dflt_envvars
[i
];
1005 /* For backwards compatibility, check if a .emacs file exists in C:/
1006 If not, then we can try to default to the appdata directory under the
1007 user's profile, which is more likely to be writable. */
1008 if (stat ("C:/.emacs", &ignored
) < 0)
1010 HRESULT profile_result
;
1011 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1012 of Windows 95 and NT4 that have not been updated to include
1013 MSIE 5. Also we don't link with shell32.dll by default. */
1014 HMODULE shell32_dll
;
1015 ShGetFolderPath_fn get_folder_path
;
1016 shell32_dll
= GetModuleHandle ("shell32.dll");
1017 get_folder_path
= (ShGetFolderPath_fn
)
1018 GetProcAddress (shell32_dll
, "SHGetFolderPathA");
1020 if (get_folder_path
!= NULL
)
1022 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1025 /* If we can't get the appdata dir, revert to old behaviour. */
1026 if (profile_result
== S_OK
)
1027 env_vars
[0].def_value
= default_home
;
1030 /* Unload shell32.dll, it is not needed anymore. */
1031 FreeLibrary (shell32_dll
);
1034 /* Get default locale info and use it for LANG. */
1035 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1036 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1037 locale_name
, sizeof (locale_name
)))
1039 for (i
= 0; i
< N_ENV_VARS
; i
++)
1041 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1043 env_vars
[i
].def_value
= locale_name
;
1049 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1051 /* Treat emacs_dir specially: set it unconditionally based on our
1052 location, if it appears that we are running from the bin subdir
1053 of a standard installation. */
1056 char modname
[MAX_PATH
];
1058 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1060 if ((p
= strrchr (modname
, '\\')) == NULL
)
1064 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
1066 char buf
[SET_ENV_BUF_SIZE
];
1069 for (p
= modname
; *p
; p
++)
1070 if (*p
== '\\') *p
= '/';
1072 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1073 _putenv (strdup (buf
));
1075 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1077 /* FIXME: should use substring of get_emacs_configuration ().
1078 But I don't think the Windows build supports alpha, mips etc
1079 anymore, so have taken the easy option for now. */
1080 else if (p
&& stricmp (p
, "\\i386") == 0)
1083 p
= strrchr (modname
, '\\');
1087 p
= strrchr (modname
, '\\');
1088 if (p
&& stricmp (p
, "\\src") == 0)
1090 char buf
[SET_ENV_BUF_SIZE
];
1093 for (p
= modname
; *p
; p
++)
1094 if (*p
== '\\') *p
= '/';
1096 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
1097 _putenv (strdup (buf
));
1103 for (i
= 0; i
< N_ENV_VARS
; i
++)
1105 if (!getenv (env_vars
[i
].name
))
1109 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1110 /* Also ignore empty environment variables. */
1113 lpval
= env_vars
[i
].def_value
;
1114 dwType
= REG_EXPAND_SZ
;
1120 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1122 if (dwType
== REG_EXPAND_SZ
)
1123 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
1124 else if (dwType
== REG_SZ
)
1125 strcpy (buf1
, lpval
);
1126 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1128 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
,
1130 _putenv (strdup (buf2
));
1140 /* Rebuild system configuration to reflect invoking system. */
1141 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1143 /* Another special case: on NT, the PATH variable is actually named
1144 "Path" although cmd.exe (perhaps NT itself) arranges for
1145 environment variable lookup and setting to be case insensitive.
1146 However, Emacs assumes a fully case sensitive environment, so we
1147 need to change "Path" to "PATH" to match the expectations of
1148 various elisp packages. We do this by the sneaky method of
1149 modifying the string in the C runtime environ entry.
1151 The same applies to COMSPEC. */
1155 for (envp
= environ
; *envp
; envp
++)
1156 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1157 memcpy (*envp
, "PATH=", 5);
1158 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1159 memcpy (*envp
, "COMSPEC=", 8);
1162 /* Remember the initial working directory for getwd, then make the
1163 real wd be the location of emacs.exe to avoid conflicts when
1164 renaming or deleting directories. (We also don't call chdir when
1165 running subprocesses for the same reason.) */
1166 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1171 static char modname
[MAX_PATH
];
1173 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1175 if ((p
= strrchr (modname
, '\\')) == NULL
)
1179 SetCurrentDirectory (modname
);
1181 /* Ensure argv[0] has the full path to Emacs. */
1186 /* Determine if there is a middle mouse button, to allow parse_button
1187 to decide whether right mouse events should be mouse-2 or
1189 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1195 emacs_root_dir (void)
1197 static char root_dir
[FILENAME_MAX
];
1200 p
= getenv ("emacs_dir");
1203 strcpy (root_dir
, p
);
1204 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1205 dostounix_filename (root_dir
);
1209 /* We don't have scripts to automatically determine the system configuration
1210 for Emacs before it's compiled, and we don't want to have to make the
1211 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1215 get_emacs_configuration (void)
1217 char *arch
, *oem
, *os
;
1219 static char configuration_buffer
[32];
1221 /* Determine the processor type. */
1222 switch (get_processor_type ())
1225 #ifdef PROCESSOR_INTEL_386
1226 case PROCESSOR_INTEL_386
:
1227 case PROCESSOR_INTEL_486
:
1228 case PROCESSOR_INTEL_PENTIUM
:
1233 #ifdef PROCESSOR_INTEL_860
1234 case PROCESSOR_INTEL_860
:
1239 #ifdef PROCESSOR_MIPS_R2000
1240 case PROCESSOR_MIPS_R2000
:
1241 case PROCESSOR_MIPS_R3000
:
1242 case PROCESSOR_MIPS_R4000
:
1247 #ifdef PROCESSOR_ALPHA_21064
1248 case PROCESSOR_ALPHA_21064
:
1258 /* Use the OEM field to reflect the compiler/library combination. */
1260 #define COMPILER_NAME "msvc"
1263 #define COMPILER_NAME "mingw"
1265 #define COMPILER_NAME "unknown"
1268 oem
= COMPILER_NAME
;
1270 switch (osinfo_cache
.dwPlatformId
) {
1271 case VER_PLATFORM_WIN32_NT
:
1273 build_num
= osinfo_cache
.dwBuildNumber
;
1275 case VER_PLATFORM_WIN32_WINDOWS
:
1276 if (osinfo_cache
.dwMinorVersion
== 0) {
1281 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1283 case VER_PLATFORM_WIN32s
:
1284 /* Not supported, should not happen. */
1286 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1294 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1295 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1296 get_w32_major_version (), get_w32_minor_version (), build_num
);
1298 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1301 return configuration_buffer
;
1305 get_emacs_configuration_options (void)
1307 static char options_buffer
[256];
1309 /* Work out the effective configure options for this build. */
1311 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1314 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1316 #define COMPILER_VERSION ""
1320 sprintf (options_buffer
, COMPILER_VERSION
);
1322 strcat (options_buffer
, " --no-opt");
1325 strcat (options_buffer
, " --cflags");
1326 strcat (options_buffer
, USER_CFLAGS
);
1329 strcat (options_buffer
, " --ldflags");
1330 strcat (options_buffer
, USER_LDFLAGS
);
1332 return options_buffer
;
1336 #include <sys/timeb.h>
1338 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1340 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1345 tv
->tv_sec
= tb
.time
;
1346 tv
->tv_usec
= tb
.millitm
* 1000L;
1349 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1350 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1354 /* ------------------------------------------------------------------------- */
1355 /* IO support and wrapper functions for W32 API. */
1356 /* ------------------------------------------------------------------------- */
1358 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1359 on network directories, so we handle that case here.
1360 (Ulrich Leodolter, 1/11/95). */
1362 sys_ctime (const time_t *t
)
1364 char *str
= (char *) ctime (t
);
1365 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1368 /* Emulate sleep...we could have done this with a define, but that
1369 would necessitate including windows.h in the files that used it.
1370 This is much easier. */
1372 sys_sleep (int seconds
)
1374 Sleep (seconds
* 1000);
1377 /* Internal MSVC functions for low-level descriptor munging */
1378 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1379 extern int __cdecl
_free_osfhnd (int fd
);
1381 /* parallel array of private info on file handles */
1382 filedesc fd_info
[ MAXDESC
];
1384 typedef struct volume_info_data
{
1385 struct volume_info_data
* next
;
1387 /* time when info was obtained */
1390 /* actual volume info */
1399 /* Global referenced by various functions. */
1400 static volume_info_data volume_info
;
1402 /* Vector to indicate which drives are local and fixed (for which cached
1403 data never expires). */
1404 static BOOL fixed_drives
[26];
1406 /* Consider cached volume information to be stale if older than 10s,
1407 at least for non-local drives. Info for fixed drives is never stale. */
1408 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1409 #define VOLINFO_STILL_VALID( root_dir, info ) \
1410 ( ( isalpha (root_dir[0]) && \
1411 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1412 || GetTickCount () - info->timestamp < 10000 )
1414 /* Cache support functions. */
1416 /* Simple linked list with linear search is sufficient. */
1417 static volume_info_data
*volume_cache
= NULL
;
1419 static volume_info_data
*
1420 lookup_volume_info (char * root_dir
)
1422 volume_info_data
* info
;
1424 for (info
= volume_cache
; info
; info
= info
->next
)
1425 if (stricmp (info
->root_dir
, root_dir
) == 0)
1431 add_volume_info (char * root_dir
, volume_info_data
* info
)
1433 info
->root_dir
= xstrdup (root_dir
);
1434 info
->next
= volume_cache
;
1435 volume_cache
= info
;
1439 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1440 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1441 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1443 GetCachedVolumeInformation (char * root_dir
)
1445 volume_info_data
* info
;
1446 char default_root
[ MAX_PATH
];
1448 /* NULL for root_dir means use root from current directory. */
1449 if (root_dir
== NULL
)
1451 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1453 parse_root (default_root
, &root_dir
);
1455 root_dir
= default_root
;
1458 /* Local fixed drives can be cached permanently. Removable drives
1459 cannot be cached permanently, since the volume name and serial
1460 number (if nothing else) can change. Remote drives should be
1461 treated as if they are removable, since there is no sure way to
1462 tell whether they are or not. Also, the UNC association of drive
1463 letters mapped to remote volumes can be changed at any time (even
1464 by other processes) without notice.
1466 As a compromise, so we can benefit from caching info for remote
1467 volumes, we use a simple expiry mechanism to invalidate cache
1468 entries that are more than ten seconds old. */
1471 /* No point doing this, because WNetGetConnection is even slower than
1472 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1473 GetDriveType is about the only call of this type which does not
1474 involve network access, and so is extremely quick). */
1476 /* Map drive letter to UNC if remote. */
1477 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1479 char remote_name
[ 256 ];
1480 char drive
[3] = { root_dir
[0], ':' };
1482 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1484 /* do something */ ;
1488 info
= lookup_volume_info (root_dir
);
1490 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1498 /* Info is not cached, or is stale. */
1499 if (!GetVolumeInformation (root_dir
,
1500 name
, sizeof (name
),
1504 type
, sizeof (type
)))
1507 /* Cache the volume information for future use, overwriting existing
1508 entry if present. */
1511 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1512 add_volume_info (root_dir
, info
);
1520 info
->name
= xstrdup (name
);
1521 info
->serialnum
= serialnum
;
1522 info
->maxcomp
= maxcomp
;
1523 info
->flags
= flags
;
1524 info
->type
= xstrdup (type
);
1525 info
->timestamp
= GetTickCount ();
1531 /* Get information on the volume where name is held; set path pointer to
1532 start of pathname in name (past UNC header\volume header if present). */
1534 get_volume_info (const char * name
, const char ** pPath
)
1536 char temp
[MAX_PATH
];
1537 char *rootname
= NULL
; /* default to current volume */
1538 volume_info_data
* info
;
1543 /* find the root name of the volume if given */
1544 if (isalpha (name
[0]) && name
[1] == ':')
1552 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1559 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1572 info
= GetCachedVolumeInformation (rootname
);
1575 /* Set global referenced by other functions. */
1576 volume_info
= *info
;
1582 /* Determine if volume is FAT format (ie. only supports short 8.3
1583 names); also set path pointer to start of pathname in name. */
1585 is_fat_volume (const char * name
, const char ** pPath
)
1587 if (get_volume_info (name
, pPath
))
1588 return (volume_info
.maxcomp
== 12);
1592 /* Map filename to a legal 8.3 name if necessary. */
1594 map_w32_filename (const char * name
, const char ** pPath
)
1596 static char shortname
[MAX_PATH
];
1597 char * str
= shortname
;
1600 const char * save_name
= name
;
1602 if (strlen (name
) >= MAX_PATH
)
1604 /* Return a filename which will cause callers to fail. */
1605 strcpy (shortname
, "?");
1609 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1611 register int left
= 8; /* maximum number of chars in part */
1612 register int extn
= 0; /* extension added? */
1613 register int dots
= 2; /* maximum number of dots allowed */
1616 *str
++ = *name
++; /* skip past UNC header */
1618 while ((c
= *name
++))
1625 extn
= 0; /* reset extension flags */
1626 dots
= 2; /* max 2 dots */
1627 left
= 8; /* max length 8 for main part */
1631 extn
= 0; /* reset extension flags */
1632 dots
= 2; /* max 2 dots */
1633 left
= 8; /* max length 8 for main part */
1638 /* Convert path components of the form .xxx to _xxx,
1639 but leave . and .. as they are. This allows .emacs
1640 to be read as _emacs, for example. */
1644 IS_DIRECTORY_SEP (*name
))
1659 extn
= 1; /* we've got an extension */
1660 left
= 3; /* 3 chars in extension */
1664 /* any embedded dots after the first are converted to _ */
1669 case '#': /* don't lose these, they're important */
1671 str
[-1] = c
; /* replace last character of part */
1676 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1678 dots
= 0; /* started a path component */
1687 strcpy (shortname
, name
);
1688 unixtodos_filename (shortname
);
1692 *pPath
= shortname
+ (path
- save_name
);
1698 is_exec (const char * name
)
1700 char * p
= strrchr (name
, '.');
1703 && (stricmp (p
, ".exe") == 0 ||
1704 stricmp (p
, ".com") == 0 ||
1705 stricmp (p
, ".bat") == 0 ||
1706 stricmp (p
, ".cmd") == 0));
1709 /* Emulate the Unix directory procedures opendir, closedir,
1710 and readdir. We can't use the procedures supplied in sysdep.c,
1711 so we provide them here. */
1713 struct direct dir_static
; /* simulated directory contents */
1714 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1715 static int dir_is_fat
;
1716 static char dir_pathname
[MAXPATHLEN
+1];
1717 static WIN32_FIND_DATA dir_find_data
;
1719 /* Support shares on a network resource as subdirectories of a read-only
1721 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1722 HANDLE
open_unc_volume (const char *);
1723 char *read_unc_volume (HANDLE
, char *, int);
1724 void close_unc_volume (HANDLE
);
1727 opendir (char *filename
)
1731 /* Opening is done by FindFirstFile. However, a read is inherent to
1732 this operation, so we defer the open until read time. */
1734 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1736 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1739 if (is_unc_volume (filename
))
1741 wnet_enum_handle
= open_unc_volume (filename
);
1742 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1746 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1753 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1754 dir_pathname
[MAXPATHLEN
] = '\0';
1755 dir_is_fat
= is_fat_volume (filename
, NULL
);
1761 closedir (DIR *dirp
)
1763 /* If we have a find-handle open, close it. */
1764 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1766 FindClose (dir_find_handle
);
1767 dir_find_handle
= INVALID_HANDLE_VALUE
;
1769 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1771 close_unc_volume (wnet_enum_handle
);
1772 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1774 xfree ((char *) dirp
);
1780 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1782 if (!read_unc_volume (wnet_enum_handle
,
1783 dir_find_data
.cFileName
,
1787 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1788 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1790 char filename
[MAXNAMLEN
+ 3];
1793 strcpy (filename
, dir_pathname
);
1794 ln
= strlen (filename
) - 1;
1795 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1796 strcat (filename
, "\\");
1797 strcat (filename
, "*");
1799 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1801 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1806 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1810 /* Emacs never uses this value, so don't bother making it match
1811 value returned by stat(). */
1812 dir_static
.d_ino
= 1;
1814 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1815 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1817 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1818 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1820 _strlwr (dir_static
.d_name
);
1821 else if (!NILP (Vw32_downcase_file_names
))
1824 for (p
= dir_static
.d_name
; *p
; p
++)
1825 if (*p
>= 'a' && *p
<= 'z')
1828 _strlwr (dir_static
.d_name
);
1835 open_unc_volume (const char *path
)
1841 nr
.dwScope
= RESOURCE_GLOBALNET
;
1842 nr
.dwType
= RESOURCETYPE_DISK
;
1843 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1844 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1845 nr
.lpLocalName
= NULL
;
1846 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
1847 nr
.lpComment
= NULL
;
1848 nr
.lpProvider
= NULL
;
1850 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1851 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1853 if (result
== NO_ERROR
)
1856 return INVALID_HANDLE_VALUE
;
1860 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1864 DWORD bufsize
= 512;
1869 buffer
= alloca (bufsize
);
1870 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1871 if (result
!= NO_ERROR
)
1874 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1875 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1877 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1880 strncpy (readbuf
, ptr
, size
);
1885 close_unc_volume (HANDLE henum
)
1887 if (henum
!= INVALID_HANDLE_VALUE
)
1888 WNetCloseEnum (henum
);
1892 unc_volume_file_attributes (const char *path
)
1897 henum
= open_unc_volume (path
);
1898 if (henum
== INVALID_HANDLE_VALUE
)
1901 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1903 close_unc_volume (henum
);
1909 /* Shadow some MSVC runtime functions to map requests for long filenames
1910 to reasonable short names if necessary. This was originally added to
1911 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1915 sys_access (const char * path
, int mode
)
1919 /* MSVC implementation doesn't recognize D_OK. */
1920 path
= map_w32_filename (path
, NULL
);
1921 if (is_unc_volume (path
))
1923 attributes
= unc_volume_file_attributes (path
);
1924 if (attributes
== -1) {
1929 else if ((attributes
= GetFileAttributes (path
)) == -1)
1931 /* Should try mapping GetLastError to errno; for now just indicate
1932 that path doesn't exist. */
1936 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1941 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1946 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1955 sys_chdir (const char * path
)
1957 return _chdir (map_w32_filename (path
, NULL
));
1961 sys_chmod (const char * path
, int mode
)
1963 return _chmod (map_w32_filename (path
, NULL
), mode
);
1967 sys_chown (const char *path
, uid_t owner
, gid_t group
)
1969 if (sys_chmod (path
, _S_IREAD
) == -1) /* check if file exists */
1975 sys_creat (const char * path
, int mode
)
1977 return _creat (map_w32_filename (path
, NULL
), mode
);
1981 sys_fopen(const char * path
, const char * mode
)
1985 const char * mode_save
= mode
;
1987 /* Force all file handles to be non-inheritable. This is necessary to
1988 ensure child processes don't unwittingly inherit handles that might
1989 prevent future file access. */
1993 else if (mode
[0] == 'w' || mode
[0] == 'a')
1994 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1998 /* Only do simplistic option parsing. */
2002 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2005 else if (mode
[0] == 'b')
2010 else if (mode
[0] == 't')
2017 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2021 return _fdopen (fd
, mode_save
);
2024 /* This only works on NTFS volumes, but is useful to have. */
2026 sys_link (const char * old
, const char * new)
2030 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2032 if (old
== NULL
|| new == NULL
)
2038 strcpy (oldname
, map_w32_filename (old
, NULL
));
2039 strcpy (newname
, map_w32_filename (new, NULL
));
2041 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2042 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2043 if (fileh
!= INVALID_HANDLE_VALUE
)
2047 /* Confusingly, the "alternate" stream name field does not apply
2048 when restoring a hard link, and instead contains the actual
2049 stream data for the link (ie. the name of the link to create).
2050 The WIN32_STREAM_ID structure before the cStreamName field is
2051 the stream header, which is then immediately followed by the
2055 WIN32_STREAM_ID wid
;
2056 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2059 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2060 data
.wid
.cStreamName
, MAX_PATH
);
2063 LPVOID context
= NULL
;
2066 data
.wid
.dwStreamId
= BACKUP_LINK
;
2067 data
.wid
.dwStreamAttributes
= 0;
2068 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
2069 data
.wid
.Size
.HighPart
= 0;
2070 data
.wid
.dwStreamNameSize
= 0;
2072 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2073 offsetof (WIN32_STREAM_ID
, cStreamName
)
2074 + data
.wid
.Size
.LowPart
,
2075 &wbytes
, FALSE
, FALSE
, &context
)
2076 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2083 /* Should try mapping GetLastError to errno; for now just
2084 indicate a general error (eg. links not supported). */
2085 errno
= EINVAL
; // perhaps EMLINK?
2089 CloseHandle (fileh
);
2098 sys_mkdir (const char * path
)
2100 return _mkdir (map_w32_filename (path
, NULL
));
2103 /* Because of long name mapping issues, we need to implement this
2104 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2105 a unique name, instead of setting the input template to an empty
2108 Standard algorithm seems to be use pid or tid with a letter on the
2109 front (in place of the 6 X's) and cycle through the letters to find a
2110 unique name. We extend that to allow any reasonable character as the
2111 first of the 6 X's. */
2113 sys_mktemp (char * template)
2117 unsigned uid
= GetCurrentThreadId ();
2118 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2120 if (template == NULL
)
2122 p
= template + strlen (template);
2124 /* replace up to the last 5 X's with uid in decimal */
2125 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2127 p
[0] = '0' + uid
% 10;
2131 if (i
< 0 && p
[0] == 'X')
2136 int save_errno
= errno
;
2137 p
[0] = first_char
[i
];
2138 if (sys_access (template, 0) < 0)
2144 while (++i
< sizeof (first_char
));
2147 /* Template is badly formed or else we can't generate a unique name,
2148 so return empty string */
2154 sys_open (const char * path
, int oflag
, int mode
)
2156 const char* mpath
= map_w32_filename (path
, NULL
);
2157 /* Try to open file without _O_CREAT, to be able to write to hidden
2158 and system files. Force all file handles to be
2160 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2163 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2167 sys_rename (const char * oldname
, const char * newname
)
2170 char temp
[MAX_PATH
];
2172 /* MoveFile on Windows 95 doesn't correctly change the short file name
2173 alias in a number of circumstances (it is not easy to predict when
2174 just by looking at oldname and newname, unfortunately). In these
2175 cases, renaming through a temporary name avoids the problem.
2177 A second problem on Windows 95 is that renaming through a temp name when
2178 newname is uppercase fails (the final long name ends up in
2179 lowercase, although the short alias might be uppercase) UNLESS the
2180 long temp name is not 8.3.
2182 So, on Windows 95 we always rename through a temp name, and we make sure
2183 the temp name has a long extension to ensure correct renaming. */
2185 strcpy (temp
, map_w32_filename (oldname
, NULL
));
2187 if (os_subtype
== OS_WIN95
)
2193 oldname
= map_w32_filename (oldname
, NULL
);
2194 if (o
= strrchr (oldname
, '\\'))
2197 o
= (char *) oldname
;
2199 if (p
= strrchr (temp
, '\\'))
2206 /* Force temp name to require a manufactured 8.3 alias - this
2207 seems to make the second rename work properly. */
2208 sprintf (p
, "_.%s.%u", o
, i
);
2210 result
= rename (oldname
, temp
);
2212 /* This loop must surely terminate! */
2213 while (result
< 0 && errno
== EEXIST
);
2218 /* Emulate Unix behaviour - newname is deleted if it already exists
2219 (at least if it is a file; don't do this for directories).
2221 Since we mustn't do this if we are just changing the case of the
2222 file name (we would end up deleting the file we are trying to
2223 rename!), we let rename detect if the destination file already
2224 exists - that way we avoid the possible pitfalls of trying to
2225 determine ourselves whether two names really refer to the same
2226 file, which is not always possible in the general case. (Consider
2227 all the permutations of shared or subst'd drives, etc.) */
2229 newname
= map_w32_filename (newname
, NULL
);
2230 result
= rename (temp
, newname
);
2234 && _chmod (newname
, 0666) == 0
2235 && _unlink (newname
) == 0)
2236 result
= rename (temp
, newname
);
2242 sys_rmdir (const char * path
)
2244 return _rmdir (map_w32_filename (path
, NULL
));
2248 sys_unlink (const char * path
)
2250 path
= map_w32_filename (path
, NULL
);
2252 /* On Unix, unlink works without write permission. */
2253 _chmod (path
, 0666);
2254 return _unlink (path
);
2257 static FILETIME utc_base_ft
;
2258 static long double utc_base
;
2259 static int init
= 0;
2262 convert_time (FILETIME ft
)
2268 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2277 st
.wMilliseconds
= 0;
2279 SystemTimeToFileTime (&st
, &utc_base_ft
);
2280 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2281 * 4096.0L * 1024.0L * 1024.0L + utc_base_ft
.dwLowDateTime
;
2285 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
2288 ret
= (long double) ft
.dwHighDateTime
2289 * 4096.0L * 1024.0L * 1024.0L + ft
.dwLowDateTime
;
2291 return (time_t) (ret
* 1e-7L);
2295 convert_from_time_t (time_t time
, FILETIME
* pft
)
2301 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
2310 st
.wMilliseconds
= 0;
2312 SystemTimeToFileTime (&st
, &utc_base_ft
);
2313 utc_base
= (long double) utc_base_ft
.dwHighDateTime
2314 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2318 /* time in 100ns units since 1-Jan-1601 */
2319 tmp
= (long double) time
* 1e7
+ utc_base
;
2320 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2321 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2325 /* No reason to keep this; faking inode values either by hashing or even
2326 using the file index from GetInformationByHandle, is not perfect and
2327 so by default Emacs doesn't use the inode values on Windows.
2328 Instead, we now determine file-truename correctly (except for
2329 possible drive aliasing etc). */
2331 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2333 hashval (const unsigned char * str
)
2338 h
= (h
<< 4) + *str
++;
2344 /* Return the hash value of the canonical pathname, excluding the
2345 drive/UNC header, to get a hopefully unique inode number. */
2347 generate_inode_val (const char * name
)
2349 char fullname
[ MAX_PATH
];
2353 /* Get the truly canonical filename, if it exists. (Note: this
2354 doesn't resolve aliasing due to subst commands, or recognise hard
2356 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2359 parse_root (fullname
, &p
);
2360 /* Normal W32 filesystems are still case insensitive. */
2367 /* MSVC stat function can't cope with UNC names and has other bugs, so
2368 replace it with our own. This also allows us to calculate consistent
2369 inode values without hacks in the main Emacs code. */
2371 stat (const char * path
, struct stat
* buf
)
2374 WIN32_FIND_DATA wfd
;
2379 int rootdir
= FALSE
;
2381 if (path
== NULL
|| buf
== NULL
)
2387 name
= (char *) map_w32_filename (path
, &path
);
2388 /* Must be valid filename, no wild cards or other invalid
2389 characters. We use _mbspbrk to support multibyte strings that
2390 might look to strpbrk as if they included literal *, ?, and other
2391 characters mentioned below that are disallowed by Windows
2393 if (_mbspbrk (name
, "*?|<>\""))
2399 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2400 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2401 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2406 /* Remove trailing directory separator, unless name is the root
2407 directory of a drive or UNC volume in which case ensure there
2408 is a trailing separator. */
2409 len
= strlen (name
);
2410 rootdir
= (path
>= name
+ len
- 1
2411 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2412 name
= strcpy (alloca (len
+ 2), name
);
2414 if (is_unc_volume (name
))
2416 DWORD attrs
= unc_volume_file_attributes (name
);
2421 memset (&wfd
, 0, sizeof (wfd
));
2422 wfd
.dwFileAttributes
= attrs
;
2423 wfd
.ftCreationTime
= utc_base_ft
;
2424 wfd
.ftLastAccessTime
= utc_base_ft
;
2425 wfd
.ftLastWriteTime
= utc_base_ft
;
2426 strcpy (wfd
.cFileName
, name
);
2430 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2431 strcat (name
, "\\");
2432 if (GetDriveType (name
) < 2)
2437 memset (&wfd
, 0, sizeof (wfd
));
2438 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2439 wfd
.ftCreationTime
= utc_base_ft
;
2440 wfd
.ftLastAccessTime
= utc_base_ft
;
2441 wfd
.ftLastWriteTime
= utc_base_ft
;
2442 strcpy (wfd
.cFileName
, name
);
2446 if (IS_DIRECTORY_SEP (name
[len
-1]))
2449 /* (This is hacky, but helps when doing file completions on
2450 network drives.) Optimize by using information available from
2451 active readdir if possible. */
2452 len
= strlen (dir_pathname
);
2453 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2455 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2456 && strnicmp (name
, dir_pathname
, len
) == 0
2457 && IS_DIRECTORY_SEP (name
[len
])
2458 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2460 /* This was the last entry returned by readdir. */
2461 wfd
= dir_find_data
;
2465 fh
= FindFirstFile (name
, &wfd
);
2466 if (fh
== INVALID_HANDLE_VALUE
)
2475 if (!NILP (Vw32_get_true_file_attributes
)
2476 /* No access rights required to get info. */
2477 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
2478 FILE_FLAG_BACKUP_SEMANTICS
, NULL
))
2479 != INVALID_HANDLE_VALUE
)
2481 /* This is more accurate in terms of gettting the correct number
2482 of links, but is quite slow (it is noticeable when Emacs is
2483 making a list of file name completions). */
2484 BY_HANDLE_FILE_INFORMATION info
;
2486 if (GetFileInformationByHandle (fh
, &info
))
2488 buf
->st_nlink
= info
.nNumberOfLinks
;
2489 /* Might as well use file index to fake inode values, but this
2490 is not guaranteed to be unique unless we keep a handle open
2491 all the time (even then there are situations where it is
2492 not unique). Reputedly, there are at most 48 bits of info
2493 (on NTFS, presumably less on FAT). */
2494 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2502 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2504 buf
->st_mode
= _S_IFDIR
;
2508 switch (GetFileType (fh
))
2510 case FILE_TYPE_DISK
:
2511 buf
->st_mode
= _S_IFREG
;
2513 case FILE_TYPE_PIPE
:
2514 buf
->st_mode
= _S_IFIFO
;
2516 case FILE_TYPE_CHAR
:
2517 case FILE_TYPE_UNKNOWN
:
2519 buf
->st_mode
= _S_IFCHR
;
2526 /* Don't bother to make this information more accurate. */
2527 buf
->st_mode
= (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ?
2528 _S_IFDIR
: _S_IFREG
;
2534 /* Not sure if there is any point in this. */
2535 if (!NILP (Vw32_generate_fake_inodes
))
2536 fake_inode
= generate_inode_val (name
);
2537 else if (fake_inode
== 0)
2539 /* For want of something better, try to make everything unique. */
2540 static DWORD gen_num
= 0;
2541 fake_inode
= ++gen_num
;
2545 /* MSVC defines _ino_t to be short; other libc's might not. */
2546 if (sizeof (buf
->st_ino
) == 2)
2547 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2549 buf
->st_ino
= fake_inode
;
2551 /* consider files to belong to current user */
2552 buf
->st_uid
= the_passwd
.pw_uid
;
2553 buf
->st_gid
= the_passwd
.pw_gid
;
2555 /* volume_info is set indirectly by map_w32_filename */
2556 buf
->st_dev
= volume_info
.serialnum
;
2557 buf
->st_rdev
= volume_info
.serialnum
;
2560 buf
->st_size
= wfd
.nFileSizeLow
;
2562 /* Convert timestamps to Unix format. */
2563 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2564 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2565 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2566 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2567 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2569 /* determine rwx permissions */
2570 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2571 permission
= _S_IREAD
;
2573 permission
= _S_IREAD
| _S_IWRITE
;
2575 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2576 permission
|= _S_IEXEC
;
2577 else if (is_exec (name
))
2578 permission
|= _S_IEXEC
;
2580 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2585 /* Provide fstat and utime as well as stat for consistent handling of
2588 fstat (int desc
, struct stat
* buf
)
2590 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2591 BY_HANDLE_FILE_INFORMATION info
;
2595 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2597 case FILE_TYPE_DISK
:
2598 buf
->st_mode
= _S_IFREG
;
2599 if (!GetFileInformationByHandle (fh
, &info
))
2605 case FILE_TYPE_PIPE
:
2606 buf
->st_mode
= _S_IFIFO
;
2608 case FILE_TYPE_CHAR
:
2609 case FILE_TYPE_UNKNOWN
:
2611 buf
->st_mode
= _S_IFCHR
;
2613 memset (&info
, 0, sizeof (info
));
2614 info
.dwFileAttributes
= 0;
2615 info
.ftCreationTime
= utc_base_ft
;
2616 info
.ftLastAccessTime
= utc_base_ft
;
2617 info
.ftLastWriteTime
= utc_base_ft
;
2620 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2621 buf
->st_mode
= _S_IFDIR
;
2623 buf
->st_nlink
= info
.nNumberOfLinks
;
2624 /* Might as well use file index to fake inode values, but this
2625 is not guaranteed to be unique unless we keep a handle open
2626 all the time (even then there are situations where it is
2627 not unique). Reputedly, there are at most 48 bits of info
2628 (on NTFS, presumably less on FAT). */
2629 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2631 /* MSVC defines _ino_t to be short; other libc's might not. */
2632 if (sizeof (buf
->st_ino
) == 2)
2633 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2635 buf
->st_ino
= fake_inode
;
2637 /* consider files to belong to current user */
2641 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2642 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2644 buf
->st_size
= info
.nFileSizeLow
;
2646 /* Convert timestamps to Unix format. */
2647 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2648 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2649 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2650 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2651 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2653 /* determine rwx permissions */
2654 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2655 permission
= _S_IREAD
;
2657 permission
= _S_IREAD
| _S_IWRITE
;
2659 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2660 permission
|= _S_IEXEC
;
2663 #if 0 /* no way of knowing the filename */
2664 char * p
= strrchr (name
, '.');
2666 (stricmp (p
, ".exe") == 0 ||
2667 stricmp (p
, ".com") == 0 ||
2668 stricmp (p
, ".bat") == 0 ||
2669 stricmp (p
, ".cmd") == 0))
2670 permission
|= _S_IEXEC
;
2674 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2680 utime (const char *name
, struct utimbuf
*times
)
2682 struct utimbuf deftime
;
2689 deftime
.modtime
= deftime
.actime
= time (NULL
);
2693 /* Need write access to set times. */
2694 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2695 0, OPEN_EXISTING
, 0, NULL
);
2698 convert_from_time_t (times
->actime
, &atime
);
2699 convert_from_time_t (times
->modtime
, &mtime
);
2700 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2718 /* Wrappers for winsock functions to map between our file descriptors
2719 and winsock's handles; also set h_errno for convenience.
2721 To allow Emacs to run on systems which don't have winsock support
2722 installed, we dynamically link to winsock on startup if present, and
2723 otherwise provide the minimum necessary functionality
2724 (eg. gethostname). */
2726 /* function pointers for relevant socket functions */
2727 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2728 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2729 int (PASCAL
*pfn_WSAGetLastError
) (void);
2730 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
2731 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
2732 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
2733 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2734 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2735 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2736 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2737 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2738 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2739 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2740 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2741 int (PASCAL
*pfn_WSACleanup
) (void);
2743 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2744 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2745 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2746 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2747 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2748 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2749 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
2750 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2751 const char * optval
, int optlen
);
2752 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2753 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2755 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2756 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2757 struct sockaddr
* from
, int * fromlen
);
2758 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2759 const struct sockaddr
* to
, int tolen
);
2761 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2762 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2763 #ifndef HANDLE_FLAG_INHERIT
2764 #define HANDLE_FLAG_INHERIT 1
2768 static int winsock_inuse
;
2773 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2775 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2776 after WSAStartup returns successfully, but it seems reasonable
2777 to allow unloading winsock anyway in that case. */
2778 if (pfn_WSACleanup () == 0 ||
2779 pfn_WSAGetLastError () == WSAENETDOWN
)
2781 if (FreeLibrary (winsock_lib
))
2790 init_winsock (int load_now
)
2792 WSADATA winsockData
;
2794 if (winsock_lib
!= NULL
)
2797 pfn_SetHandleInformation
= NULL
;
2798 pfn_SetHandleInformation
2799 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2800 "SetHandleInformation");
2802 winsock_lib
= LoadLibrary ("Ws2_32.dll");
2804 if (winsock_lib
!= NULL
)
2806 /* dynamically link to socket functions */
2808 #define LOAD_PROC(fn) \
2809 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2812 LOAD_PROC( WSAStartup
);
2813 LOAD_PROC( WSASetLastError
);
2814 LOAD_PROC( WSAGetLastError
);
2815 LOAD_PROC( WSAEventSelect
);
2816 LOAD_PROC( WSACreateEvent
);
2817 LOAD_PROC( WSACloseEvent
);
2818 LOAD_PROC( socket
);
2820 LOAD_PROC( connect
);
2821 LOAD_PROC( ioctlsocket
);
2824 LOAD_PROC( closesocket
);
2825 LOAD_PROC( shutdown
);
2828 LOAD_PROC( inet_addr
);
2829 LOAD_PROC( gethostname
);
2830 LOAD_PROC( gethostbyname
);
2831 LOAD_PROC( getservbyname
);
2832 LOAD_PROC( getpeername
);
2833 LOAD_PROC( WSACleanup
);
2834 LOAD_PROC( setsockopt
);
2835 LOAD_PROC( listen
);
2836 LOAD_PROC( getsockname
);
2837 LOAD_PROC( accept
);
2838 LOAD_PROC( recvfrom
);
2839 LOAD_PROC( sendto
);
2842 /* specify version 1.1 of winsock */
2843 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2845 if (winsockData
.wVersion
!= 0x101)
2850 /* Report that winsock exists and is usable, but leave
2851 socket functions disabled. I am assuming that calling
2852 WSAStartup does not require any network interaction,
2853 and in particular does not cause or require a dial-up
2854 connection to be established. */
2857 FreeLibrary (winsock_lib
);
2865 FreeLibrary (winsock_lib
);
2875 /* function to set h_errno for compatability; map winsock error codes to
2876 normal system codes where they overlap (non-overlapping definitions
2877 are already in <sys/socket.h> */
2881 if (winsock_lib
== NULL
)
2884 h_errno
= pfn_WSAGetLastError ();
2888 case WSAEACCES
: h_errno
= EACCES
; break;
2889 case WSAEBADF
: h_errno
= EBADF
; break;
2890 case WSAEFAULT
: h_errno
= EFAULT
; break;
2891 case WSAEINTR
: h_errno
= EINTR
; break;
2892 case WSAEINVAL
: h_errno
= EINVAL
; break;
2893 case WSAEMFILE
: h_errno
= EMFILE
; break;
2894 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2895 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2903 if (h_errno
== 0 && winsock_lib
!= NULL
)
2904 pfn_WSASetLastError (0);
2907 /* Extend strerror to handle the winsock-specific error codes. */
2911 } _wsa_errlist
[] = {
2912 WSAEINTR
, "Interrupted function call",
2913 WSAEBADF
, "Bad file descriptor",
2914 WSAEACCES
, "Permission denied",
2915 WSAEFAULT
, "Bad address",
2916 WSAEINVAL
, "Invalid argument",
2917 WSAEMFILE
, "Too many open files",
2919 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2920 WSAEINPROGRESS
, "Operation now in progress",
2921 WSAEALREADY
, "Operation already in progress",
2922 WSAENOTSOCK
, "Socket operation on non-socket",
2923 WSAEDESTADDRREQ
, "Destination address required",
2924 WSAEMSGSIZE
, "Message too long",
2925 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2926 WSAENOPROTOOPT
, "Bad protocol option",
2927 WSAEPROTONOSUPPORT
, "Protocol not supported",
2928 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2929 WSAEOPNOTSUPP
, "Operation not supported",
2930 WSAEPFNOSUPPORT
, "Protocol family not supported",
2931 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2932 WSAEADDRINUSE
, "Address already in use",
2933 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2934 WSAENETDOWN
, "Network is down",
2935 WSAENETUNREACH
, "Network is unreachable",
2936 WSAENETRESET
, "Network dropped connection on reset",
2937 WSAECONNABORTED
, "Software caused connection abort",
2938 WSAECONNRESET
, "Connection reset by peer",
2939 WSAENOBUFS
, "No buffer space available",
2940 WSAEISCONN
, "Socket is already connected",
2941 WSAENOTCONN
, "Socket is not connected",
2942 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2943 WSAETOOMANYREFS
, "Too many references", /* not sure */
2944 WSAETIMEDOUT
, "Connection timed out",
2945 WSAECONNREFUSED
, "Connection refused",
2946 WSAELOOP
, "Network loop", /* not sure */
2947 WSAENAMETOOLONG
, "Name is too long",
2948 WSAEHOSTDOWN
, "Host is down",
2949 WSAEHOSTUNREACH
, "No route to host",
2950 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2951 WSAEPROCLIM
, "Too many processes",
2952 WSAEUSERS
, "Too many users", /* not sure */
2953 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2954 WSAESTALE
, "Data is stale", /* not sure */
2955 WSAEREMOTE
, "Remote error", /* not sure */
2957 WSASYSNOTREADY
, "Network subsystem is unavailable",
2958 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2959 WSANOTINITIALISED
, "Winsock not initialized successfully",
2960 WSAEDISCON
, "Graceful shutdown in progress",
2962 WSAENOMORE
, "No more operations allowed", /* not sure */
2963 WSAECANCELLED
, "Operation cancelled", /* not sure */
2964 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2965 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2966 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2967 WSASYSCALLFAILURE
, "System call failure",
2968 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2969 WSATYPE_NOT_FOUND
, "Class type not found",
2970 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2971 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2972 WSAEREFUSED
, "Operation refused", /* not sure */
2975 WSAHOST_NOT_FOUND
, "Host not found",
2976 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2977 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2978 WSANO_DATA
, "Valid name, no data record of requested type",
2984 sys_strerror(int error_no
)
2987 static char unknown_msg
[40];
2989 if (error_no
>= 0 && error_no
< sys_nerr
)
2990 return sys_errlist
[error_no
];
2992 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2993 if (_wsa_errlist
[i
].errnum
== error_no
)
2994 return _wsa_errlist
[i
].msg
;
2996 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
3000 /* [andrewi 3-May-96] I've had conflicting results using both methods,
3001 but I believe the method of keeping the socket handle separate (and
3002 insuring it is not inheritable) is the correct one. */
3004 //#define SOCK_REPLACE_HANDLE
3006 #ifdef SOCK_REPLACE_HANDLE
3007 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
3009 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
3012 int socket_to_fd (SOCKET s
);
3015 sys_socket(int af
, int type
, int protocol
)
3019 if (winsock_lib
== NULL
)
3022 return INVALID_SOCKET
;
3027 /* call the real socket function */
3028 s
= pfn_socket (af
, type
, protocol
);
3030 if (s
!= INVALID_SOCKET
)
3031 return socket_to_fd (s
);
3037 /* Convert a SOCKET to a file descriptor. */
3039 socket_to_fd (SOCKET s
)
3044 /* Although under NT 3.5 _open_osfhandle will accept a socket
3045 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
3046 that does not work under NT 3.1. However, we can get the same
3047 effect by using a backdoor function to replace an existing
3048 descriptor handle with the one we want. */
3050 /* allocate a file descriptor (with appropriate flags) */
3051 fd
= _open ("NUL:", _O_RDWR
);
3054 #ifdef SOCK_REPLACE_HANDLE
3055 /* now replace handle to NUL with our socket handle */
3056 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
3058 _set_osfhnd (fd
, s
);
3059 /* setmode (fd, _O_BINARY); */
3061 /* Make a non-inheritable copy of the socket handle. Note
3062 that it is possible that sockets aren't actually kernel
3063 handles, which appears to be the case on Windows 9x when
3064 the MS Proxy winsock client is installed. */
3066 /* Apparently there is a bug in NT 3.51 with some service
3067 packs, which prevents using DuplicateHandle to make a
3068 socket handle non-inheritable (causes WSACleanup to
3069 hang). The work-around is to use SetHandleInformation
3070 instead if it is available and implemented. */
3071 if (pfn_SetHandleInformation
)
3073 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
3077 HANDLE parent
= GetCurrentProcess ();
3078 HANDLE new_s
= INVALID_HANDLE_VALUE
;
3080 if (DuplicateHandle (parent
,
3086 DUPLICATE_SAME_ACCESS
))
3088 /* It is possible that DuplicateHandle succeeds even
3089 though the socket wasn't really a kernel handle,
3090 because a real handle has the same value. So
3091 test whether the new handle really is a socket. */
3092 long nonblocking
= 0;
3093 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
3095 pfn_closesocket (s
);
3100 CloseHandle (new_s
);
3105 fd_info
[fd
].hnd
= (HANDLE
) s
;
3108 /* set our own internal flags */
3109 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
3115 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3117 /* attach child_process to fd_info */
3118 if (fd_info
[ fd
].cp
!= NULL
)
3120 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
3124 fd_info
[ fd
].cp
= cp
;
3127 winsock_inuse
++; /* count open sockets */
3134 pfn_closesocket (s
);
3141 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
3143 if (winsock_lib
== NULL
)
3146 return SOCKET_ERROR
;
3150 if (fd_info
[s
].flags
& FILE_SOCKET
)
3152 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
3153 if (rc
== SOCKET_ERROR
)
3158 return SOCKET_ERROR
;
3163 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
3165 if (winsock_lib
== NULL
)
3168 return SOCKET_ERROR
;
3172 if (fd_info
[s
].flags
& FILE_SOCKET
)
3174 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
3175 if (rc
== SOCKET_ERROR
)
3180 return SOCKET_ERROR
;
3184 sys_htons (u_short hostshort
)
3186 return (winsock_lib
!= NULL
) ?
3187 pfn_htons (hostshort
) : hostshort
;
3191 sys_ntohs (u_short netshort
)
3193 return (winsock_lib
!= NULL
) ?
3194 pfn_ntohs (netshort
) : netshort
;
3198 sys_inet_addr (const char * cp
)
3200 return (winsock_lib
!= NULL
) ?
3201 pfn_inet_addr (cp
) : INADDR_NONE
;
3205 sys_gethostname (char * name
, int namelen
)
3207 if (winsock_lib
!= NULL
)
3208 return pfn_gethostname (name
, namelen
);
3210 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
3211 return !GetComputerName (name
, (DWORD
*)&namelen
);
3214 return SOCKET_ERROR
;
3218 sys_gethostbyname(const char * name
)
3220 struct hostent
* host
;
3222 if (winsock_lib
== NULL
)
3229 host
= pfn_gethostbyname (name
);
3236 sys_getservbyname(const char * name
, const char * proto
)
3238 struct servent
* serv
;
3240 if (winsock_lib
== NULL
)
3247 serv
= pfn_getservbyname (name
, proto
);
3254 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
3256 if (winsock_lib
== NULL
)
3259 return SOCKET_ERROR
;
3263 if (fd_info
[s
].flags
& FILE_SOCKET
)
3265 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
3266 if (rc
== SOCKET_ERROR
)
3271 return SOCKET_ERROR
;
3276 sys_shutdown (int s
, int how
)
3278 if (winsock_lib
== NULL
)
3281 return SOCKET_ERROR
;
3285 if (fd_info
[s
].flags
& FILE_SOCKET
)
3287 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
3288 if (rc
== SOCKET_ERROR
)
3293 return SOCKET_ERROR
;
3297 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
3299 if (winsock_lib
== NULL
)
3302 return SOCKET_ERROR
;
3306 if (fd_info
[s
].flags
& FILE_SOCKET
)
3308 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
3309 (const char *)optval
, optlen
);
3310 if (rc
== SOCKET_ERROR
)
3315 return SOCKET_ERROR
;
3319 sys_listen (int s
, int backlog
)
3321 if (winsock_lib
== NULL
)
3324 return SOCKET_ERROR
;
3328 if (fd_info
[s
].flags
& FILE_SOCKET
)
3330 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
3331 if (rc
== SOCKET_ERROR
)
3334 fd_info
[s
].flags
|= FILE_LISTEN
;
3338 return SOCKET_ERROR
;
3342 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
3344 if (winsock_lib
== NULL
)
3347 return SOCKET_ERROR
;
3351 if (fd_info
[s
].flags
& FILE_SOCKET
)
3353 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3354 if (rc
== SOCKET_ERROR
)
3359 return SOCKET_ERROR
;
3363 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3365 if (winsock_lib
== NULL
)
3372 if (fd_info
[s
].flags
& FILE_LISTEN
)
3374 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3376 if (t
== INVALID_SOCKET
)
3379 fd
= socket_to_fd (t
);
3381 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3382 ResetEvent (fd_info
[s
].cp
->char_avail
);
3390 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3391 struct sockaddr
* from
, int * fromlen
)
3393 if (winsock_lib
== NULL
)
3396 return SOCKET_ERROR
;
3400 if (fd_info
[s
].flags
& FILE_SOCKET
)
3402 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3403 if (rc
== SOCKET_ERROR
)
3408 return SOCKET_ERROR
;
3412 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3413 const struct sockaddr
* to
, int tolen
)
3415 if (winsock_lib
== NULL
)
3418 return SOCKET_ERROR
;
3422 if (fd_info
[s
].flags
& FILE_SOCKET
)
3424 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3425 if (rc
== SOCKET_ERROR
)
3430 return SOCKET_ERROR
;
3433 /* Windows does not have an fcntl function. Provide an implementation
3434 solely for making sockets non-blocking. */
3436 fcntl (int s
, int cmd
, int options
)
3438 if (winsock_lib
== NULL
)
3445 if (fd_info
[s
].flags
& FILE_SOCKET
)
3447 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
3449 unsigned long nblock
= 1;
3450 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
3451 if (rc
== SOCKET_ERROR
)
3453 /* Keep track of the fact that we set this to non-blocking. */
3454 fd_info
[s
].flags
|= FILE_NDELAY
;
3460 return SOCKET_ERROR
;
3464 return SOCKET_ERROR
;
3467 #endif /* HAVE_SOCKETS */
3470 /* Shadow main io functions: we need to handle pipes and sockets more
3471 intelligently, and implement non-blocking mode as well. */
3484 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
3486 child_process
* cp
= fd_info
[fd
].cp
;
3488 fd_info
[fd
].cp
= NULL
;
3490 if (CHILD_ACTIVE (cp
))
3492 /* if last descriptor to active child_process then cleanup */
3494 for (i
= 0; i
< MAXDESC
; i
++)
3498 if (fd_info
[i
].cp
== cp
)
3504 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3506 #ifndef SOCK_REPLACE_HANDLE
3507 if (winsock_lib
== NULL
) abort ();
3509 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3510 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3512 winsock_inuse
--; /* count open sockets */
3520 /* Note that sockets do not need special treatment here (at least on
3521 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3522 closesocket is equivalent to CloseHandle, which is to be expected
3523 because socket handles are fully fledged kernel handles. */
3526 if (rc
== 0 && fd
< MAXDESC
)
3527 fd_info
[fd
].flags
= 0;
3538 if (new_fd
>= 0 && new_fd
< MAXDESC
)
3540 /* duplicate our internal info as well */
3541 fd_info
[new_fd
] = fd_info
[fd
];
3548 sys_dup2 (int src
, int dst
)
3552 if (dst
< 0 || dst
>= MAXDESC
)
3558 /* make sure we close the destination first if it's a pipe or socket */
3559 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3562 rc
= _dup2 (src
, dst
);
3565 /* duplicate our internal info as well */
3566 fd_info
[dst
] = fd_info
[src
];
3571 /* Unix pipe() has only one arg */
3573 sys_pipe (int * phandles
)
3578 /* make pipe handles non-inheritable; when we spawn a child, we
3579 replace the relevant handle with an inheritable one. Also put
3580 pipes into binary mode; we will do text mode translation ourselves
3582 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3586 /* Protect against overflow, since Windows can open more handles than
3587 our fd_info array has room for. */
3588 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
3590 _close (phandles
[0]);
3591 _close (phandles
[1]);
3596 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3597 fd_info
[phandles
[0]].flags
= flags
;
3599 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3600 fd_info
[phandles
[1]].flags
= flags
;
3608 extern int w32_pipe_read_delay
;
3610 /* Function to do blocking read of one byte, needed to implement
3611 select. It is only allowed on sockets and pipes. */
3613 _sys_read_ahead (int fd
)
3618 if (fd
< 0 || fd
>= MAXDESC
)
3619 return STATUS_READ_ERROR
;
3621 cp
= fd_info
[fd
].cp
;
3623 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3624 return STATUS_READ_ERROR
;
3626 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3627 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3629 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3633 cp
->status
= STATUS_READ_IN_PROGRESS
;
3635 if (fd_info
[fd
].flags
& FILE_PIPE
)
3637 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3639 /* Give subprocess time to buffer some more output for us before
3640 reporting that input is available; we need this because Windows 95
3641 connects DOS programs to pipes by making the pipe appear to be
3642 the normal console stdout - as a result most DOS programs will
3643 write to stdout without buffering, ie. one character at a
3644 time. Even some W32 programs do this - "dir" in a command
3645 shell on NT is very slow if we don't do this. */
3648 int wait
= w32_pipe_read_delay
;
3654 /* Yield remainder of our time slice, effectively giving a
3655 temporary priority boost to the child process. */
3660 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3662 unsigned long nblock
= 0;
3663 /* We always want this to block, so temporarily disable NDELAY. */
3664 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3665 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3667 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3669 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3672 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3677 if (rc
== sizeof (char))
3678 cp
->status
= STATUS_READ_SUCCEEDED
;
3680 cp
->status
= STATUS_READ_FAILED
;
3686 _sys_wait_accept (int fd
)
3692 if (fd
< 0 || fd
>= MAXDESC
)
3693 return STATUS_READ_ERROR
;
3695 cp
= fd_info
[fd
].cp
;
3697 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3698 return STATUS_READ_ERROR
;
3700 cp
->status
= STATUS_READ_FAILED
;
3702 hEv
= pfn_WSACreateEvent ();
3703 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
3704 if (rc
!= SOCKET_ERROR
)
3706 rc
= WaitForSingleObject (hEv
, INFINITE
);
3707 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
3708 if (rc
== WAIT_OBJECT_0
)
3709 cp
->status
= STATUS_READ_SUCCEEDED
;
3711 pfn_WSACloseEvent (hEv
);
3717 sys_read (int fd
, char * buffer
, unsigned int count
)
3722 char * orig_buffer
= buffer
;
3730 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3732 child_process
*cp
= fd_info
[fd
].cp
;
3734 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3742 /* re-read CR carried over from last read */
3743 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3745 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3749 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3752 /* presence of a child_process structure means we are operating in
3753 non-blocking mode - otherwise we just call _read directly.
3754 Note that the child_process structure might be missing because
3755 reap_subprocess has been called; in this case the pipe is
3756 already broken, so calling _read on it is okay. */
3759 int current_status
= cp
->status
;
3761 switch (current_status
)
3763 case STATUS_READ_FAILED
:
3764 case STATUS_READ_ERROR
:
3765 /* report normal EOF if nothing in buffer */
3767 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3770 case STATUS_READ_READY
:
3771 case STATUS_READ_IN_PROGRESS
:
3772 DebPrint (("sys_read called when read is in progress\n"));
3773 errno
= EWOULDBLOCK
;
3776 case STATUS_READ_SUCCEEDED
:
3777 /* consume read-ahead char */
3778 *buffer
++ = cp
->chr
;
3781 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3782 ResetEvent (cp
->char_avail
);
3784 case STATUS_READ_ACKNOWLEDGED
:
3788 DebPrint (("sys_read: bad status %d\n", current_status
));
3793 if (fd_info
[fd
].flags
& FILE_PIPE
)
3795 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3796 to_read
= min (waiting
, (DWORD
) count
);
3799 nchars
+= _read (fd
, buffer
, to_read
);
3802 else /* FILE_SOCKET */
3804 if (winsock_lib
== NULL
) abort ();
3806 /* do the equivalent of a non-blocking read */
3807 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3808 if (waiting
== 0 && nchars
== 0)
3810 h_errno
= errno
= EWOULDBLOCK
;
3816 /* always use binary mode for sockets */
3817 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3818 if (res
== SOCKET_ERROR
)
3820 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3821 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3832 int nread
= _read (fd
, buffer
, count
);
3835 else if (nchars
== 0)
3840 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3841 /* Perform text mode translation if required. */
3842 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3844 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3845 /* If buffer contains only CR, return that. To be absolutely
3846 sure we should attempt to read the next char, but in
3847 practice a CR to be followed by LF would not appear by
3848 itself in the buffer. */
3849 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3851 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3857 nchars
= _read (fd
, buffer
, count
);
3862 /* For now, don't bother with a non-blocking mode */
3864 sys_write (int fd
, const void * buffer
, unsigned int count
)
3874 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3876 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3882 /* Perform text mode translation if required. */
3883 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3885 char * tmpbuf
= alloca (count
* 2);
3886 unsigned char * src
= (void *)buffer
;
3887 unsigned char * dst
= tmpbuf
;
3892 unsigned char *next
;
3893 /* copy next line or remaining bytes */
3894 next
= _memccpy (dst
, src
, '\n', nbytes
);
3897 /* copied one line ending with '\n' */
3898 int copied
= next
- dst
;
3901 /* insert '\r' before '\n' */
3908 /* copied remaining partial line -> now finished */
3916 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
3918 unsigned long nblock
= 0;
3919 if (winsock_lib
== NULL
) abort ();
3921 /* TODO: implement select() properly so non-blocking I/O works. */
3922 /* For now, make sure the write blocks. */
3923 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3924 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3926 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3928 /* Set the socket back to non-blocking if it was before,
3929 for other operations that support it. */
3930 if (fd_info
[fd
].flags
& FILE_NDELAY
)
3933 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
3936 if (nchars
== SOCKET_ERROR
)
3938 DebPrint(("sys_write.send failed with error %d on socket %ld\n",
3939 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3945 nchars
= _write (fd
, buffer
, count
);
3951 check_windows_init_file ()
3953 extern int noninteractive
, inhibit_window_system
;
3955 /* A common indication that Emacs is not installed properly is when
3956 it cannot find the Windows installation file. If this file does
3957 not exist in the expected place, tell the user. */
3959 if (!noninteractive
&& !inhibit_window_system
)
3961 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3962 Lisp_Object objs
[2];
3963 Lisp_Object full_load_path
;
3964 Lisp_Object init_file
;
3967 objs
[0] = Vload_path
;
3968 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3969 full_load_path
= Fappend (2, objs
);
3970 init_file
= build_string ("term/w32-win");
3971 fd
= openp (full_load_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
3974 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3975 char *init_file_name
= SDATA (init_file
);
3976 char *load_path
= SDATA (load_path_print
);
3977 char *buffer
= alloca (1024
3978 + strlen (init_file_name
)
3979 + strlen (load_path
));
3982 "The Emacs Windows initialization file \"%s.el\" "
3983 "could not be found in your Emacs installation. "
3984 "Emacs checked the following directories for this file:\n"
3986 "When Emacs cannot find this file, it usually means that it "
3987 "was not installed properly, or its distribution file was "
3988 "not unpacked properly.\nSee the README.W32 file in the "
3989 "top-level Emacs directory for more information.",
3990 init_file_name
, load_path
);
3993 "Emacs Abort Dialog",
3994 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3995 /* Use the low-level Emacs abort. */
4010 /* shutdown the socket interface if necessary */
4021 /* Initialise the socket interface now if available and requested by
4022 the user by defining PRELOAD_WINSOCK; otherwise loading will be
4023 delayed until open-network-stream is called (w32-has-winsock can
4024 also be used to dynamically load or reload winsock).
4026 Conveniently, init_environment is called before us, so
4027 PRELOAD_WINSOCK can be set in the registry. */
4029 /* Always initialize this correctly. */
4032 if (getenv ("PRELOAD_WINSOCK") != NULL
)
4033 init_winsock (TRUE
);
4036 /* Initial preparation for subprocess support: replace our standard
4037 handles with non-inheritable versions. */
4040 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
4041 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
4042 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
4044 parent
= GetCurrentProcess ();
4046 /* ignore errors when duplicating and closing; typically the
4047 handles will be invalid when running as a gui program. */
4048 DuplicateHandle (parent
,
4049 GetStdHandle (STD_INPUT_HANDLE
),
4054 DUPLICATE_SAME_ACCESS
);
4056 DuplicateHandle (parent
,
4057 GetStdHandle (STD_OUTPUT_HANDLE
),
4062 DUPLICATE_SAME_ACCESS
);
4064 DuplicateHandle (parent
,
4065 GetStdHandle (STD_ERROR_HANDLE
),
4070 DUPLICATE_SAME_ACCESS
);
4076 if (stdin_save
!= INVALID_HANDLE_VALUE
)
4077 _open_osfhandle ((long) stdin_save
, O_TEXT
);
4079 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
4082 if (stdout_save
!= INVALID_HANDLE_VALUE
)
4083 _open_osfhandle ((long) stdout_save
, O_TEXT
);
4085 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4088 if (stderr_save
!= INVALID_HANDLE_VALUE
)
4089 _open_osfhandle ((long) stderr_save
, O_TEXT
);
4091 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
4095 /* unfortunately, atexit depends on implementation of malloc */
4096 /* atexit (term_ntproc); */
4097 signal (SIGABRT
, term_ntproc
);
4099 /* determine which drives are fixed, for GetCachedVolumeInformation */
4101 /* GetDriveType must have trailing backslash. */
4102 char drive
[] = "A:\\";
4104 /* Loop over all possible drive letters */
4105 while (*drive
<= 'Z')
4107 /* Record if this drive letter refers to a fixed drive. */
4108 fixed_drives
[DRIVE_INDEX (*drive
)] =
4109 (GetDriveType (drive
) == DRIVE_FIXED
);
4114 /* Reset the volume info cache. */
4115 volume_cache
= NULL
;
4118 /* Check to see if Emacs has been installed correctly. */
4119 check_windows_init_file ();
4123 shutdown_handler ensures that buffers' autosave files are
4124 up to date when the user logs off, or the system shuts down.
4126 BOOL WINAPI
shutdown_handler(DWORD type
)
4128 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
4129 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
4130 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
4131 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
4133 /* Shut down cleanly, making sure autosave files are up to date. */
4134 shut_down_emacs (0, 0, Qnil
);
4137 /* Allow other handlers to handle this signal. */
4142 globals_of_w32 is used to initialize those global variables that
4143 must always be initialized on startup even when the global variable
4144 initialized is non zero (see the function main in emacs.c).
4149 g_b_init_is_windows_9x
= 0;
4150 g_b_init_open_process_token
= 0;
4151 g_b_init_get_token_information
= 0;
4152 g_b_init_lookup_account_sid
= 0;
4153 g_b_init_get_sid_identifier_authority
= 0;
4154 /* The following sets a handler for shutdown notifications for
4155 console apps. This actually applies to Emacs in both console and
4156 GUI modes, since we had to fool windows into thinking emacs is a
4157 console application to get console mode to work. */
4158 SetConsoleCtrlHandler(shutdown_handler
, TRUE
);
4163 /* arch-tag: 90442dd3-37be-482b-b272-ac752e3049f1
4164 (do not change this comment) */