1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1994, 1995 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 */
68 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
69 #include <sys/socket.h>
88 #define min(x, y) (((x) < (y)) ? (x) : (y))
89 #define max(x, y) (((x) > (y)) ? (x) : (y))
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
;
96 static char startup_dir
[MAXPATHLEN
];
98 /* Get the current working directory. */
103 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
107 /* Emacs doesn't actually change directory itself, and we want to
108 force our real wd to be where emacs.exe is to avoid unnecessary
109 conflicts when trying to rename or delete directories. */
110 strcpy (dir
, startup_dir
);
116 /* Emulate gethostname. */
118 gethostname (char *buffer
, int size
)
120 /* NT only allows small host names, so the buffer is
121 certainly large enough. */
122 return !GetComputerName (buffer
, &size
);
124 #endif /* HAVE_SOCKETS */
126 /* Emulate getloadavg. */
128 getloadavg (double loadavg
[], int nelem
)
132 /* A faithful emulation is going to have to be saved for a rainy day. */
133 for (i
= 0; i
< nelem
; i
++)
140 /* Emulate getpwuid, getpwnam and others. */
142 #define PASSWD_FIELD_SIZE 256
144 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
145 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
146 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
147 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
148 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
150 static struct passwd the_passwd
=
165 return the_passwd
.pw_uid
;
171 /* I could imagine arguing for checking to see whether the user is
172 in the Administrators group and returning a UID of 0 for that
173 case, but I don't know how wise that would be in the long run. */
180 return the_passwd
.pw_gid
;
192 if (uid
== the_passwd
.pw_uid
)
198 getpwnam (char *name
)
202 pw
= getpwuid (getuid ());
206 if (stricmp (name
, pw
->pw_name
))
215 /* Find the user's real name by opening the process token and
216 looking up the name associated with the user-sid in that token.
218 Use the relative portion of the identifier authority value from
219 the user-sid as the user id value (same for group id using the
220 primary group sid from the process token). */
222 char user_sid
[256], name
[256], domain
[256];
223 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
225 SID_NAME_USE user_type
;
227 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY
, &token
)
228 && GetTokenInformation (token
, TokenUser
,
229 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
230 && LookupAccountSid (NULL
, *((PSID
*) user_sid
), name
, &length
,
231 domain
, &dlength
, &user_type
))
233 strcpy (the_passwd
.pw_name
, name
);
234 /* Determine a reasonable uid value. */
235 if (stricmp ("administrator", name
) == 0)
237 the_passwd
.pw_uid
= 0;
238 the_passwd
.pw_gid
= 0;
242 SID_IDENTIFIER_AUTHORITY
* pSIA
;
244 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
245 /* I believe the relative portion is the last 4 bytes (of 6)
247 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
248 (pSIA
->Value
[3] << 16) +
249 (pSIA
->Value
[4] << 8) +
250 (pSIA
->Value
[5] << 0));
251 /* restrict to conventional uid range for normal users */
252 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
255 if (GetTokenInformation (token
, TokenPrimaryGroup
,
256 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
258 SID_IDENTIFIER_AUTHORITY
* pSIA
;
260 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
261 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
262 (pSIA
->Value
[3] << 16) +
263 (pSIA
->Value
[4] << 8) +
264 (pSIA
->Value
[5] << 0));
265 /* I don't know if this is necessary, but for safety... */
266 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
269 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
272 /* If security calls are not supported (presumably because we
273 are running under Windows 95), fallback to this. */
274 else if (GetUserName (name
, &length
))
276 strcpy (the_passwd
.pw_name
, name
);
277 if (stricmp ("administrator", name
) == 0)
278 the_passwd
.pw_uid
= 0;
280 the_passwd
.pw_uid
= 123;
281 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
285 strcpy (the_passwd
.pw_name
, "unknown");
286 the_passwd
.pw_uid
= 123;
287 the_passwd
.pw_gid
= 123;
290 /* Ensure HOME and SHELL are defined. */
291 if (getenv ("HOME") == NULL
)
293 if (getenv ("SHELL") == NULL
)
296 /* Set dir and shell from environment variables. */
297 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
298 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
307 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
308 return ((rand () << 15) | rand ());
318 /* Normalize filename by converting all path separators to
319 the specified separator. Also conditionally convert upper
320 case path name components to lower case. */
323 normalize_filename (fp
, path_sep
)
330 /* Always lower-case drive letters a-z, even if the filesystem
331 preserves case in filenames.
332 This is so filenames can be compared by string comparison
333 functions that are case-sensitive. Even case-preserving filesystems
334 do not distinguish case in drive letters. */
335 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
341 if (NILP (Vw32_downcase_file_names
))
345 if (*fp
== '/' || *fp
== '\\')
352 sep
= path_sep
; /* convert to this path separator */
353 elem
= fp
; /* start of current path element */
356 if (*fp
>= 'a' && *fp
<= 'z')
357 elem
= 0; /* don't convert this element */
359 if (*fp
== 0 || *fp
== ':')
361 sep
= *fp
; /* restore current separator (or 0) */
362 *fp
= '/'; /* after conversion of this element */
365 if (*fp
== '/' || *fp
== '\\')
367 if (elem
&& elem
!= fp
)
369 *fp
= 0; /* temporary end of string */
370 _strlwr (elem
); /* while we convert to lower case */
372 *fp
= sep
; /* convert (or restore) path separator */
373 elem
= fp
+ 1; /* next element starts after separator */
379 /* Destructively turn backslashes into slashes. */
381 dostounix_filename (p
)
384 normalize_filename (p
, '/');
387 /* Destructively turn slashes into backslashes. */
389 unixtodos_filename (p
)
392 normalize_filename (p
, '\\');
395 /* Remove all CR's that are followed by a LF.
396 (From msdos.c...probably should figure out a way to share it,
397 although this code isn't going to ever change.) */
401 register unsigned char *buf
;
403 unsigned char *np
= buf
;
404 unsigned char *startp
= buf
;
405 unsigned char *endp
= buf
+ n
;
409 while (buf
< endp
- 1)
413 if (*(++buf
) != 0x0a)
424 /* Parse the root part of file name, if present. Return length and
425 optionally store pointer to char after root. */
427 parse_root (char * name
, char ** pPath
)
434 /* find the root name of the volume if given */
435 if (isalpha (name
[0]) && name
[1] == ':')
437 /* skip past drive specifier */
439 if (IS_DIRECTORY_SEP (name
[0]))
442 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
448 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
453 if (IS_DIRECTORY_SEP (name
[0]))
463 /* Get long base name for name; name is assumed to be absolute. */
465 get_long_basename (char * name
, char * buf
, int size
)
467 WIN32_FIND_DATA find_data
;
471 /* must be valid filename, no wild cards or other invalid characters */
472 if (strpbrk (name
, "*?|<>\""))
475 dir_handle
= FindFirstFile (name
, &find_data
);
476 if (dir_handle
!= INVALID_HANDLE_VALUE
)
478 if ((len
= strlen (find_data
.cFileName
)) < size
)
479 memcpy (buf
, find_data
.cFileName
, len
+ 1);
482 FindClose (dir_handle
);
487 /* Get long name for file, if possible (assumed to be absolute). */
489 w32_get_long_filename (char * name
, char * buf
, int size
)
494 char full
[ MAX_PATH
];
501 /* Use local copy for destructive modification. */
502 memcpy (full
, name
, len
+1);
503 unixtodos_filename (full
);
505 /* Copy root part verbatim. */
506 len
= parse_root (full
, &p
);
507 memcpy (o
, full
, len
);
512 while (p
!= NULL
&& *p
)
515 p
= strchr (q
, '\\');
517 len
= get_long_basename (full
, o
, size
);
540 is_unc_volume (const char *filename
)
542 const char *ptr
= filename
;
544 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
547 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
553 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
556 sigsetmask (int signal_mask
)
580 setpgrp (int pid
, int gid
)
592 unrequest_sigio (void)
603 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
606 w32_get_resource (key
, lpdwtype
)
611 HKEY hrootkey
= NULL
;
615 /* Check both the current user and the local machine to see if
616 we have any resources. */
618 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
622 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
623 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
624 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
629 if (lpvalue
) xfree (lpvalue
);
631 RegCloseKey (hrootkey
);
634 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
638 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
639 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
640 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
645 if (lpvalue
) xfree (lpvalue
);
647 RegCloseKey (hrootkey
);
653 char *get_emacs_configuration (void);
654 extern Lisp_Object Vsystem_configuration
;
657 init_environment (char ** argv
)
660 static const char * const tempdirs
[] = {
661 "$TMPDIR", "$TEMP", "$TMP", "c:/"
664 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
666 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
667 temporary files and assume "/tmp" if $TMPDIR is unset, which
668 will break on DOS/Windows. Refuse to work if we cannot find
669 a directory, not even "c:/", usable for that purpose. */
670 for (i
= 0; i
< imax
; i
++)
672 const char *tmp
= tempdirs
[i
];
675 tmp
= getenv (tmp
+ 1);
676 /* Note that `access' can lie to us if the directory resides on a
677 read-only filesystem, like CD-ROM or a write-protected floppy.
678 The only way to be really sure is to actually create a file and
679 see if it succeeds. But I think that's too much to ask. */
680 if (tmp
&& access (tmp
, D_OK
) == 0)
682 char * var
= alloca (strlen (tmp
) + 8);
683 sprintf (var
, "TMPDIR=%s", tmp
);
691 Fcons (build_string ("no usable temporary directories found!!"),
693 "While setting TMPDIR: ");
695 /* Check for environment variables and use registry settings if they
696 don't exist. Fallback on default values where applicable. */
702 static struct env_entry
709 {"PRELOAD_WINSOCK", NULL
},
710 {"emacs_dir", "C:/emacs"},
711 {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
712 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
713 {"EMACSDATA", "%emacs_dir%/etc"},
714 {"EMACSPATH", "%emacs_dir%/bin"},
715 {"EMACSLOCKDIR", "%emacs_dir%/lock"},
716 /* We no longer set INFOPATH because Info-default-directory-list
718 /* {"INFOPATH", "%emacs_dir%/info"}, */
719 {"EMACSDOC", "%emacs_dir%/etc"},
723 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
725 /* Treat emacs_dir specially: set it unconditionally based on our
726 location, if it appears that we are running from the bin subdir
727 of a standard installation. */
730 char modname
[MAX_PATH
];
732 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
734 if ((p
= strrchr (modname
, '\\')) == NULL
)
738 if ((p
= strrchr (modname
, '\\')) && stricmp (p
, "\\bin") == 0)
740 char buf
[SET_ENV_BUF_SIZE
];
743 for (p
= modname
; *p
; p
++)
744 if (*p
== '\\') *p
= '/';
746 _snprintf (buf
, sizeof(buf
)-1, "emacs_dir=%s", modname
);
747 putenv (strdup (buf
));
751 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
753 if (!getenv (env_vars
[i
].name
))
757 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
)
759 lpval
= env_vars
[i
].def_value
;
760 dwType
= REG_EXPAND_SZ
;
766 if (dwType
== REG_EXPAND_SZ
)
768 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
770 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof(buf1
));
771 _snprintf (buf2
, sizeof(buf2
)-1, "%s=%s", env_vars
[i
].name
, buf1
);
772 putenv (strdup (buf2
));
774 else if (dwType
== REG_SZ
)
776 char buf
[SET_ENV_BUF_SIZE
];
778 _snprintf (buf
, sizeof(buf
)-1, "%s=%s", env_vars
[i
].name
, lpval
);
779 putenv (strdup (buf
));
789 /* Rebuild system configuration to reflect invoking system. */
790 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
792 /* Another special case: on NT, the PATH variable is actually named
793 "Path" although cmd.exe (perhaps NT itself) arranges for
794 environment variable lookup and setting to be case insensitive.
795 However, Emacs assumes a fully case sensitive environment, so we
796 need to change "Path" to "PATH" to match the expectations of
797 various elisp packages. We do this by the sneaky method of
798 modifying the string in the C runtime environ entry.
800 The same applies to COMSPEC. */
804 for (envp
= environ
; *envp
; envp
++)
805 if (_strnicmp (*envp
, "PATH=", 5) == 0)
806 memcpy (*envp
, "PATH=", 5);
807 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
808 memcpy (*envp
, "COMSPEC=", 8);
811 /* Remember the initial working directory for getwd, then make the
812 real wd be the location of emacs.exe to avoid conflicts when
813 renaming or deleting directories. (We also don't call chdir when
814 running subprocesses for the same reason.) */
815 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
820 static char modname
[MAX_PATH
];
822 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
824 if ((p
= strrchr (modname
, '\\')) == NULL
)
828 SetCurrentDirectory (modname
);
830 /* Ensure argv[0] has the full path to Emacs. */
835 /* Determine if there is a middle mouse button, to allow parse_button
836 to decide whether right mouse events should be mouse-2 or
838 XSETINT (Vw32_num_mouse_buttons
, GetSystemMetrics (SM_CMOUSEBUTTONS
));
843 /* We don't have scripts to automatically determine the system configuration
844 for Emacs before it's compiled, and we don't want to have to make the
845 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
848 static char configuration_buffer
[32];
851 get_emacs_configuration (void)
853 char *arch
, *oem
, *os
;
856 /* Determine the processor type. */
857 switch (get_processor_type ())
860 #ifdef PROCESSOR_INTEL_386
861 case PROCESSOR_INTEL_386
:
862 case PROCESSOR_INTEL_486
:
863 case PROCESSOR_INTEL_PENTIUM
:
868 #ifdef PROCESSOR_INTEL_860
869 case PROCESSOR_INTEL_860
:
874 #ifdef PROCESSOR_MIPS_R2000
875 case PROCESSOR_MIPS_R2000
:
876 case PROCESSOR_MIPS_R3000
:
877 case PROCESSOR_MIPS_R4000
:
882 #ifdef PROCESSOR_ALPHA_21064
883 case PROCESSOR_ALPHA_21064
:
893 /* Let oem be "*" until we figure out how to decode the OEM field. */
896 switch (osinfo_cache
.dwPlatformId
) {
897 case VER_PLATFORM_WIN32_NT
:
899 build_num
= osinfo_cache
.dwBuildNumber
;
901 case VER_PLATFORM_WIN32_WINDOWS
:
902 if (osinfo_cache
.dwMinorVersion
== 0) {
907 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
909 case VER_PLATFORM_WIN32s
:
910 /* Not supported, should not happen. */
912 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
920 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
921 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
922 get_w32_major_version (), get_w32_minor_version (), build_num
);
924 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
927 return configuration_buffer
;
930 #include <sys/timeb.h>
932 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
934 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
939 tv
->tv_sec
= tb
.time
;
940 tv
->tv_usec
= tb
.millitm
* 1000L;
943 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
944 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
948 /* ------------------------------------------------------------------------- */
949 /* IO support and wrapper functions for W32 API. */
950 /* ------------------------------------------------------------------------- */
952 /* Place a wrapper around the MSVC version of ctime. It returns NULL
953 on network directories, so we handle that case here.
954 (Ulrich Leodolter, 1/11/95). */
956 sys_ctime (const time_t *t
)
958 char *str
= (char *) ctime (t
);
959 return (str
? str
: "Sun Jan 01 00:00:00 1970");
962 /* Emulate sleep...we could have done this with a define, but that
963 would necessitate including windows.h in the files that used it.
964 This is much easier. */
966 sys_sleep (int seconds
)
968 Sleep (seconds
* 1000);
971 /* Internal MSVC functions for low-level descriptor munging */
972 extern int __cdecl
_set_osfhnd (int fd
, long h
);
973 extern int __cdecl
_free_osfhnd (int fd
);
975 /* parallel array of private info on file handles */
976 filedesc fd_info
[ MAXDESC
];
978 typedef struct volume_info_data
{
979 struct volume_info_data
* next
;
981 /* time when info was obtained */
984 /* actual volume info */
993 /* Global referenced by various functions. */
994 static volume_info_data volume_info
;
996 /* Vector to indicate which drives are local and fixed (for which cached
997 data never expires). */
998 static BOOL fixed_drives
[26];
1000 /* Consider cached volume information to be stale if older than 10s,
1001 at least for non-local drives. Info for fixed drives is never stale. */
1002 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1003 #define VOLINFO_STILL_VALID( root_dir, info ) \
1004 ( ( isalpha (root_dir[0]) && \
1005 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
1006 || GetTickCount () - info->timestamp < 10000 )
1008 /* Cache support functions. */
1010 /* Simple linked list with linear search is sufficient. */
1011 static volume_info_data
*volume_cache
= NULL
;
1013 static volume_info_data
*
1014 lookup_volume_info (char * root_dir
)
1016 volume_info_data
* info
;
1018 for (info
= volume_cache
; info
; info
= info
->next
)
1019 if (stricmp (info
->root_dir
, root_dir
) == 0)
1025 add_volume_info (char * root_dir
, volume_info_data
* info
)
1027 info
->root_dir
= strdup (root_dir
);
1028 info
->next
= volume_cache
;
1029 volume_cache
= info
;
1033 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1034 performance penalty (~2ms on 486 for local drives, 7.5ms for local
1035 cdrom drive, ~5-10ms or more for remote drives on LAN). */
1037 GetCachedVolumeInformation (char * root_dir
)
1039 volume_info_data
* info
;
1040 char default_root
[ MAX_PATH
];
1042 /* NULL for root_dir means use root from current directory. */
1043 if (root_dir
== NULL
)
1045 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
1047 parse_root (default_root
, &root_dir
);
1049 root_dir
= default_root
;
1052 /* Local fixed drives can be cached permanently. Removable drives
1053 cannot be cached permanently, since the volume name and serial
1054 number (if nothing else) can change. Remote drives should be
1055 treated as if they are removable, since there is no sure way to
1056 tell whether they are or not. Also, the UNC association of drive
1057 letters mapped to remote volumes can be changed at any time (even
1058 by other processes) without notice.
1060 As a compromise, so we can benefit from caching info for remote
1061 volumes, we use a simple expiry mechanism to invalidate cache
1062 entries that are more than ten seconds old. */
1065 /* No point doing this, because WNetGetConnection is even slower than
1066 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1067 GetDriveType is about the only call of this type which does not
1068 involve network access, and so is extremely quick). */
1070 /* Map drive letter to UNC if remote. */
1071 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1073 char remote_name
[ 256 ];
1074 char drive
[3] = { root_dir
[0], ':' };
1076 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1078 /* do something */ ;
1082 info
= lookup_volume_info (root_dir
);
1084 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1092 /* Info is not cached, or is stale. */
1093 if (!GetVolumeInformation (root_dir
,
1094 name
, sizeof (name
),
1098 type
, sizeof (type
)))
1101 /* Cache the volume information for future use, overwriting existing
1102 entry if present. */
1105 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1106 add_volume_info (root_dir
, info
);
1114 info
->name
= strdup (name
);
1115 info
->serialnum
= serialnum
;
1116 info
->maxcomp
= maxcomp
;
1117 info
->flags
= flags
;
1118 info
->type
= strdup (type
);
1119 info
->timestamp
= GetTickCount ();
1125 /* Get information on the volume where name is held; set path pointer to
1126 start of pathname in name (past UNC header\volume header if present). */
1128 get_volume_info (const char * name
, const char ** pPath
)
1130 char temp
[MAX_PATH
];
1131 char *rootname
= NULL
; /* default to current volume */
1132 volume_info_data
* info
;
1137 /* find the root name of the volume if given */
1138 if (isalpha (name
[0]) && name
[1] == ':')
1146 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1153 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1166 info
= GetCachedVolumeInformation (rootname
);
1169 /* Set global referenced by other functions. */
1170 volume_info
= *info
;
1176 /* Determine if volume is FAT format (ie. only supports short 8.3
1177 names); also set path pointer to start of pathname in name. */
1179 is_fat_volume (const char * name
, const char ** pPath
)
1181 if (get_volume_info (name
, pPath
))
1182 return (volume_info
.maxcomp
== 12);
1186 /* Map filename to a legal 8.3 name if necessary. */
1188 map_w32_filename (const char * name
, const char ** pPath
)
1190 static char shortname
[MAX_PATH
];
1191 char * str
= shortname
;
1194 const char * save_name
= name
;
1196 if (strlen (name
) >= MAX_PATH
)
1198 /* Return a filename which will cause callers to fail. */
1199 strcpy (shortname
, "?");
1203 if (is_fat_volume (name
, &path
)) /* truncate to 8.3 */
1205 register int left
= 8; /* maximum number of chars in part */
1206 register int extn
= 0; /* extension added? */
1207 register int dots
= 2; /* maximum number of dots allowed */
1210 *str
++ = *name
++; /* skip past UNC header */
1212 while ((c
= *name
++))
1219 extn
= 0; /* reset extension flags */
1220 dots
= 2; /* max 2 dots */
1221 left
= 8; /* max length 8 for main part */
1225 extn
= 0; /* reset extension flags */
1226 dots
= 2; /* max 2 dots */
1227 left
= 8; /* max length 8 for main part */
1232 /* Convert path components of the form .xxx to _xxx,
1233 but leave . and .. as they are. This allows .emacs
1234 to be read as _emacs, for example. */
1238 IS_DIRECTORY_SEP (*name
))
1253 extn
= 1; /* we've got an extension */
1254 left
= 3; /* 3 chars in extension */
1258 /* any embedded dots after the first are converted to _ */
1263 case '#': /* don't lose these, they're important */
1265 str
[-1] = c
; /* replace last character of part */
1270 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1272 dots
= 0; /* started a path component */
1281 strcpy (shortname
, name
);
1282 unixtodos_filename (shortname
);
1286 *pPath
= shortname
+ (path
- save_name
);
1292 is_exec (const char * name
)
1294 char * p
= strrchr (name
, '.');
1297 && (stricmp (p
, ".exe") == 0 ||
1298 stricmp (p
, ".com") == 0 ||
1299 stricmp (p
, ".bat") == 0 ||
1300 stricmp (p
, ".cmd") == 0));
1303 /* Emulate the Unix directory procedures opendir, closedir,
1304 and readdir. We can't use the procedures supplied in sysdep.c,
1305 so we provide them here. */
1307 struct direct dir_static
; /* simulated directory contents */
1308 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1309 static int dir_is_fat
;
1310 static char dir_pathname
[MAXPATHLEN
+1];
1311 static WIN32_FIND_DATA dir_find_data
;
1313 /* Support shares on a network resource as subdirectories of a read-only
1315 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1316 HANDLE
open_unc_volume (char *);
1317 char *read_unc_volume (HANDLE
, char *, int);
1318 void close_unc_volume (HANDLE
);
1321 opendir (char *filename
)
1325 /* Opening is done by FindFirstFile. However, a read is inherent to
1326 this operation, so we defer the open until read time. */
1328 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1330 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1333 if (is_unc_volume (filename
))
1335 wnet_enum_handle
= open_unc_volume (filename
);
1336 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1340 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1347 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1348 dir_pathname
[MAXPATHLEN
] = '\0';
1349 dir_is_fat
= is_fat_volume (filename
, NULL
);
1355 closedir (DIR *dirp
)
1357 /* If we have a find-handle open, close it. */
1358 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1360 FindClose (dir_find_handle
);
1361 dir_find_handle
= INVALID_HANDLE_VALUE
;
1363 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1365 close_unc_volume (wnet_enum_handle
);
1366 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1368 xfree ((char *) dirp
);
1374 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1376 if (!read_unc_volume (wnet_enum_handle
,
1377 dir_find_data
.cFileName
,
1381 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1382 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1384 char filename
[MAXNAMLEN
+ 3];
1387 strcpy (filename
, dir_pathname
);
1388 ln
= strlen (filename
) - 1;
1389 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1390 strcat (filename
, "\\");
1391 strcat (filename
, "*");
1393 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1395 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1400 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1404 /* Emacs never uses this value, so don't bother making it match
1405 value returned by stat(). */
1406 dir_static
.d_ino
= 1;
1408 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1409 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1411 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1412 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1414 _strlwr (dir_static
.d_name
);
1415 else if (!NILP (Vw32_downcase_file_names
))
1418 for (p
= dir_static
.d_name
; *p
; p
++)
1419 if (*p
>= 'a' && *p
<= 'z')
1422 _strlwr (dir_static
.d_name
);
1429 open_unc_volume (char *path
)
1435 nr
.dwScope
= RESOURCE_GLOBALNET
;
1436 nr
.dwType
= RESOURCETYPE_DISK
;
1437 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1438 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1439 nr
.lpLocalName
= NULL
;
1440 nr
.lpRemoteName
= map_w32_filename (path
, NULL
);
1441 nr
.lpComment
= NULL
;
1442 nr
.lpProvider
= NULL
;
1444 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1445 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1447 if (result
== NO_ERROR
)
1450 return INVALID_HANDLE_VALUE
;
1454 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1463 buffer
= alloca (bufsize
);
1464 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1465 if (result
!= NO_ERROR
)
1468 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1469 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1471 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1474 strncpy (readbuf
, ptr
, size
);
1479 close_unc_volume (HANDLE henum
)
1481 if (henum
!= INVALID_HANDLE_VALUE
)
1482 WNetCloseEnum (henum
);
1486 unc_volume_file_attributes (char *path
)
1491 henum
= open_unc_volume (path
);
1492 if (henum
== INVALID_HANDLE_VALUE
)
1495 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1497 close_unc_volume (henum
);
1503 /* Shadow some MSVC runtime functions to map requests for long filenames
1504 to reasonable short names if necessary. This was originally added to
1505 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1509 sys_access (const char * path
, int mode
)
1513 /* MSVC implementation doesn't recognize D_OK. */
1514 path
= map_w32_filename (path
, NULL
);
1515 if (is_unc_volume (path
))
1517 attributes
= unc_volume_file_attributes (path
);
1518 if (attributes
== -1) {
1523 else if ((attributes
= GetFileAttributes (path
)) == -1)
1525 /* Should try mapping GetLastError to errno; for now just indicate
1526 that path doesn't exist. */
1530 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1535 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1540 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1549 sys_chdir (const char * path
)
1551 return _chdir (map_w32_filename (path
, NULL
));
1555 sys_chmod (const char * path
, int mode
)
1557 return _chmod (map_w32_filename (path
, NULL
), mode
);
1561 sys_creat (const char * path
, int mode
)
1563 return _creat (map_w32_filename (path
, NULL
), mode
);
1567 sys_fopen(const char * path
, const char * mode
)
1571 const char * mode_save
= mode
;
1573 /* Force all file handles to be non-inheritable. This is necessary to
1574 ensure child processes don't unwittingly inherit handles that might
1575 prevent future file access. */
1579 else if (mode
[0] == 'w' || mode
[0] == 'a')
1580 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1584 /* Only do simplistic option parsing. */
1588 oflag
&= ~(O_RDONLY
| O_WRONLY
);
1591 else if (mode
[0] == 'b')
1596 else if (mode
[0] == 't')
1603 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
1607 return _fdopen (fd
, mode_save
);
1610 /* This only works on NTFS volumes, but is useful to have. */
1612 sys_link (const char * old
, const char * new)
1616 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
1618 if (old
== NULL
|| new == NULL
)
1624 strcpy (oldname
, map_w32_filename (old
, NULL
));
1625 strcpy (newname
, map_w32_filename (new, NULL
));
1627 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
1628 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
1629 if (fileh
!= INVALID_HANDLE_VALUE
)
1633 /* Confusingly, the "alternate" stream name field does not apply
1634 when restoring a hard link, and instead contains the actual
1635 stream data for the link (ie. the name of the link to create).
1636 The WIN32_STREAM_ID structure before the cStreamName field is
1637 the stream header, which is then immediately followed by the
1641 WIN32_STREAM_ID wid
;
1642 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
1645 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
1646 data
.wid
.cStreamName
, MAX_PATH
);
1649 LPVOID context
= NULL
;
1652 data
.wid
.dwStreamId
= BACKUP_LINK
;
1653 data
.wid
.dwStreamAttributes
= 0;
1654 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
1655 data
.wid
.Size
.HighPart
= 0;
1656 data
.wid
.dwStreamNameSize
= 0;
1658 if (BackupWrite (fileh
, (LPBYTE
)&data
,
1659 offsetof (WIN32_STREAM_ID
, cStreamName
)
1660 + data
.wid
.Size
.LowPart
,
1661 &wbytes
, FALSE
, FALSE
, &context
)
1662 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
1669 /* Should try mapping GetLastError to errno; for now just
1670 indicate a general error (eg. links not supported). */
1671 errno
= EINVAL
; // perhaps EMLINK?
1675 CloseHandle (fileh
);
1684 sys_mkdir (const char * path
)
1686 return _mkdir (map_w32_filename (path
, NULL
));
1689 /* Because of long name mapping issues, we need to implement this
1690 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1691 a unique name, instead of setting the input template to an empty
1694 Standard algorithm seems to be use pid or tid with a letter on the
1695 front (in place of the 6 X's) and cycle through the letters to find a
1696 unique name. We extend that to allow any reasonable character as the
1697 first of the 6 X's. */
1699 sys_mktemp (char * template)
1703 unsigned uid
= GetCurrentThreadId ();
1704 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1706 if (template == NULL
)
1708 p
= template + strlen (template);
1710 /* replace up to the last 5 X's with uid in decimal */
1711 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1713 p
[0] = '0' + uid
% 10;
1717 if (i
< 0 && p
[0] == 'X')
1722 int save_errno
= errno
;
1723 p
[0] = first_char
[i
];
1724 if (sys_access (template, 0) < 0)
1730 while (++i
< sizeof (first_char
));
1733 /* Template is badly formed or else we can't generate a unique name,
1734 so return empty string */
1740 sys_open (const char * path
, int oflag
, int mode
)
1742 /* Force all file handles to be non-inheritable. */
1743 return _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, mode
);
1747 sys_rename (const char * oldname
, const char * newname
)
1750 char temp
[MAX_PATH
];
1752 /* MoveFile on Windows 95 doesn't correctly change the short file name
1753 alias in a number of circumstances (it is not easy to predict when
1754 just by looking at oldname and newname, unfortunately). In these
1755 cases, renaming through a temporary name avoids the problem.
1757 A second problem on Windows 95 is that renaming through a temp name when
1758 newname is uppercase fails (the final long name ends up in
1759 lowercase, although the short alias might be uppercase) UNLESS the
1760 long temp name is not 8.3.
1762 So, on Windows 95 we always rename through a temp name, and we make sure
1763 the temp name has a long extension to ensure correct renaming. */
1765 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1767 if (os_subtype
== OS_WIN95
)
1773 oldname
= map_w32_filename (oldname
, NULL
);
1774 if (o
= strrchr (oldname
, '\\'))
1777 o
= (char *) oldname
;
1779 if (p
= strrchr (temp
, '\\'))
1786 /* Force temp name to require a manufactured 8.3 alias - this
1787 seems to make the second rename work properly. */
1788 sprintf (p
, "_.%s.%u", o
, i
);
1790 result
= rename (oldname
, temp
);
1792 /* This loop must surely terminate! */
1793 while (result
< 0 && (errno
== EEXIST
|| errno
== EACCES
));
1798 /* Emulate Unix behaviour - newname is deleted if it already exists
1799 (at least if it is a file; don't do this for directories).
1801 Since we mustn't do this if we are just changing the case of the
1802 file name (we would end up deleting the file we are trying to
1803 rename!), we let rename detect if the destination file already
1804 exists - that way we avoid the possible pitfalls of trying to
1805 determine ourselves whether two names really refer to the same
1806 file, which is not always possible in the general case. (Consider
1807 all the permutations of shared or subst'd drives, etc.) */
1809 newname
= map_w32_filename (newname
, NULL
);
1810 result
= rename (temp
, newname
);
1813 && (errno
== EEXIST
|| errno
== EACCES
)
1814 && _chmod (newname
, 0666) == 0
1815 && _unlink (newname
) == 0)
1816 result
= rename (temp
, newname
);
1822 sys_rmdir (const char * path
)
1824 return _rmdir (map_w32_filename (path
, NULL
));
1828 sys_unlink (const char * path
)
1830 path
= map_w32_filename (path
, NULL
);
1832 /* On Unix, unlink works without write permission. */
1833 _chmod (path
, 0666);
1834 return _unlink (path
);
1837 static FILETIME utc_base_ft
;
1838 static long double utc_base
;
1839 static int init
= 0;
1842 convert_time (FILETIME ft
)
1848 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1857 st
.wMilliseconds
= 0;
1859 SystemTimeToFileTime (&st
, &utc_base_ft
);
1860 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1861 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1865 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1868 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1870 return (time_t) (ret
* 1e-7);
1874 convert_from_time_t (time_t time
, FILETIME
* pft
)
1880 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1889 st
.wMilliseconds
= 0;
1891 SystemTimeToFileTime (&st
, &utc_base_ft
);
1892 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1893 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1897 /* time in 100ns units since 1-Jan-1601 */
1898 tmp
= (long double) time
* 1e7
+ utc_base
;
1899 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
1900 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
1904 /* No reason to keep this; faking inode values either by hashing or even
1905 using the file index from GetInformationByHandle, is not perfect and
1906 so by default Emacs doesn't use the inode values on Windows.
1907 Instead, we now determine file-truename correctly (except for
1908 possible drive aliasing etc). */
1910 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
1912 hashval (const unsigned char * str
)
1917 h
= (h
<< 4) + *str
++;
1923 /* Return the hash value of the canonical pathname, excluding the
1924 drive/UNC header, to get a hopefully unique inode number. */
1926 generate_inode_val (const char * name
)
1928 char fullname
[ MAX_PATH
];
1932 /* Get the truly canonical filename, if it exists. (Note: this
1933 doesn't resolve aliasing due to subst commands, or recognise hard
1935 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
1938 parse_root (fullname
, &p
);
1939 /* Normal W32 filesystems are still case insensitive. */
1946 /* MSVC stat function can't cope with UNC names and has other bugs, so
1947 replace it with our own. This also allows us to calculate consistent
1948 inode values without hacks in the main Emacs code. */
1950 stat (const char * path
, struct stat
* buf
)
1953 WIN32_FIND_DATA wfd
;
1958 int rootdir
= FALSE
;
1960 if (path
== NULL
|| buf
== NULL
)
1966 name
= (char *) map_w32_filename (path
, &path
);
1967 /* must be valid filename, no wild cards or other invalid characters */
1968 if (strpbrk (name
, "*?|<>\""))
1974 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
1975 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
1976 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
1981 /* Remove trailing directory separator, unless name is the root
1982 directory of a drive or UNC volume in which case ensure there
1983 is a trailing separator. */
1984 len
= strlen (name
);
1985 rootdir
= (path
>= name
+ len
- 1
1986 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
1987 name
= strcpy (alloca (len
+ 2), name
);
1989 if (is_unc_volume (name
))
1991 DWORD attrs
= unc_volume_file_attributes (name
);
1996 memset (&wfd
, 0, sizeof (wfd
));
1997 wfd
.dwFileAttributes
= attrs
;
1998 wfd
.ftCreationTime
= utc_base_ft
;
1999 wfd
.ftLastAccessTime
= utc_base_ft
;
2000 wfd
.ftLastWriteTime
= utc_base_ft
;
2001 strcpy (wfd
.cFileName
, name
);
2005 if (!IS_DIRECTORY_SEP (name
[len
-1]))
2006 strcat (name
, "\\");
2007 if (GetDriveType (name
) < 2)
2012 memset (&wfd
, 0, sizeof (wfd
));
2013 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
2014 wfd
.ftCreationTime
= utc_base_ft
;
2015 wfd
.ftLastAccessTime
= utc_base_ft
;
2016 wfd
.ftLastWriteTime
= utc_base_ft
;
2017 strcpy (wfd
.cFileName
, name
);
2021 if (IS_DIRECTORY_SEP (name
[len
-1]))
2024 /* (This is hacky, but helps when doing file completions on
2025 network drives.) Optimize by using information available from
2026 active readdir if possible. */
2027 len
= strlen (dir_pathname
);
2028 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
2030 if (dir_find_handle
!= INVALID_HANDLE_VALUE
2031 && strnicmp (name
, dir_pathname
, len
) == 0
2032 && IS_DIRECTORY_SEP (name
[len
])
2033 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
2035 /* This was the last entry returned by readdir. */
2036 wfd
= dir_find_data
;
2040 fh
= FindFirstFile (name
, &wfd
);
2041 if (fh
== INVALID_HANDLE_VALUE
)
2050 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2052 buf
->st_mode
= _S_IFDIR
;
2053 buf
->st_nlink
= 2; /* doesn't really matter */
2054 fake_inode
= 0; /* this doesn't either I think */
2056 else if (!NILP (Vw32_get_true_file_attributes
)
2057 /* No access rights required to get info. */
2058 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
, 0, NULL
))
2059 != INVALID_HANDLE_VALUE
)
2061 /* This is more accurate in terms of gettting the correct number
2062 of links, but is quite slow (it is noticable when Emacs is
2063 making a list of file name completions). */
2064 BY_HANDLE_FILE_INFORMATION info
;
2066 if (GetFileInformationByHandle (fh
, &info
))
2068 buf
->st_nlink
= info
.nNumberOfLinks
;
2069 /* Might as well use file index to fake inode values, but this
2070 is not guaranteed to be unique unless we keep a handle open
2071 all the time (even then there are situations where it is
2072 not unique). Reputedly, there are at most 48 bits of info
2073 (on NTFS, presumably less on FAT). */
2074 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2082 switch (GetFileType (fh
))
2084 case FILE_TYPE_DISK
:
2085 buf
->st_mode
= _S_IFREG
;
2087 case FILE_TYPE_PIPE
:
2088 buf
->st_mode
= _S_IFIFO
;
2090 case FILE_TYPE_CHAR
:
2091 case FILE_TYPE_UNKNOWN
:
2093 buf
->st_mode
= _S_IFCHR
;
2099 /* Don't bother to make this information more accurate. */
2100 buf
->st_mode
= _S_IFREG
;
2106 /* Not sure if there is any point in this. */
2107 if (!NILP (Vw32_generate_fake_inodes
))
2108 fake_inode
= generate_inode_val (name
);
2109 else if (fake_inode
== 0)
2111 /* For want of something better, try to make everything unique. */
2112 static DWORD gen_num
= 0;
2113 fake_inode
= ++gen_num
;
2117 /* MSVC defines _ino_t to be short; other libc's might not. */
2118 if (sizeof (buf
->st_ino
) == 2)
2119 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2121 buf
->st_ino
= fake_inode
;
2123 /* consider files to belong to current user */
2124 buf
->st_uid
= the_passwd
.pw_uid
;
2125 buf
->st_gid
= the_passwd
.pw_gid
;
2127 /* volume_info is set indirectly by map_w32_filename */
2128 buf
->st_dev
= volume_info
.serialnum
;
2129 buf
->st_rdev
= volume_info
.serialnum
;
2132 buf
->st_size
= wfd
.nFileSizeLow
;
2134 /* Convert timestamps to Unix format. */
2135 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2136 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2137 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2138 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2139 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2141 /* determine rwx permissions */
2142 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2143 permission
= _S_IREAD
;
2145 permission
= _S_IREAD
| _S_IWRITE
;
2147 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2148 permission
|= _S_IEXEC
;
2149 else if (is_exec (name
))
2150 permission
|= _S_IEXEC
;
2152 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2157 /* Provide fstat and utime as well as stat for consistent handling of
2160 fstat (int desc
, struct stat
* buf
)
2162 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2163 BY_HANDLE_FILE_INFORMATION info
;
2167 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2169 case FILE_TYPE_DISK
:
2170 buf
->st_mode
= _S_IFREG
;
2171 if (!GetFileInformationByHandle (fh
, &info
))
2177 case FILE_TYPE_PIPE
:
2178 buf
->st_mode
= _S_IFIFO
;
2180 case FILE_TYPE_CHAR
:
2181 case FILE_TYPE_UNKNOWN
:
2183 buf
->st_mode
= _S_IFCHR
;
2185 memset (&info
, 0, sizeof (info
));
2186 info
.dwFileAttributes
= 0;
2187 info
.ftCreationTime
= utc_base_ft
;
2188 info
.ftLastAccessTime
= utc_base_ft
;
2189 info
.ftLastWriteTime
= utc_base_ft
;
2192 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2194 buf
->st_mode
= _S_IFDIR
;
2195 buf
->st_nlink
= 2; /* doesn't really matter */
2196 fake_inode
= 0; /* this doesn't either I think */
2200 buf
->st_nlink
= info
.nNumberOfLinks
;
2201 /* Might as well use file index to fake inode values, but this
2202 is not guaranteed to be unique unless we keep a handle open
2203 all the time (even then there are situations where it is
2204 not unique). Reputedly, there are at most 48 bits of info
2205 (on NTFS, presumably less on FAT). */
2206 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2209 /* MSVC defines _ino_t to be short; other libc's might not. */
2210 if (sizeof (buf
->st_ino
) == 2)
2211 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2213 buf
->st_ino
= fake_inode
;
2215 /* consider files to belong to current user */
2219 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2220 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2222 buf
->st_size
= info
.nFileSizeLow
;
2224 /* Convert timestamps to Unix format. */
2225 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2226 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2227 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2228 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2229 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2231 /* determine rwx permissions */
2232 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2233 permission
= _S_IREAD
;
2235 permission
= _S_IREAD
| _S_IWRITE
;
2237 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2238 permission
|= _S_IEXEC
;
2241 #if 0 /* no way of knowing the filename */
2242 char * p
= strrchr (name
, '.');
2244 (stricmp (p
, ".exe") == 0 ||
2245 stricmp (p
, ".com") == 0 ||
2246 stricmp (p
, ".bat") == 0 ||
2247 stricmp (p
, ".cmd") == 0))
2248 permission
|= _S_IEXEC
;
2252 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2258 utime (const char *name
, struct utimbuf
*times
)
2260 struct utimbuf deftime
;
2267 deftime
.modtime
= deftime
.actime
= time (NULL
);
2271 /* Need write access to set times. */
2272 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2273 0, OPEN_EXISTING
, 0, NULL
);
2276 convert_from_time_t (times
->actime
, &atime
);
2277 convert_from_time_t (times
->modtime
, &mtime
);
2278 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2296 /* Wrappers for winsock functions to map between our file descriptors
2297 and winsock's handles; also set h_errno for convenience.
2299 To allow Emacs to run on systems which don't have winsock support
2300 installed, we dynamically link to winsock on startup if present, and
2301 otherwise provide the minimum necessary functionality
2302 (eg. gethostname). */
2304 /* function pointers for relevant socket functions */
2305 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2306 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2307 int (PASCAL
*pfn_WSAGetLastError
) (void);
2308 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2309 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2310 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2311 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2312 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2313 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2314 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2315 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2316 int (PASCAL
*pfn_WSACleanup
) (void);
2318 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2319 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2320 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2321 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2322 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2323 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2325 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2326 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2327 #ifndef HANDLE_FLAG_INHERIT
2328 #define HANDLE_FLAG_INHERIT 1
2332 static int winsock_inuse
;
2337 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2339 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2340 after WSAStartup returns successfully, but it seems reasonable
2341 to allow unloading winsock anyway in that case. */
2342 if (pfn_WSACleanup () == 0 ||
2343 pfn_WSAGetLastError () == WSAENETDOWN
)
2345 if (FreeLibrary (winsock_lib
))
2354 init_winsock (int load_now
)
2356 WSADATA winsockData
;
2358 if (winsock_lib
!= NULL
)
2361 pfn_SetHandleInformation
= NULL
;
2362 pfn_SetHandleInformation
2363 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2364 "SetHandleInformation");
2366 winsock_lib
= LoadLibrary ("wsock32.dll");
2368 if (winsock_lib
!= NULL
)
2370 /* dynamically link to socket functions */
2372 #define LOAD_PROC(fn) \
2373 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2376 LOAD_PROC( WSAStartup
);
2377 LOAD_PROC( WSASetLastError
);
2378 LOAD_PROC( WSAGetLastError
);
2379 LOAD_PROC( socket
);
2381 LOAD_PROC( connect
);
2382 LOAD_PROC( ioctlsocket
);
2385 LOAD_PROC( closesocket
);
2386 LOAD_PROC( shutdown
);
2389 LOAD_PROC( inet_addr
);
2390 LOAD_PROC( gethostname
);
2391 LOAD_PROC( gethostbyname
);
2392 LOAD_PROC( getservbyname
);
2393 LOAD_PROC( WSACleanup
);
2397 /* specify version 1.1 of winsock */
2398 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2400 if (winsockData
.wVersion
!= 0x101)
2405 /* Report that winsock exists and is usable, but leave
2406 socket functions disabled. I am assuming that calling
2407 WSAStartup does not require any network interaction,
2408 and in particular does not cause or require a dial-up
2409 connection to be established. */
2412 FreeLibrary (winsock_lib
);
2420 FreeLibrary (winsock_lib
);
2430 /* function to set h_errno for compatability; map winsock error codes to
2431 normal system codes where they overlap (non-overlapping definitions
2432 are already in <sys/socket.h> */
2433 static void set_errno ()
2435 if (winsock_lib
== NULL
)
2438 h_errno
= pfn_WSAGetLastError ();
2442 case WSAEACCES
: h_errno
= EACCES
; break;
2443 case WSAEBADF
: h_errno
= EBADF
; break;
2444 case WSAEFAULT
: h_errno
= EFAULT
; break;
2445 case WSAEINTR
: h_errno
= EINTR
; break;
2446 case WSAEINVAL
: h_errno
= EINVAL
; break;
2447 case WSAEMFILE
: h_errno
= EMFILE
; break;
2448 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2449 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2454 static void check_errno ()
2456 if (h_errno
== 0 && winsock_lib
!= NULL
)
2457 pfn_WSASetLastError (0);
2460 /* Extend strerror to handle the winsock-specific error codes. */
2464 } _wsa_errlist
[] = {
2465 WSAEINTR
, "Interrupted function call",
2466 WSAEBADF
, "Bad file descriptor",
2467 WSAEACCES
, "Permission denied",
2468 WSAEFAULT
, "Bad address",
2469 WSAEINVAL
, "Invalid argument",
2470 WSAEMFILE
, "Too many open files",
2472 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2473 WSAEINPROGRESS
, "Operation now in progress",
2474 WSAEALREADY
, "Operation already in progress",
2475 WSAENOTSOCK
, "Socket operation on non-socket",
2476 WSAEDESTADDRREQ
, "Destination address required",
2477 WSAEMSGSIZE
, "Message too long",
2478 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2479 WSAENOPROTOOPT
, "Bad protocol option",
2480 WSAEPROTONOSUPPORT
, "Protocol not supported",
2481 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2482 WSAEOPNOTSUPP
, "Operation not supported",
2483 WSAEPFNOSUPPORT
, "Protocol family not supported",
2484 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2485 WSAEADDRINUSE
, "Address already in use",
2486 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2487 WSAENETDOWN
, "Network is down",
2488 WSAENETUNREACH
, "Network is unreachable",
2489 WSAENETRESET
, "Network dropped connection on reset",
2490 WSAECONNABORTED
, "Software caused connection abort",
2491 WSAECONNRESET
, "Connection reset by peer",
2492 WSAENOBUFS
, "No buffer space available",
2493 WSAEISCONN
, "Socket is already connected",
2494 WSAENOTCONN
, "Socket is not connected",
2495 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2496 WSAETOOMANYREFS
, "Too many references", /* not sure */
2497 WSAETIMEDOUT
, "Connection timed out",
2498 WSAECONNREFUSED
, "Connection refused",
2499 WSAELOOP
, "Network loop", /* not sure */
2500 WSAENAMETOOLONG
, "Name is too long",
2501 WSAEHOSTDOWN
, "Host is down",
2502 WSAEHOSTUNREACH
, "No route to host",
2503 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2504 WSAEPROCLIM
, "Too many processes",
2505 WSAEUSERS
, "Too many users", /* not sure */
2506 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2507 WSAESTALE
, "Data is stale", /* not sure */
2508 WSAEREMOTE
, "Remote error", /* not sure */
2510 WSASYSNOTREADY
, "Network subsystem is unavailable",
2511 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2512 WSANOTINITIALISED
, "Winsock not initialized successfully",
2513 WSAEDISCON
, "Graceful shutdown in progress",
2515 WSAENOMORE
, "No more operations allowed", /* not sure */
2516 WSAECANCELLED
, "Operation cancelled", /* not sure */
2517 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2518 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2519 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2520 WSASYSCALLFAILURE
, "System call failured",
2521 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2522 WSATYPE_NOT_FOUND
, "Class type not found",
2523 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2524 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2525 WSAEREFUSED
, "Operation refused", /* not sure */
2528 WSAHOST_NOT_FOUND
, "Host not found",
2529 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2530 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2531 WSANO_DATA
, "Valid name, no data record of requested type",
2537 sys_strerror(int error_no
)
2540 static char unknown_msg
[40];
2542 if (error_no
>= 0 && error_no
< _sys_nerr
)
2543 return _sys_errlist
[error_no
];
2545 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2546 if (_wsa_errlist
[i
].errnum
== error_no
)
2547 return _wsa_errlist
[i
].msg
;
2549 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
2553 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2554 but I believe the method of keeping the socket handle separate (and
2555 insuring it is not inheritable) is the correct one. */
2557 //#define SOCK_REPLACE_HANDLE
2559 #ifdef SOCK_REPLACE_HANDLE
2560 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2562 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2566 sys_socket(int af
, int type
, int protocol
)
2572 if (winsock_lib
== NULL
)
2575 return INVALID_SOCKET
;
2580 /* call the real socket function */
2581 s
= (long) pfn_socket (af
, type
, protocol
);
2583 if (s
!= INVALID_SOCKET
)
2585 /* Although under NT 3.5 _open_osfhandle will accept a socket
2586 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2587 that does not work under NT 3.1. However, we can get the same
2588 effect by using a backdoor function to replace an existing
2589 descriptor handle with the one we want. */
2591 /* allocate a file descriptor (with appropriate flags) */
2592 fd
= _open ("NUL:", _O_RDWR
);
2595 #ifdef SOCK_REPLACE_HANDLE
2596 /* now replace handle to NUL with our socket handle */
2597 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
2599 _set_osfhnd (fd
, s
);
2600 /* setmode (fd, _O_BINARY); */
2602 /* Make a non-inheritable copy of the socket handle. Note
2603 that it is possible that sockets aren't actually kernel
2604 handles, which appears to be the case on Windows 9x when
2605 the MS Proxy winsock client is installed. */
2607 /* Apparently there is a bug in NT 3.51 with some service
2608 packs, which prevents using DuplicateHandle to make a
2609 socket handle non-inheritable (causes WSACleanup to
2610 hang). The work-around is to use SetHandleInformation
2611 instead if it is available and implemented. */
2612 if (pfn_SetHandleInformation
)
2614 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
2618 HANDLE parent
= GetCurrentProcess ();
2619 HANDLE new_s
= INVALID_HANDLE_VALUE
;
2621 if (DuplicateHandle (parent
,
2627 DUPLICATE_SAME_ACCESS
))
2629 /* It is possible that DuplicateHandle succeeds even
2630 though the socket wasn't really a kernel handle,
2631 because a real handle has the same value. So
2632 test whether the new handle really is a socket. */
2633 long nonblocking
= 0;
2634 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
2636 pfn_closesocket (s
);
2641 CloseHandle (new_s
);
2646 fd_info
[fd
].hnd
= (HANDLE
) s
;
2649 /* set our own internal flags */
2650 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
2656 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2658 /* attach child_process to fd_info */
2659 if (fd_info
[ fd
].cp
!= NULL
)
2661 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
2665 fd_info
[ fd
].cp
= cp
;
2668 winsock_inuse
++; /* count open sockets */
2675 pfn_closesocket (s
);
2685 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
2687 if (winsock_lib
== NULL
)
2690 return SOCKET_ERROR
;
2694 if (fd_info
[s
].flags
& FILE_SOCKET
)
2696 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
2697 if (rc
== SOCKET_ERROR
)
2702 return SOCKET_ERROR
;
2707 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
2709 if (winsock_lib
== NULL
)
2712 return SOCKET_ERROR
;
2716 if (fd_info
[s
].flags
& FILE_SOCKET
)
2718 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
2719 if (rc
== SOCKET_ERROR
)
2724 return SOCKET_ERROR
;
2728 sys_htons (u_short hostshort
)
2730 return (winsock_lib
!= NULL
) ?
2731 pfn_htons (hostshort
) : hostshort
;
2735 sys_ntohs (u_short netshort
)
2737 return (winsock_lib
!= NULL
) ?
2738 pfn_ntohs (netshort
) : netshort
;
2742 sys_inet_addr (const char * cp
)
2744 return (winsock_lib
!= NULL
) ?
2745 pfn_inet_addr (cp
) : INADDR_NONE
;
2749 sys_gethostname (char * name
, int namelen
)
2751 if (winsock_lib
!= NULL
)
2752 return pfn_gethostname (name
, namelen
);
2754 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
2755 return !GetComputerName (name
, &namelen
);
2758 return SOCKET_ERROR
;
2762 sys_gethostbyname(const char * name
)
2764 struct hostent
* host
;
2766 if (winsock_lib
== NULL
)
2773 host
= pfn_gethostbyname (name
);
2780 sys_getservbyname(const char * name
, const char * proto
)
2782 struct servent
* serv
;
2784 if (winsock_lib
== NULL
)
2791 serv
= pfn_getservbyname (name
, proto
);
2798 sys_shutdown (int s
, int how
)
2802 if (winsock_lib
== NULL
)
2805 return SOCKET_ERROR
;
2809 if (fd_info
[s
].flags
& FILE_SOCKET
)
2811 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
2812 if (rc
== SOCKET_ERROR
)
2817 return SOCKET_ERROR
;
2820 #endif /* HAVE_SOCKETS */
2823 /* Shadow main io functions: we need to handle pipes and sockets more
2824 intelligently, and implement non-blocking mode as well. */
2831 if (fd
< 0 || fd
>= MAXDESC
)
2839 child_process
* cp
= fd_info
[fd
].cp
;
2841 fd_info
[fd
].cp
= NULL
;
2843 if (CHILD_ACTIVE (cp
))
2845 /* if last descriptor to active child_process then cleanup */
2847 for (i
= 0; i
< MAXDESC
; i
++)
2851 if (fd_info
[i
].cp
== cp
)
2857 if (fd_info
[fd
].flags
& FILE_SOCKET
)
2859 #ifndef SOCK_REPLACE_HANDLE
2860 if (winsock_lib
== NULL
) abort ();
2862 pfn_shutdown (SOCK_HANDLE (fd
), 2);
2863 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
2865 winsock_inuse
--; /* count open sockets */
2873 /* Note that sockets do not need special treatment here (at least on
2874 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
2875 closesocket is equivalent to CloseHandle, which is to be expected
2876 because socket handles are fully fledged kernel handles. */
2880 fd_info
[fd
].flags
= 0;
2893 /* duplicate our internal info as well */
2894 fd_info
[new_fd
] = fd_info
[fd
];
2901 sys_dup2 (int src
, int dst
)
2905 if (dst
< 0 || dst
>= MAXDESC
)
2911 /* make sure we close the destination first if it's a pipe or socket */
2912 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
2915 rc
= _dup2 (src
, dst
);
2918 /* duplicate our internal info as well */
2919 fd_info
[dst
] = fd_info
[src
];
2924 /* Unix pipe() has only one arg */
2926 sys_pipe (int * phandles
)
2932 /* make pipe handles non-inheritable; when we spawn a child, we
2933 replace the relevant handle with an inheritable one. Also put
2934 pipes into binary mode; we will do text mode translation ourselves
2936 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
2940 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
2941 fd_info
[phandles
[0]].flags
= flags
;
2943 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
2944 fd_info
[phandles
[1]].flags
= flags
;
2951 extern Lisp_Object Vw32_pipe_read_delay
;
2953 /* Function to do blocking read of one byte, needed to implement
2954 select. It is only allowed on sockets and pipes. */
2956 _sys_read_ahead (int fd
)
2961 if (fd
< 0 || fd
>= MAXDESC
)
2962 return STATUS_READ_ERROR
;
2964 cp
= fd_info
[fd
].cp
;
2966 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
2967 return STATUS_READ_ERROR
;
2969 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
2970 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
2972 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
2976 cp
->status
= STATUS_READ_IN_PROGRESS
;
2978 if (fd_info
[fd
].flags
& FILE_PIPE
)
2980 rc
= _read (fd
, &cp
->chr
, sizeof (char));
2982 /* Give subprocess time to buffer some more output for us before
2983 reporting that input is available; we need this because Windows 95
2984 connects DOS programs to pipes by making the pipe appear to be
2985 the normal console stdout - as a result most DOS programs will
2986 write to stdout without buffering, ie. one character at a
2987 time. Even some W32 programs do this - "dir" in a command
2988 shell on NT is very slow if we don't do this. */
2991 int wait
= XINT (Vw32_pipe_read_delay
);
2997 /* Yield remainder of our time slice, effectively giving a
2998 temporary priority boost to the child process. */
3003 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
3004 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
3007 if (rc
== sizeof (char))
3008 cp
->status
= STATUS_READ_SUCCEEDED
;
3010 cp
->status
= STATUS_READ_FAILED
;
3016 sys_read (int fd
, char * buffer
, unsigned int count
)
3021 char * orig_buffer
= buffer
;
3023 if (fd
< 0 || fd
>= MAXDESC
)
3029 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3031 child_process
*cp
= fd_info
[fd
].cp
;
3033 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
3041 /* re-read CR carried over from last read */
3042 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
3044 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
3048 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
3051 /* presence of a child_process structure means we are operating in
3052 non-blocking mode - otherwise we just call _read directly.
3053 Note that the child_process structure might be missing because
3054 reap_subprocess has been called; in this case the pipe is
3055 already broken, so calling _read on it is okay. */
3058 int current_status
= cp
->status
;
3060 switch (current_status
)
3062 case STATUS_READ_FAILED
:
3063 case STATUS_READ_ERROR
:
3064 /* report normal EOF if nothing in buffer */
3066 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3069 case STATUS_READ_READY
:
3070 case STATUS_READ_IN_PROGRESS
:
3071 DebPrint (("sys_read called when read is in progress\n"));
3072 errno
= EWOULDBLOCK
;
3075 case STATUS_READ_SUCCEEDED
:
3076 /* consume read-ahead char */
3077 *buffer
++ = cp
->chr
;
3080 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3081 ResetEvent (cp
->char_avail
);
3083 case STATUS_READ_ACKNOWLEDGED
:
3087 DebPrint (("sys_read: bad status %d\n", current_status
));
3092 if (fd_info
[fd
].flags
& FILE_PIPE
)
3094 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3095 to_read
= min (waiting
, (DWORD
) count
);
3098 nchars
+= _read (fd
, buffer
, to_read
);
3101 else /* FILE_SOCKET */
3103 if (winsock_lib
== NULL
) abort ();
3105 /* do the equivalent of a non-blocking read */
3106 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3107 if (waiting
== 0 && nchars
== 0)
3109 h_errno
= errno
= EWOULDBLOCK
;
3115 /* always use binary mode for sockets */
3116 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3117 if (res
== SOCKET_ERROR
)
3119 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3120 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3131 int nread
= _read (fd
, buffer
, count
);
3134 else if (nchars
== 0)
3139 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3140 /* Perform text mode translation if required. */
3141 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3143 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3144 /* If buffer contains only CR, return that. To be absolutely
3145 sure we should attempt to read the next char, but in
3146 practice a CR to be followed by LF would not appear by
3147 itself in the buffer. */
3148 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3150 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3156 nchars
= _read (fd
, buffer
, count
);
3161 /* For now, don't bother with a non-blocking mode */
3163 sys_write (int fd
, const void * buffer
, unsigned int count
)
3167 if (fd
< 0 || fd
>= MAXDESC
)
3173 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3175 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3181 /* Perform text mode translation if required. */
3182 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3184 char * tmpbuf
= alloca (count
* 2);
3185 unsigned char * src
= (void *)buffer
;
3186 unsigned char * dst
= tmpbuf
;
3191 unsigned char *next
;
3192 /* copy next line or remaining bytes */
3193 next
= _memccpy (dst
, src
, '\n', nbytes
);
3196 /* copied one line ending with '\n' */
3197 int copied
= next
- dst
;
3200 /* insert '\r' before '\n' */
3207 /* copied remaining partial line -> now finished */
3215 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3217 if (winsock_lib
== NULL
) abort ();
3218 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3219 if (nchars
== SOCKET_ERROR
)
3221 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3222 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3228 nchars
= _write (fd
, buffer
, count
);
3234 check_windows_init_file ()
3236 extern int noninteractive
, inhibit_window_system
;
3238 /* A common indication that Emacs is not installed properly is when
3239 it cannot find the Windows installation file. If this file does
3240 not exist in the expected place, tell the user. */
3242 if (!noninteractive
&& !inhibit_window_system
)
3244 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3245 Lisp_Object objs
[2];
3246 Lisp_Object full_load_path
;
3247 Lisp_Object init_file
;
3250 objs
[0] = Vload_path
;
3251 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3252 full_load_path
= Fappend (2, objs
);
3253 init_file
= build_string ("term/w32-win");
3254 fd
= openp (full_load_path
, init_file
, ".el:.elc", NULL
, 0);
3257 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3258 char *init_file_name
= XSTRING (init_file
)->data
;
3259 char *load_path
= XSTRING (load_path_print
)->data
;
3260 char *buffer
= alloca (1024);
3263 "The Emacs Windows initialization file \"%s.el\" "
3264 "could not be found in your Emacs installation. "
3265 "Emacs checked the following directories for this file:\n"
3267 "When Emacs cannot find this file, it usually means that it "
3268 "was not installed properly, or its distribution file was "
3269 "not unpacked properly.\nSee the README.W32 file in the "
3270 "top-level Emacs directory for more information.",
3271 init_file_name
, load_path
);
3274 "Emacs Abort Dialog",
3275 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3276 /* Use the low-level Emacs abort. */
3291 /* shutdown the socket interface if necessary */
3300 /* Initialise the socket interface now if available and requested by
3301 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3302 delayed until open-network-stream is called (w32-has-winsock can
3303 also be used to dynamically load or reload winsock).
3305 Conveniently, init_environment is called before us, so
3306 PRELOAD_WINSOCK can be set in the registry. */
3308 /* Always initialize this correctly. */
3311 if (getenv ("PRELOAD_WINSOCK") != NULL
)
3312 init_winsock (TRUE
);
3315 /* Initial preparation for subprocess support: replace our standard
3316 handles with non-inheritable versions. */
3319 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
3320 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
3321 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
3323 parent
= GetCurrentProcess ();
3325 /* ignore errors when duplicating and closing; typically the
3326 handles will be invalid when running as a gui program. */
3327 DuplicateHandle (parent
,
3328 GetStdHandle (STD_INPUT_HANDLE
),
3333 DUPLICATE_SAME_ACCESS
);
3335 DuplicateHandle (parent
,
3336 GetStdHandle (STD_OUTPUT_HANDLE
),
3341 DUPLICATE_SAME_ACCESS
);
3343 DuplicateHandle (parent
,
3344 GetStdHandle (STD_ERROR_HANDLE
),
3349 DUPLICATE_SAME_ACCESS
);
3355 if (stdin_save
!= INVALID_HANDLE_VALUE
)
3356 _open_osfhandle ((long) stdin_save
, O_TEXT
);
3358 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
3361 if (stdout_save
!= INVALID_HANDLE_VALUE
)
3362 _open_osfhandle ((long) stdout_save
, O_TEXT
);
3364 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3367 if (stderr_save
!= INVALID_HANDLE_VALUE
)
3368 _open_osfhandle ((long) stderr_save
, O_TEXT
);
3370 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3374 /* unfortunately, atexit depends on implementation of malloc */
3375 /* atexit (term_ntproc); */
3376 signal (SIGABRT
, term_ntproc
);
3378 /* determine which drives are fixed, for GetCachedVolumeInformation */
3380 /* GetDriveType must have trailing backslash. */
3381 char drive
[] = "A:\\";
3383 /* Loop over all possible drive letters */
3384 while (*drive
<= 'Z')
3386 /* Record if this drive letter refers to a fixed drive. */
3387 fixed_drives
[DRIVE_INDEX (*drive
)] =
3388 (GetDriveType (drive
) == DRIVE_FIXED
);
3394 /* Check to see if Emacs has been installed correctly. */
3395 check_windows_init_file ();