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 */
71 #define _ANONYMOUS_UNION
72 #define _ANONYMOUS_STRUCT
76 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
77 #include <sys/socket.h>
101 extern Lisp_Object Vw32_downcase_file_names
;
102 extern Lisp_Object Vw32_generate_fake_inodes
;
103 extern Lisp_Object Vw32_get_true_file_attributes
;
104 extern Lisp_Object Vw32_num_mouse_buttons
;
107 /* Equivalent of strerror for W32 error codes. */
109 w32_strerror (int error_no
)
111 static char buf
[500];
114 error_no
= GetLastError ();
117 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
119 0, /* choose most suitable language */
120 buf
, sizeof (buf
), NULL
))
121 sprintf (buf
, "w32 error %u", error_no
);
125 static char startup_dir
[MAXPATHLEN
];
127 /* Get the current working directory. */
132 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
136 /* Emacs doesn't actually change directory itself, and we want to
137 force our real wd to be where emacs.exe is to avoid unnecessary
138 conflicts when trying to rename or delete directories. */
139 strcpy (dir
, startup_dir
);
145 /* Emulate gethostname. */
147 gethostname (char *buffer
, int size
)
149 /* NT only allows small host names, so the buffer is
150 certainly large enough. */
151 return !GetComputerName (buffer
, &size
);
153 #endif /* HAVE_SOCKETS */
155 /* Emulate getloadavg. */
157 getloadavg (double loadavg
[], int nelem
)
161 /* A faithful emulation is going to have to be saved for a rainy day. */
162 for (i
= 0; i
< nelem
; i
++)
169 /* Emulate getpwuid, getpwnam and others. */
171 #define PASSWD_FIELD_SIZE 256
173 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
174 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
175 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
176 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
177 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
179 static struct passwd the_passwd
=
194 return the_passwd
.pw_uid
;
200 /* I could imagine arguing for checking to see whether the user is
201 in the Administrators group and returning a UID of 0 for that
202 case, but I don't know how wise that would be in the long run. */
209 return the_passwd
.pw_gid
;
221 if (uid
== the_passwd
.pw_uid
)
227 getpwnam (char *name
)
231 pw
= getpwuid (getuid ());
235 if (stricmp (name
, pw
->pw_name
))
244 /* Find the user's real name by opening the process token and
245 looking up the name associated with the user-sid in that token.
247 Use the relative portion of the identifier authority value from
248 the user-sid as the user id value (same for group id using the
249 primary group sid from the process token). */
251 char user_sid
[256], name
[256], domain
[256];
252 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
254 SID_NAME_USE user_type
;
256 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY
, &token
)
257 && GetTokenInformation (token
, TokenUser
,
258 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
259 && LookupAccountSid (NULL
, *((PSID
*) user_sid
), name
, &length
,
260 domain
, &dlength
, &user_type
))
262 strcpy (the_passwd
.pw_name
, name
);
263 /* Determine a reasonable uid value. */
264 if (stricmp ("administrator", name
) == 0)
266 the_passwd
.pw_uid
= 0;
267 the_passwd
.pw_gid
= 0;
271 SID_IDENTIFIER_AUTHORITY
* pSIA
;
273 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
274 /* I believe the relative portion is the last 4 bytes (of 6)
276 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
277 (pSIA
->Value
[3] << 16) +
278 (pSIA
->Value
[4] << 8) +
279 (pSIA
->Value
[5] << 0));
280 /* restrict to conventional uid range for normal users */
281 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
284 if (GetTokenInformation (token
, TokenPrimaryGroup
,
285 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
287 SID_IDENTIFIER_AUTHORITY
* pSIA
;
289 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
290 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
291 (pSIA
->Value
[3] << 16) +
292 (pSIA
->Value
[4] << 8) +
293 (pSIA
->Value
[5] << 0));
294 /* I don't know if this is necessary, but for safety... */
295 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
298 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
301 /* If security calls are not supported (presumably because we
302 are running under Windows 95), fallback to this. */
303 else if (GetUserName (name
, &length
))
305 strcpy (the_passwd
.pw_name
, name
);
306 if (stricmp ("administrator", name
) == 0)
307 the_passwd
.pw_uid
= 0;
309 the_passwd
.pw_uid
= 123;
310 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
314 strcpy (the_passwd
.pw_name
, "unknown");
315 the_passwd
.pw_uid
= 123;
316 the_passwd
.pw_gid
= 123;
319 /* Ensure HOME and SHELL are defined. */
320 if (getenv ("HOME") == NULL
)
322 if (getenv ("SHELL") == NULL
)
325 /* Set dir and shell from environment variables. */
326 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
327 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
336 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
337 return ((rand () << 15) | rand ());
347 /* Normalize filename by converting all path separators to
348 the specified separator. Also conditionally convert upper
349 case path name components to lower case. */
352 normalize_filename (fp
, path_sep
)
359 /* Always lower-case drive letters a-z, even if the filesystem
360 preserves case in filenames.
361 This is so filenames can be compared by string comparison
362 functions that are case-sensitive. Even case-preserving filesystems
363 do not distinguish case in drive letters. */
364 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
370 if (NILP (Vw32_downcase_file_names
))
374 if (*fp
== '/' || *fp
== '\\')
381 sep
= path_sep
; /* convert to this path separator */
382 elem
= fp
; /* start of current path element */
385 if (*fp
>= 'a' && *fp
<= 'z')
386 elem
= 0; /* don't convert this element */
388 if (*fp
== 0 || *fp
== ':')
390 sep
= *fp
; /* restore current separator (or 0) */
391 *fp
= '/'; /* after conversion of this element */
394 if (*fp
== '/' || *fp
== '\\')
396 if (elem
&& elem
!= fp
)
398 *fp
= 0; /* temporary end of string */
399 _strlwr (elem
); /* while we convert to lower case */
401 *fp
= sep
; /* convert (or restore) path separator */
402 elem
= fp
+ 1; /* next element starts after separator */
408 /* Destructively turn backslashes into slashes. */
410 dostounix_filename (p
)
413 normalize_filename (p
, '/');
416 /* Destructively turn slashes into backslashes. */
418 unixtodos_filename (p
)
421 normalize_filename (p
, '\\');
424 /* Remove all CR's that are followed by a LF.
425 (From msdos.c...probably should figure out a way to share it,
426 although this code isn't going to ever change.) */
430 register unsigned char *buf
;
432 unsigned char *np
= buf
;
433 unsigned char *startp
= buf
;
434 unsigned char *endp
= buf
+ n
;
438 while (buf
< endp
- 1)
442 if (*(++buf
) != 0x0a)
453 /* Parse the root part of file name, if present. Return length and
454 optionally store pointer to char after root. */
456 parse_root (char * name
, char ** pPath
)
463 /* find the root name of the volume if given */
464 if (isalpha (name
[0]) && name
[1] == ':')
466 /* skip past drive specifier */
468 if (IS_DIRECTORY_SEP (name
[0]))
471 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
477 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
482 if (IS_DIRECTORY_SEP (name
[0]))
492 /* Get long base name for name; name is assumed to be absolute. */
494 get_long_basename (char * name
, char * buf
, int size
)
496 WIN32_FIND_DATA find_data
;
500 /* must be valid filename, no wild cards or other invalid characters */
501 if (strpbrk (name
, "*?|<>\""))
504 dir_handle
= FindFirstFile (name
, &find_data
);
505 if (dir_handle
!= INVALID_HANDLE_VALUE
)
507 if ((len
= strlen (find_data
.cFileName
)) < size
)
508 memcpy (buf
, find_data
.cFileName
, len
+ 1);
511 FindClose (dir_handle
);
516 /* Get long name for file, if possible (assumed to be absolute). */
518 w32_get_long_filename (char * name
, char * buf
, int size
)
523 char full
[ MAX_PATH
];
530 /* Use local copy for destructive modification. */
531 memcpy (full
, name
, len
+1);
532 unixtodos_filename (full
);
534 /* Copy root part verbatim. */
535 len
= parse_root (full
, &p
);
536 memcpy (o
, full
, len
);
541 while (p
!= NULL
&& *p
)
544 p
= strchr (q
, '\\');
546 len
= get_long_basename (full
, o
, size
);
569 is_unc_volume (const char *filename
)
571 const char *ptr
= filename
;
573 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
576 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
582 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
585 sigsetmask (int signal_mask
)
609 setpgrp (int pid
, int gid
)
621 unrequest_sigio (void)
632 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
635 w32_get_resource (key
, lpdwtype
)
640 HKEY hrootkey
= NULL
;
644 /* Check both the current user and the local machine to see if
645 we have any resources. */
647 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
651 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
652 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
653 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
658 if (lpvalue
) xfree (lpvalue
);
660 RegCloseKey (hrootkey
);
663 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
667 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
668 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
669 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
674 if (lpvalue
) xfree (lpvalue
);
676 RegCloseKey (hrootkey
);
682 char *get_emacs_configuration (void);
683 extern Lisp_Object Vsystem_configuration
;
686 init_environment (char ** argv
)
688 static const char * const tempdirs
[] = {
689 "$TMPDIR", "$TEMP", "$TMP", "c:/"
692 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
694 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
695 temporary files and assume "/tmp" if $TMPDIR is unset, which
696 will break on DOS/Windows. Refuse to work if we cannot find
697 a directory, not even "c:/", usable for that purpose. */
698 for (i
= 0; i
< imax
; i
++)
700 const char *tmp
= tempdirs
[i
];
703 tmp
= getenv (tmp
+ 1);
704 /* Note that `access' can lie to us if the directory resides on a
705 read-only filesystem, like CD-ROM or a write-protected floppy.
706 The only way to be really sure is to actually create a file and
707 see if it succeeds. But I think that's too much to ask. */
708 if (tmp
&& _access (tmp
, D_OK
) == 0)
710 char * var
= alloca (strlen (tmp
) + 8);
711 sprintf (var
, "TMPDIR=%s", tmp
);
712 _putenv (strdup (var
));
719 Fcons (build_string ("no usable temporary directories found!!"),
721 "While setting TMPDIR: ");
723 /* Check for environment variables and use registry settings if they
724 don't exist. Fallback on default values where applicable. */
729 char locale_name
[32];
731 static struct env_entry
738 {"PRELOAD_WINSOCK", NULL
},
739 {"emacs_dir", "C:/emacs"},
740 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
741 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
742 {"EMACSDATA", "%emacs_dir%/etc"},
743 {"EMACSPATH", "%emacs_dir%/bin"},
744 {"EMACSLOCKDIR", "%emacs_dir%/lock"},
745 /* We no longer set INFOPATH because Info-default-directory-list
747 /* {"INFOPATH", "%emacs_dir%/info"}, */
748 {"EMACSDOC", "%emacs_dir%/etc"},
753 /* Get default locale info and use it for LANG. */
754 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
755 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
756 locale_name
, sizeof (locale_name
)))
758 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
760 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
762 env_vars
[i
].def_value
= locale_name
;
768 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
770 /* Treat emacs_dir specially: set it unconditionally based on our
771 location, if it appears that we are running from the bin subdir
772 of a standard installation. */
775 char modname
[MAX_PATH
];
777 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
779 if ((p
= strrchr (modname
, '\\')) == NULL
)
783 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
785 char buf
[SET_ENV_BUF_SIZE
];
788 for (p
= modname
; *p
; p
++)
789 if (*p
== '\\') *p
= '/';
791 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
792 _putenv (strdup (buf
));
796 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
798 if (!getenv (env_vars
[i
].name
))
802 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
)
804 lpval
= env_vars
[i
].def_value
;
805 dwType
= REG_EXPAND_SZ
;
811 if (dwType
== REG_EXPAND_SZ
)
813 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
815 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
816 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
, buf1
);
817 _putenv (strdup (buf2
));
819 else if (dwType
== REG_SZ
)
821 char buf
[SET_ENV_BUF_SIZE
];
823 _snprintf (buf
, sizeof(buf
)-1, "%s=%s", env_vars
[i
].name
, lpval
);
824 _putenv (strdup (buf
));
834 /* Rebuild system configuration to reflect invoking system. */
835 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
837 /* Another special case: on NT, the PATH variable is actually named
838 "Path" although cmd.exe (perhaps NT itself) arranges for
839 environment variable lookup and setting to be case insensitive.
840 However, Emacs assumes a fully case sensitive environment, so we
841 need to change "Path" to "PATH" to match the expectations of
842 various elisp packages. We do this by the sneaky method of
843 modifying the string in the C runtime environ entry.
845 The same applies to COMSPEC. */
849 for (envp
= environ
; *envp
; envp
++)
850 if (_strnicmp (*envp
, "PATH=", 5) == 0)
851 memcpy (*envp
, "PATH=", 5);
852 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
853 memcpy (*envp
, "COMSPEC=", 8);
856 /* Remember the initial working directory for getwd, then make the
857 real wd be the location of emacs.exe to avoid conflicts when
858 renaming or deleting directories. (We also don't call chdir when
859 running subprocesses for the same reason.) */
860 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
865 static char modname
[MAX_PATH
];
867 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
869 if ((p
= strrchr (modname
, '\\')) == NULL
)
873 SetCurrentDirectory (modname
);
875 /* Ensure argv[0] has the full path to Emacs. */
880 /* Determine if there is a middle mouse button, to allow parse_button
881 to decide whether right mouse events should be mouse-2 or
883 XSETINT (Vw32_num_mouse_buttons
, GetSystemMetrics (SM_CMOUSEBUTTONS
));
889 emacs_root_dir (void)
891 static char root_dir
[FILENAME_MAX
];
894 p
= getenv ("emacs_dir");
897 strcpy (root_dir
, p
);
898 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
899 dostounix_filename (root_dir
);
903 /* We don't have scripts to automatically determine the system configuration
904 for Emacs before it's compiled, and we don't want to have to make the
905 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
909 get_emacs_configuration (void)
911 char *arch
, *oem
, *os
;
913 static char configuration_buffer
[32];
915 /* Determine the processor type. */
916 switch (get_processor_type ())
919 #ifdef PROCESSOR_INTEL_386
920 case PROCESSOR_INTEL_386
:
921 case PROCESSOR_INTEL_486
:
922 case PROCESSOR_INTEL_PENTIUM
:
927 #ifdef PROCESSOR_INTEL_860
928 case PROCESSOR_INTEL_860
:
933 #ifdef PROCESSOR_MIPS_R2000
934 case PROCESSOR_MIPS_R2000
:
935 case PROCESSOR_MIPS_R3000
:
936 case PROCESSOR_MIPS_R4000
:
941 #ifdef PROCESSOR_ALPHA_21064
942 case PROCESSOR_ALPHA_21064
:
952 /* Use the OEM field to reflect the compiler/library combination. */
954 #define COMPILER_NAME "msvc"
957 #define COMPILER_NAME "mingw"
959 #define COMPILER_NAME "unknown"
964 switch (osinfo_cache
.dwPlatformId
) {
965 case VER_PLATFORM_WIN32_NT
:
967 build_num
= osinfo_cache
.dwBuildNumber
;
969 case VER_PLATFORM_WIN32_WINDOWS
:
970 if (osinfo_cache
.dwMinorVersion
== 0) {
975 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
977 case VER_PLATFORM_WIN32s
:
978 /* Not supported, should not happen. */
980 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
988 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
989 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
990 get_w32_major_version (), get_w32_minor_version (), build_num
);
992 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
995 return configuration_buffer
;
999 get_emacs_configuration_options (void)
1001 static char options_buffer
[256];
1003 /* Work out the effective configure options for this build. */
1005 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1008 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1010 #define COMPILER_VERSION ""
1014 sprintf (options_buffer
, COMPILER_VERSION
);
1016 strcat (options_buffer
, " --no-opt");
1019 strcat (options_buffer
, " --cflags");
1020 strcat (options_buffer
, USER_CFLAGS
);
1023 strcat (options_buffer
, " --ldflags");
1024 strcat (options_buffer
, USER_LDFLAGS
);
1026 return options_buffer
;
1030 #include <sys/timeb.h>
1032 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1034 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1039 tv
->tv_sec
= tb
.time
;
1040 tv
->tv_usec
= tb
.millitm
* 1000L;
1043 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1044 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1048 /* ------------------------------------------------------------------------- */
1049 /* IO support and wrapper functions for W32 API. */
1050 /* ------------------------------------------------------------------------- */
1052 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1053 on network directories, so we handle that case here.
1054 (Ulrich Leodolter, 1/11/95). */
1056 sys_ctime (const time_t *t
)
1058 char *str
= (char *) ctime (t
);
1059 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1062 /* Emulate sleep...we could have done this with a define, but that
1063 would necessitate including windows.h in the files that used it.
1064 This is much easier. */
1066 sys_sleep (int seconds
)
1068 Sleep (seconds
* 1000);
1071 /* Internal MSVC functions for low-level descriptor munging */
1072 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1073 extern int __cdecl
_free_osfhnd (int fd
);
1075 /* parallel array of private info on file handles */
1076 filedesc fd_info
[ MAXDESC
];
1078 typedef struct volume_info_data
{
1079 struct volume_info_data
* next
;
1081 /* time when info was obtained */
1084 /* actual volume info */
1093 /* Global referenced by various functions. */
1094 static volume_info_data volume_info
;
1096 /* Vector to indicate which drives are local and fixed (for which cached
1097 data never expires). */
1098 static BOOL fixed_drives
[26];
1100 /* Consider cached volume information to be stale if older than 10s,
1101 at least for non-local drives. Info for fixed drives is never stale. */
1102 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1103 #define VOLINFO_STILL_VALID( root_dir, info ) \
1104 ( ( isalpha (root_dir[0]) && \
1105 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1106 || GetTickCount () - info->timestamp < 10000 )
1108 /* Cache support functions. */
1110 /* Simple linked list with linear search is sufficient. */
1111 static volume_info_data
*volume_cache
= NULL
;
1113 static volume_info_data
*
1114 lookup_volume_info (char * root_dir
)
1116 volume_info_data
* info
;
1118 for (info
= volume_cache
; info
; info
= info
->next
)
1119 if (stricmp (info
->root_dir
, root_dir
) == 0)
1125 add_volume_info (char * root_dir
, volume_info_data
* info
)
1127 info
->root_dir
= xstrdup (root_dir
);
1128 info
->next
= volume_cache
;
1129 volume_cache
= info
;
1133 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1134 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1135 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1137 GetCachedVolumeInformation (char * root_dir
)
1139 volume_info_data
* info
;
1140 char default_root
[ MAX_PATH
];
1142 /* NULL for root_dir means use root from current directory. */
1143 if (root_dir
== NULL
)
1145 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1147 parse_root (default_root
, &root_dir
);
1149 root_dir
= default_root
;
1152 /* Local fixed drives can be cached permanently. Removable drives
1153 cannot be cached permanently, since the volume name and serial
1154 number (if nothing else) can change. Remote drives should be
1155 treated as if they are removable, since there is no sure way to
1156 tell whether they are or not. Also, the UNC association of drive
1157 letters mapped to remote volumes can be changed at any time (even
1158 by other processes) without notice.
1160 As a compromise, so we can benefit from caching info for remote
1161 volumes, we use a simple expiry mechanism to invalidate cache
1162 entries that are more than ten seconds old. */
1165 /* No point doing this, because WNetGetConnection is even slower than
1166 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1167 GetDriveType is about the only call of this type which does not
1168 involve network access, and so is extremely quick). */
1170 /* Map drive letter to UNC if remote. */
1171 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1173 char remote_name
[ 256 ];
1174 char drive
[3] = { root_dir
[0], ':' };
1176 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1178 /* do something */ ;
1182 info
= lookup_volume_info (root_dir
);
1184 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1192 /* Info is not cached, or is stale. */
1193 if (!GetVolumeInformation (root_dir
,
1194 name
, sizeof (name
),
1198 type
, sizeof (type
)))
1201 /* Cache the volume information for future use, overwriting existing
1202 entry if present. */
1205 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1206 add_volume_info (root_dir
, info
);
1214 info
->name
= xstrdup (name
);
1215 info
->serialnum
= serialnum
;
1216 info
->maxcomp
= maxcomp
;
1217 info
->flags
= flags
;
1218 info
->type
= xstrdup (type
);
1219 info
->timestamp
= GetTickCount ();
1225 /* Get information on the volume where name is held; set path pointer to
1226 start of pathname in name (past UNC header\volume header if present). */
1228 get_volume_info (const char * name
, const char ** pPath
)
1230 char temp
[MAX_PATH
];
1231 char *rootname
= NULL
; /* default to current volume */
1232 volume_info_data
* info
;
1237 /* find the root name of the volume if given */
1238 if (isalpha (name
[0]) && name
[1] == ':')
1246 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1253 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1266 info
= GetCachedVolumeInformation (rootname
);
1269 /* Set global referenced by other functions. */
1270 volume_info
= *info
;
1276 /* Determine if volume is FAT format (ie. only supports short 8.3
1277 names); also set path pointer to start of pathname in name. */
1279 is_fat_volume (const char * name
, const char ** pPath
)
1281 if (get_volume_info (name
, pPath
))
1282 return (volume_info
.maxcomp
== 12);
1286 /* Map filename to a legal 8.3 name if necessary. */
1288 map_w32_filename (const char * name
, const char ** pPath
)
1290 static char shortname
[MAX_PATH
];
1291 char * str
= shortname
;
1294 const char * save_name
= name
;
1296 if (strlen (name
) >= MAX_PATH
)
1298 /* Return a filename which will cause callers to fail. */
1299 strcpy (shortname
, "?");
1303 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1305 register int left
= 8; /* maximum number of chars in part */
1306 register int extn
= 0; /* extension added? */
1307 register int dots
= 2; /* maximum number of dots allowed */
1310 *str
++ = *name
++; /* skip past UNC header */
1312 while ((c
= *name
++))
1319 extn
= 0; /* reset extension flags */
1320 dots
= 2; /* max 2 dots */
1321 left
= 8; /* max length 8 for main part */
1325 extn
= 0; /* reset extension flags */
1326 dots
= 2; /* max 2 dots */
1327 left
= 8; /* max length 8 for main part */
1332 /* Convert path components of the form .xxx to _xxx,
1333 but leave . and .. as they are. This allows .emacs
1334 to be read as _emacs, for example. */
1338 IS_DIRECTORY_SEP (*name
))
1353 extn
= 1; /* we've got an extension */
1354 left
= 3; /* 3 chars in extension */
1358 /* any embedded dots after the first are converted to _ */
1363 case '#': /* don't lose these, they're important */
1365 str
[-1] = c
; /* replace last character of part */
1370 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1372 dots
= 0; /* started a path component */
1381 strcpy (shortname
, name
);
1382 unixtodos_filename (shortname
);
1386 *pPath
= shortname
+ (path
- save_name
);
1392 is_exec (const char * name
)
1394 char * p
= strrchr (name
, '.');
1397 && (stricmp (p
, ".exe") == 0 ||
1398 stricmp (p
, ".com") == 0 ||
1399 stricmp (p
, ".bat") == 0 ||
1400 stricmp (p
, ".cmd") == 0));
1403 /* Emulate the Unix directory procedures opendir, closedir,
1404 and readdir. We can't use the procedures supplied in sysdep.c,
1405 so we provide them here. */
1407 struct direct dir_static
; /* simulated directory contents */
1408 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1409 static int dir_is_fat
;
1410 static char dir_pathname
[MAXPATHLEN
+1];
1411 static WIN32_FIND_DATA dir_find_data
;
1413 /* Support shares on a network resource as subdirectories of a read-only
1415 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1416 HANDLE
open_unc_volume (char *);
1417 char *read_unc_volume (HANDLE
, char *, int);
1418 void close_unc_volume (HANDLE
);
1421 opendir (char *filename
)
1425 /* Opening is done by FindFirstFile. However, a read is inherent to
1426 this operation, so we defer the open until read time. */
1428 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1430 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1433 if (is_unc_volume (filename
))
1435 wnet_enum_handle
= open_unc_volume (filename
);
1436 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1440 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1447 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1448 dir_pathname
[MAXPATHLEN
] = '\0';
1449 dir_is_fat
= is_fat_volume (filename
, NULL
);
1455 closedir (DIR *dirp
)
1457 /* If we have a find-handle open, close it. */
1458 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1460 FindClose (dir_find_handle
);
1461 dir_find_handle
= INVALID_HANDLE_VALUE
;
1463 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1465 close_unc_volume (wnet_enum_handle
);
1466 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1468 xfree ((char *) dirp
);
1474 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1476 if (!read_unc_volume (wnet_enum_handle
,
1477 dir_find_data
.cFileName
,
1481 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1482 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1484 char filename
[MAXNAMLEN
+ 3];
1487 strcpy (filename
, dir_pathname
);
1488 ln
= strlen (filename
) - 1;
1489 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1490 strcat (filename
, "\\");
1491 strcat (filename
, "*");
1493 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1495 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1500 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1504 /* Emacs never uses this value, so don't bother making it match
1505 value returned by stat(). */
1506 dir_static
.d_ino
= 1;
1508 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1509 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1511 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1512 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1514 _strlwr (dir_static
.d_name
);
1515 else if (!NILP (Vw32_downcase_file_names
))
1518 for (p
= dir_static
.d_name
; *p
; p
++)
1519 if (*p
>= 'a' && *p
<= 'z')
1522 _strlwr (dir_static
.d_name
);
1529 open_unc_volume (char *path
)
1535 nr
.dwScope
= RESOURCE_GLOBALNET
;
1536 nr
.dwType
= RESOURCETYPE_DISK
;
1537 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1538 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1539 nr
.lpLocalName
= NULL
;
1540 nr
.lpRemoteName
= map_w32_filename (path
, NULL
);
1541 nr
.lpComment
= NULL
;
1542 nr
.lpProvider
= NULL
;
1544 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1545 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1547 if (result
== NO_ERROR
)
1550 return INVALID_HANDLE_VALUE
;
1554 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1558 DWORD bufsize
= 512;
1563 buffer
= alloca (bufsize
);
1564 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1565 if (result
!= NO_ERROR
)
1568 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1569 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1571 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1574 strncpy (readbuf
, ptr
, size
);
1579 close_unc_volume (HANDLE henum
)
1581 if (henum
!= INVALID_HANDLE_VALUE
)
1582 WNetCloseEnum (henum
);
1586 unc_volume_file_attributes (char *path
)
1591 henum
= open_unc_volume (path
);
1592 if (henum
== INVALID_HANDLE_VALUE
)
1595 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1597 close_unc_volume (henum
);
1603 /* Shadow some MSVC runtime functions to map requests for long filenames
1604 to reasonable short names if necessary. This was originally added to
1605 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1609 sys_access (const char * path
, int mode
)
1613 /* MSVC implementation doesn't recognize D_OK. */
1614 path
= map_w32_filename (path
, NULL
);
1615 if (is_unc_volume (path
))
1617 attributes
= unc_volume_file_attributes (path
);
1618 if (attributes
== -1) {
1623 else if ((attributes
= GetFileAttributes (path
)) == -1)
1625 /* Should try mapping GetLastError to errno; for now just indicate
1626 that path doesn't exist. */
1630 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1635 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1640 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1649 sys_chdir (const char * path
)
1651 return _chdir (map_w32_filename (path
, NULL
));
1655 sys_chmod (const char * path
, int mode
)
1657 return _chmod (map_w32_filename (path
, NULL
), mode
);
1661 sys_creat (const char * path
, int mode
)
1663 return _creat (map_w32_filename (path
, NULL
), mode
);
1667 sys_fopen(const char * path
, const char * mode
)
1671 const char * mode_save
= mode
;
1673 /* Force all file handles to be non-inheritable. This is necessary to
1674 ensure child processes don't unwittingly inherit handles that might
1675 prevent future file access. */
1679 else if (mode
[0] == 'w' || mode
[0] == 'a')
1680 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1684 /* Only do simplistic option parsing. */
1688 oflag
&= ~(O_RDONLY
| O_WRONLY
);
1691 else if (mode
[0] == 'b')
1696 else if (mode
[0] == 't')
1703 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
1707 return _fdopen (fd
, mode_save
);
1710 /* This only works on NTFS volumes, but is useful to have. */
1712 sys_link (const char * old
, const char * new)
1716 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
1718 if (old
== NULL
|| new == NULL
)
1724 strcpy (oldname
, map_w32_filename (old
, NULL
));
1725 strcpy (newname
, map_w32_filename (new, NULL
));
1727 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
1728 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
1729 if (fileh
!= INVALID_HANDLE_VALUE
)
1733 /* Confusingly, the "alternate" stream name field does not apply
1734 when restoring a hard link, and instead contains the actual
1735 stream data for the link (ie. the name of the link to create).
1736 The WIN32_STREAM_ID structure before the cStreamName field is
1737 the stream header, which is then immediately followed by the
1741 WIN32_STREAM_ID wid
;
1742 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
1745 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
1746 data
.wid
.cStreamName
, MAX_PATH
);
1749 LPVOID context
= NULL
;
1752 data
.wid
.dwStreamId
= BACKUP_LINK
;
1753 data
.wid
.dwStreamAttributes
= 0;
1754 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
1755 data
.wid
.Size
.HighPart
= 0;
1756 data
.wid
.dwStreamNameSize
= 0;
1758 if (BackupWrite (fileh
, (LPBYTE
)&data
,
1759 offsetof (WIN32_STREAM_ID
, cStreamName
)
1760 + data
.wid
.Size
.LowPart
,
1761 &wbytes
, FALSE
, FALSE
, &context
)
1762 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
1769 /* Should try mapping GetLastError to errno; for now just
1770 indicate a general error (eg. links not supported). */
1771 errno
= EINVAL
; // perhaps EMLINK?
1775 CloseHandle (fileh
);
1784 sys_mkdir (const char * path
)
1786 return _mkdir (map_w32_filename (path
, NULL
));
1789 /* Because of long name mapping issues, we need to implement this
1790 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1791 a unique name, instead of setting the input template to an empty
1794 Standard algorithm seems to be use pid or tid with a letter on the
1795 front (in place of the 6 X's) and cycle through the letters to find a
1796 unique name. We extend that to allow any reasonable character as the
1797 first of the 6 X's. */
1799 sys_mktemp (char * template)
1803 unsigned uid
= GetCurrentThreadId ();
1804 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1806 if (template == NULL
)
1808 p
= template + strlen (template);
1810 /* replace up to the last 5 X's with uid in decimal */
1811 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1813 p
[0] = '0' + uid
% 10;
1817 if (i
< 0 && p
[0] == 'X')
1822 int save_errno
= errno
;
1823 p
[0] = first_char
[i
];
1824 if (sys_access (template, 0) < 0)
1830 while (++i
< sizeof (first_char
));
1833 /* Template is badly formed or else we can't generate a unique name,
1834 so return empty string */
1840 sys_open (const char * path
, int oflag
, int mode
)
1842 const char* mpath
= map_w32_filename (path
, NULL
);
1843 /* Try to open file without _O_CREAT, to be able to write to hidden
1844 and system files. Force all file handles to be
1846 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
1849 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
1853 sys_rename (const char * oldname
, const char * newname
)
1856 char temp
[MAX_PATH
];
1858 /* MoveFile on Windows 95 doesn't correctly change the short file name
1859 alias in a number of circumstances (it is not easy to predict when
1860 just by looking at oldname and newname, unfortunately). In these
1861 cases, renaming through a temporary name avoids the problem.
1863 A second problem on Windows 95 is that renaming through a temp name when
1864 newname is uppercase fails (the final long name ends up in
1865 lowercase, although the short alias might be uppercase) UNLESS the
1866 long temp name is not 8.3.
1868 So, on Windows 95 we always rename through a temp name, and we make sure
1869 the temp name has a long extension to ensure correct renaming. */
1871 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1873 if (os_subtype
== OS_WIN95
)
1879 oldname
= map_w32_filename (oldname
, NULL
);
1880 if (o
= strrchr (oldname
, '\\'))
1883 o
= (char *) oldname
;
1885 if (p
= strrchr (temp
, '\\'))
1892 /* Force temp name to require a manufactured 8.3 alias - this
1893 seems to make the second rename work properly. */
1894 sprintf (p
, "_.%s.%u", o
, i
);
1896 result
= rename (oldname
, temp
);
1898 /* This loop must surely terminate! */
1899 while (result
< 0 && errno
== EEXIST
);
1904 /* Emulate Unix behaviour - newname is deleted if it already exists
1905 (at least if it is a file; don't do this for directories).
1907 Since we mustn't do this if we are just changing the case of the
1908 file name (we would end up deleting the file we are trying to
1909 rename!), we let rename detect if the destination file already
1910 exists - that way we avoid the possible pitfalls of trying to
1911 determine ourselves whether two names really refer to the same
1912 file, which is not always possible in the general case. (Consider
1913 all the permutations of shared or subst'd drives, etc.) */
1915 newname
= map_w32_filename (newname
, NULL
);
1916 result
= rename (temp
, newname
);
1920 && _chmod (newname
, 0666) == 0
1921 && _unlink (newname
) == 0)
1922 result
= rename (temp
, newname
);
1928 sys_rmdir (const char * path
)
1930 return _rmdir (map_w32_filename (path
, NULL
));
1934 sys_unlink (const char * path
)
1936 path
= map_w32_filename (path
, NULL
);
1938 /* On Unix, unlink works without write permission. */
1939 _chmod (path
, 0666);
1940 return _unlink (path
);
1943 static FILETIME utc_base_ft
;
1944 static long double utc_base
;
1945 static int init
= 0;
1948 convert_time (FILETIME ft
)
1954 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1963 st
.wMilliseconds
= 0;
1965 SystemTimeToFileTime (&st
, &utc_base_ft
);
1966 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1967 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1971 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1974 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1976 return (time_t) (ret
* 1e-7);
1980 convert_from_time_t (time_t time
, FILETIME
* pft
)
1986 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1995 st
.wMilliseconds
= 0;
1997 SystemTimeToFileTime (&st
, &utc_base_ft
);
1998 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1999 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
2003 /* time in 100ns units since 1-Jan-1601 */
2004 tmp
= (long double) time
* 1e7
+ utc_base
;
2005 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
2006 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2010 /* No reason to keep this; faking inode values either by hashing or even
2011 using the file index from GetInformationByHandle, is not perfect and
2012 so by default Emacs doesn't use the inode values on Windows.
2013 Instead, we now determine file-truename correctly (except for
2014 possible drive aliasing etc). */
2016 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2018 hashval (const unsigned char * str
)
2023 h
= (h
<< 4) + *str
++;
2029 /* Return the hash value of the canonical pathname, excluding the
2030 drive/UNC header, to get a hopefully unique inode number. */
2032 generate_inode_val (const char * name
)
2034 char fullname
[ MAX_PATH
];
2038 /* Get the truly canonical filename, if it exists. (Note: this
2039 doesn't resolve aliasing due to subst commands, or recognise hard
2041 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2044 parse_root (fullname
, &p
);
2045 /* Normal W32 filesystems are still case insensitive. */
2052 /* MSVC stat function can't cope with UNC names and has other bugs, so
2053 replace it with our own. This also allows us to calculate consistent
2054 inode values without hacks in the main Emacs code. */
2056 stat (const char * path
, struct stat
* buf
)
2059 WIN32_FIND_DATA wfd
;
2064 int rootdir
= FALSE
;
2066 if (path
== NULL
|| buf
== NULL
)
2072 name
= (char *) map_w32_filename (path
, &path
);
2073 /* must be valid filename, no wild cards or other invalid characters */
2074 if (strpbrk (name
, "*?|<>\""))
2080 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2081 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2082 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2087 /* Remove trailing directory separator, unless name is the root
2088 directory of a drive or UNC volume in which case ensure there
2089 is a trailing separator. */
2090 len
= strlen (name
);
2091 rootdir
= (path
>= name
+ len
- 1
2092 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2093 name
= strcpy (alloca (len
+ 2), name
);
2095 if (is_unc_volume (name
))
2097 DWORD attrs
= unc_volume_file_attributes (name
);
2102 memset (&wfd
, 0, sizeof (wfd
));
2103 wfd
.dwFileAttributes
= attrs
;
2104 wfd
.ftCreationTime
= utc_base_ft
;
2105 wfd
.ftLastAccessTime
= utc_base_ft
;
2106 wfd
.ftLastWriteTime
= utc_base_ft
;
2107 strcpy (wfd
.cFileName
, name
);
2111 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2112 strcat (name
, "\\");
2113 if (GetDriveType (name
) < 2)
2118 memset (&wfd
, 0, sizeof (wfd
));
2119 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2120 wfd
.ftCreationTime
= utc_base_ft
;
2121 wfd
.ftLastAccessTime
= utc_base_ft
;
2122 wfd
.ftLastWriteTime
= utc_base_ft
;
2123 strcpy (wfd
.cFileName
, name
);
2127 if (IS_DIRECTORY_SEP (name
[len
-1]))
2130 /* (This is hacky, but helps when doing file completions on
2131 network drives.) Optimize by using information available from
2132 active readdir if possible. */
2133 len
= strlen (dir_pathname
);
2134 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2136 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2137 && strnicmp (name
, dir_pathname
, len
) == 0
2138 && IS_DIRECTORY_SEP (name
[len
])
2139 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2141 /* This was the last entry returned by readdir. */
2142 wfd
= dir_find_data
;
2146 fh
= FindFirstFile (name
, &wfd
);
2147 if (fh
== INVALID_HANDLE_VALUE
)
2156 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2158 buf
->st_mode
= _S_IFDIR
;
2159 buf
->st_nlink
= 2; /* doesn't really matter */
2160 fake_inode
= 0; /* this doesn't either I think */
2162 else if (!NILP (Vw32_get_true_file_attributes
)
2163 /* No access rights required to get info. */
2164 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
, 0, NULL
))
2165 != INVALID_HANDLE_VALUE
)
2167 /* This is more accurate in terms of gettting the correct number
2168 of links, but is quite slow (it is noticable when Emacs is
2169 making a list of file name completions). */
2170 BY_HANDLE_FILE_INFORMATION info
;
2172 if (GetFileInformationByHandle (fh
, &info
))
2174 buf
->st_nlink
= info
.nNumberOfLinks
;
2175 /* Might as well use file index to fake inode values, but this
2176 is not guaranteed to be unique unless we keep a handle open
2177 all the time (even then there are situations where it is
2178 not unique). Reputedly, there are at most 48 bits of info
2179 (on NTFS, presumably less on FAT). */
2180 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2188 switch (GetFileType (fh
))
2190 case FILE_TYPE_DISK
:
2191 buf
->st_mode
= _S_IFREG
;
2193 case FILE_TYPE_PIPE
:
2194 buf
->st_mode
= _S_IFIFO
;
2196 case FILE_TYPE_CHAR
:
2197 case FILE_TYPE_UNKNOWN
:
2199 buf
->st_mode
= _S_IFCHR
;
2205 /* Don't bother to make this information more accurate. */
2206 buf
->st_mode
= _S_IFREG
;
2212 /* Not sure if there is any point in this. */
2213 if (!NILP (Vw32_generate_fake_inodes
))
2214 fake_inode
= generate_inode_val (name
);
2215 else if (fake_inode
== 0)
2217 /* For want of something better, try to make everything unique. */
2218 static DWORD gen_num
= 0;
2219 fake_inode
= ++gen_num
;
2223 /* MSVC defines _ino_t to be short; other libc's might not. */
2224 if (sizeof (buf
->st_ino
) == 2)
2225 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2227 buf
->st_ino
= fake_inode
;
2229 /* consider files to belong to current user */
2230 buf
->st_uid
= the_passwd
.pw_uid
;
2231 buf
->st_gid
= the_passwd
.pw_gid
;
2233 /* volume_info is set indirectly by map_w32_filename */
2234 buf
->st_dev
= volume_info
.serialnum
;
2235 buf
->st_rdev
= volume_info
.serialnum
;
2238 buf
->st_size
= wfd
.nFileSizeLow
;
2240 /* Convert timestamps to Unix format. */
2241 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2242 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2243 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2244 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2245 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2247 /* determine rwx permissions */
2248 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2249 permission
= _S_IREAD
;
2251 permission
= _S_IREAD
| _S_IWRITE
;
2253 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2254 permission
|= _S_IEXEC
;
2255 else if (is_exec (name
))
2256 permission
|= _S_IEXEC
;
2258 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2263 /* Provide fstat and utime as well as stat for consistent handling of
2266 fstat (int desc
, struct stat
* buf
)
2268 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2269 BY_HANDLE_FILE_INFORMATION info
;
2273 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2275 case FILE_TYPE_DISK
:
2276 buf
->st_mode
= _S_IFREG
;
2277 if (!GetFileInformationByHandle (fh
, &info
))
2283 case FILE_TYPE_PIPE
:
2284 buf
->st_mode
= _S_IFIFO
;
2286 case FILE_TYPE_CHAR
:
2287 case FILE_TYPE_UNKNOWN
:
2289 buf
->st_mode
= _S_IFCHR
;
2291 memset (&info
, 0, sizeof (info
));
2292 info
.dwFileAttributes
= 0;
2293 info
.ftCreationTime
= utc_base_ft
;
2294 info
.ftLastAccessTime
= utc_base_ft
;
2295 info
.ftLastWriteTime
= utc_base_ft
;
2298 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2300 buf
->st_mode
= _S_IFDIR
;
2301 buf
->st_nlink
= 2; /* doesn't really matter */
2302 fake_inode
= 0; /* this doesn't either I think */
2306 buf
->st_nlink
= info
.nNumberOfLinks
;
2307 /* Might as well use file index to fake inode values, but this
2308 is not guaranteed to be unique unless we keep a handle open
2309 all the time (even then there are situations where it is
2310 not unique). Reputedly, there are at most 48 bits of info
2311 (on NTFS, presumably less on FAT). */
2312 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2315 /* MSVC defines _ino_t to be short; other libc's might not. */
2316 if (sizeof (buf
->st_ino
) == 2)
2317 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2319 buf
->st_ino
= fake_inode
;
2321 /* consider files to belong to current user */
2325 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2326 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2328 buf
->st_size
= info
.nFileSizeLow
;
2330 /* Convert timestamps to Unix format. */
2331 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2332 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2333 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2334 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2335 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2337 /* determine rwx permissions */
2338 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2339 permission
= _S_IREAD
;
2341 permission
= _S_IREAD
| _S_IWRITE
;
2343 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2344 permission
|= _S_IEXEC
;
2347 #if 0 /* no way of knowing the filename */
2348 char * p
= strrchr (name
, '.');
2350 (stricmp (p
, ".exe") == 0 ||
2351 stricmp (p
, ".com") == 0 ||
2352 stricmp (p
, ".bat") == 0 ||
2353 stricmp (p
, ".cmd") == 0))
2354 permission
|= _S_IEXEC
;
2358 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2364 utime (const char *name
, struct utimbuf
*times
)
2366 struct utimbuf deftime
;
2373 deftime
.modtime
= deftime
.actime
= time (NULL
);
2377 /* Need write access to set times. */
2378 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2379 0, OPEN_EXISTING
, 0, NULL
);
2382 convert_from_time_t (times
->actime
, &atime
);
2383 convert_from_time_t (times
->modtime
, &mtime
);
2384 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2402 /* Wrappers for winsock functions to map between our file descriptors
2403 and winsock's handles; also set h_errno for convenience.
2405 To allow Emacs to run on systems which don't have winsock support
2406 installed, we dynamically link to winsock on startup if present, and
2407 otherwise provide the minimum necessary functionality
2408 (eg. gethostname). */
2410 /* function pointers for relevant socket functions */
2411 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2412 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2413 int (PASCAL
*pfn_WSAGetLastError
) (void);
2414 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2415 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2416 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2417 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2418 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2419 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2420 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2421 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2422 int (PASCAL
*pfn_WSACleanup
) (void);
2424 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2425 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2426 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2427 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2428 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2429 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2431 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
2432 const char * optval
, int optlen
);
2433 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
2434 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
2436 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
2437 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
2438 struct sockaddr
* from
, int * fromlen
);
2439 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
2440 const struct sockaddr
* to
, int tolen
);
2442 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2443 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2444 #ifndef HANDLE_FLAG_INHERIT
2445 #define HANDLE_FLAG_INHERIT 1
2449 static int winsock_inuse
;
2454 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2456 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2457 after WSAStartup returns successfully, but it seems reasonable
2458 to allow unloading winsock anyway in that case. */
2459 if (pfn_WSACleanup () == 0 ||
2460 pfn_WSAGetLastError () == WSAENETDOWN
)
2462 if (FreeLibrary (winsock_lib
))
2471 init_winsock (int load_now
)
2473 WSADATA winsockData
;
2475 if (winsock_lib
!= NULL
)
2478 pfn_SetHandleInformation
= NULL
;
2479 pfn_SetHandleInformation
2480 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2481 "SetHandleInformation");
2483 winsock_lib
= LoadLibrary ("wsock32.dll");
2485 if (winsock_lib
!= NULL
)
2487 /* dynamically link to socket functions */
2489 #define LOAD_PROC(fn) \
2490 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2493 LOAD_PROC( WSAStartup
);
2494 LOAD_PROC( WSASetLastError
);
2495 LOAD_PROC( WSAGetLastError
);
2496 LOAD_PROC( socket
);
2498 LOAD_PROC( connect
);
2499 LOAD_PROC( ioctlsocket
);
2502 LOAD_PROC( closesocket
);
2503 LOAD_PROC( shutdown
);
2506 LOAD_PROC( inet_addr
);
2507 LOAD_PROC( gethostname
);
2508 LOAD_PROC( gethostbyname
);
2509 LOAD_PROC( getservbyname
);
2510 LOAD_PROC( WSACleanup
);
2511 LOAD_PROC( setsockopt
);
2512 LOAD_PROC( listen
);
2513 LOAD_PROC( getsockname
);
2514 LOAD_PROC( accept
);
2515 LOAD_PROC( recvfrom
);
2516 LOAD_PROC( sendto
);
2519 /* specify version 1.1 of winsock */
2520 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2522 if (winsockData
.wVersion
!= 0x101)
2527 /* Report that winsock exists and is usable, but leave
2528 socket functions disabled. I am assuming that calling
2529 WSAStartup does not require any network interaction,
2530 and in particular does not cause or require a dial-up
2531 connection to be established. */
2534 FreeLibrary (winsock_lib
);
2542 FreeLibrary (winsock_lib
);
2552 /* function to set h_errno for compatability; map winsock error codes to
2553 normal system codes where they overlap (non-overlapping definitions
2554 are already in <sys/socket.h> */
2555 static void set_errno ()
2557 if (winsock_lib
== NULL
)
2560 h_errno
= pfn_WSAGetLastError ();
2564 case WSAEACCES
: h_errno
= EACCES
; break;
2565 case WSAEBADF
: h_errno
= EBADF
; break;
2566 case WSAEFAULT
: h_errno
= EFAULT
; break;
2567 case WSAEINTR
: h_errno
= EINTR
; break;
2568 case WSAEINVAL
: h_errno
= EINVAL
; break;
2569 case WSAEMFILE
: h_errno
= EMFILE
; break;
2570 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2571 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2576 static void check_errno ()
2578 if (h_errno
== 0 && winsock_lib
!= NULL
)
2579 pfn_WSASetLastError (0);
2582 /* Extend strerror to handle the winsock-specific error codes. */
2586 } _wsa_errlist
[] = {
2587 WSAEINTR
, "Interrupted function call",
2588 WSAEBADF
, "Bad file descriptor",
2589 WSAEACCES
, "Permission denied",
2590 WSAEFAULT
, "Bad address",
2591 WSAEINVAL
, "Invalid argument",
2592 WSAEMFILE
, "Too many open files",
2594 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2595 WSAEINPROGRESS
, "Operation now in progress",
2596 WSAEALREADY
, "Operation already in progress",
2597 WSAENOTSOCK
, "Socket operation on non-socket",
2598 WSAEDESTADDRREQ
, "Destination address required",
2599 WSAEMSGSIZE
, "Message too long",
2600 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2601 WSAENOPROTOOPT
, "Bad protocol option",
2602 WSAEPROTONOSUPPORT
, "Protocol not supported",
2603 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2604 WSAEOPNOTSUPP
, "Operation not supported",
2605 WSAEPFNOSUPPORT
, "Protocol family not supported",
2606 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2607 WSAEADDRINUSE
, "Address already in use",
2608 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2609 WSAENETDOWN
, "Network is down",
2610 WSAENETUNREACH
, "Network is unreachable",
2611 WSAENETRESET
, "Network dropped connection on reset",
2612 WSAECONNABORTED
, "Software caused connection abort",
2613 WSAECONNRESET
, "Connection reset by peer",
2614 WSAENOBUFS
, "No buffer space available",
2615 WSAEISCONN
, "Socket is already connected",
2616 WSAENOTCONN
, "Socket is not connected",
2617 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2618 WSAETOOMANYREFS
, "Too many references", /* not sure */
2619 WSAETIMEDOUT
, "Connection timed out",
2620 WSAECONNREFUSED
, "Connection refused",
2621 WSAELOOP
, "Network loop", /* not sure */
2622 WSAENAMETOOLONG
, "Name is too long",
2623 WSAEHOSTDOWN
, "Host is down",
2624 WSAEHOSTUNREACH
, "No route to host",
2625 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2626 WSAEPROCLIM
, "Too many processes",
2627 WSAEUSERS
, "Too many users", /* not sure */
2628 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2629 WSAESTALE
, "Data is stale", /* not sure */
2630 WSAEREMOTE
, "Remote error", /* not sure */
2632 WSASYSNOTREADY
, "Network subsystem is unavailable",
2633 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2634 WSANOTINITIALISED
, "Winsock not initialized successfully",
2635 WSAEDISCON
, "Graceful shutdown in progress",
2637 WSAENOMORE
, "No more operations allowed", /* not sure */
2638 WSAECANCELLED
, "Operation cancelled", /* not sure */
2639 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2640 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2641 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2642 WSASYSCALLFAILURE
, "System call failured",
2643 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2644 WSATYPE_NOT_FOUND
, "Class type not found",
2645 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2646 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2647 WSAEREFUSED
, "Operation refused", /* not sure */
2650 WSAHOST_NOT_FOUND
, "Host not found",
2651 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2652 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2653 WSANO_DATA
, "Valid name, no data record of requested type",
2659 sys_strerror(int error_no
)
2662 static char unknown_msg
[40];
2664 if (error_no
>= 0 && error_no
< sys_nerr
)
2665 return sys_errlist
[error_no
];
2667 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2668 if (_wsa_errlist
[i
].errnum
== error_no
)
2669 return _wsa_errlist
[i
].msg
;
2671 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
2675 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2676 but I believe the method of keeping the socket handle separate (and
2677 insuring it is not inheritable) is the correct one. */
2679 //#define SOCK_REPLACE_HANDLE
2681 #ifdef SOCK_REPLACE_HANDLE
2682 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2684 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2687 int socket_to_fd (SOCKET s
);
2690 sys_socket(int af
, int type
, int protocol
)
2694 if (winsock_lib
== NULL
)
2697 return INVALID_SOCKET
;
2702 /* call the real socket function */
2703 s
= pfn_socket (af
, type
, protocol
);
2705 if (s
!= INVALID_SOCKET
)
2706 return socket_to_fd (s
);
2712 /* Convert a SOCKET to a file descriptor. */
2714 socket_to_fd (SOCKET s
)
2719 /* Although under NT 3.5 _open_osfhandle will accept a socket
2720 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2721 that does not work under NT 3.1. However, we can get the same
2722 effect by using a backdoor function to replace an existing
2723 descriptor handle with the one we want. */
2725 /* allocate a file descriptor (with appropriate flags) */
2726 fd
= _open ("NUL:", _O_RDWR
);
2729 #ifdef SOCK_REPLACE_HANDLE
2730 /* now replace handle to NUL with our socket handle */
2731 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
2733 _set_osfhnd (fd
, s
);
2734 /* setmode (fd, _O_BINARY); */
2736 /* Make a non-inheritable copy of the socket handle. Note
2737 that it is possible that sockets aren't actually kernel
2738 handles, which appears to be the case on Windows 9x when
2739 the MS Proxy winsock client is installed. */
2741 /* Apparently there is a bug in NT 3.51 with some service
2742 packs, which prevents using DuplicateHandle to make a
2743 socket handle non-inheritable (causes WSACleanup to
2744 hang). The work-around is to use SetHandleInformation
2745 instead if it is available and implemented. */
2746 if (pfn_SetHandleInformation
)
2748 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
2752 HANDLE parent
= GetCurrentProcess ();
2753 HANDLE new_s
= INVALID_HANDLE_VALUE
;
2755 if (DuplicateHandle (parent
,
2761 DUPLICATE_SAME_ACCESS
))
2763 /* It is possible that DuplicateHandle succeeds even
2764 though the socket wasn't really a kernel handle,
2765 because a real handle has the same value. So
2766 test whether the new handle really is a socket. */
2767 long nonblocking
= 0;
2768 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
2770 pfn_closesocket (s
);
2775 CloseHandle (new_s
);
2780 fd_info
[fd
].hnd
= (HANDLE
) s
;
2783 /* set our own internal flags */
2784 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
2790 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2792 /* attach child_process to fd_info */
2793 if (fd_info
[ fd
].cp
!= NULL
)
2795 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
2799 fd_info
[ fd
].cp
= cp
;
2802 winsock_inuse
++; /* count open sockets */
2809 pfn_closesocket (s
);
2816 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
2818 if (winsock_lib
== NULL
)
2821 return SOCKET_ERROR
;
2825 if (fd_info
[s
].flags
& FILE_SOCKET
)
2827 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
2828 if (rc
== SOCKET_ERROR
)
2833 return SOCKET_ERROR
;
2838 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
2840 if (winsock_lib
== NULL
)
2843 return SOCKET_ERROR
;
2847 if (fd_info
[s
].flags
& FILE_SOCKET
)
2849 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
2850 if (rc
== SOCKET_ERROR
)
2855 return SOCKET_ERROR
;
2859 sys_htons (u_short hostshort
)
2861 return (winsock_lib
!= NULL
) ?
2862 pfn_htons (hostshort
) : hostshort
;
2866 sys_ntohs (u_short netshort
)
2868 return (winsock_lib
!= NULL
) ?
2869 pfn_ntohs (netshort
) : netshort
;
2873 sys_inet_addr (const char * cp
)
2875 return (winsock_lib
!= NULL
) ?
2876 pfn_inet_addr (cp
) : INADDR_NONE
;
2880 sys_gethostname (char * name
, int namelen
)
2882 if (winsock_lib
!= NULL
)
2883 return pfn_gethostname (name
, namelen
);
2885 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
2886 return !GetComputerName (name
, (DWORD
*)&namelen
);
2889 return SOCKET_ERROR
;
2893 sys_gethostbyname(const char * name
)
2895 struct hostent
* host
;
2897 if (winsock_lib
== NULL
)
2904 host
= pfn_gethostbyname (name
);
2911 sys_getservbyname(const char * name
, const char * proto
)
2913 struct servent
* serv
;
2915 if (winsock_lib
== NULL
)
2922 serv
= pfn_getservbyname (name
, proto
);
2929 sys_shutdown (int s
, int how
)
2931 if (winsock_lib
== NULL
)
2934 return SOCKET_ERROR
;
2938 if (fd_info
[s
].flags
& FILE_SOCKET
)
2940 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
2941 if (rc
== SOCKET_ERROR
)
2946 return SOCKET_ERROR
;
2950 sys_setsockopt (int s
, int level
, int optname
, const char * optval
, int optlen
)
2952 if (winsock_lib
== NULL
)
2955 return SOCKET_ERROR
;
2959 if (fd_info
[s
].flags
& FILE_SOCKET
)
2961 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
2963 if (rc
== SOCKET_ERROR
)
2968 return SOCKET_ERROR
;
2972 sys_listen (int s
, int backlog
)
2974 if (winsock_lib
== NULL
)
2977 return SOCKET_ERROR
;
2981 if (fd_info
[s
].flags
& FILE_SOCKET
)
2983 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
2984 if (rc
== SOCKET_ERROR
)
2989 return SOCKET_ERROR
;
2993 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
2995 if (winsock_lib
== NULL
)
2998 return SOCKET_ERROR
;
3002 if (fd_info
[s
].flags
& FILE_SOCKET
)
3004 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
3005 if (rc
== SOCKET_ERROR
)
3010 return SOCKET_ERROR
;
3014 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
3016 if (winsock_lib
== NULL
)
3023 if (fd_info
[s
].flags
& FILE_SOCKET
)
3025 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
3026 if (t
!= INVALID_SOCKET
)
3027 return socket_to_fd (t
);
3037 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
3038 struct sockaddr
* from
, int * fromlen
)
3040 if (winsock_lib
== NULL
)
3043 return SOCKET_ERROR
;
3047 if (fd_info
[s
].flags
& FILE_SOCKET
)
3049 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
3050 if (rc
== SOCKET_ERROR
)
3055 return SOCKET_ERROR
;
3059 sys_sendto (int s
, const char * buf
, int len
, int flags
,
3060 const struct sockaddr
* to
, int tolen
)
3062 if (winsock_lib
== NULL
)
3065 return SOCKET_ERROR
;
3069 if (fd_info
[s
].flags
& FILE_SOCKET
)
3071 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
3072 if (rc
== SOCKET_ERROR
)
3077 return SOCKET_ERROR
;
3080 #endif /* HAVE_SOCKETS */
3083 /* Shadow main io functions: we need to handle pipes and sockets more
3084 intelligently, and implement non-blocking mode as well. */
3091 if (fd
< 0 || fd
>= MAXDESC
)
3099 child_process
* cp
= fd_info
[fd
].cp
;
3101 fd_info
[fd
].cp
= NULL
;
3103 if (CHILD_ACTIVE (cp
))
3105 /* if last descriptor to active child_process then cleanup */
3107 for (i
= 0; i
< MAXDESC
; i
++)
3111 if (fd_info
[i
].cp
== cp
)
3117 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3119 #ifndef SOCK_REPLACE_HANDLE
3120 if (winsock_lib
== NULL
) abort ();
3122 pfn_shutdown (SOCK_HANDLE (fd
), 2);
3123 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
3125 winsock_inuse
--; /* count open sockets */
3133 /* Note that sockets do not need special treatment here (at least on
3134 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3135 closesocket is equivalent to CloseHandle, which is to be expected
3136 because socket handles are fully fledged kernel handles. */
3140 fd_info
[fd
].flags
= 0;
3153 /* duplicate our internal info as well */
3154 fd_info
[new_fd
] = fd_info
[fd
];
3161 sys_dup2 (int src
, int dst
)
3165 if (dst
< 0 || dst
>= MAXDESC
)
3171 /* make sure we close the destination first if it's a pipe or socket */
3172 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3175 rc
= _dup2 (src
, dst
);
3178 /* duplicate our internal info as well */
3179 fd_info
[dst
] = fd_info
[src
];
3184 /* Unix pipe() has only one arg */
3186 sys_pipe (int * phandles
)
3191 /* make pipe handles non-inheritable; when we spawn a child, we
3192 replace the relevant handle with an inheritable one. Also put
3193 pipes into binary mode; we will do text mode translation ourselves
3195 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3199 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3200 fd_info
[phandles
[0]].flags
= flags
;
3202 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3203 fd_info
[phandles
[1]].flags
= flags
;
3210 extern Lisp_Object Vw32_pipe_read_delay
;
3212 /* Function to do blocking read of one byte, needed to implement
3213 select. It is only allowed on sockets and pipes. */
3215 _sys_read_ahead (int fd
)
3220 if (fd
< 0 || fd
>= MAXDESC
)
3221 return STATUS_READ_ERROR
;
3223 cp
= fd_info
[fd
].cp
;
3225 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3226 return STATUS_READ_ERROR
;
3228 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3229 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3231 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3235 cp
->status
= STATUS_READ_IN_PROGRESS
;
3237 if (fd_info
[fd
].flags
& FILE_PIPE
)
3239 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3241 /* Give subprocess time to buffer some more output for us before
3242 reporting that input is available; we need this because Windows 95
3243 connects DOS programs to pipes by making the pipe appear to be
3244 the normal console stdout - as a result most DOS programs will
3245 write to stdout without buffering, ie. one character at a
3246 time. Even some W32 programs do this - "dir" in a command
3247 shell on NT is very slow if we don't do this. */
3250 int wait
= XINT (Vw32_pipe_read_delay
);
3256 /* Yield remainder of our time slice, effectively giving a
3257 temporary priority boost to the child process. */
3262 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3263 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3266 if (rc
== sizeof (char))
3267 cp
->status
= STATUS_READ_SUCCEEDED
;
3269 cp
->status
= STATUS_READ_FAILED
;
3275 sys_read (int fd
, char * buffer
, unsigned int count
)
3280 char * orig_buffer
= buffer
;
3282 if (fd
< 0 || fd
>= MAXDESC
)
3288 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3290 child_process
*cp
= fd_info
[fd
].cp
;
3292 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3300 /* re-read CR carried over from last read */
3301 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3303 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3307 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3310 /* presence of a child_process structure means we are operating in
3311 non-blocking mode - otherwise we just call _read directly.
3312 Note that the child_process structure might be missing because
3313 reap_subprocess has been called; in this case the pipe is
3314 already broken, so calling _read on it is okay. */
3317 int current_status
= cp
->status
;
3319 switch (current_status
)
3321 case STATUS_READ_FAILED
:
3322 case STATUS_READ_ERROR
:
3323 /* report normal EOF if nothing in buffer */
3325 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3328 case STATUS_READ_READY
:
3329 case STATUS_READ_IN_PROGRESS
:
3330 DebPrint (("sys_read called when read is in progress\n"));
3331 errno
= EWOULDBLOCK
;
3334 case STATUS_READ_SUCCEEDED
:
3335 /* consume read-ahead char */
3336 *buffer
++ = cp
->chr
;
3339 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3340 ResetEvent (cp
->char_avail
);
3342 case STATUS_READ_ACKNOWLEDGED
:
3346 DebPrint (("sys_read: bad status %d\n", current_status
));
3351 if (fd_info
[fd
].flags
& FILE_PIPE
)
3353 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3354 to_read
= min (waiting
, (DWORD
) count
);
3357 nchars
+= _read (fd
, buffer
, to_read
);
3360 else /* FILE_SOCKET */
3362 if (winsock_lib
== NULL
) abort ();
3364 /* do the equivalent of a non-blocking read */
3365 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3366 if (waiting
== 0 && nchars
== 0)
3368 h_errno
= errno
= EWOULDBLOCK
;
3374 /* always use binary mode for sockets */
3375 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3376 if (res
== SOCKET_ERROR
)
3378 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3379 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3390 int nread
= _read (fd
, buffer
, count
);
3393 else if (nchars
== 0)
3398 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3399 /* Perform text mode translation if required. */
3400 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3402 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3403 /* If buffer contains only CR, return that. To be absolutely
3404 sure we should attempt to read the next char, but in
3405 practice a CR to be followed by LF would not appear by
3406 itself in the buffer. */
3407 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3409 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3415 nchars
= _read (fd
, buffer
, count
);
3420 /* For now, don't bother with a non-blocking mode */
3422 sys_write (int fd
, const void * buffer
, unsigned int count
)
3426 if (fd
< 0 || fd
>= MAXDESC
)
3432 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3434 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3440 /* Perform text mode translation if required. */
3441 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3443 char * tmpbuf
= alloca (count
* 2);
3444 unsigned char * src
= (void *)buffer
;
3445 unsigned char * dst
= tmpbuf
;
3450 unsigned char *next
;
3451 /* copy next line or remaining bytes */
3452 next
= _memccpy (dst
, src
, '\n', nbytes
);
3455 /* copied one line ending with '\n' */
3456 int copied
= next
- dst
;
3459 /* insert '\r' before '\n' */
3466 /* copied remaining partial line -> now finished */
3474 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3476 if (winsock_lib
== NULL
) abort ();
3477 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3478 if (nchars
== SOCKET_ERROR
)
3480 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3481 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3487 nchars
= _write (fd
, buffer
, count
);
3493 check_windows_init_file ()
3495 extern int noninteractive
, inhibit_window_system
;
3497 /* A common indication that Emacs is not installed properly is when
3498 it cannot find the Windows installation file. If this file does
3499 not exist in the expected place, tell the user. */
3501 if (!noninteractive
&& !inhibit_window_system
)
3503 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3504 Lisp_Object objs
[2];
3505 Lisp_Object full_load_path
;
3506 Lisp_Object init_file
;
3509 objs
[0] = Vload_path
;
3510 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3511 full_load_path
= Fappend (2, objs
);
3512 init_file
= build_string ("term/w32-win");
3513 fd
= openp (full_load_path
, init_file
, Vload_suffixes
, NULL
, 0);
3516 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3517 char *init_file_name
= XSTRING (init_file
)->data
;
3518 char *load_path
= XSTRING (load_path_print
)->data
;
3519 char *buffer
= alloca (1024);
3522 "The Emacs Windows initialization file \"%s.el\" "
3523 "could not be found in your Emacs installation. "
3524 "Emacs checked the following directories for this file:\n"
3526 "When Emacs cannot find this file, it usually means that it "
3527 "was not installed properly, or its distribution file was "
3528 "not unpacked properly.\nSee the README.W32 file in the "
3529 "top-level Emacs directory for more information.",
3530 init_file_name
, load_path
);
3533 "Emacs Abort Dialog",
3534 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3535 /* Use the low-level Emacs abort. */
3550 /* shutdown the socket interface if necessary */
3559 /* Initialise the socket interface now if available and requested by
3560 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3561 delayed until open-network-stream is called (w32-has-winsock can
3562 also be used to dynamically load or reload winsock).
3564 Conveniently, init_environment is called before us, so
3565 PRELOAD_WINSOCK can be set in the registry. */
3567 /* Always initialize this correctly. */
3570 if (getenv ("PRELOAD_WINSOCK") != NULL
)
3571 init_winsock (TRUE
);
3574 /* Initial preparation for subprocess support: replace our standard
3575 handles with non-inheritable versions. */
3578 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
3579 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
3580 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
3582 parent
= GetCurrentProcess ();
3584 /* ignore errors when duplicating and closing; typically the
3585 handles will be invalid when running as a gui program. */
3586 DuplicateHandle (parent
,
3587 GetStdHandle (STD_INPUT_HANDLE
),
3592 DUPLICATE_SAME_ACCESS
);
3594 DuplicateHandle (parent
,
3595 GetStdHandle (STD_OUTPUT_HANDLE
),
3600 DUPLICATE_SAME_ACCESS
);
3602 DuplicateHandle (parent
,
3603 GetStdHandle (STD_ERROR_HANDLE
),
3608 DUPLICATE_SAME_ACCESS
);
3614 if (stdin_save
!= INVALID_HANDLE_VALUE
)
3615 _open_osfhandle ((long) stdin_save
, O_TEXT
);
3617 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
3620 if (stdout_save
!= INVALID_HANDLE_VALUE
)
3621 _open_osfhandle ((long) stdout_save
, O_TEXT
);
3623 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3626 if (stderr_save
!= INVALID_HANDLE_VALUE
)
3627 _open_osfhandle ((long) stderr_save
, O_TEXT
);
3629 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3633 /* unfortunately, atexit depends on implementation of malloc */
3634 /* atexit (term_ntproc); */
3635 signal (SIGABRT
, term_ntproc
);
3637 /* determine which drives are fixed, for GetCachedVolumeInformation */
3639 /* GetDriveType must have trailing backslash. */
3640 char drive
[] = "A:\\";
3642 /* Loop over all possible drive letters */
3643 while (*drive
<= 'Z')
3645 /* Record if this drive letter refers to a fixed drive. */
3646 fixed_drives
[DRIVE_INDEX (*drive
)] =
3647 (GetDriveType (drive
) == DRIVE_FIXED
);
3652 /* Reset the volume info cache. */
3653 volume_cache
= NULL
;
3656 /* Check to see if Emacs has been installed correctly. */
3657 check_windows_init_file ();