1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994, 1995, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
25 #include <stddef.h> /* for offsetof */
35 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
67 #define _ANONYMOUS_UNION
68 #define _ANONYMOUS_STRUCT
72 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
73 #include <sys/socket.h>
91 extern Lisp_Object Vw32_downcase_file_names
;
92 extern Lisp_Object Vw32_generate_fake_inodes
;
93 extern Lisp_Object Vw32_get_true_file_attributes
;
94 extern Lisp_Object Vw32_num_mouse_buttons
;
97 /* Equivalent of strerror for W32 error codes. */
99 w32_strerror (int error_no
)
101 static char buf
[500];
104 error_no
= GetLastError ();
107 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
109 0, /* choose most suitable language */
110 buf
, sizeof (buf
), NULL
))
111 sprintf (buf
, "w32 error %u", error_no
);
115 static char startup_dir
[MAXPATHLEN
];
117 /* Get the current working directory. */
122 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
126 /* Emacs doesn't actually change directory itself, and we want to
127 force our real wd to be where emacs.exe is to avoid unnecessary
128 conflicts when trying to rename or delete directories. */
129 strcpy (dir
, startup_dir
);
135 /* Emulate gethostname. */
137 gethostname (char *buffer
, int size
)
139 /* NT only allows small host names, so the buffer is
140 certainly large enough. */
141 return !GetComputerName (buffer
, &size
);
143 #endif /* HAVE_SOCKETS */
145 /* Emulate getloadavg. */
147 getloadavg (double loadavg
[], int nelem
)
151 /* A faithful emulation is going to have to be saved for a rainy day. */
152 for (i
= 0; i
< nelem
; i
++)
159 /* Emulate getpwuid, getpwnam and others. */
161 #define PASSWD_FIELD_SIZE 256
163 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
164 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
165 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
166 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
167 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
169 static struct passwd the_passwd
=
184 return the_passwd
.pw_uid
;
190 /* I could imagine arguing for checking to see whether the user is
191 in the Administrators group and returning a UID of 0 for that
192 case, but I don't know how wise that would be in the long run. */
199 return the_passwd
.pw_gid
;
211 if (uid
== the_passwd
.pw_uid
)
217 getpwnam (char *name
)
221 pw
= getpwuid (getuid ());
225 if (stricmp (name
, pw
->pw_name
))
234 /* Find the user's real name by opening the process token and
235 looking up the name associated with the user-sid in that token.
237 Use the relative portion of the identifier authority value from
238 the user-sid as the user id value (same for group id using the
239 primary group sid from the process token). */
241 char user_sid
[256], name
[256], domain
[256];
242 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
244 SID_NAME_USE user_type
;
246 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY
, &token
)
247 && GetTokenInformation (token
, TokenUser
,
248 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
249 && LookupAccountSid (NULL
, *((PSID
*) user_sid
), name
, &length
,
250 domain
, &dlength
, &user_type
))
252 strcpy (the_passwd
.pw_name
, name
);
253 /* Determine a reasonable uid value. */
254 if (stricmp ("administrator", name
) == 0)
256 the_passwd
.pw_uid
= 0;
257 the_passwd
.pw_gid
= 0;
261 SID_IDENTIFIER_AUTHORITY
* pSIA
;
263 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
264 /* I believe the relative portion is the last 4 bytes (of 6)
266 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
267 (pSIA
->Value
[3] << 16) +
268 (pSIA
->Value
[4] << 8) +
269 (pSIA
->Value
[5] << 0));
270 /* restrict to conventional uid range for normal users */
271 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
274 if (GetTokenInformation (token
, TokenPrimaryGroup
,
275 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
277 SID_IDENTIFIER_AUTHORITY
* pSIA
;
279 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
280 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
281 (pSIA
->Value
[3] << 16) +
282 (pSIA
->Value
[4] << 8) +
283 (pSIA
->Value
[5] << 0));
284 /* I don't know if this is necessary, but for safety... */
285 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
288 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
291 /* If security calls are not supported (presumably because we
292 are running under Windows 95), fallback to this. */
293 else if (GetUserName (name
, &length
))
295 strcpy (the_passwd
.pw_name
, name
);
296 if (stricmp ("administrator", name
) == 0)
297 the_passwd
.pw_uid
= 0;
299 the_passwd
.pw_uid
= 123;
300 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
304 strcpy (the_passwd
.pw_name
, "unknown");
305 the_passwd
.pw_uid
= 123;
306 the_passwd
.pw_gid
= 123;
309 /* Ensure HOME and SHELL are defined. */
310 if (getenv ("HOME") == NULL
)
312 if (getenv ("SHELL") == NULL
)
315 /* Set dir and shell from environment variables. */
316 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
317 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
326 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
327 return ((rand () << 15) | rand ());
337 /* Normalize filename by converting all path separators to
338 the specified separator. Also conditionally convert upper
339 case path name components to lower case. */
342 normalize_filename (fp
, path_sep
)
349 /* Always lower-case drive letters a-z, even if the filesystem
350 preserves case in filenames.
351 This is so filenames can be compared by string comparison
352 functions that are case-sensitive. Even case-preserving filesystems
353 do not distinguish case in drive letters. */
354 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
360 if (NILP (Vw32_downcase_file_names
))
364 if (*fp
== '/' || *fp
== '\\')
371 sep
= path_sep
; /* convert to this path separator */
372 elem
= fp
; /* start of current path element */
375 if (*fp
>= 'a' && *fp
<= 'z')
376 elem
= 0; /* don't convert this element */
378 if (*fp
== 0 || *fp
== ':')
380 sep
= *fp
; /* restore current separator (or 0) */
381 *fp
= '/'; /* after conversion of this element */
384 if (*fp
== '/' || *fp
== '\\')
386 if (elem
&& elem
!= fp
)
388 *fp
= 0; /* temporary end of string */
389 _strlwr (elem
); /* while we convert to lower case */
391 *fp
= sep
; /* convert (or restore) path separator */
392 elem
= fp
+ 1; /* next element starts after separator */
398 /* Destructively turn backslashes into slashes. */
400 dostounix_filename (p
)
403 normalize_filename (p
, '/');
406 /* Destructively turn slashes into backslashes. */
408 unixtodos_filename (p
)
411 normalize_filename (p
, '\\');
414 /* Remove all CR's that are followed by a LF.
415 (From msdos.c...probably should figure out a way to share it,
416 although this code isn't going to ever change.) */
420 register unsigned char *buf
;
422 unsigned char *np
= buf
;
423 unsigned char *startp
= buf
;
424 unsigned char *endp
= buf
+ n
;
428 while (buf
< endp
- 1)
432 if (*(++buf
) != 0x0a)
443 /* Parse the root part of file name, if present. Return length and
444 optionally store pointer to char after root. */
446 parse_root (char * name
, char ** pPath
)
453 /* find the root name of the volume if given */
454 if (isalpha (name
[0]) && name
[1] == ':')
456 /* skip past drive specifier */
458 if (IS_DIRECTORY_SEP (name
[0]))
461 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
467 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
472 if (IS_DIRECTORY_SEP (name
[0]))
482 /* Get long base name for name; name is assumed to be absolute. */
484 get_long_basename (char * name
, char * buf
, int size
)
486 WIN32_FIND_DATA find_data
;
490 /* must be valid filename, no wild cards or other invalid characters */
491 if (strpbrk (name
, "*?|<>\""))
494 dir_handle
= FindFirstFile (name
, &find_data
);
495 if (dir_handle
!= INVALID_HANDLE_VALUE
)
497 if ((len
= strlen (find_data
.cFileName
)) < size
)
498 memcpy (buf
, find_data
.cFileName
, len
+ 1);
501 FindClose (dir_handle
);
506 /* Get long name for file, if possible (assumed to be absolute). */
508 w32_get_long_filename (char * name
, char * buf
, int size
)
513 char full
[ MAX_PATH
];
520 /* Use local copy for destructive modification. */
521 memcpy (full
, name
, len
+1);
522 unixtodos_filename (full
);
524 /* Copy root part verbatim. */
525 len
= parse_root (full
, &p
);
526 memcpy (o
, full
, len
);
531 while (p
!= NULL
&& *p
)
534 p
= strchr (q
, '\\');
536 len
= get_long_basename (full
, o
, size
);
559 is_unc_volume (const char *filename
)
561 const char *ptr
= filename
;
563 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
566 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
572 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
575 sigsetmask (int signal_mask
)
599 setpgrp (int pid
, int gid
)
611 unrequest_sigio (void)
622 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
625 w32_get_resource (key
, lpdwtype
)
630 HKEY hrootkey
= NULL
;
634 /* Check both the current user and the local machine to see if
635 we have any resources. */
637 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
641 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
642 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
643 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
648 if (lpvalue
) xfree (lpvalue
);
650 RegCloseKey (hrootkey
);
653 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
657 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
658 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
659 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
664 if (lpvalue
) xfree (lpvalue
);
666 RegCloseKey (hrootkey
);
672 char *get_emacs_configuration (void);
673 extern Lisp_Object Vsystem_configuration
;
676 init_environment (char ** argv
)
678 static const char * const tempdirs
[] = {
679 "$TMPDIR", "$TEMP", "$TMP", "c:/"
682 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
684 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
685 temporary files and assume "/tmp" if $TMPDIR is unset, which
686 will break on DOS/Windows. Refuse to work if we cannot find
687 a directory, not even "c:/", usable for that purpose. */
688 for (i
= 0; i
< imax
; i
++)
690 const char *tmp
= tempdirs
[i
];
693 tmp
= getenv (tmp
+ 1);
694 /* Note that `access' can lie to us if the directory resides on a
695 read-only filesystem, like CD-ROM or a write-protected floppy.
696 The only way to be really sure is to actually create a file and
697 see if it succeeds. But I think that's too much to ask. */
698 if (tmp
&& _access (tmp
, D_OK
) == 0)
700 char * var
= alloca (strlen (tmp
) + 8);
701 sprintf (var
, "TMPDIR=%s", tmp
);
702 _putenv (strdup (var
));
709 Fcons (build_string ("no usable temporary directories found!!"),
711 "While setting TMPDIR: ");
713 /* Check for environment variables and use registry settings if they
714 don't exist. Fallback on default values where applicable. */
719 char locale_name
[32];
721 static struct env_entry
728 {"PRELOAD_WINSOCK", NULL
},
729 {"emacs_dir", "C:/emacs"},
730 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
731 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
732 {"EMACSDATA", "%emacs_dir%/etc"},
733 {"EMACSPATH", "%emacs_dir%/bin"},
734 {"EMACSLOCKDIR", "%emacs_dir%/lock"},
735 /* We no longer set INFOPATH because Info-default-directory-list
737 /* {"INFOPATH", "%emacs_dir%/info"}, */
738 {"EMACSDOC", "%emacs_dir%/etc"},
743 /* Get default locale info and use it for LANG. */
744 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
745 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
746 locale_name
, sizeof (locale_name
)))
748 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
750 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
752 env_vars
[i
].def_value
= locale_name
;
758 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
760 /* Treat emacs_dir specially: set it unconditionally based on our
761 location, if it appears that we are running from the bin subdir
762 of a standard installation. */
765 char modname
[MAX_PATH
];
767 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
769 if ((p
= strrchr (modname
, '\\')) == NULL
)
773 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
775 char buf
[SET_ENV_BUF_SIZE
];
778 for (p
= modname
; *p
; p
++)
779 if (*p
== '\\') *p
= '/';
781 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
782 _putenv (strdup (buf
));
786 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
788 if (!getenv (env_vars
[i
].name
))
792 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
)
794 lpval
= env_vars
[i
].def_value
;
795 dwType
= REG_EXPAND_SZ
;
801 if (dwType
== REG_EXPAND_SZ
)
803 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
805 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
806 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
, buf1
);
807 _putenv (strdup (buf2
));
809 else if (dwType
== REG_SZ
)
811 char buf
[SET_ENV_BUF_SIZE
];
813 _snprintf (buf
, sizeof(buf
)-1, "%s=%s", env_vars
[i
].name
, lpval
);
814 _putenv (strdup (buf
));
824 /* Rebuild system configuration to reflect invoking system. */
825 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
827 /* Another special case: on NT, the PATH variable is actually named
828 "Path" although cmd.exe (perhaps NT itself) arranges for
829 environment variable lookup and setting to be case insensitive.
830 However, Emacs assumes a fully case sensitive environment, so we
831 need to change "Path" to "PATH" to match the expectations of
832 various elisp packages. We do this by the sneaky method of
833 modifying the string in the C runtime environ entry.
835 The same applies to COMSPEC. */
839 for (envp
= environ
; *envp
; envp
++)
840 if (_strnicmp (*envp
, "PATH=", 5) == 0)
841 memcpy (*envp
, "PATH=", 5);
842 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
843 memcpy (*envp
, "COMSPEC=", 8);
846 /* Remember the initial working directory for getwd, then make the
847 real wd be the location of emacs.exe to avoid conflicts when
848 renaming or deleting directories. (We also don't call chdir when
849 running subprocesses for the same reason.) */
850 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
855 static char modname
[MAX_PATH
];
857 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
859 if ((p
= strrchr (modname
, '\\')) == NULL
)
863 SetCurrentDirectory (modname
);
865 /* Ensure argv[0] has the full path to Emacs. */
870 /* Determine if there is a middle mouse button, to allow parse_button
871 to decide whether right mouse events should be mouse-2 or
873 XSETINT (Vw32_num_mouse_buttons
, GetSystemMetrics (SM_CMOUSEBUTTONS
));
878 /* We don't have scripts to automatically determine the system configuration
879 for Emacs before it's compiled, and we don't want to have to make the
880 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
884 get_emacs_configuration (void)
886 char *arch
, *oem
, *os
;
888 static char configuration_buffer
[32];
890 /* Determine the processor type. */
891 switch (get_processor_type ())
894 #ifdef PROCESSOR_INTEL_386
895 case PROCESSOR_INTEL_386
:
896 case PROCESSOR_INTEL_486
:
897 case PROCESSOR_INTEL_PENTIUM
:
902 #ifdef PROCESSOR_INTEL_860
903 case PROCESSOR_INTEL_860
:
908 #ifdef PROCESSOR_MIPS_R2000
909 case PROCESSOR_MIPS_R2000
:
910 case PROCESSOR_MIPS_R3000
:
911 case PROCESSOR_MIPS_R4000
:
916 #ifdef PROCESSOR_ALPHA_21064
917 case PROCESSOR_ALPHA_21064
:
927 /* Use the OEM field to reflect the compiler/library combination. */
929 #define COMPILER_NAME "msvc"
932 #define COMPILER_NAME "mingw"
934 #define COMPILER_NAME "unknown"
939 switch (osinfo_cache
.dwPlatformId
) {
940 case VER_PLATFORM_WIN32_NT
:
942 build_num
= osinfo_cache
.dwBuildNumber
;
944 case VER_PLATFORM_WIN32_WINDOWS
:
945 if (osinfo_cache
.dwMinorVersion
== 0) {
950 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
952 case VER_PLATFORM_WIN32s
:
953 /* Not supported, should not happen. */
955 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
963 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
964 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
965 get_w32_major_version (), get_w32_minor_version (), build_num
);
967 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
970 return configuration_buffer
;
974 get_emacs_configuration_options (void)
976 static char options_buffer
[256];
978 /* Work out the effective configure options for this build. */
980 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
983 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
985 #define COMPILER_VERSION ""
989 sprintf (options_buffer
, COMPILER_VERSION
);
991 strcat (options_buffer
, " --no-opt");
994 strcat (options_buffer
, " --cflags");
995 strcat (options_buffer
, USER_CFLAGS
);
998 strcat (options_buffer
, " --ldflags");
999 strcat (options_buffer
, USER_LDFLAGS
);
1001 return options_buffer
;
1005 #include <sys/timeb.h>
1007 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1009 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1014 tv
->tv_sec
= tb
.time
;
1015 tv
->tv_usec
= tb
.millitm
* 1000L;
1018 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1019 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1023 /* ------------------------------------------------------------------------- */
1024 /* IO support and wrapper functions for W32 API. */
1025 /* ------------------------------------------------------------------------- */
1027 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1028 on network directories, so we handle that case here.
1029 (Ulrich Leodolter, 1/11/95). */
1031 sys_ctime (const time_t *t
)
1033 char *str
= (char *) ctime (t
);
1034 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1037 /* Emulate sleep...we could have done this with a define, but that
1038 would necessitate including windows.h in the files that used it.
1039 This is much easier. */
1041 sys_sleep (int seconds
)
1043 Sleep (seconds
* 1000);
1046 /* Internal MSVC functions for low-level descriptor munging */
1047 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1048 extern int __cdecl
_free_osfhnd (int fd
);
1050 /* parallel array of private info on file handles */
1051 filedesc fd_info
[ MAXDESC
];
1053 typedef struct volume_info_data
{
1054 struct volume_info_data
* next
;
1056 /* time when info was obtained */
1059 /* actual volume info */
1068 /* Global referenced by various functions. */
1069 static volume_info_data volume_info
;
1071 /* Vector to indicate which drives are local and fixed (for which cached
1072 data never expires). */
1073 static BOOL fixed_drives
[26];
1075 /* Consider cached volume information to be stale if older than 10s,
1076 at least for non-local drives. Info for fixed drives is never stale. */
1077 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1078 #define VOLINFO_STILL_VALID( root_dir, info ) \
1079 ( ( isalpha (root_dir[0]) && \
1080 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1081 || GetTickCount () - info->timestamp < 10000 )
1083 /* Cache support functions. */
1085 /* Simple linked list with linear search is sufficient. */
1086 static volume_info_data
*volume_cache
= NULL
;
1088 static volume_info_data
*
1089 lookup_volume_info (char * root_dir
)
1091 volume_info_data
* info
;
1093 for (info
= volume_cache
; info
; info
= info
->next
)
1094 if (stricmp (info
->root_dir
, root_dir
) == 0)
1100 add_volume_info (char * root_dir
, volume_info_data
* info
)
1102 info
->root_dir
= xstrdup (root_dir
);
1103 info
->next
= volume_cache
;
1104 volume_cache
= info
;
1108 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1109 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1110 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1112 GetCachedVolumeInformation (char * root_dir
)
1114 volume_info_data
* info
;
1115 char default_root
[ MAX_PATH
];
1117 /* NULL for root_dir means use root from current directory. */
1118 if (root_dir
== NULL
)
1120 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1122 parse_root (default_root
, &root_dir
);
1124 root_dir
= default_root
;
1127 /* Local fixed drives can be cached permanently. Removable drives
1128 cannot be cached permanently, since the volume name and serial
1129 number (if nothing else) can change. Remote drives should be
1130 treated as if they are removable, since there is no sure way to
1131 tell whether they are or not. Also, the UNC association of drive
1132 letters mapped to remote volumes can be changed at any time (even
1133 by other processes) without notice.
1135 As a compromise, so we can benefit from caching info for remote
1136 volumes, we use a simple expiry mechanism to invalidate cache
1137 entries that are more than ten seconds old. */
1140 /* No point doing this, because WNetGetConnection is even slower than
1141 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1142 GetDriveType is about the only call of this type which does not
1143 involve network access, and so is extremely quick). */
1145 /* Map drive letter to UNC if remote. */
1146 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1148 char remote_name
[ 256 ];
1149 char drive
[3] = { root_dir
[0], ':' };
1151 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1153 /* do something */ ;
1157 info
= lookup_volume_info (root_dir
);
1159 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1167 /* Info is not cached, or is stale. */
1168 if (!GetVolumeInformation (root_dir
,
1169 name
, sizeof (name
),
1173 type
, sizeof (type
)))
1176 /* Cache the volume information for future use, overwriting existing
1177 entry if present. */
1180 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1181 add_volume_info (root_dir
, info
);
1189 info
->name
= xstrdup (name
);
1190 info
->serialnum
= serialnum
;
1191 info
->maxcomp
= maxcomp
;
1192 info
->flags
= flags
;
1193 info
->type
= xstrdup (type
);
1194 info
->timestamp
= GetTickCount ();
1200 /* Get information on the volume where name is held; set path pointer to
1201 start of pathname in name (past UNC header\volume header if present). */
1203 get_volume_info (const char * name
, const char ** pPath
)
1205 char temp
[MAX_PATH
];
1206 char *rootname
= NULL
; /* default to current volume */
1207 volume_info_data
* info
;
1212 /* find the root name of the volume if given */
1213 if (isalpha (name
[0]) && name
[1] == ':')
1221 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1228 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1241 info
= GetCachedVolumeInformation (rootname
);
1244 /* Set global referenced by other functions. */
1245 volume_info
= *info
;
1251 /* Determine if volume is FAT format (ie. only supports short 8.3
1252 names); also set path pointer to start of pathname in name. */
1254 is_fat_volume (const char * name
, const char ** pPath
)
1256 if (get_volume_info (name
, pPath
))
1257 return (volume_info
.maxcomp
== 12);
1261 /* Map filename to a legal 8.3 name if necessary. */
1263 map_w32_filename (const char * name
, const char ** pPath
)
1265 static char shortname
[MAX_PATH
];
1266 char * str
= shortname
;
1269 const char * save_name
= name
;
1271 if (strlen (name
) >= MAX_PATH
)
1273 /* Return a filename which will cause callers to fail. */
1274 strcpy (shortname
, "?");
1278 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1280 register int left
= 8; /* maximum number of chars in part */
1281 register int extn
= 0; /* extension added? */
1282 register int dots
= 2; /* maximum number of dots allowed */
1285 *str
++ = *name
++; /* skip past UNC header */
1287 while ((c
= *name
++))
1294 extn
= 0; /* reset extension flags */
1295 dots
= 2; /* max 2 dots */
1296 left
= 8; /* max length 8 for main part */
1300 extn
= 0; /* reset extension flags */
1301 dots
= 2; /* max 2 dots */
1302 left
= 8; /* max length 8 for main part */
1307 /* Convert path components of the form .xxx to _xxx,
1308 but leave . and .. as they are. This allows .emacs
1309 to be read as _emacs, for example. */
1313 IS_DIRECTORY_SEP (*name
))
1328 extn
= 1; /* we've got an extension */
1329 left
= 3; /* 3 chars in extension */
1333 /* any embedded dots after the first are converted to _ */
1338 case '#': /* don't lose these, they're important */
1340 str
[-1] = c
; /* replace last character of part */
1345 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1347 dots
= 0; /* started a path component */
1356 strcpy (shortname
, name
);
1357 unixtodos_filename (shortname
);
1361 *pPath
= shortname
+ (path
- save_name
);
1367 is_exec (const char * name
)
1369 char * p
= strrchr (name
, '.');
1372 && (stricmp (p
, ".exe") == 0 ||
1373 stricmp (p
, ".com") == 0 ||
1374 stricmp (p
, ".bat") == 0 ||
1375 stricmp (p
, ".cmd") == 0));
1378 /* Emulate the Unix directory procedures opendir, closedir,
1379 and readdir. We can't use the procedures supplied in sysdep.c,
1380 so we provide them here. */
1382 struct direct dir_static
; /* simulated directory contents */
1383 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1384 static int dir_is_fat
;
1385 static char dir_pathname
[MAXPATHLEN
+1];
1386 static WIN32_FIND_DATA dir_find_data
;
1388 /* Support shares on a network resource as subdirectories of a read-only
1390 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1391 HANDLE
open_unc_volume (char *);
1392 char *read_unc_volume (HANDLE
, char *, int);
1393 void close_unc_volume (HANDLE
);
1396 opendir (char *filename
)
1400 /* Opening is done by FindFirstFile. However, a read is inherent to
1401 this operation, so we defer the open until read time. */
1403 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1405 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1408 if (is_unc_volume (filename
))
1410 wnet_enum_handle
= open_unc_volume (filename
);
1411 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1415 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1422 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1423 dir_pathname
[MAXPATHLEN
] = '\0';
1424 dir_is_fat
= is_fat_volume (filename
, NULL
);
1430 closedir (DIR *dirp
)
1432 /* If we have a find-handle open, close it. */
1433 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1435 FindClose (dir_find_handle
);
1436 dir_find_handle
= INVALID_HANDLE_VALUE
;
1438 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1440 close_unc_volume (wnet_enum_handle
);
1441 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1443 xfree ((char *) dirp
);
1449 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1451 if (!read_unc_volume (wnet_enum_handle
,
1452 dir_find_data
.cFileName
,
1456 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1457 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1459 char filename
[MAXNAMLEN
+ 3];
1462 strcpy (filename
, dir_pathname
);
1463 ln
= strlen (filename
) - 1;
1464 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1465 strcat (filename
, "\\");
1466 strcat (filename
, "*");
1468 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1470 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1475 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1479 /* Emacs never uses this value, so don't bother making it match
1480 value returned by stat(). */
1481 dir_static
.d_ino
= 1;
1483 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1484 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1486 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1487 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1489 _strlwr (dir_static
.d_name
);
1490 else if (!NILP (Vw32_downcase_file_names
))
1493 for (p
= dir_static
.d_name
; *p
; p
++)
1494 if (*p
>= 'a' && *p
<= 'z')
1497 _strlwr (dir_static
.d_name
);
1504 open_unc_volume (char *path
)
1510 nr
.dwScope
= RESOURCE_GLOBALNET
;
1511 nr
.dwType
= RESOURCETYPE_DISK
;
1512 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1513 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1514 nr
.lpLocalName
= NULL
;
1515 nr
.lpRemoteName
= map_w32_filename (path
, NULL
);
1516 nr
.lpComment
= NULL
;
1517 nr
.lpProvider
= NULL
;
1519 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1520 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1522 if (result
== NO_ERROR
)
1525 return INVALID_HANDLE_VALUE
;
1529 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1533 DWORD bufsize
= 512;
1538 buffer
= alloca (bufsize
);
1539 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1540 if (result
!= NO_ERROR
)
1543 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1544 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1546 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1549 strncpy (readbuf
, ptr
, size
);
1554 close_unc_volume (HANDLE henum
)
1556 if (henum
!= INVALID_HANDLE_VALUE
)
1557 WNetCloseEnum (henum
);
1561 unc_volume_file_attributes (char *path
)
1566 henum
= open_unc_volume (path
);
1567 if (henum
== INVALID_HANDLE_VALUE
)
1570 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1572 close_unc_volume (henum
);
1578 /* Shadow some MSVC runtime functions to map requests for long filenames
1579 to reasonable short names if necessary. This was originally added to
1580 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1584 sys_access (const char * path
, int mode
)
1588 /* MSVC implementation doesn't recognize D_OK. */
1589 path
= map_w32_filename (path
, NULL
);
1590 if (is_unc_volume (path
))
1592 attributes
= unc_volume_file_attributes (path
);
1593 if (attributes
== -1) {
1598 else if ((attributes
= GetFileAttributes (path
)) == -1)
1600 /* Should try mapping GetLastError to errno; for now just indicate
1601 that path doesn't exist. */
1605 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1610 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1615 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1624 sys_chdir (const char * path
)
1626 return _chdir (map_w32_filename (path
, NULL
));
1630 sys_chmod (const char * path
, int mode
)
1632 return _chmod (map_w32_filename (path
, NULL
), mode
);
1636 sys_creat (const char * path
, int mode
)
1638 return _creat (map_w32_filename (path
, NULL
), mode
);
1642 sys_fopen(const char * path
, const char * mode
)
1646 const char * mode_save
= mode
;
1648 /* Force all file handles to be non-inheritable. This is necessary to
1649 ensure child processes don't unwittingly inherit handles that might
1650 prevent future file access. */
1654 else if (mode
[0] == 'w' || mode
[0] == 'a')
1655 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1659 /* Only do simplistic option parsing. */
1663 oflag
&= ~(O_RDONLY
| O_WRONLY
);
1666 else if (mode
[0] == 'b')
1671 else if (mode
[0] == 't')
1678 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
1682 return _fdopen (fd
, mode_save
);
1685 /* This only works on NTFS volumes, but is useful to have. */
1687 sys_link (const char * old
, const char * new)
1691 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
1693 if (old
== NULL
|| new == NULL
)
1699 strcpy (oldname
, map_w32_filename (old
, NULL
));
1700 strcpy (newname
, map_w32_filename (new, NULL
));
1702 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
1703 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
1704 if (fileh
!= INVALID_HANDLE_VALUE
)
1708 /* Confusingly, the "alternate" stream name field does not apply
1709 when restoring a hard link, and instead contains the actual
1710 stream data for the link (ie. the name of the link to create).
1711 The WIN32_STREAM_ID structure before the cStreamName field is
1712 the stream header, which is then immediately followed by the
1716 WIN32_STREAM_ID wid
;
1717 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
1720 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
1721 data
.wid
.cStreamName
, MAX_PATH
);
1724 LPVOID context
= NULL
;
1727 data
.wid
.dwStreamId
= BACKUP_LINK
;
1728 data
.wid
.dwStreamAttributes
= 0;
1729 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
1730 data
.wid
.Size
.HighPart
= 0;
1731 data
.wid
.dwStreamNameSize
= 0;
1733 if (BackupWrite (fileh
, (LPBYTE
)&data
,
1734 offsetof (WIN32_STREAM_ID
, cStreamName
)
1735 + data
.wid
.Size
.LowPart
,
1736 &wbytes
, FALSE
, FALSE
, &context
)
1737 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
1744 /* Should try mapping GetLastError to errno; for now just
1745 indicate a general error (eg. links not supported). */
1746 errno
= EINVAL
; // perhaps EMLINK?
1750 CloseHandle (fileh
);
1759 sys_mkdir (const char * path
)
1761 return _mkdir (map_w32_filename (path
, NULL
));
1764 /* Because of long name mapping issues, we need to implement this
1765 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1766 a unique name, instead of setting the input template to an empty
1769 Standard algorithm seems to be use pid or tid with a letter on the
1770 front (in place of the 6 X's) and cycle through the letters to find a
1771 unique name. We extend that to allow any reasonable character as the
1772 first of the 6 X's. */
1774 sys_mktemp (char * template)
1778 unsigned uid
= GetCurrentThreadId ();
1779 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1781 if (template == NULL
)
1783 p
= template + strlen (template);
1785 /* replace up to the last 5 X's with uid in decimal */
1786 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1788 p
[0] = '0' + uid
% 10;
1792 if (i
< 0 && p
[0] == 'X')
1797 int save_errno
= errno
;
1798 p
[0] = first_char
[i
];
1799 if (sys_access (template, 0) < 0)
1805 while (++i
< sizeof (first_char
));
1808 /* Template is badly formed or else we can't generate a unique name,
1809 so return empty string */
1815 sys_open (const char * path
, int oflag
, int mode
)
1817 const char* mpath
= map_w32_filename (path
, NULL
);
1818 /* Try to open file without _O_CREAT, to be able to write to hidden
1819 and system files. Force all file handles to be
1821 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
1824 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
1828 sys_rename (const char * oldname
, const char * newname
)
1831 char temp
[MAX_PATH
];
1833 /* MoveFile on Windows 95 doesn't correctly change the short file name
1834 alias in a number of circumstances (it is not easy to predict when
1835 just by looking at oldname and newname, unfortunately). In these
1836 cases, renaming through a temporary name avoids the problem.
1838 A second problem on Windows 95 is that renaming through a temp name when
1839 newname is uppercase fails (the final long name ends up in
1840 lowercase, although the short alias might be uppercase) UNLESS the
1841 long temp name is not 8.3.
1843 So, on Windows 95 we always rename through a temp name, and we make sure
1844 the temp name has a long extension to ensure correct renaming. */
1846 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1848 if (os_subtype
== OS_WIN95
)
1854 oldname
= map_w32_filename (oldname
, NULL
);
1855 if (o
= strrchr (oldname
, '\\'))
1858 o
= (char *) oldname
;
1860 if (p
= strrchr (temp
, '\\'))
1867 /* Force temp name to require a manufactured 8.3 alias - this
1868 seems to make the second rename work properly. */
1869 sprintf (p
, "_.%s.%u", o
, i
);
1871 result
= rename (oldname
, temp
);
1873 /* This loop must surely terminate! */
1874 while (result
< 0 && errno
== EEXIST
);
1879 /* Emulate Unix behaviour - newname is deleted if it already exists
1880 (at least if it is a file; don't do this for directories).
1882 Since we mustn't do this if we are just changing the case of the
1883 file name (we would end up deleting the file we are trying to
1884 rename!), we let rename detect if the destination file already
1885 exists - that way we avoid the possible pitfalls of trying to
1886 determine ourselves whether two names really refer to the same
1887 file, which is not always possible in the general case. (Consider
1888 all the permutations of shared or subst'd drives, etc.) */
1890 newname
= map_w32_filename (newname
, NULL
);
1891 result
= rename (temp
, newname
);
1895 && _chmod (newname
, 0666) == 0
1896 && _unlink (newname
) == 0)
1897 result
= rename (temp
, newname
);
1903 sys_rmdir (const char * path
)
1905 return _rmdir (map_w32_filename (path
, NULL
));
1909 sys_unlink (const char * path
)
1911 path
= map_w32_filename (path
, NULL
);
1913 /* On Unix, unlink works without write permission. */
1914 _chmod (path
, 0666);
1915 return _unlink (path
);
1918 static FILETIME utc_base_ft
;
1919 static long double utc_base
;
1920 static int init
= 0;
1923 convert_time (FILETIME ft
)
1929 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1938 st
.wMilliseconds
= 0;
1940 SystemTimeToFileTime (&st
, &utc_base_ft
);
1941 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1942 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1946 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1949 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1951 return (time_t) (ret
* 1e-7);
1955 convert_from_time_t (time_t time
, FILETIME
* pft
)
1961 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1970 st
.wMilliseconds
= 0;
1972 SystemTimeToFileTime (&st
, &utc_base_ft
);
1973 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1974 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1978 /* time in 100ns units since 1-Jan-1601 */
1979 tmp
= (long double) time
* 1e7
+ utc_base
;
1980 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
1981 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
1985 /* No reason to keep this; faking inode values either by hashing or even
1986 using the file index from GetInformationByHandle, is not perfect and
1987 so by default Emacs doesn't use the inode values on Windows.
1988 Instead, we now determine file-truename correctly (except for
1989 possible drive aliasing etc). */
1991 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
1993 hashval (const unsigned char * str
)
1998 h
= (h
<< 4) + *str
++;
2004 /* Return the hash value of the canonical pathname, excluding the
2005 drive/UNC header, to get a hopefully unique inode number. */
2007 generate_inode_val (const char * name
)
2009 char fullname
[ MAX_PATH
];
2013 /* Get the truly canonical filename, if it exists. (Note: this
2014 doesn't resolve aliasing due to subst commands, or recognise hard
2016 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2019 parse_root (fullname
, &p
);
2020 /* Normal W32 filesystems are still case insensitive. */
2027 /* MSVC stat function can't cope with UNC names and has other bugs, so
2028 replace it with our own. This also allows us to calculate consistent
2029 inode values without hacks in the main Emacs code. */
2031 stat (const char * path
, struct stat
* buf
)
2034 WIN32_FIND_DATA wfd
;
2039 int rootdir
= FALSE
;
2041 if (path
== NULL
|| buf
== NULL
)
2047 name
= (char *) map_w32_filename (path
, &path
);
2048 /* must be valid filename, no wild cards or other invalid characters */
2049 if (strpbrk (name
, "*?|<>\""))
2055 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2056 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2057 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2062 /* Remove trailing directory separator, unless name is the root
2063 directory of a drive or UNC volume in which case ensure there
2064 is a trailing separator. */
2065 len
= strlen (name
);
2066 rootdir
= (path
>= name
+ len
- 1
2067 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2068 name
= strcpy (alloca (len
+ 2), name
);
2070 if (is_unc_volume (name
))
2072 DWORD attrs
= unc_volume_file_attributes (name
);
2077 memset (&wfd
, 0, sizeof (wfd
));
2078 wfd
.dwFileAttributes
= attrs
;
2079 wfd
.ftCreationTime
= utc_base_ft
;
2080 wfd
.ftLastAccessTime
= utc_base_ft
;
2081 wfd
.ftLastWriteTime
= utc_base_ft
;
2082 strcpy (wfd
.cFileName
, name
);
2086 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2087 strcat (name
, "\\");
2088 if (GetDriveType (name
) < 2)
2093 memset (&wfd
, 0, sizeof (wfd
));
2094 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2095 wfd
.ftCreationTime
= utc_base_ft
;
2096 wfd
.ftLastAccessTime
= utc_base_ft
;
2097 wfd
.ftLastWriteTime
= utc_base_ft
;
2098 strcpy (wfd
.cFileName
, name
);
2102 if (IS_DIRECTORY_SEP (name
[len
-1]))
2105 /* (This is hacky, but helps when doing file completions on
2106 network drives.) Optimize by using information available from
2107 active readdir if possible. */
2108 len
= strlen (dir_pathname
);
2109 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2111 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2112 && strnicmp (name
, dir_pathname
, len
) == 0
2113 && IS_DIRECTORY_SEP (name
[len
])
2114 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2116 /* This was the last entry returned by readdir. */
2117 wfd
= dir_find_data
;
2121 fh
= FindFirstFile (name
, &wfd
);
2122 if (fh
== INVALID_HANDLE_VALUE
)
2131 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2133 buf
->st_mode
= _S_IFDIR
;
2134 buf
->st_nlink
= 2; /* doesn't really matter */
2135 fake_inode
= 0; /* this doesn't either I think */
2137 else if (!NILP (Vw32_get_true_file_attributes
)
2138 /* No access rights required to get info. */
2139 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
, 0, NULL
))
2140 != INVALID_HANDLE_VALUE
)
2142 /* This is more accurate in terms of gettting the correct number
2143 of links, but is quite slow (it is noticable when Emacs is
2144 making a list of file name completions). */
2145 BY_HANDLE_FILE_INFORMATION info
;
2147 if (GetFileInformationByHandle (fh
, &info
))
2149 buf
->st_nlink
= info
.nNumberOfLinks
;
2150 /* Might as well use file index to fake inode values, but this
2151 is not guaranteed to be unique unless we keep a handle open
2152 all the time (even then there are situations where it is
2153 not unique). Reputedly, there are at most 48 bits of info
2154 (on NTFS, presumably less on FAT). */
2155 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2163 switch (GetFileType (fh
))
2165 case FILE_TYPE_DISK
:
2166 buf
->st_mode
= _S_IFREG
;
2168 case FILE_TYPE_PIPE
:
2169 buf
->st_mode
= _S_IFIFO
;
2171 case FILE_TYPE_CHAR
:
2172 case FILE_TYPE_UNKNOWN
:
2174 buf
->st_mode
= _S_IFCHR
;
2180 /* Don't bother to make this information more accurate. */
2181 buf
->st_mode
= _S_IFREG
;
2187 /* Not sure if there is any point in this. */
2188 if (!NILP (Vw32_generate_fake_inodes
))
2189 fake_inode
= generate_inode_val (name
);
2190 else if (fake_inode
== 0)
2192 /* For want of something better, try to make everything unique. */
2193 static DWORD gen_num
= 0;
2194 fake_inode
= ++gen_num
;
2198 /* MSVC defines _ino_t to be short; other libc's might not. */
2199 if (sizeof (buf
->st_ino
) == 2)
2200 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2202 buf
->st_ino
= fake_inode
;
2204 /* consider files to belong to current user */
2205 buf
->st_uid
= the_passwd
.pw_uid
;
2206 buf
->st_gid
= the_passwd
.pw_gid
;
2208 /* volume_info is set indirectly by map_w32_filename */
2209 buf
->st_dev
= volume_info
.serialnum
;
2210 buf
->st_rdev
= volume_info
.serialnum
;
2213 buf
->st_size
= wfd
.nFileSizeLow
;
2215 /* Convert timestamps to Unix format. */
2216 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2217 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2218 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2219 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2220 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2222 /* determine rwx permissions */
2223 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2224 permission
= _S_IREAD
;
2226 permission
= _S_IREAD
| _S_IWRITE
;
2228 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2229 permission
|= _S_IEXEC
;
2230 else if (is_exec (name
))
2231 permission
|= _S_IEXEC
;
2233 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2238 /* Provide fstat and utime as well as stat for consistent handling of
2241 fstat (int desc
, struct stat
* buf
)
2243 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2244 BY_HANDLE_FILE_INFORMATION info
;
2248 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2250 case FILE_TYPE_DISK
:
2251 buf
->st_mode
= _S_IFREG
;
2252 if (!GetFileInformationByHandle (fh
, &info
))
2258 case FILE_TYPE_PIPE
:
2259 buf
->st_mode
= _S_IFIFO
;
2261 case FILE_TYPE_CHAR
:
2262 case FILE_TYPE_UNKNOWN
:
2264 buf
->st_mode
= _S_IFCHR
;
2266 memset (&info
, 0, sizeof (info
));
2267 info
.dwFileAttributes
= 0;
2268 info
.ftCreationTime
= utc_base_ft
;
2269 info
.ftLastAccessTime
= utc_base_ft
;
2270 info
.ftLastWriteTime
= utc_base_ft
;
2273 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2275 buf
->st_mode
= _S_IFDIR
;
2276 buf
->st_nlink
= 2; /* doesn't really matter */
2277 fake_inode
= 0; /* this doesn't either I think */
2281 buf
->st_nlink
= info
.nNumberOfLinks
;
2282 /* Might as well use file index to fake inode values, but this
2283 is not guaranteed to be unique unless we keep a handle open
2284 all the time (even then there are situations where it is
2285 not unique). Reputedly, there are at most 48 bits of info
2286 (on NTFS, presumably less on FAT). */
2287 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2290 /* MSVC defines _ino_t to be short; other libc's might not. */
2291 if (sizeof (buf
->st_ino
) == 2)
2292 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2294 buf
->st_ino
= fake_inode
;
2296 /* consider files to belong to current user */
2300 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2301 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2303 buf
->st_size
= info
.nFileSizeLow
;
2305 /* Convert timestamps to Unix format. */
2306 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2307 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2308 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2309 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2310 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2312 /* determine rwx permissions */
2313 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2314 permission
= _S_IREAD
;
2316 permission
= _S_IREAD
| _S_IWRITE
;
2318 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2319 permission
|= _S_IEXEC
;
2322 #if 0 /* no way of knowing the filename */
2323 char * p
= strrchr (name
, '.');
2325 (stricmp (p
, ".exe") == 0 ||
2326 stricmp (p
, ".com") == 0 ||
2327 stricmp (p
, ".bat") == 0 ||
2328 stricmp (p
, ".cmd") == 0))
2329 permission
|= _S_IEXEC
;
2333 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2339 utime (const char *name
, struct utimbuf
*times
)
2341 struct utimbuf deftime
;
2348 deftime
.modtime
= deftime
.actime
= time (NULL
);
2352 /* Need write access to set times. */
2353 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2354 0, OPEN_EXISTING
, 0, NULL
);
2357 convert_from_time_t (times
->actime
, &atime
);
2358 convert_from_time_t (times
->modtime
, &mtime
);
2359 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2377 /* Wrappers for winsock functions to map between our file descriptors
2378 and winsock's handles; also set h_errno for convenience.
2380 To allow Emacs to run on systems which don't have winsock support
2381 installed, we dynamically link to winsock on startup if present, and
2382 otherwise provide the minimum necessary functionality
2383 (eg. gethostname). */
2385 /* function pointers for relevant socket functions */
2386 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2387 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2388 int (PASCAL
*pfn_WSAGetLastError
) (void);
2389 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2390 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2391 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2392 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2393 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2394 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2395 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2396 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2397 int (PASCAL
*pfn_WSACleanup
) (void);
2399 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2400 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2401 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2402 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2403 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2404 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2406 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2407 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2408 #ifndef HANDLE_FLAG_INHERIT
2409 #define HANDLE_FLAG_INHERIT 1
2413 static int winsock_inuse
;
2418 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2420 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2421 after WSAStartup returns successfully, but it seems reasonable
2422 to allow unloading winsock anyway in that case. */
2423 if (pfn_WSACleanup () == 0 ||
2424 pfn_WSAGetLastError () == WSAENETDOWN
)
2426 if (FreeLibrary (winsock_lib
))
2435 init_winsock (int load_now
)
2437 WSADATA winsockData
;
2439 if (winsock_lib
!= NULL
)
2442 pfn_SetHandleInformation
= NULL
;
2443 pfn_SetHandleInformation
2444 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2445 "SetHandleInformation");
2447 winsock_lib
= LoadLibrary ("wsock32.dll");
2449 if (winsock_lib
!= NULL
)
2451 /* dynamically link to socket functions */
2453 #define LOAD_PROC(fn) \
2454 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2457 LOAD_PROC( WSAStartup
);
2458 LOAD_PROC( WSASetLastError
);
2459 LOAD_PROC( WSAGetLastError
);
2460 LOAD_PROC( socket
);
2462 LOAD_PROC( connect
);
2463 LOAD_PROC( ioctlsocket
);
2466 LOAD_PROC( closesocket
);
2467 LOAD_PROC( shutdown
);
2470 LOAD_PROC( inet_addr
);
2471 LOAD_PROC( gethostname
);
2472 LOAD_PROC( gethostbyname
);
2473 LOAD_PROC( getservbyname
);
2474 LOAD_PROC( WSACleanup
);
2478 /* specify version 1.1 of winsock */
2479 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2481 if (winsockData
.wVersion
!= 0x101)
2486 /* Report that winsock exists and is usable, but leave
2487 socket functions disabled. I am assuming that calling
2488 WSAStartup does not require any network interaction,
2489 and in particular does not cause or require a dial-up
2490 connection to be established. */
2493 FreeLibrary (winsock_lib
);
2501 FreeLibrary (winsock_lib
);
2511 /* function to set h_errno for compatability; map winsock error codes to
2512 normal system codes where they overlap (non-overlapping definitions
2513 are already in <sys/socket.h> */
2514 static void set_errno ()
2516 if (winsock_lib
== NULL
)
2519 h_errno
= pfn_WSAGetLastError ();
2523 case WSAEACCES
: h_errno
= EACCES
; break;
2524 case WSAEBADF
: h_errno
= EBADF
; break;
2525 case WSAEFAULT
: h_errno
= EFAULT
; break;
2526 case WSAEINTR
: h_errno
= EINTR
; break;
2527 case WSAEINVAL
: h_errno
= EINVAL
; break;
2528 case WSAEMFILE
: h_errno
= EMFILE
; break;
2529 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2530 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2535 static void check_errno ()
2537 if (h_errno
== 0 && winsock_lib
!= NULL
)
2538 pfn_WSASetLastError (0);
2541 /* Extend strerror to handle the winsock-specific error codes. */
2545 } _wsa_errlist
[] = {
2546 WSAEINTR
, "Interrupted function call",
2547 WSAEBADF
, "Bad file descriptor",
2548 WSAEACCES
, "Permission denied",
2549 WSAEFAULT
, "Bad address",
2550 WSAEINVAL
, "Invalid argument",
2551 WSAEMFILE
, "Too many open files",
2553 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2554 WSAEINPROGRESS
, "Operation now in progress",
2555 WSAEALREADY
, "Operation already in progress",
2556 WSAENOTSOCK
, "Socket operation on non-socket",
2557 WSAEDESTADDRREQ
, "Destination address required",
2558 WSAEMSGSIZE
, "Message too long",
2559 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2560 WSAENOPROTOOPT
, "Bad protocol option",
2561 WSAEPROTONOSUPPORT
, "Protocol not supported",
2562 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2563 WSAEOPNOTSUPP
, "Operation not supported",
2564 WSAEPFNOSUPPORT
, "Protocol family not supported",
2565 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2566 WSAEADDRINUSE
, "Address already in use",
2567 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2568 WSAENETDOWN
, "Network is down",
2569 WSAENETUNREACH
, "Network is unreachable",
2570 WSAENETRESET
, "Network dropped connection on reset",
2571 WSAECONNABORTED
, "Software caused connection abort",
2572 WSAECONNRESET
, "Connection reset by peer",
2573 WSAENOBUFS
, "No buffer space available",
2574 WSAEISCONN
, "Socket is already connected",
2575 WSAENOTCONN
, "Socket is not connected",
2576 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2577 WSAETOOMANYREFS
, "Too many references", /* not sure */
2578 WSAETIMEDOUT
, "Connection timed out",
2579 WSAECONNREFUSED
, "Connection refused",
2580 WSAELOOP
, "Network loop", /* not sure */
2581 WSAENAMETOOLONG
, "Name is too long",
2582 WSAEHOSTDOWN
, "Host is down",
2583 WSAEHOSTUNREACH
, "No route to host",
2584 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2585 WSAEPROCLIM
, "Too many processes",
2586 WSAEUSERS
, "Too many users", /* not sure */
2587 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2588 WSAESTALE
, "Data is stale", /* not sure */
2589 WSAEREMOTE
, "Remote error", /* not sure */
2591 WSASYSNOTREADY
, "Network subsystem is unavailable",
2592 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2593 WSANOTINITIALISED
, "Winsock not initialized successfully",
2594 WSAEDISCON
, "Graceful shutdown in progress",
2596 WSAENOMORE
, "No more operations allowed", /* not sure */
2597 WSAECANCELLED
, "Operation cancelled", /* not sure */
2598 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2599 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2600 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2601 WSASYSCALLFAILURE
, "System call failured",
2602 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2603 WSATYPE_NOT_FOUND
, "Class type not found",
2604 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2605 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2606 WSAEREFUSED
, "Operation refused", /* not sure */
2609 WSAHOST_NOT_FOUND
, "Host not found",
2610 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2611 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2612 WSANO_DATA
, "Valid name, no data record of requested type",
2618 sys_strerror(int error_no
)
2621 static char unknown_msg
[40];
2623 if (error_no
>= 0 && error_no
< sys_nerr
)
2624 return sys_errlist
[error_no
];
2626 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2627 if (_wsa_errlist
[i
].errnum
== error_no
)
2628 return _wsa_errlist
[i
].msg
;
2630 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
2634 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2635 but I believe the method of keeping the socket handle separate (and
2636 insuring it is not inheritable) is the correct one. */
2638 //#define SOCK_REPLACE_HANDLE
2640 #ifdef SOCK_REPLACE_HANDLE
2641 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2643 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2647 sys_socket(int af
, int type
, int protocol
)
2653 if (winsock_lib
== NULL
)
2656 return INVALID_SOCKET
;
2661 /* call the real socket function */
2662 s
= (long) pfn_socket (af
, type
, protocol
);
2664 if (s
!= INVALID_SOCKET
)
2666 /* Although under NT 3.5 _open_osfhandle will accept a socket
2667 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2668 that does not work under NT 3.1. However, we can get the same
2669 effect by using a backdoor function to replace an existing
2670 descriptor handle with the one we want. */
2672 /* allocate a file descriptor (with appropriate flags) */
2673 fd
= _open ("NUL:", _O_RDWR
);
2676 #ifdef SOCK_REPLACE_HANDLE
2677 /* now replace handle to NUL with our socket handle */
2678 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
2680 _set_osfhnd (fd
, s
);
2681 /* setmode (fd, _O_BINARY); */
2683 /* Make a non-inheritable copy of the socket handle. Note
2684 that it is possible that sockets aren't actually kernel
2685 handles, which appears to be the case on Windows 9x when
2686 the MS Proxy winsock client is installed. */
2688 /* Apparently there is a bug in NT 3.51 with some service
2689 packs, which prevents using DuplicateHandle to make a
2690 socket handle non-inheritable (causes WSACleanup to
2691 hang). The work-around is to use SetHandleInformation
2692 instead if it is available and implemented. */
2693 if (pfn_SetHandleInformation
)
2695 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
2699 HANDLE parent
= GetCurrentProcess ();
2700 HANDLE new_s
= INVALID_HANDLE_VALUE
;
2702 if (DuplicateHandle (parent
,
2708 DUPLICATE_SAME_ACCESS
))
2710 /* It is possible that DuplicateHandle succeeds even
2711 though the socket wasn't really a kernel handle,
2712 because a real handle has the same value. So
2713 test whether the new handle really is a socket. */
2714 long nonblocking
= 0;
2715 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
2717 pfn_closesocket (s
);
2722 CloseHandle (new_s
);
2727 fd_info
[fd
].hnd
= (HANDLE
) s
;
2730 /* set our own internal flags */
2731 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
2737 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2739 /* attach child_process to fd_info */
2740 if (fd_info
[ fd
].cp
!= NULL
)
2742 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
2746 fd_info
[ fd
].cp
= cp
;
2749 winsock_inuse
++; /* count open sockets */
2756 pfn_closesocket (s
);
2766 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
2768 if (winsock_lib
== NULL
)
2771 return SOCKET_ERROR
;
2775 if (fd_info
[s
].flags
& FILE_SOCKET
)
2777 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
2778 if (rc
== SOCKET_ERROR
)
2783 return SOCKET_ERROR
;
2788 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
2790 if (winsock_lib
== NULL
)
2793 return SOCKET_ERROR
;
2797 if (fd_info
[s
].flags
& FILE_SOCKET
)
2799 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
2800 if (rc
== SOCKET_ERROR
)
2805 return SOCKET_ERROR
;
2809 sys_htons (u_short hostshort
)
2811 return (winsock_lib
!= NULL
) ?
2812 pfn_htons (hostshort
) : hostshort
;
2816 sys_ntohs (u_short netshort
)
2818 return (winsock_lib
!= NULL
) ?
2819 pfn_ntohs (netshort
) : netshort
;
2823 sys_inet_addr (const char * cp
)
2825 return (winsock_lib
!= NULL
) ?
2826 pfn_inet_addr (cp
) : INADDR_NONE
;
2830 sys_gethostname (char * name
, int namelen
)
2832 if (winsock_lib
!= NULL
)
2833 return pfn_gethostname (name
, namelen
);
2835 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
2836 return !GetComputerName (name
, (DWORD
*)&namelen
);
2839 return SOCKET_ERROR
;
2843 sys_gethostbyname(const char * name
)
2845 struct hostent
* host
;
2847 if (winsock_lib
== NULL
)
2854 host
= pfn_gethostbyname (name
);
2861 sys_getservbyname(const char * name
, const char * proto
)
2863 struct servent
* serv
;
2865 if (winsock_lib
== NULL
)
2872 serv
= pfn_getservbyname (name
, proto
);
2879 sys_shutdown (int s
, int how
)
2881 if (winsock_lib
== NULL
)
2884 return SOCKET_ERROR
;
2888 if (fd_info
[s
].flags
& FILE_SOCKET
)
2890 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
2891 if (rc
== SOCKET_ERROR
)
2896 return SOCKET_ERROR
;
2899 #endif /* HAVE_SOCKETS */
2902 /* Shadow main io functions: we need to handle pipes and sockets more
2903 intelligently, and implement non-blocking mode as well. */
2910 if (fd
< 0 || fd
>= MAXDESC
)
2918 child_process
* cp
= fd_info
[fd
].cp
;
2920 fd_info
[fd
].cp
= NULL
;
2922 if (CHILD_ACTIVE (cp
))
2924 /* if last descriptor to active child_process then cleanup */
2926 for (i
= 0; i
< MAXDESC
; i
++)
2930 if (fd_info
[i
].cp
== cp
)
2936 if (fd_info
[fd
].flags
& FILE_SOCKET
)
2938 #ifndef SOCK_REPLACE_HANDLE
2939 if (winsock_lib
== NULL
) abort ();
2941 pfn_shutdown (SOCK_HANDLE (fd
), 2);
2942 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
2944 winsock_inuse
--; /* count open sockets */
2952 /* Note that sockets do not need special treatment here (at least on
2953 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
2954 closesocket is equivalent to CloseHandle, which is to be expected
2955 because socket handles are fully fledged kernel handles. */
2959 fd_info
[fd
].flags
= 0;
2972 /* duplicate our internal info as well */
2973 fd_info
[new_fd
] = fd_info
[fd
];
2980 sys_dup2 (int src
, int dst
)
2984 if (dst
< 0 || dst
>= MAXDESC
)
2990 /* make sure we close the destination first if it's a pipe or socket */
2991 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
2994 rc
= _dup2 (src
, dst
);
2997 /* duplicate our internal info as well */
2998 fd_info
[dst
] = fd_info
[src
];
3003 /* Unix pipe() has only one arg */
3005 sys_pipe (int * phandles
)
3010 /* make pipe handles non-inheritable; when we spawn a child, we
3011 replace the relevant handle with an inheritable one. Also put
3012 pipes into binary mode; we will do text mode translation ourselves
3014 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3018 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3019 fd_info
[phandles
[0]].flags
= flags
;
3021 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3022 fd_info
[phandles
[1]].flags
= flags
;
3029 extern Lisp_Object Vw32_pipe_read_delay
;
3031 /* Function to do blocking read of one byte, needed to implement
3032 select. It is only allowed on sockets and pipes. */
3034 _sys_read_ahead (int fd
)
3039 if (fd
< 0 || fd
>= MAXDESC
)
3040 return STATUS_READ_ERROR
;
3042 cp
= fd_info
[fd
].cp
;
3044 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3045 return STATUS_READ_ERROR
;
3047 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3048 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3050 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3054 cp
->status
= STATUS_READ_IN_PROGRESS
;
3056 if (fd_info
[fd
].flags
& FILE_PIPE
)
3058 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3060 /* Give subprocess time to buffer some more output for us before
3061 reporting that input is available; we need this because Windows 95
3062 connects DOS programs to pipes by making the pipe appear to be
3063 the normal console stdout - as a result most DOS programs will
3064 write to stdout without buffering, ie. one character at a
3065 time. Even some W32 programs do this - "dir" in a command
3066 shell on NT is very slow if we don't do this. */
3069 int wait
= XINT (Vw32_pipe_read_delay
);
3075 /* Yield remainder of our time slice, effectively giving a
3076 temporary priority boost to the child process. */
3081 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3082 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3085 if (rc
== sizeof (char))
3086 cp
->status
= STATUS_READ_SUCCEEDED
;
3088 cp
->status
= STATUS_READ_FAILED
;
3094 sys_read (int fd
, char * buffer
, unsigned int count
)
3099 char * orig_buffer
= buffer
;
3101 if (fd
< 0 || fd
>= MAXDESC
)
3107 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3109 child_process
*cp
= fd_info
[fd
].cp
;
3111 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3119 /* re-read CR carried over from last read */
3120 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3122 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3126 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3129 /* presence of a child_process structure means we are operating in
3130 non-blocking mode - otherwise we just call _read directly.
3131 Note that the child_process structure might be missing because
3132 reap_subprocess has been called; in this case the pipe is
3133 already broken, so calling _read on it is okay. */
3136 int current_status
= cp
->status
;
3138 switch (current_status
)
3140 case STATUS_READ_FAILED
:
3141 case STATUS_READ_ERROR
:
3142 /* report normal EOF if nothing in buffer */
3144 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3147 case STATUS_READ_READY
:
3148 case STATUS_READ_IN_PROGRESS
:
3149 DebPrint (("sys_read called when read is in progress\n"));
3150 errno
= EWOULDBLOCK
;
3153 case STATUS_READ_SUCCEEDED
:
3154 /* consume read-ahead char */
3155 *buffer
++ = cp
->chr
;
3158 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3159 ResetEvent (cp
->char_avail
);
3161 case STATUS_READ_ACKNOWLEDGED
:
3165 DebPrint (("sys_read: bad status %d\n", current_status
));
3170 if (fd_info
[fd
].flags
& FILE_PIPE
)
3172 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3173 to_read
= min (waiting
, (DWORD
) count
);
3176 nchars
+= _read (fd
, buffer
, to_read
);
3179 else /* FILE_SOCKET */
3181 if (winsock_lib
== NULL
) abort ();
3183 /* do the equivalent of a non-blocking read */
3184 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3185 if (waiting
== 0 && nchars
== 0)
3187 h_errno
= errno
= EWOULDBLOCK
;
3193 /* always use binary mode for sockets */
3194 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3195 if (res
== SOCKET_ERROR
)
3197 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3198 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3209 int nread
= _read (fd
, buffer
, count
);
3212 else if (nchars
== 0)
3217 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3218 /* Perform text mode translation if required. */
3219 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3221 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3222 /* If buffer contains only CR, return that. To be absolutely
3223 sure we should attempt to read the next char, but in
3224 practice a CR to be followed by LF would not appear by
3225 itself in the buffer. */
3226 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3228 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3234 nchars
= _read (fd
, buffer
, count
);
3239 /* For now, don't bother with a non-blocking mode */
3241 sys_write (int fd
, const void * buffer
, unsigned int count
)
3245 if (fd
< 0 || fd
>= MAXDESC
)
3251 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3253 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3259 /* Perform text mode translation if required. */
3260 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3262 char * tmpbuf
= alloca (count
* 2);
3263 unsigned char * src
= (void *)buffer
;
3264 unsigned char * dst
= tmpbuf
;
3269 unsigned char *next
;
3270 /* copy next line or remaining bytes */
3271 next
= _memccpy (dst
, src
, '\n', nbytes
);
3274 /* copied one line ending with '\n' */
3275 int copied
= next
- dst
;
3278 /* insert '\r' before '\n' */
3285 /* copied remaining partial line -> now finished */
3293 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3295 if (winsock_lib
== NULL
) abort ();
3296 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3297 if (nchars
== SOCKET_ERROR
)
3299 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3300 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3306 nchars
= _write (fd
, buffer
, count
);
3312 check_windows_init_file ()
3314 extern int noninteractive
, inhibit_window_system
;
3316 /* A common indication that Emacs is not installed properly is when
3317 it cannot find the Windows installation file. If this file does
3318 not exist in the expected place, tell the user. */
3320 if (!noninteractive
&& !inhibit_window_system
)
3322 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3323 Lisp_Object objs
[2];
3324 Lisp_Object full_load_path
;
3325 Lisp_Object init_file
;
3328 objs
[0] = Vload_path
;
3329 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3330 full_load_path
= Fappend (2, objs
);
3331 init_file
= build_string ("term/w32-win");
3332 fd
= openp (full_load_path
, init_file
, Vload_suffixes
, NULL
, 0);
3335 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3336 char *init_file_name
= XSTRING (init_file
)->data
;
3337 char *load_path
= XSTRING (load_path_print
)->data
;
3338 char *buffer
= alloca (1024);
3341 "The Emacs Windows initialization file \"%s.el\" "
3342 "could not be found in your Emacs installation. "
3343 "Emacs checked the following directories for this file:\n"
3345 "When Emacs cannot find this file, it usually means that it "
3346 "was not installed properly, or its distribution file was "
3347 "not unpacked properly.\nSee the README.W32 file in the "
3348 "top-level Emacs directory for more information.",
3349 init_file_name
, load_path
);
3352 "Emacs Abort Dialog",
3353 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3354 /* Use the low-level Emacs abort. */
3369 /* shutdown the socket interface if necessary */
3378 /* Initialise the socket interface now if available and requested by
3379 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3380 delayed until open-network-stream is called (w32-has-winsock can
3381 also be used to dynamically load or reload winsock).
3383 Conveniently, init_environment is called before us, so
3384 PRELOAD_WINSOCK can be set in the registry. */
3386 /* Always initialize this correctly. */
3389 if (getenv ("PRELOAD_WINSOCK") != NULL
)
3390 init_winsock (TRUE
);
3393 /* Initial preparation for subprocess support: replace our standard
3394 handles with non-inheritable versions. */
3397 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
3398 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
3399 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
3401 parent
= GetCurrentProcess ();
3403 /* ignore errors when duplicating and closing; typically the
3404 handles will be invalid when running as a gui program. */
3405 DuplicateHandle (parent
,
3406 GetStdHandle (STD_INPUT_HANDLE
),
3411 DUPLICATE_SAME_ACCESS
);
3413 DuplicateHandle (parent
,
3414 GetStdHandle (STD_OUTPUT_HANDLE
),
3419 DUPLICATE_SAME_ACCESS
);
3421 DuplicateHandle (parent
,
3422 GetStdHandle (STD_ERROR_HANDLE
),
3427 DUPLICATE_SAME_ACCESS
);
3433 if (stdin_save
!= INVALID_HANDLE_VALUE
)
3434 _open_osfhandle ((long) stdin_save
, O_TEXT
);
3436 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
3439 if (stdout_save
!= INVALID_HANDLE_VALUE
)
3440 _open_osfhandle ((long) stdout_save
, O_TEXT
);
3442 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3445 if (stderr_save
!= INVALID_HANDLE_VALUE
)
3446 _open_osfhandle ((long) stderr_save
, O_TEXT
);
3448 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3452 /* unfortunately, atexit depends on implementation of malloc */
3453 /* atexit (term_ntproc); */
3454 signal (SIGABRT
, term_ntproc
);
3456 /* determine which drives are fixed, for GetCachedVolumeInformation */
3458 /* GetDriveType must have trailing backslash. */
3459 char drive
[] = "A:\\";
3461 /* Loop over all possible drive letters */
3462 while (*drive
<= 'Z')
3464 /* Record if this drive letter refers to a fixed drive. */
3465 fixed_drives
[DRIVE_INDEX (*drive
)] =
3466 (GetDriveType (drive
) == DRIVE_FIXED
);
3471 /* Reset the volume info cache. */
3472 volume_cache
= NULL
;
3475 /* Check to see if Emacs has been installed correctly. */
3476 check_windows_init_file ();