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
));
879 emacs_root_dir (void)
881 static char root_dir
[FILENAME_MAX
];
884 p
= getenv ("emacs_dir");
887 strcpy (root_dir
, p
);
888 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
889 dostounix_filename (root_dir
);
893 /* We don't have scripts to automatically determine the system configuration
894 for Emacs before it's compiled, and we don't want to have to make the
895 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
899 get_emacs_configuration (void)
901 char *arch
, *oem
, *os
;
903 static char configuration_buffer
[32];
905 /* Determine the processor type. */
906 switch (get_processor_type ())
909 #ifdef PROCESSOR_INTEL_386
910 case PROCESSOR_INTEL_386
:
911 case PROCESSOR_INTEL_486
:
912 case PROCESSOR_INTEL_PENTIUM
:
917 #ifdef PROCESSOR_INTEL_860
918 case PROCESSOR_INTEL_860
:
923 #ifdef PROCESSOR_MIPS_R2000
924 case PROCESSOR_MIPS_R2000
:
925 case PROCESSOR_MIPS_R3000
:
926 case PROCESSOR_MIPS_R4000
:
931 #ifdef PROCESSOR_ALPHA_21064
932 case PROCESSOR_ALPHA_21064
:
942 /* Use the OEM field to reflect the compiler/library combination. */
944 #define COMPILER_NAME "msvc"
947 #define COMPILER_NAME "mingw"
949 #define COMPILER_NAME "unknown"
954 switch (osinfo_cache
.dwPlatformId
) {
955 case VER_PLATFORM_WIN32_NT
:
957 build_num
= osinfo_cache
.dwBuildNumber
;
959 case VER_PLATFORM_WIN32_WINDOWS
:
960 if (osinfo_cache
.dwMinorVersion
== 0) {
965 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
967 case VER_PLATFORM_WIN32s
:
968 /* Not supported, should not happen. */
970 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
978 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
979 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
980 get_w32_major_version (), get_w32_minor_version (), build_num
);
982 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
985 return configuration_buffer
;
989 get_emacs_configuration_options (void)
991 static char options_buffer
[256];
993 /* Work out the effective configure options for this build. */
995 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
998 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1000 #define COMPILER_VERSION ""
1004 sprintf (options_buffer
, COMPILER_VERSION
);
1006 strcat (options_buffer
, " --no-opt");
1009 strcat (options_buffer
, " --cflags");
1010 strcat (options_buffer
, USER_CFLAGS
);
1013 strcat (options_buffer
, " --ldflags");
1014 strcat (options_buffer
, USER_LDFLAGS
);
1016 return options_buffer
;
1020 #include <sys/timeb.h>
1022 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
1024 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
1029 tv
->tv_sec
= tb
.time
;
1030 tv
->tv_usec
= tb
.millitm
* 1000L;
1033 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
1034 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
1038 /* ------------------------------------------------------------------------- */
1039 /* IO support and wrapper functions for W32 API. */
1040 /* ------------------------------------------------------------------------- */
1042 /* Place a wrapper around the MSVC version of ctime. It returns NULL
1043 on network directories, so we handle that case here.
1044 (Ulrich Leodolter, 1/11/95). */
1046 sys_ctime (const time_t *t
)
1048 char *str
= (char *) ctime (t
);
1049 return (str
? str
: "Sun Jan 01 00:00:00 1970");
1052 /* Emulate sleep...we could have done this with a define, but that
1053 would necessitate including windows.h in the files that used it.
1054 This is much easier. */
1056 sys_sleep (int seconds
)
1058 Sleep (seconds
* 1000);
1061 /* Internal MSVC functions for low-level descriptor munging */
1062 extern int __cdecl
_set_osfhnd (int fd
, long h
);
1063 extern int __cdecl
_free_osfhnd (int fd
);
1065 /* parallel array of private info on file handles */
1066 filedesc fd_info
[ MAXDESC
];
1068 typedef struct volume_info_data
{
1069 struct volume_info_data
* next
;
1071 /* time when info was obtained */
1074 /* actual volume info */
1083 /* Global referenced by various functions. */
1084 static volume_info_data volume_info
;
1086 /* Vector to indicate which drives are local and fixed (for which cached
1087 data never expires). */
1088 static BOOL fixed_drives
[26];
1090 /* Consider cached volume information to be stale if older than 10s,
1091 at least for non-local drives. Info for fixed drives is never stale. */
1092 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1093 #define VOLINFO_STILL_VALID( root_dir, info ) \
1094 ( ( isalpha (root_dir[0]) && \
1095 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1096 || GetTickCount () - info->timestamp < 10000 )
1098 /* Cache support functions. */
1100 /* Simple linked list with linear search is sufficient. */
1101 static volume_info_data
*volume_cache
= NULL
;
1103 static volume_info_data
*
1104 lookup_volume_info (char * root_dir
)
1106 volume_info_data
* info
;
1108 for (info
= volume_cache
; info
; info
= info
->next
)
1109 if (stricmp (info
->root_dir
, root_dir
) == 0)
1115 add_volume_info (char * root_dir
, volume_info_data
* info
)
1117 info
->root_dir
= xstrdup (root_dir
);
1118 info
->next
= volume_cache
;
1119 volume_cache
= info
;
1123 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1124 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1125 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1127 GetCachedVolumeInformation (char * root_dir
)
1129 volume_info_data
* info
;
1130 char default_root
[ MAX_PATH
];
1132 /* NULL for root_dir means use root from current directory. */
1133 if (root_dir
== NULL
)
1135 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1137 parse_root (default_root
, &root_dir
);
1139 root_dir
= default_root
;
1142 /* Local fixed drives can be cached permanently. Removable drives
1143 cannot be cached permanently, since the volume name and serial
1144 number (if nothing else) can change. Remote drives should be
1145 treated as if they are removable, since there is no sure way to
1146 tell whether they are or not. Also, the UNC association of drive
1147 letters mapped to remote volumes can be changed at any time (even
1148 by other processes) without notice.
1150 As a compromise, so we can benefit from caching info for remote
1151 volumes, we use a simple expiry mechanism to invalidate cache
1152 entries that are more than ten seconds old. */
1155 /* No point doing this, because WNetGetConnection is even slower than
1156 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1157 GetDriveType is about the only call of this type which does not
1158 involve network access, and so is extremely quick). */
1160 /* Map drive letter to UNC if remote. */
1161 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1163 char remote_name
[ 256 ];
1164 char drive
[3] = { root_dir
[0], ':' };
1166 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1168 /* do something */ ;
1172 info
= lookup_volume_info (root_dir
);
1174 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1182 /* Info is not cached, or is stale. */
1183 if (!GetVolumeInformation (root_dir
,
1184 name
, sizeof (name
),
1188 type
, sizeof (type
)))
1191 /* Cache the volume information for future use, overwriting existing
1192 entry if present. */
1195 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1196 add_volume_info (root_dir
, info
);
1204 info
->name
= xstrdup (name
);
1205 info
->serialnum
= serialnum
;
1206 info
->maxcomp
= maxcomp
;
1207 info
->flags
= flags
;
1208 info
->type
= xstrdup (type
);
1209 info
->timestamp
= GetTickCount ();
1215 /* Get information on the volume where name is held; set path pointer to
1216 start of pathname in name (past UNC header\volume header if present). */
1218 get_volume_info (const char * name
, const char ** pPath
)
1220 char temp
[MAX_PATH
];
1221 char *rootname
= NULL
; /* default to current volume */
1222 volume_info_data
* info
;
1227 /* find the root name of the volume if given */
1228 if (isalpha (name
[0]) && name
[1] == ':')
1236 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1243 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1256 info
= GetCachedVolumeInformation (rootname
);
1259 /* Set global referenced by other functions. */
1260 volume_info
= *info
;
1266 /* Determine if volume is FAT format (ie. only supports short 8.3
1267 names); also set path pointer to start of pathname in name. */
1269 is_fat_volume (const char * name
, const char ** pPath
)
1271 if (get_volume_info (name
, pPath
))
1272 return (volume_info
.maxcomp
== 12);
1276 /* Map filename to a legal 8.3 name if necessary. */
1278 map_w32_filename (const char * name
, const char ** pPath
)
1280 static char shortname
[MAX_PATH
];
1281 char * str
= shortname
;
1284 const char * save_name
= name
;
1286 if (strlen (name
) >= MAX_PATH
)
1288 /* Return a filename which will cause callers to fail. */
1289 strcpy (shortname
, "?");
1293 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
1295 register int left
= 8; /* maximum number of chars in part */
1296 register int extn
= 0; /* extension added? */
1297 register int dots
= 2; /* maximum number of dots allowed */
1300 *str
++ = *name
++; /* skip past UNC header */
1302 while ((c
= *name
++))
1309 extn
= 0; /* reset extension flags */
1310 dots
= 2; /* max 2 dots */
1311 left
= 8; /* max length 8 for main part */
1315 extn
= 0; /* reset extension flags */
1316 dots
= 2; /* max 2 dots */
1317 left
= 8; /* max length 8 for main part */
1322 /* Convert path components of the form .xxx to _xxx,
1323 but leave . and .. as they are. This allows .emacs
1324 to be read as _emacs, for example. */
1328 IS_DIRECTORY_SEP (*name
))
1343 extn
= 1; /* we've got an extension */
1344 left
= 3; /* 3 chars in extension */
1348 /* any embedded dots after the first are converted to _ */
1353 case '#': /* don't lose these, they're important */
1355 str
[-1] = c
; /* replace last character of part */
1360 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1362 dots
= 0; /* started a path component */
1371 strcpy (shortname
, name
);
1372 unixtodos_filename (shortname
);
1376 *pPath
= shortname
+ (path
- save_name
);
1382 is_exec (const char * name
)
1384 char * p
= strrchr (name
, '.');
1387 && (stricmp (p
, ".exe") == 0 ||
1388 stricmp (p
, ".com") == 0 ||
1389 stricmp (p
, ".bat") == 0 ||
1390 stricmp (p
, ".cmd") == 0));
1393 /* Emulate the Unix directory procedures opendir, closedir,
1394 and readdir. We can't use the procedures supplied in sysdep.c,
1395 so we provide them here. */
1397 struct direct dir_static
; /* simulated directory contents */
1398 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1399 static int dir_is_fat
;
1400 static char dir_pathname
[MAXPATHLEN
+1];
1401 static WIN32_FIND_DATA dir_find_data
;
1403 /* Support shares on a network resource as subdirectories of a read-only
1405 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1406 HANDLE
open_unc_volume (char *);
1407 char *read_unc_volume (HANDLE
, char *, int);
1408 void close_unc_volume (HANDLE
);
1411 opendir (char *filename
)
1415 /* Opening is done by FindFirstFile. However, a read is inherent to
1416 this operation, so we defer the open until read time. */
1418 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1420 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1423 if (is_unc_volume (filename
))
1425 wnet_enum_handle
= open_unc_volume (filename
);
1426 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1430 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1437 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1438 dir_pathname
[MAXPATHLEN
] = '\0';
1439 dir_is_fat
= is_fat_volume (filename
, NULL
);
1445 closedir (DIR *dirp
)
1447 /* If we have a find-handle open, close it. */
1448 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1450 FindClose (dir_find_handle
);
1451 dir_find_handle
= INVALID_HANDLE_VALUE
;
1453 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1455 close_unc_volume (wnet_enum_handle
);
1456 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1458 xfree ((char *) dirp
);
1464 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1466 if (!read_unc_volume (wnet_enum_handle
,
1467 dir_find_data
.cFileName
,
1471 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1472 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1474 char filename
[MAXNAMLEN
+ 3];
1477 strcpy (filename
, dir_pathname
);
1478 ln
= strlen (filename
) - 1;
1479 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1480 strcat (filename
, "\\");
1481 strcat (filename
, "*");
1483 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1485 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1490 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1494 /* Emacs never uses this value, so don't bother making it match
1495 value returned by stat(). */
1496 dir_static
.d_ino
= 1;
1498 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1499 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1501 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1502 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1504 _strlwr (dir_static
.d_name
);
1505 else if (!NILP (Vw32_downcase_file_names
))
1508 for (p
= dir_static
.d_name
; *p
; p
++)
1509 if (*p
>= 'a' && *p
<= 'z')
1512 _strlwr (dir_static
.d_name
);
1519 open_unc_volume (char *path
)
1525 nr
.dwScope
= RESOURCE_GLOBALNET
;
1526 nr
.dwType
= RESOURCETYPE_DISK
;
1527 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1528 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1529 nr
.lpLocalName
= NULL
;
1530 nr
.lpRemoteName
= map_w32_filename (path
, NULL
);
1531 nr
.lpComment
= NULL
;
1532 nr
.lpProvider
= NULL
;
1534 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1535 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1537 if (result
== NO_ERROR
)
1540 return INVALID_HANDLE_VALUE
;
1544 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1548 DWORD bufsize
= 512;
1553 buffer
= alloca (bufsize
);
1554 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1555 if (result
!= NO_ERROR
)
1558 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1559 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1561 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1564 strncpy (readbuf
, ptr
, size
);
1569 close_unc_volume (HANDLE henum
)
1571 if (henum
!= INVALID_HANDLE_VALUE
)
1572 WNetCloseEnum (henum
);
1576 unc_volume_file_attributes (char *path
)
1581 henum
= open_unc_volume (path
);
1582 if (henum
== INVALID_HANDLE_VALUE
)
1585 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1587 close_unc_volume (henum
);
1593 /* Shadow some MSVC runtime functions to map requests for long filenames
1594 to reasonable short names if necessary. This was originally added to
1595 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1599 sys_access (const char * path
, int mode
)
1603 /* MSVC implementation doesn't recognize D_OK. */
1604 path
= map_w32_filename (path
, NULL
);
1605 if (is_unc_volume (path
))
1607 attributes
= unc_volume_file_attributes (path
);
1608 if (attributes
== -1) {
1613 else if ((attributes
= GetFileAttributes (path
)) == -1)
1615 /* Should try mapping GetLastError to errno; for now just indicate
1616 that path doesn't exist. */
1620 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1625 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1630 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1639 sys_chdir (const char * path
)
1641 return _chdir (map_w32_filename (path
, NULL
));
1645 sys_chmod (const char * path
, int mode
)
1647 return _chmod (map_w32_filename (path
, NULL
), mode
);
1651 sys_creat (const char * path
, int mode
)
1653 return _creat (map_w32_filename (path
, NULL
), mode
);
1657 sys_fopen(const char * path
, const char * mode
)
1661 const char * mode_save
= mode
;
1663 /* Force all file handles to be non-inheritable. This is necessary to
1664 ensure child processes don't unwittingly inherit handles that might
1665 prevent future file access. */
1669 else if (mode
[0] == 'w' || mode
[0] == 'a')
1670 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1674 /* Only do simplistic option parsing. */
1678 oflag
&= ~(O_RDONLY
| O_WRONLY
);
1681 else if (mode
[0] == 'b')
1686 else if (mode
[0] == 't')
1693 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
1697 return _fdopen (fd
, mode_save
);
1700 /* This only works on NTFS volumes, but is useful to have. */
1702 sys_link (const char * old
, const char * new)
1706 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
1708 if (old
== NULL
|| new == NULL
)
1714 strcpy (oldname
, map_w32_filename (old
, NULL
));
1715 strcpy (newname
, map_w32_filename (new, NULL
));
1717 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
1718 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
1719 if (fileh
!= INVALID_HANDLE_VALUE
)
1723 /* Confusingly, the "alternate" stream name field does not apply
1724 when restoring a hard link, and instead contains the actual
1725 stream data for the link (ie. the name of the link to create).
1726 The WIN32_STREAM_ID structure before the cStreamName field is
1727 the stream header, which is then immediately followed by the
1731 WIN32_STREAM_ID wid
;
1732 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
1735 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
1736 data
.wid
.cStreamName
, MAX_PATH
);
1739 LPVOID context
= NULL
;
1742 data
.wid
.dwStreamId
= BACKUP_LINK
;
1743 data
.wid
.dwStreamAttributes
= 0;
1744 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
1745 data
.wid
.Size
.HighPart
= 0;
1746 data
.wid
.dwStreamNameSize
= 0;
1748 if (BackupWrite (fileh
, (LPBYTE
)&data
,
1749 offsetof (WIN32_STREAM_ID
, cStreamName
)
1750 + data
.wid
.Size
.LowPart
,
1751 &wbytes
, FALSE
, FALSE
, &context
)
1752 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
1759 /* Should try mapping GetLastError to errno; for now just
1760 indicate a general error (eg. links not supported). */
1761 errno
= EINVAL
; // perhaps EMLINK?
1765 CloseHandle (fileh
);
1774 sys_mkdir (const char * path
)
1776 return _mkdir (map_w32_filename (path
, NULL
));
1779 /* Because of long name mapping issues, we need to implement this
1780 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1781 a unique name, instead of setting the input template to an empty
1784 Standard algorithm seems to be use pid or tid with a letter on the
1785 front (in place of the 6 X's) and cycle through the letters to find a
1786 unique name. We extend that to allow any reasonable character as the
1787 first of the 6 X's. */
1789 sys_mktemp (char * template)
1793 unsigned uid
= GetCurrentThreadId ();
1794 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1796 if (template == NULL
)
1798 p
= template + strlen (template);
1800 /* replace up to the last 5 X's with uid in decimal */
1801 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1803 p
[0] = '0' + uid
% 10;
1807 if (i
< 0 && p
[0] == 'X')
1812 int save_errno
= errno
;
1813 p
[0] = first_char
[i
];
1814 if (sys_access (template, 0) < 0)
1820 while (++i
< sizeof (first_char
));
1823 /* Template is badly formed or else we can't generate a unique name,
1824 so return empty string */
1830 sys_open (const char * path
, int oflag
, int mode
)
1832 const char* mpath
= map_w32_filename (path
, NULL
);
1833 /* Try to open file without _O_CREAT, to be able to write to hidden
1834 and system files. Force all file handles to be
1836 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
1839 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
1843 sys_rename (const char * oldname
, const char * newname
)
1846 char temp
[MAX_PATH
];
1848 /* MoveFile on Windows 95 doesn't correctly change the short file name
1849 alias in a number of circumstances (it is not easy to predict when
1850 just by looking at oldname and newname, unfortunately). In these
1851 cases, renaming through a temporary name avoids the problem.
1853 A second problem on Windows 95 is that renaming through a temp name when
1854 newname is uppercase fails (the final long name ends up in
1855 lowercase, although the short alias might be uppercase) UNLESS the
1856 long temp name is not 8.3.
1858 So, on Windows 95 we always rename through a temp name, and we make sure
1859 the temp name has a long extension to ensure correct renaming. */
1861 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1863 if (os_subtype
== OS_WIN95
)
1869 oldname
= map_w32_filename (oldname
, NULL
);
1870 if (o
= strrchr (oldname
, '\\'))
1873 o
= (char *) oldname
;
1875 if (p
= strrchr (temp
, '\\'))
1882 /* Force temp name to require a manufactured 8.3 alias - this
1883 seems to make the second rename work properly. */
1884 sprintf (p
, "_.%s.%u", o
, i
);
1886 result
= rename (oldname
, temp
);
1888 /* This loop must surely terminate! */
1889 while (result
< 0 && errno
== EEXIST
);
1894 /* Emulate Unix behaviour - newname is deleted if it already exists
1895 (at least if it is a file; don't do this for directories).
1897 Since we mustn't do this if we are just changing the case of the
1898 file name (we would end up deleting the file we are trying to
1899 rename!), we let rename detect if the destination file already
1900 exists - that way we avoid the possible pitfalls of trying to
1901 determine ourselves whether two names really refer to the same
1902 file, which is not always possible in the general case. (Consider
1903 all the permutations of shared or subst'd drives, etc.) */
1905 newname
= map_w32_filename (newname
, NULL
);
1906 result
= rename (temp
, newname
);
1910 && _chmod (newname
, 0666) == 0
1911 && _unlink (newname
) == 0)
1912 result
= rename (temp
, newname
);
1918 sys_rmdir (const char * path
)
1920 return _rmdir (map_w32_filename (path
, NULL
));
1924 sys_unlink (const char * path
)
1926 path
= map_w32_filename (path
, NULL
);
1928 /* On Unix, unlink works without write permission. */
1929 _chmod (path
, 0666);
1930 return _unlink (path
);
1933 static FILETIME utc_base_ft
;
1934 static long double utc_base
;
1935 static int init
= 0;
1938 convert_time (FILETIME ft
)
1944 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1953 st
.wMilliseconds
= 0;
1955 SystemTimeToFileTime (&st
, &utc_base_ft
);
1956 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1957 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1961 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1964 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1966 return (time_t) (ret
* 1e-7);
1970 convert_from_time_t (time_t time
, FILETIME
* pft
)
1976 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1985 st
.wMilliseconds
= 0;
1987 SystemTimeToFileTime (&st
, &utc_base_ft
);
1988 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1989 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1993 /* time in 100ns units since 1-Jan-1601 */
1994 tmp
= (long double) time
* 1e7
+ utc_base
;
1995 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
1996 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
2000 /* No reason to keep this; faking inode values either by hashing or even
2001 using the file index from GetInformationByHandle, is not perfect and
2002 so by default Emacs doesn't use the inode values on Windows.
2003 Instead, we now determine file-truename correctly (except for
2004 possible drive aliasing etc). */
2006 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2008 hashval (const unsigned char * str
)
2013 h
= (h
<< 4) + *str
++;
2019 /* Return the hash value of the canonical pathname, excluding the
2020 drive/UNC header, to get a hopefully unique inode number. */
2022 generate_inode_val (const char * name
)
2024 char fullname
[ MAX_PATH
];
2028 /* Get the truly canonical filename, if it exists. (Note: this
2029 doesn't resolve aliasing due to subst commands, or recognise hard
2031 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
2034 parse_root (fullname
, &p
);
2035 /* Normal W32 filesystems are still case insensitive. */
2042 /* MSVC stat function can't cope with UNC names and has other bugs, so
2043 replace it with our own. This also allows us to calculate consistent
2044 inode values without hacks in the main Emacs code. */
2046 stat (const char * path
, struct stat
* buf
)
2049 WIN32_FIND_DATA wfd
;
2054 int rootdir
= FALSE
;
2056 if (path
== NULL
|| buf
== NULL
)
2062 name
= (char *) map_w32_filename (path
, &path
);
2063 /* must be valid filename, no wild cards or other invalid characters */
2064 if (strpbrk (name
, "*?|<>\""))
2070 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
2071 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
2072 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
2077 /* Remove trailing directory separator, unless name is the root
2078 directory of a drive or UNC volume in which case ensure there
2079 is a trailing separator. */
2080 len
= strlen (name
);
2081 rootdir
= (path
>= name
+ len
- 1
2082 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
2083 name
= strcpy (alloca (len
+ 2), name
);
2085 if (is_unc_volume (name
))
2087 DWORD attrs
= unc_volume_file_attributes (name
);
2092 memset (&wfd
, 0, sizeof (wfd
));
2093 wfd
.dwFileAttributes
= attrs
;
2094 wfd
.ftCreationTime
= utc_base_ft
;
2095 wfd
.ftLastAccessTime
= utc_base_ft
;
2096 wfd
.ftLastWriteTime
= utc_base_ft
;
2097 strcpy (wfd
.cFileName
, name
);
2101 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2102 strcat (name
, "\\");
2103 if (GetDriveType (name
) < 2)
2108 memset (&wfd
, 0, sizeof (wfd
));
2109 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2110 wfd
.ftCreationTime
= utc_base_ft
;
2111 wfd
.ftLastAccessTime
= utc_base_ft
;
2112 wfd
.ftLastWriteTime
= utc_base_ft
;
2113 strcpy (wfd
.cFileName
, name
);
2117 if (IS_DIRECTORY_SEP (name
[len
-1]))
2120 /* (This is hacky, but helps when doing file completions on
2121 network drives.) Optimize by using information available from
2122 active readdir if possible. */
2123 len
= strlen (dir_pathname
);
2124 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2126 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2127 && strnicmp (name
, dir_pathname
, len
) == 0
2128 && IS_DIRECTORY_SEP (name
[len
])
2129 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2131 /* This was the last entry returned by readdir. */
2132 wfd
= dir_find_data
;
2136 fh
= FindFirstFile (name
, &wfd
);
2137 if (fh
== INVALID_HANDLE_VALUE
)
2146 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2148 buf
->st_mode
= _S_IFDIR
;
2149 buf
->st_nlink
= 2; /* doesn't really matter */
2150 fake_inode
= 0; /* this doesn't either I think */
2152 else if (!NILP (Vw32_get_true_file_attributes
)
2153 /* No access rights required to get info. */
2154 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
, 0, NULL
))
2155 != INVALID_HANDLE_VALUE
)
2157 /* This is more accurate in terms of gettting the correct number
2158 of links, but is quite slow (it is noticable when Emacs is
2159 making a list of file name completions). */
2160 BY_HANDLE_FILE_INFORMATION info
;
2162 if (GetFileInformationByHandle (fh
, &info
))
2164 buf
->st_nlink
= info
.nNumberOfLinks
;
2165 /* Might as well use file index to fake inode values, but this
2166 is not guaranteed to be unique unless we keep a handle open
2167 all the time (even then there are situations where it is
2168 not unique). Reputedly, there are at most 48 bits of info
2169 (on NTFS, presumably less on FAT). */
2170 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2178 switch (GetFileType (fh
))
2180 case FILE_TYPE_DISK
:
2181 buf
->st_mode
= _S_IFREG
;
2183 case FILE_TYPE_PIPE
:
2184 buf
->st_mode
= _S_IFIFO
;
2186 case FILE_TYPE_CHAR
:
2187 case FILE_TYPE_UNKNOWN
:
2189 buf
->st_mode
= _S_IFCHR
;
2195 /* Don't bother to make this information more accurate. */
2196 buf
->st_mode
= _S_IFREG
;
2202 /* Not sure if there is any point in this. */
2203 if (!NILP (Vw32_generate_fake_inodes
))
2204 fake_inode
= generate_inode_val (name
);
2205 else if (fake_inode
== 0)
2207 /* For want of something better, try to make everything unique. */
2208 static DWORD gen_num
= 0;
2209 fake_inode
= ++gen_num
;
2213 /* MSVC defines _ino_t to be short; other libc's might not. */
2214 if (sizeof (buf
->st_ino
) == 2)
2215 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2217 buf
->st_ino
= fake_inode
;
2219 /* consider files to belong to current user */
2220 buf
->st_uid
= the_passwd
.pw_uid
;
2221 buf
->st_gid
= the_passwd
.pw_gid
;
2223 /* volume_info is set indirectly by map_w32_filename */
2224 buf
->st_dev
= volume_info
.serialnum
;
2225 buf
->st_rdev
= volume_info
.serialnum
;
2228 buf
->st_size
= wfd
.nFileSizeLow
;
2230 /* Convert timestamps to Unix format. */
2231 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2232 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2233 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2234 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2235 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2237 /* determine rwx permissions */
2238 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2239 permission
= _S_IREAD
;
2241 permission
= _S_IREAD
| _S_IWRITE
;
2243 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2244 permission
|= _S_IEXEC
;
2245 else if (is_exec (name
))
2246 permission
|= _S_IEXEC
;
2248 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2253 /* Provide fstat and utime as well as stat for consistent handling of
2256 fstat (int desc
, struct stat
* buf
)
2258 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2259 BY_HANDLE_FILE_INFORMATION info
;
2263 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2265 case FILE_TYPE_DISK
:
2266 buf
->st_mode
= _S_IFREG
;
2267 if (!GetFileInformationByHandle (fh
, &info
))
2273 case FILE_TYPE_PIPE
:
2274 buf
->st_mode
= _S_IFIFO
;
2276 case FILE_TYPE_CHAR
:
2277 case FILE_TYPE_UNKNOWN
:
2279 buf
->st_mode
= _S_IFCHR
;
2281 memset (&info
, 0, sizeof (info
));
2282 info
.dwFileAttributes
= 0;
2283 info
.ftCreationTime
= utc_base_ft
;
2284 info
.ftLastAccessTime
= utc_base_ft
;
2285 info
.ftLastWriteTime
= utc_base_ft
;
2288 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2290 buf
->st_mode
= _S_IFDIR
;
2291 buf
->st_nlink
= 2; /* doesn't really matter */
2292 fake_inode
= 0; /* this doesn't either I think */
2296 buf
->st_nlink
= info
.nNumberOfLinks
;
2297 /* Might as well use file index to fake inode values, but this
2298 is not guaranteed to be unique unless we keep a handle open
2299 all the time (even then there are situations where it is
2300 not unique). Reputedly, there are at most 48 bits of info
2301 (on NTFS, presumably less on FAT). */
2302 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2305 /* MSVC defines _ino_t to be short; other libc's might not. */
2306 if (sizeof (buf
->st_ino
) == 2)
2307 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2309 buf
->st_ino
= fake_inode
;
2311 /* consider files to belong to current user */
2315 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2316 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2318 buf
->st_size
= info
.nFileSizeLow
;
2320 /* Convert timestamps to Unix format. */
2321 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2322 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2323 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2324 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2325 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2327 /* determine rwx permissions */
2328 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2329 permission
= _S_IREAD
;
2331 permission
= _S_IREAD
| _S_IWRITE
;
2333 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2334 permission
|= _S_IEXEC
;
2337 #if 0 /* no way of knowing the filename */
2338 char * p
= strrchr (name
, '.');
2340 (stricmp (p
, ".exe") == 0 ||
2341 stricmp (p
, ".com") == 0 ||
2342 stricmp (p
, ".bat") == 0 ||
2343 stricmp (p
, ".cmd") == 0))
2344 permission
|= _S_IEXEC
;
2348 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2354 utime (const char *name
, struct utimbuf
*times
)
2356 struct utimbuf deftime
;
2363 deftime
.modtime
= deftime
.actime
= time (NULL
);
2367 /* Need write access to set times. */
2368 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2369 0, OPEN_EXISTING
, 0, NULL
);
2372 convert_from_time_t (times
->actime
, &atime
);
2373 convert_from_time_t (times
->modtime
, &mtime
);
2374 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2392 /* Wrappers for winsock functions to map between our file descriptors
2393 and winsock's handles; also set h_errno for convenience.
2395 To allow Emacs to run on systems which don't have winsock support
2396 installed, we dynamically link to winsock on startup if present, and
2397 otherwise provide the minimum necessary functionality
2398 (eg. gethostname). */
2400 /* function pointers for relevant socket functions */
2401 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2402 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2403 int (PASCAL
*pfn_WSAGetLastError
) (void);
2404 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2405 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2406 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2407 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2408 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2409 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2410 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2411 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2412 int (PASCAL
*pfn_WSACleanup
) (void);
2414 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2415 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2416 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2417 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2418 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2419 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2421 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2422 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2423 #ifndef HANDLE_FLAG_INHERIT
2424 #define HANDLE_FLAG_INHERIT 1
2428 static int winsock_inuse
;
2433 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2435 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2436 after WSAStartup returns successfully, but it seems reasonable
2437 to allow unloading winsock anyway in that case. */
2438 if (pfn_WSACleanup () == 0 ||
2439 pfn_WSAGetLastError () == WSAENETDOWN
)
2441 if (FreeLibrary (winsock_lib
))
2450 init_winsock (int load_now
)
2452 WSADATA winsockData
;
2454 if (winsock_lib
!= NULL
)
2457 pfn_SetHandleInformation
= NULL
;
2458 pfn_SetHandleInformation
2459 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2460 "SetHandleInformation");
2462 winsock_lib
= LoadLibrary ("wsock32.dll");
2464 if (winsock_lib
!= NULL
)
2466 /* dynamically link to socket functions */
2468 #define LOAD_PROC(fn) \
2469 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2472 LOAD_PROC( WSAStartup
);
2473 LOAD_PROC( WSASetLastError
);
2474 LOAD_PROC( WSAGetLastError
);
2475 LOAD_PROC( socket
);
2477 LOAD_PROC( connect
);
2478 LOAD_PROC( ioctlsocket
);
2481 LOAD_PROC( closesocket
);
2482 LOAD_PROC( shutdown
);
2485 LOAD_PROC( inet_addr
);
2486 LOAD_PROC( gethostname
);
2487 LOAD_PROC( gethostbyname
);
2488 LOAD_PROC( getservbyname
);
2489 LOAD_PROC( WSACleanup
);
2493 /* specify version 1.1 of winsock */
2494 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2496 if (winsockData
.wVersion
!= 0x101)
2501 /* Report that winsock exists and is usable, but leave
2502 socket functions disabled. I am assuming that calling
2503 WSAStartup does not require any network interaction,
2504 and in particular does not cause or require a dial-up
2505 connection to be established. */
2508 FreeLibrary (winsock_lib
);
2516 FreeLibrary (winsock_lib
);
2526 /* function to set h_errno for compatability; map winsock error codes to
2527 normal system codes where they overlap (non-overlapping definitions
2528 are already in <sys/socket.h> */
2529 static void set_errno ()
2531 if (winsock_lib
== NULL
)
2534 h_errno
= pfn_WSAGetLastError ();
2538 case WSAEACCES
: h_errno
= EACCES
; break;
2539 case WSAEBADF
: h_errno
= EBADF
; break;
2540 case WSAEFAULT
: h_errno
= EFAULT
; break;
2541 case WSAEINTR
: h_errno
= EINTR
; break;
2542 case WSAEINVAL
: h_errno
= EINVAL
; break;
2543 case WSAEMFILE
: h_errno
= EMFILE
; break;
2544 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2545 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2550 static void check_errno ()
2552 if (h_errno
== 0 && winsock_lib
!= NULL
)
2553 pfn_WSASetLastError (0);
2556 /* Extend strerror to handle the winsock-specific error codes. */
2560 } _wsa_errlist
[] = {
2561 WSAEINTR
, "Interrupted function call",
2562 WSAEBADF
, "Bad file descriptor",
2563 WSAEACCES
, "Permission denied",
2564 WSAEFAULT
, "Bad address",
2565 WSAEINVAL
, "Invalid argument",
2566 WSAEMFILE
, "Too many open files",
2568 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2569 WSAEINPROGRESS
, "Operation now in progress",
2570 WSAEALREADY
, "Operation already in progress",
2571 WSAENOTSOCK
, "Socket operation on non-socket",
2572 WSAEDESTADDRREQ
, "Destination address required",
2573 WSAEMSGSIZE
, "Message too long",
2574 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2575 WSAENOPROTOOPT
, "Bad protocol option",
2576 WSAEPROTONOSUPPORT
, "Protocol not supported",
2577 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2578 WSAEOPNOTSUPP
, "Operation not supported",
2579 WSAEPFNOSUPPORT
, "Protocol family not supported",
2580 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2581 WSAEADDRINUSE
, "Address already in use",
2582 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2583 WSAENETDOWN
, "Network is down",
2584 WSAENETUNREACH
, "Network is unreachable",
2585 WSAENETRESET
, "Network dropped connection on reset",
2586 WSAECONNABORTED
, "Software caused connection abort",
2587 WSAECONNRESET
, "Connection reset by peer",
2588 WSAENOBUFS
, "No buffer space available",
2589 WSAEISCONN
, "Socket is already connected",
2590 WSAENOTCONN
, "Socket is not connected",
2591 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2592 WSAETOOMANYREFS
, "Too many references", /* not sure */
2593 WSAETIMEDOUT
, "Connection timed out",
2594 WSAECONNREFUSED
, "Connection refused",
2595 WSAELOOP
, "Network loop", /* not sure */
2596 WSAENAMETOOLONG
, "Name is too long",
2597 WSAEHOSTDOWN
, "Host is down",
2598 WSAEHOSTUNREACH
, "No route to host",
2599 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2600 WSAEPROCLIM
, "Too many processes",
2601 WSAEUSERS
, "Too many users", /* not sure */
2602 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2603 WSAESTALE
, "Data is stale", /* not sure */
2604 WSAEREMOTE
, "Remote error", /* not sure */
2606 WSASYSNOTREADY
, "Network subsystem is unavailable",
2607 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2608 WSANOTINITIALISED
, "Winsock not initialized successfully",
2609 WSAEDISCON
, "Graceful shutdown in progress",
2611 WSAENOMORE
, "No more operations allowed", /* not sure */
2612 WSAECANCELLED
, "Operation cancelled", /* not sure */
2613 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2614 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2615 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2616 WSASYSCALLFAILURE
, "System call failured",
2617 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2618 WSATYPE_NOT_FOUND
, "Class type not found",
2619 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2620 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2621 WSAEREFUSED
, "Operation refused", /* not sure */
2624 WSAHOST_NOT_FOUND
, "Host not found",
2625 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2626 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2627 WSANO_DATA
, "Valid name, no data record of requested type",
2633 sys_strerror(int error_no
)
2636 static char unknown_msg
[40];
2638 if (error_no
>= 0 && error_no
< sys_nerr
)
2639 return sys_errlist
[error_no
];
2641 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2642 if (_wsa_errlist
[i
].errnum
== error_no
)
2643 return _wsa_errlist
[i
].msg
;
2645 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
2649 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2650 but I believe the method of keeping the socket handle separate (and
2651 insuring it is not inheritable) is the correct one. */
2653 //#define SOCK_REPLACE_HANDLE
2655 #ifdef SOCK_REPLACE_HANDLE
2656 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2658 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2662 sys_socket(int af
, int type
, int protocol
)
2668 if (winsock_lib
== NULL
)
2671 return INVALID_SOCKET
;
2676 /* call the real socket function */
2677 s
= (long) pfn_socket (af
, type
, protocol
);
2679 if (s
!= INVALID_SOCKET
)
2681 /* Although under NT 3.5 _open_osfhandle will accept a socket
2682 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2683 that does not work under NT 3.1. However, we can get the same
2684 effect by using a backdoor function to replace an existing
2685 descriptor handle with the one we want. */
2687 /* allocate a file descriptor (with appropriate flags) */
2688 fd
= _open ("NUL:", _O_RDWR
);
2691 #ifdef SOCK_REPLACE_HANDLE
2692 /* now replace handle to NUL with our socket handle */
2693 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
2695 _set_osfhnd (fd
, s
);
2696 /* setmode (fd, _O_BINARY); */
2698 /* Make a non-inheritable copy of the socket handle. Note
2699 that it is possible that sockets aren't actually kernel
2700 handles, which appears to be the case on Windows 9x when
2701 the MS Proxy winsock client is installed. */
2703 /* Apparently there is a bug in NT 3.51 with some service
2704 packs, which prevents using DuplicateHandle to make a
2705 socket handle non-inheritable (causes WSACleanup to
2706 hang). The work-around is to use SetHandleInformation
2707 instead if it is available and implemented. */
2708 if (pfn_SetHandleInformation
)
2710 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
2714 HANDLE parent
= GetCurrentProcess ();
2715 HANDLE new_s
= INVALID_HANDLE_VALUE
;
2717 if (DuplicateHandle (parent
,
2723 DUPLICATE_SAME_ACCESS
))
2725 /* It is possible that DuplicateHandle succeeds even
2726 though the socket wasn't really a kernel handle,
2727 because a real handle has the same value. So
2728 test whether the new handle really is a socket. */
2729 long nonblocking
= 0;
2730 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
2732 pfn_closesocket (s
);
2737 CloseHandle (new_s
);
2742 fd_info
[fd
].hnd
= (HANDLE
) s
;
2745 /* set our own internal flags */
2746 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
2752 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2754 /* attach child_process to fd_info */
2755 if (fd_info
[ fd
].cp
!= NULL
)
2757 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
2761 fd_info
[ fd
].cp
= cp
;
2764 winsock_inuse
++; /* count open sockets */
2771 pfn_closesocket (s
);
2781 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
2783 if (winsock_lib
== NULL
)
2786 return SOCKET_ERROR
;
2790 if (fd_info
[s
].flags
& FILE_SOCKET
)
2792 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
2793 if (rc
== SOCKET_ERROR
)
2798 return SOCKET_ERROR
;
2803 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
2805 if (winsock_lib
== NULL
)
2808 return SOCKET_ERROR
;
2812 if (fd_info
[s
].flags
& FILE_SOCKET
)
2814 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
2815 if (rc
== SOCKET_ERROR
)
2820 return SOCKET_ERROR
;
2824 sys_htons (u_short hostshort
)
2826 return (winsock_lib
!= NULL
) ?
2827 pfn_htons (hostshort
) : hostshort
;
2831 sys_ntohs (u_short netshort
)
2833 return (winsock_lib
!= NULL
) ?
2834 pfn_ntohs (netshort
) : netshort
;
2838 sys_inet_addr (const char * cp
)
2840 return (winsock_lib
!= NULL
) ?
2841 pfn_inet_addr (cp
) : INADDR_NONE
;
2845 sys_gethostname (char * name
, int namelen
)
2847 if (winsock_lib
!= NULL
)
2848 return pfn_gethostname (name
, namelen
);
2850 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
2851 return !GetComputerName (name
, (DWORD
*)&namelen
);
2854 return SOCKET_ERROR
;
2858 sys_gethostbyname(const char * name
)
2860 struct hostent
* host
;
2862 if (winsock_lib
== NULL
)
2869 host
= pfn_gethostbyname (name
);
2876 sys_getservbyname(const char * name
, const char * proto
)
2878 struct servent
* serv
;
2880 if (winsock_lib
== NULL
)
2887 serv
= pfn_getservbyname (name
, proto
);
2894 sys_shutdown (int s
, int how
)
2896 if (winsock_lib
== NULL
)
2899 return SOCKET_ERROR
;
2903 if (fd_info
[s
].flags
& FILE_SOCKET
)
2905 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
2906 if (rc
== SOCKET_ERROR
)
2911 return SOCKET_ERROR
;
2914 #endif /* HAVE_SOCKETS */
2917 /* Shadow main io functions: we need to handle pipes and sockets more
2918 intelligently, and implement non-blocking mode as well. */
2925 if (fd
< 0 || fd
>= MAXDESC
)
2933 child_process
* cp
= fd_info
[fd
].cp
;
2935 fd_info
[fd
].cp
= NULL
;
2937 if (CHILD_ACTIVE (cp
))
2939 /* if last descriptor to active child_process then cleanup */
2941 for (i
= 0; i
< MAXDESC
; i
++)
2945 if (fd_info
[i
].cp
== cp
)
2951 if (fd_info
[fd
].flags
& FILE_SOCKET
)
2953 #ifndef SOCK_REPLACE_HANDLE
2954 if (winsock_lib
== NULL
) abort ();
2956 pfn_shutdown (SOCK_HANDLE (fd
), 2);
2957 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
2959 winsock_inuse
--; /* count open sockets */
2967 /* Note that sockets do not need special treatment here (at least on
2968 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
2969 closesocket is equivalent to CloseHandle, which is to be expected
2970 because socket handles are fully fledged kernel handles. */
2974 fd_info
[fd
].flags
= 0;
2987 /* duplicate our internal info as well */
2988 fd_info
[new_fd
] = fd_info
[fd
];
2995 sys_dup2 (int src
, int dst
)
2999 if (dst
< 0 || dst
>= MAXDESC
)
3005 /* make sure we close the destination first if it's a pipe or socket */
3006 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
3009 rc
= _dup2 (src
, dst
);
3012 /* duplicate our internal info as well */
3013 fd_info
[dst
] = fd_info
[src
];
3018 /* Unix pipe() has only one arg */
3020 sys_pipe (int * phandles
)
3025 /* make pipe handles non-inheritable; when we spawn a child, we
3026 replace the relevant handle with an inheritable one. Also put
3027 pipes into binary mode; we will do text mode translation ourselves
3029 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
3033 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
3034 fd_info
[phandles
[0]].flags
= flags
;
3036 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
3037 fd_info
[phandles
[1]].flags
= flags
;
3044 extern Lisp_Object Vw32_pipe_read_delay
;
3046 /* Function to do blocking read of one byte, needed to implement
3047 select. It is only allowed on sockets and pipes. */
3049 _sys_read_ahead (int fd
)
3054 if (fd
< 0 || fd
>= MAXDESC
)
3055 return STATUS_READ_ERROR
;
3057 cp
= fd_info
[fd
].cp
;
3059 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
3060 return STATUS_READ_ERROR
;
3062 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
3063 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
3065 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
3069 cp
->status
= STATUS_READ_IN_PROGRESS
;
3071 if (fd_info
[fd
].flags
& FILE_PIPE
)
3073 rc
= _read (fd
, &cp
->chr
, sizeof (char));
3075 /* Give subprocess time to buffer some more output for us before
3076 reporting that input is available; we need this because Windows 95
3077 connects DOS programs to pipes by making the pipe appear to be
3078 the normal console stdout - as a result most DOS programs will
3079 write to stdout without buffering, ie. one character at a
3080 time. Even some W32 programs do this - "dir" in a command
3081 shell on NT is very slow if we don't do this. */
3084 int wait
= XINT (Vw32_pipe_read_delay
);
3090 /* Yield remainder of our time slice, effectively giving a
3091 temporary priority boost to the child process. */
3096 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3097 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3100 if (rc
== sizeof (char))
3101 cp
->status
= STATUS_READ_SUCCEEDED
;
3103 cp
->status
= STATUS_READ_FAILED
;
3109 sys_read (int fd
, char * buffer
, unsigned int count
)
3114 char * orig_buffer
= buffer
;
3116 if (fd
< 0 || fd
>= MAXDESC
)
3122 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3124 child_process
*cp
= fd_info
[fd
].cp
;
3126 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3134 /* re-read CR carried over from last read */
3135 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3137 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3141 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3144 /* presence of a child_process structure means we are operating in
3145 non-blocking mode - otherwise we just call _read directly.
3146 Note that the child_process structure might be missing because
3147 reap_subprocess has been called; in this case the pipe is
3148 already broken, so calling _read on it is okay. */
3151 int current_status
= cp
->status
;
3153 switch (current_status
)
3155 case STATUS_READ_FAILED
:
3156 case STATUS_READ_ERROR
:
3157 /* report normal EOF if nothing in buffer */
3159 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3162 case STATUS_READ_READY
:
3163 case STATUS_READ_IN_PROGRESS
:
3164 DebPrint (("sys_read called when read is in progress\n"));
3165 errno
= EWOULDBLOCK
;
3168 case STATUS_READ_SUCCEEDED
:
3169 /* consume read-ahead char */
3170 *buffer
++ = cp
->chr
;
3173 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3174 ResetEvent (cp
->char_avail
);
3176 case STATUS_READ_ACKNOWLEDGED
:
3180 DebPrint (("sys_read: bad status %d\n", current_status
));
3185 if (fd_info
[fd
].flags
& FILE_PIPE
)
3187 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3188 to_read
= min (waiting
, (DWORD
) count
);
3191 nchars
+= _read (fd
, buffer
, to_read
);
3194 else /* FILE_SOCKET */
3196 if (winsock_lib
== NULL
) abort ();
3198 /* do the equivalent of a non-blocking read */
3199 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3200 if (waiting
== 0 && nchars
== 0)
3202 h_errno
= errno
= EWOULDBLOCK
;
3208 /* always use binary mode for sockets */
3209 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3210 if (res
== SOCKET_ERROR
)
3212 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3213 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3224 int nread
= _read (fd
, buffer
, count
);
3227 else if (nchars
== 0)
3232 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3233 /* Perform text mode translation if required. */
3234 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3236 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3237 /* If buffer contains only CR, return that. To be absolutely
3238 sure we should attempt to read the next char, but in
3239 practice a CR to be followed by LF would not appear by
3240 itself in the buffer. */
3241 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3243 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3249 nchars
= _read (fd
, buffer
, count
);
3254 /* For now, don't bother with a non-blocking mode */
3256 sys_write (int fd
, const void * buffer
, unsigned int count
)
3260 if (fd
< 0 || fd
>= MAXDESC
)
3266 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3268 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3274 /* Perform text mode translation if required. */
3275 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3277 char * tmpbuf
= alloca (count
* 2);
3278 unsigned char * src
= (void *)buffer
;
3279 unsigned char * dst
= tmpbuf
;
3284 unsigned char *next
;
3285 /* copy next line or remaining bytes */
3286 next
= _memccpy (dst
, src
, '\n', nbytes
);
3289 /* copied one line ending with '\n' */
3290 int copied
= next
- dst
;
3293 /* insert '\r' before '\n' */
3300 /* copied remaining partial line -> now finished */
3308 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3310 if (winsock_lib
== NULL
) abort ();
3311 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3312 if (nchars
== SOCKET_ERROR
)
3314 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3315 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3321 nchars
= _write (fd
, buffer
, count
);
3327 check_windows_init_file ()
3329 extern int noninteractive
, inhibit_window_system
;
3331 /* A common indication that Emacs is not installed properly is when
3332 it cannot find the Windows installation file. If this file does
3333 not exist in the expected place, tell the user. */
3335 if (!noninteractive
&& !inhibit_window_system
)
3337 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3338 Lisp_Object objs
[2];
3339 Lisp_Object full_load_path
;
3340 Lisp_Object init_file
;
3343 objs
[0] = Vload_path
;
3344 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3345 full_load_path
= Fappend (2, objs
);
3346 init_file
= build_string ("term/w32-win");
3347 fd
= openp (full_load_path
, init_file
, Vload_suffixes
, NULL
, 0);
3350 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3351 char *init_file_name
= XSTRING (init_file
)->data
;
3352 char *load_path
= XSTRING (load_path_print
)->data
;
3353 char *buffer
= alloca (1024);
3356 "The Emacs Windows initialization file \"%s.el\" "
3357 "could not be found in your Emacs installation. "
3358 "Emacs checked the following directories for this file:\n"
3360 "When Emacs cannot find this file, it usually means that it "
3361 "was not installed properly, or its distribution file was "
3362 "not unpacked properly.\nSee the README.W32 file in the "
3363 "top-level Emacs directory for more information.",
3364 init_file_name
, load_path
);
3367 "Emacs Abort Dialog",
3368 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3369 /* Use the low-level Emacs abort. */
3384 /* shutdown the socket interface if necessary */
3393 /* Initialise the socket interface now if available and requested by
3394 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3395 delayed until open-network-stream is called (w32-has-winsock can
3396 also be used to dynamically load or reload winsock).
3398 Conveniently, init_environment is called before us, so
3399 PRELOAD_WINSOCK can be set in the registry. */
3401 /* Always initialize this correctly. */
3404 if (getenv ("PRELOAD_WINSOCK") != NULL
)
3405 init_winsock (TRUE
);
3408 /* Initial preparation for subprocess support: replace our standard
3409 handles with non-inheritable versions. */
3412 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
3413 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
3414 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
3416 parent
= GetCurrentProcess ();
3418 /* ignore errors when duplicating and closing; typically the
3419 handles will be invalid when running as a gui program. */
3420 DuplicateHandle (parent
,
3421 GetStdHandle (STD_INPUT_HANDLE
),
3426 DUPLICATE_SAME_ACCESS
);
3428 DuplicateHandle (parent
,
3429 GetStdHandle (STD_OUTPUT_HANDLE
),
3434 DUPLICATE_SAME_ACCESS
);
3436 DuplicateHandle (parent
,
3437 GetStdHandle (STD_ERROR_HANDLE
),
3442 DUPLICATE_SAME_ACCESS
);
3448 if (stdin_save
!= INVALID_HANDLE_VALUE
)
3449 _open_osfhandle ((long) stdin_save
, O_TEXT
);
3451 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
3454 if (stdout_save
!= INVALID_HANDLE_VALUE
)
3455 _open_osfhandle ((long) stdout_save
, O_TEXT
);
3457 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3460 if (stderr_save
!= INVALID_HANDLE_VALUE
)
3461 _open_osfhandle ((long) stderr_save
, O_TEXT
);
3463 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3467 /* unfortunately, atexit depends on implementation of malloc */
3468 /* atexit (term_ntproc); */
3469 signal (SIGABRT
, term_ntproc
);
3471 /* determine which drives are fixed, for GetCachedVolumeInformation */
3473 /* GetDriveType must have trailing backslash. */
3474 char drive
[] = "A:\\";
3476 /* Loop over all possible drive letters */
3477 while (*drive
<= 'Z')
3479 /* Record if this drive letter refers to a fixed drive. */
3480 fixed_drives
[DRIVE_INDEX (*drive
)] =
3481 (GetDriveType (drive
) == DRIVE_FIXED
);
3486 /* Reset the volume info cache. */
3487 volume_cache
= NULL
;
3490 /* Check to see if Emacs has been installed correctly. */
3491 check_windows_init_file ();