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
;
95 static char startup_dir
[MAXPATHLEN
];
97 /* Get the current working directory. */
102 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
106 /* Emacs doesn't actually change directory itself, and we want to
107 force our real wd to be where emacs.exe is to avoid unnecessary
108 conflicts when trying to rename or delete directories. */
109 strcpy (dir
, startup_dir
);
115 /* Emulate gethostname. */
117 gethostname (char *buffer
, int size
)
119 /* NT only allows small host names, so the buffer is
120 certainly large enough. */
121 return !GetComputerName (buffer
, &size
);
123 #endif /* HAVE_SOCKETS */
125 /* Emulate getloadavg. */
127 getloadavg (double loadavg
[], int nelem
)
131 /* A faithful emulation is going to have to be saved for a rainy day. */
132 for (i
= 0; i
< nelem
; i
++)
139 /* Emulate getpwuid, getpwnam and others. */
141 #define PASSWD_FIELD_SIZE 256
143 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
144 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
145 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
146 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
147 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
149 static struct passwd the_passwd
=
164 return the_passwd
.pw_uid
;
170 /* I could imagine arguing for checking to see whether the user is
171 in the Administrators group and returning a UID of 0 for that
172 case, but I don't know how wise that would be in the long run. */
179 return the_passwd
.pw_gid
;
191 if (uid
== the_passwd
.pw_uid
)
197 getpwnam (char *name
)
201 pw
= getpwuid (getuid ());
205 if (stricmp (name
, pw
->pw_name
))
214 /* Find the user's real name by opening the process token and
215 looking up the name associated with the user-sid in that token.
217 Use the relative portion of the identifier authority value from
218 the user-sid as the user id value (same for group id using the
219 primary group sid from the process token). */
221 char user_sid
[256], name
[256], domain
[256];
222 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
224 SID_NAME_USE user_type
;
226 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY
, &token
)
227 && GetTokenInformation (token
, TokenUser
,
228 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
229 && LookupAccountSid (NULL
, *((PSID
*) user_sid
), name
, &length
,
230 domain
, &dlength
, &user_type
))
232 strcpy (the_passwd
.pw_name
, name
);
233 /* Determine a reasonable uid value. */
234 if (stricmp ("administrator", name
) == 0)
236 the_passwd
.pw_uid
= 0;
237 the_passwd
.pw_gid
= 0;
241 SID_IDENTIFIER_AUTHORITY
* pSIA
;
243 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
244 /* I believe the relative portion is the last 4 bytes (of 6)
246 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
247 (pSIA
->Value
[3] << 16) +
248 (pSIA
->Value
[4] << 8) +
249 (pSIA
->Value
[5] << 0));
250 /* restrict to conventional uid range for normal users */
251 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
254 if (GetTokenInformation (token
, TokenPrimaryGroup
,
255 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
257 SID_IDENTIFIER_AUTHORITY
* pSIA
;
259 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
260 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
261 (pSIA
->Value
[3] << 16) +
262 (pSIA
->Value
[4] << 8) +
263 (pSIA
->Value
[5] << 0));
264 /* I don't know if this is necessary, but for safety... */
265 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
268 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
271 /* If security calls are not supported (presumably because we
272 are running under Windows 95), fallback to this. */
273 else if (GetUserName (name
, &length
))
275 strcpy (the_passwd
.pw_name
, name
);
276 if (stricmp ("administrator", name
) == 0)
277 the_passwd
.pw_uid
= 0;
279 the_passwd
.pw_uid
= 123;
280 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
284 strcpy (the_passwd
.pw_name
, "unknown");
285 the_passwd
.pw_uid
= 123;
286 the_passwd
.pw_gid
= 123;
289 /* Ensure HOME and SHELL are defined. */
290 if (getenv ("HOME") == NULL
)
292 if (getenv ("SHELL") == NULL
)
293 putenv (os_subtype
== OS_WIN95
? "SHELL=command" : "SHELL=cmd");
295 /* Set dir and shell from environment variables. */
296 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
297 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
306 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
307 return ((rand () << 15) | rand ());
317 /* Normalize filename by converting all path separators to
318 the specified separator. Also conditionally convert upper
319 case path name components to lower case. */
322 normalize_filename (fp
, path_sep
)
329 /* Always lower-case drive letters a-z, even if the filesystem
330 preserves case in filenames.
331 This is so filenames can be compared by string comparison
332 functions that are case-sensitive. Even case-preserving filesystems
333 do not distinguish case in drive letters. */
334 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
340 if (NILP (Vw32_downcase_file_names
))
344 if (*fp
== '/' || *fp
== '\\')
351 sep
= path_sep
; /* convert to this path separator */
352 elem
= fp
; /* start of current path element */
355 if (*fp
>= 'a' && *fp
<= 'z')
356 elem
= 0; /* don't convert this element */
358 if (*fp
== 0 || *fp
== ':')
360 sep
= *fp
; /* restore current separator (or 0) */
361 *fp
= '/'; /* after conversion of this element */
364 if (*fp
== '/' || *fp
== '\\')
366 if (elem
&& elem
!= fp
)
368 *fp
= 0; /* temporary end of string */
369 _strlwr (elem
); /* while we convert to lower case */
371 *fp
= sep
; /* convert (or restore) path separator */
372 elem
= fp
+ 1; /* next element starts after separator */
378 /* Destructively turn backslashes into slashes. */
380 dostounix_filename (p
)
383 normalize_filename (p
, '/');
386 /* Destructively turn slashes into backslashes. */
388 unixtodos_filename (p
)
391 normalize_filename (p
, '\\');
394 /* Remove all CR's that are followed by a LF.
395 (From msdos.c...probably should figure out a way to share it,
396 although this code isn't going to ever change.) */
400 register unsigned char *buf
;
402 unsigned char *np
= buf
;
403 unsigned char *startp
= buf
;
404 unsigned char *endp
= buf
+ n
;
408 while (buf
< endp
- 1)
412 if (*(++buf
) != 0x0a)
423 /* Parse the root part of file name, if present. Return length and
424 optionally store pointer to char after root. */
426 parse_root (char * name
, char ** pPath
)
433 /* find the root name of the volume if given */
434 if (isalpha (name
[0]) && name
[1] == ':')
436 /* skip past drive specifier */
438 if (IS_DIRECTORY_SEP (name
[0]))
441 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
447 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
452 if (IS_DIRECTORY_SEP (name
[0]))
462 /* Get long base name for name; name is assumed to be absolute. */
464 get_long_basename (char * name
, char * buf
, int size
)
466 WIN32_FIND_DATA find_data
;
470 /* must be valid filename, no wild cards or other illegal characters */
471 if (strpbrk (name
, "*?|<>\""))
474 dir_handle
= FindFirstFile (name
, &find_data
);
475 if (dir_handle
!= INVALID_HANDLE_VALUE
)
477 if ((len
= strlen (find_data
.cFileName
)) < size
)
478 memcpy (buf
, find_data
.cFileName
, len
+ 1);
481 FindClose (dir_handle
);
486 /* Get long name for file, if possible (assumed to be absolute). */
488 w32_get_long_filename (char * name
, char * buf
, int size
)
493 char full
[ MAX_PATH
];
500 /* Use local copy for destructive modification. */
501 memcpy (full
, name
, len
+1);
502 unixtodos_filename (full
);
504 /* Copy root part verbatim. */
505 len
= parse_root (full
, &p
);
506 memcpy (o
, full
, len
);
511 while (p
!= NULL
&& *p
)
514 p
= strchr (q
, '\\');
516 len
= get_long_basename (full
, o
, size
);
539 is_unc_volume (const char *filename
)
541 const char *ptr
= filename
;
543 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
546 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
552 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
555 sigsetmask (int signal_mask
)
579 setpgrp (int pid
, int gid
)
591 unrequest_sigio (void)
602 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
605 w32_get_resource (key
, lpdwtype
)
610 HKEY hrootkey
= NULL
;
614 /* Check both the current user and the local machine to see if
615 we have any resources. */
617 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
621 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
622 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
623 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
628 if (lpvalue
) xfree (lpvalue
);
630 RegCloseKey (hrootkey
);
633 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
637 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
638 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
639 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
644 if (lpvalue
) xfree (lpvalue
);
646 RegCloseKey (hrootkey
);
652 char *get_emacs_configuration (void);
653 extern Lisp_Object Vsystem_configuration
;
656 init_environment (char ** argv
)
659 static const char * const tempdirs
[] = {
660 "$TMPDIR", "$TEMP", "$TMP", "c:/"
663 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
665 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
666 temporary files and assume "/tmp" if $TMPDIR is unset, which
667 will break on DOS/Windows. Refuse to work if we cannot find
668 a directory, not even "c:/", usable for that purpose. */
669 for (i
= 0; i
< imax
; i
++)
671 const char *tmp
= tempdirs
[i
];
674 tmp
= getenv (tmp
+ 1);
675 /* Note that `access' can lie to us if the directory resides on a
676 read-only filesystem, like CD-ROM or a write-protected floppy.
677 The only way to be really sure is to actually create a file and
678 see if it succeeds. But I think that's too much to ask. */
679 if (tmp
&& access (tmp
, D_OK
) == 0)
681 char * var
= alloca (strlen (tmp
) + 8);
682 sprintf (var
, "TMPDIR=%s", tmp
);
690 Fcons (build_string ("no usable temporary directories found!!"),
692 "While setting TMPDIR: ");
694 /* Check for environment variables and use registry if they don't exist */
700 static char * env_vars
[] =
711 /* We no longer set INFOPATH because Info-default-directory-list
712 is then ignored. We use a hook in winnt.el instead. */
718 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
720 if (!getenv (env_vars
[i
])
721 && (lpval
= w32_get_resource (env_vars
[i
], &dwType
)) != NULL
)
723 if (dwType
== REG_EXPAND_SZ
)
725 char buf1
[500], buf2
[500];
727 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, 500);
728 _snprintf (buf2
, 499, "%s=%s", env_vars
[i
], buf1
);
729 putenv (strdup (buf2
));
731 else if (dwType
== REG_SZ
)
735 _snprintf (buf
, 499, "%s=%s", env_vars
[i
], lpval
);
736 putenv (strdup (buf
));
744 /* Rebuild system configuration to reflect invoking system. */
745 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
747 /* Another special case: on NT, the PATH variable is actually named
748 "Path" although cmd.exe (perhaps NT itself) arranges for
749 environment variable lookup and setting to be case insensitive.
750 However, Emacs assumes a fully case sensitive environment, so we
751 need to change "Path" to "PATH" to match the expectations of
752 various elisp packages. We do this by the sneaky method of
753 modifying the string in the C runtime environ entry.
755 The same applies to COMSPEC. */
759 for (envp
= environ
; *envp
; envp
++)
760 if (_strnicmp (*envp
, "PATH=", 5) == 0)
761 memcpy (*envp
, "PATH=", 5);
762 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
763 memcpy (*envp
, "COMSPEC=", 8);
766 /* Remember the initial working directory for getwd, then make the
767 real wd be the location of emacs.exe to avoid conflicts when
768 renaming or deleting directories. (We also don't call chdir when
769 running subprocesses for the same reason.) */
770 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
775 static char modname
[MAX_PATH
];
777 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
779 if ((p
= strrchr (modname
, '\\')) == NULL
)
783 SetCurrentDirectory (modname
);
785 /* Ensure argv[0] has the full path to Emacs. */
793 /* We don't have scripts to automatically determine the system configuration
794 for Emacs before it's compiled, and we don't want to have to make the
795 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
798 static char configuration_buffer
[32];
801 get_emacs_configuration (void)
803 char *arch
, *oem
, *os
;
806 /* Determine the processor type. */
807 switch (get_processor_type ())
810 #ifdef PROCESSOR_INTEL_386
811 case PROCESSOR_INTEL_386
:
812 case PROCESSOR_INTEL_486
:
813 case PROCESSOR_INTEL_PENTIUM
:
818 #ifdef PROCESSOR_INTEL_860
819 case PROCESSOR_INTEL_860
:
824 #ifdef PROCESSOR_MIPS_R2000
825 case PROCESSOR_MIPS_R2000
:
826 case PROCESSOR_MIPS_R3000
:
827 case PROCESSOR_MIPS_R4000
:
832 #ifdef PROCESSOR_ALPHA_21064
833 case PROCESSOR_ALPHA_21064
:
843 /* Let oem be "*" until we figure out how to decode the OEM field. */
846 switch (osinfo_cache
.dwPlatformId
) {
847 case VER_PLATFORM_WIN32_NT
:
849 build_num
= osinfo_cache
.dwBuildNumber
;
851 case VER_PLATFORM_WIN32_WINDOWS
:
852 if (osinfo_cache
.dwMinorVersion
== 0) {
857 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
859 case VER_PLATFORM_WIN32s
:
860 /* Not supported, should not happen. */
862 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
870 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
871 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
872 get_w32_major_version (), get_w32_minor_version (), build_num
);
874 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
877 return configuration_buffer
;
880 #include <sys/timeb.h>
882 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
884 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
889 tv
->tv_sec
= tb
.time
;
890 tv
->tv_usec
= tb
.millitm
* 1000L;
893 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
894 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
898 /* ------------------------------------------------------------------------- */
899 /* IO support and wrapper functions for W32 API. */
900 /* ------------------------------------------------------------------------- */
902 /* Place a wrapper around the MSVC version of ctime. It returns NULL
903 on network directories, so we handle that case here.
904 (Ulrich Leodolter, 1/11/95). */
906 sys_ctime (const time_t *t
)
908 char *str
= (char *) ctime (t
);
909 return (str
? str
: "Sun Jan 01 00:00:00 1970");
912 /* Emulate sleep...we could have done this with a define, but that
913 would necessitate including windows.h in the files that used it.
914 This is much easier. */
916 sys_sleep (int seconds
)
918 Sleep (seconds
* 1000);
921 /* Internal MSVC functions for low-level descriptor munging */
922 extern int __cdecl
_set_osfhnd (int fd
, long h
);
923 extern int __cdecl
_free_osfhnd (int fd
);
925 /* parallel array of private info on file handles */
926 filedesc fd_info
[ MAXDESC
];
928 typedef struct volume_info_data
{
929 struct volume_info_data
* next
;
931 /* time when info was obtained */
934 /* actual volume info */
943 /* Global referenced by various functions. */
944 static volume_info_data volume_info
;
946 /* Vector to indicate which drives are local and fixed (for which cached
947 data never expires). */
948 static BOOL fixed_drives
[26];
950 /* Consider cached volume information to be stale if older than 10s,
951 at least for non-local drives. Info for fixed drives is never stale. */
952 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
953 #define VOLINFO_STILL_VALID( root_dir, info ) \
954 ( ( isalpha (root_dir[0]) && \
955 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
956 || GetTickCount () - info->timestamp < 10000 )
958 /* Cache support functions. */
960 /* Simple linked list with linear search is sufficient. */
961 static volume_info_data
*volume_cache
= NULL
;
963 static volume_info_data
*
964 lookup_volume_info (char * root_dir
)
966 volume_info_data
* info
;
968 for (info
= volume_cache
; info
; info
= info
->next
)
969 if (stricmp (info
->root_dir
, root_dir
) == 0)
975 add_volume_info (char * root_dir
, volume_info_data
* info
)
977 info
->root_dir
= strdup (root_dir
);
978 info
->next
= volume_cache
;
983 /* Wrapper for GetVolumeInformation, which uses caching to avoid
984 performance penalty (~2ms on 486 for local drives, 7.5ms for local
985 cdrom drive, ~5-10ms or more for remote drives on LAN). */
987 GetCachedVolumeInformation (char * root_dir
)
989 volume_info_data
* info
;
990 char default_root
[ MAX_PATH
];
992 /* NULL for root_dir means use root from current directory. */
993 if (root_dir
== NULL
)
995 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
997 parse_root (default_root
, &root_dir
);
999 root_dir
= default_root
;
1002 /* Local fixed drives can be cached permanently. Removable drives
1003 cannot be cached permanently, since the volume name and serial
1004 number (if nothing else) can change. Remote drives should be
1005 treated as if they are removable, since there is no sure way to
1006 tell whether they are or not. Also, the UNC association of drive
1007 letters mapped to remote volumes can be changed at any time (even
1008 by other processes) without notice.
1010 As a compromise, so we can benefit from caching info for remote
1011 volumes, we use a simple expiry mechanism to invalidate cache
1012 entries that are more than ten seconds old. */
1015 /* No point doing this, because WNetGetConnection is even slower than
1016 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1017 GetDriveType is about the only call of this type which does not
1018 involve network access, and so is extremely quick). */
1020 /* Map drive letter to UNC if remote. */
1021 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1023 char remote_name
[ 256 ];
1024 char drive
[3] = { root_dir
[0], ':' };
1026 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1028 /* do something */ ;
1032 info
= lookup_volume_info (root_dir
);
1034 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1042 /* Info is not cached, or is stale. */
1043 if (!GetVolumeInformation (root_dir
,
1044 name
, sizeof (name
),
1048 type
, sizeof (type
)))
1051 /* Cache the volume information for future use, overwriting existing
1052 entry if present. */
1055 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1056 add_volume_info (root_dir
, info
);
1064 info
->name
= strdup (name
);
1065 info
->serialnum
= serialnum
;
1066 info
->maxcomp
= maxcomp
;
1067 info
->flags
= flags
;
1068 info
->type
= strdup (type
);
1069 info
->timestamp
= GetTickCount ();
1075 /* Get information on the volume where name is held; set path pointer to
1076 start of pathname in name (past UNC header\volume header if present). */
1078 get_volume_info (const char * name
, const char ** pPath
)
1080 char temp
[MAX_PATH
];
1081 char *rootname
= NULL
; /* default to current volume */
1082 volume_info_data
* info
;
1087 /* find the root name of the volume if given */
1088 if (isalpha (name
[0]) && name
[1] == ':')
1096 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1103 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1116 info
= GetCachedVolumeInformation (rootname
);
1119 /* Set global referenced by other functions. */
1120 volume_info
= *info
;
1126 /* Determine if volume is FAT format (ie. only supports short 8.3
1127 names); also set path pointer to start of pathname in name. */
1129 is_fat_volume (const char * name
, const char ** pPath
)
1131 if (get_volume_info (name
, pPath
))
1132 return (volume_info
.maxcomp
== 12);
1136 /* Map filename to a legal 8.3 name if necessary. */
1138 map_w32_filename (const char * name
, const char ** pPath
)
1140 static char shortname
[MAX_PATH
];
1141 char * str
= shortname
;
1144 const char * save_name
= name
;
1146 if (is_fat_volume (name
, &path
)) /* truncate to 8.3 */
1148 register int left
= 8; /* maximum number of chars in part */
1149 register int extn
= 0; /* extension added? */
1150 register int dots
= 2; /* maximum number of dots allowed */
1153 *str
++ = *name
++; /* skip past UNC header */
1155 while ((c
= *name
++))
1162 extn
= 0; /* reset extension flags */
1163 dots
= 2; /* max 2 dots */
1164 left
= 8; /* max length 8 for main part */
1168 extn
= 0; /* reset extension flags */
1169 dots
= 2; /* max 2 dots */
1170 left
= 8; /* max length 8 for main part */
1175 /* Convert path components of the form .xxx to _xxx,
1176 but leave . and .. as they are. This allows .emacs
1177 to be read as _emacs, for example. */
1181 IS_DIRECTORY_SEP (*name
))
1196 extn
= 1; /* we've got an extension */
1197 left
= 3; /* 3 chars in extension */
1201 /* any embedded dots after the first are converted to _ */
1206 case '#': /* don't lose these, they're important */
1208 str
[-1] = c
; /* replace last character of part */
1213 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1215 dots
= 0; /* started a path component */
1224 strcpy (shortname
, name
);
1225 unixtodos_filename (shortname
);
1229 *pPath
= shortname
+ (path
- save_name
);
1235 is_exec (const char * name
)
1237 char * p
= strrchr (name
, '.');
1240 && (stricmp (p
, ".exe") == 0 ||
1241 stricmp (p
, ".com") == 0 ||
1242 stricmp (p
, ".bat") == 0 ||
1243 stricmp (p
, ".cmd") == 0));
1246 /* Emulate the Unix directory procedures opendir, closedir,
1247 and readdir. We can't use the procedures supplied in sysdep.c,
1248 so we provide them here. */
1250 struct direct dir_static
; /* simulated directory contents */
1251 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1252 static int dir_is_fat
;
1253 static char dir_pathname
[MAXPATHLEN
+1];
1254 static WIN32_FIND_DATA dir_find_data
;
1256 /* Support shares on a network resource as subdirectories of a read-only
1258 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1259 HANDLE
open_unc_volume (char *);
1260 char *read_unc_volume (HANDLE
, char *, int);
1261 void close_unc_volume (HANDLE
);
1264 opendir (char *filename
)
1268 /* Opening is done by FindFirstFile. However, a read is inherent to
1269 this operation, so we defer the open until read time. */
1271 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1273 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1276 if (is_unc_volume (filename
))
1278 wnet_enum_handle
= open_unc_volume (filename
);
1279 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1283 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1290 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1291 dir_pathname
[MAXPATHLEN
] = '\0';
1292 dir_is_fat
= is_fat_volume (filename
, NULL
);
1298 closedir (DIR *dirp
)
1300 /* If we have a find-handle open, close it. */
1301 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1303 FindClose (dir_find_handle
);
1304 dir_find_handle
= INVALID_HANDLE_VALUE
;
1306 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1308 close_unc_volume (wnet_enum_handle
);
1309 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1311 xfree ((char *) dirp
);
1317 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1319 if (!read_unc_volume (wnet_enum_handle
,
1320 dir_find_data
.cFileName
,
1324 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1325 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1327 char filename
[MAXNAMLEN
+ 3];
1330 strcpy (filename
, dir_pathname
);
1331 ln
= strlen (filename
) - 1;
1332 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1333 strcat (filename
, "\\");
1334 strcat (filename
, "*");
1336 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1338 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1343 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1347 /* Emacs never uses this value, so don't bother making it match
1348 value returned by stat(). */
1349 dir_static
.d_ino
= 1;
1351 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1352 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1354 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1355 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1357 _strlwr (dir_static
.d_name
);
1358 else if (!NILP (Vw32_downcase_file_names
))
1361 for (p
= dir_static
.d_name
; *p
; p
++)
1362 if (*p
>= 'a' && *p
<= 'z')
1365 _strlwr (dir_static
.d_name
);
1372 open_unc_volume (char *path
)
1378 nr
.dwScope
= RESOURCE_GLOBALNET
;
1379 nr
.dwType
= RESOURCETYPE_DISK
;
1380 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1381 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1382 nr
.lpLocalName
= NULL
;
1383 nr
.lpRemoteName
= map_w32_filename (path
, NULL
);
1384 nr
.lpComment
= NULL
;
1385 nr
.lpProvider
= NULL
;
1387 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1388 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1390 if (result
== NO_ERROR
)
1393 return INVALID_HANDLE_VALUE
;
1397 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1406 buffer
= alloca (bufsize
);
1407 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1408 if (result
!= NO_ERROR
)
1411 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1412 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1414 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1417 strncpy (readbuf
, ptr
, size
);
1422 close_unc_volume (HANDLE henum
)
1424 if (henum
!= INVALID_HANDLE_VALUE
)
1425 WNetCloseEnum (henum
);
1429 unc_volume_file_attributes (char *path
)
1434 henum
= open_unc_volume (path
);
1435 if (henum
== INVALID_HANDLE_VALUE
)
1438 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1440 close_unc_volume (henum
);
1446 /* Shadow some MSVC runtime functions to map requests for long filenames
1447 to reasonable short names if necessary. This was originally added to
1448 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1452 sys_access (const char * path
, int mode
)
1456 /* MSVC implementation doesn't recognize D_OK. */
1457 path
= map_w32_filename (path
, NULL
);
1458 if (is_unc_volume (path
))
1460 attributes
= unc_volume_file_attributes (path
);
1461 if (attributes
== -1) {
1466 else if ((attributes
= GetFileAttributes (path
)) == -1)
1468 /* Should try mapping GetLastError to errno; for now just indicate
1469 that path doesn't exist. */
1473 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1478 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1483 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1492 sys_chdir (const char * path
)
1494 return _chdir (map_w32_filename (path
, NULL
));
1498 sys_chmod (const char * path
, int mode
)
1500 return _chmod (map_w32_filename (path
, NULL
), mode
);
1504 sys_creat (const char * path
, int mode
)
1506 return _creat (map_w32_filename (path
, NULL
), mode
);
1510 sys_fopen(const char * path
, const char * mode
)
1514 const char * mode_save
= mode
;
1516 /* Force all file handles to be non-inheritable. This is necessary to
1517 ensure child processes don't unwittingly inherit handles that might
1518 prevent future file access. */
1522 else if (mode
[0] == 'w' || mode
[0] == 'a')
1523 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1527 /* Only do simplistic option parsing. */
1531 oflag
&= ~(O_RDONLY
| O_WRONLY
);
1534 else if (mode
[0] == 'b')
1539 else if (mode
[0] == 't')
1546 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
1550 return _fdopen (fd
, mode_save
);
1553 /* This only works on NTFS volumes, but is useful to have. */
1555 sys_link (const char * old
, const char * new)
1559 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
1561 if (old
== NULL
|| new == NULL
)
1567 strcpy (oldname
, map_w32_filename (old
, NULL
));
1568 strcpy (newname
, map_w32_filename (new, NULL
));
1570 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
1571 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
1572 if (fileh
!= INVALID_HANDLE_VALUE
)
1576 /* Confusingly, the "alternate" stream name field does not apply
1577 when restoring a hard link, and instead contains the actual
1578 stream data for the link (ie. the name of the link to create).
1579 The WIN32_STREAM_ID structure before the cStreamName field is
1580 the stream header, which is then immediately followed by the
1584 WIN32_STREAM_ID wid
;
1585 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
1588 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
1589 data
.wid
.cStreamName
, MAX_PATH
);
1592 LPVOID context
= NULL
;
1595 data
.wid
.dwStreamId
= BACKUP_LINK
;
1596 data
.wid
.dwStreamAttributes
= 0;
1597 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
1598 data
.wid
.Size
.HighPart
= 0;
1599 data
.wid
.dwStreamNameSize
= 0;
1601 if (BackupWrite (fileh
, (LPBYTE
)&data
,
1602 offsetof (WIN32_STREAM_ID
, cStreamName
)
1603 + data
.wid
.Size
.LowPart
,
1604 &wbytes
, FALSE
, FALSE
, &context
)
1605 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
1612 /* Should try mapping GetLastError to errno; for now just
1613 indicate a general error (eg. links not supported). */
1614 errno
= EINVAL
; // perhaps EMLINK?
1618 CloseHandle (fileh
);
1627 sys_mkdir (const char * path
)
1629 return _mkdir (map_w32_filename (path
, NULL
));
1632 /* Because of long name mapping issues, we need to implement this
1633 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1634 a unique name, instead of setting the input template to an empty
1637 Standard algorithm seems to be use pid or tid with a letter on the
1638 front (in place of the 6 X's) and cycle through the letters to find a
1639 unique name. We extend that to allow any reasonable character as the
1640 first of the 6 X's. */
1642 sys_mktemp (char * template)
1646 unsigned uid
= GetCurrentThreadId ();
1647 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1649 if (template == NULL
)
1651 p
= template + strlen (template);
1653 /* replace up to the last 5 X's with uid in decimal */
1654 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1656 p
[0] = '0' + uid
% 10;
1660 if (i
< 0 && p
[0] == 'X')
1665 int save_errno
= errno
;
1666 p
[0] = first_char
[i
];
1667 if (sys_access (template, 0) < 0)
1673 while (++i
< sizeof (first_char
));
1676 /* Template is badly formed or else we can't generate a unique name,
1677 so return empty string */
1683 sys_open (const char * path
, int oflag
, int mode
)
1685 /* Force all file handles to be non-inheritable. */
1686 return _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, mode
);
1690 sys_rename (const char * oldname
, const char * newname
)
1693 char temp
[MAX_PATH
];
1695 /* MoveFile on Windows 95 doesn't correctly change the short file name
1696 alias in a number of circumstances (it is not easy to predict when
1697 just by looking at oldname and newname, unfortunately). In these
1698 cases, renaming through a temporary name avoids the problem.
1700 A second problem on Windows 95 is that renaming through a temp name when
1701 newname is uppercase fails (the final long name ends up in
1702 lowercase, although the short alias might be uppercase) UNLESS the
1703 long temp name is not 8.3.
1705 So, on Windows 95 we always rename through a temp name, and we make sure
1706 the temp name has a long extension to ensure correct renaming. */
1708 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1710 if (os_subtype
== OS_WIN95
)
1716 oldname
= map_w32_filename (oldname
, NULL
);
1717 if (o
= strrchr (oldname
, '\\'))
1720 o
= (char *) oldname
;
1722 if (p
= strrchr (temp
, '\\'))
1729 /* Force temp name to require a manufactured 8.3 alias - this
1730 seems to make the second rename work properly. */
1731 sprintf (p
, "_.%s.%u", o
, i
);
1733 result
= rename (oldname
, temp
);
1735 /* This loop must surely terminate! */
1736 while (result
< 0 && (errno
== EEXIST
|| errno
== EACCES
));
1741 /* Emulate Unix behaviour - newname is deleted if it already exists
1742 (at least if it is a file; don't do this for directories).
1744 Since we mustn't do this if we are just changing the case of the
1745 file name (we would end up deleting the file we are trying to
1746 rename!), we let rename detect if the destination file already
1747 exists - that way we avoid the possible pitfalls of trying to
1748 determine ourselves whether two names really refer to the same
1749 file, which is not always possible in the general case. (Consider
1750 all the permutations of shared or subst'd drives, etc.) */
1752 newname
= map_w32_filename (newname
, NULL
);
1753 result
= rename (temp
, newname
);
1756 && (errno
== EEXIST
|| errno
== EACCES
)
1757 && _chmod (newname
, 0666) == 0
1758 && _unlink (newname
) == 0)
1759 result
= rename (temp
, newname
);
1765 sys_rmdir (const char * path
)
1767 return _rmdir (map_w32_filename (path
, NULL
));
1771 sys_unlink (const char * path
)
1773 path
= map_w32_filename (path
, NULL
);
1775 /* On Unix, unlink works without write permission. */
1776 _chmod (path
, 0666);
1777 return _unlink (path
);
1780 static FILETIME utc_base_ft
;
1781 static long double utc_base
;
1782 static int init
= 0;
1785 convert_time (FILETIME ft
)
1791 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1800 st
.wMilliseconds
= 0;
1802 SystemTimeToFileTime (&st
, &utc_base_ft
);
1803 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1804 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1808 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1811 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1813 return (time_t) (ret
* 1e-7);
1817 convert_from_time_t (time_t time
, FILETIME
* pft
)
1823 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1832 st
.wMilliseconds
= 0;
1834 SystemTimeToFileTime (&st
, &utc_base_ft
);
1835 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1836 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1840 /* time in 100ns units since 1-Jan-1601 */
1841 tmp
= (long double) time
* 1e7
+ utc_base
;
1842 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
1843 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
1847 /* No reason to keep this; faking inode values either by hashing or even
1848 using the file index from GetInformationByHandle, is not perfect and
1849 so by default Emacs doesn't use the inode values on Windows.
1850 Instead, we now determine file-truename correctly (except for
1851 possible drive aliasing etc). */
1853 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
1855 hashval (const unsigned char * str
)
1860 h
= (h
<< 4) + *str
++;
1866 /* Return the hash value of the canonical pathname, excluding the
1867 drive/UNC header, to get a hopefully unique inode number. */
1869 generate_inode_val (const char * name
)
1871 char fullname
[ MAX_PATH
];
1875 /* Get the truly canonical filename, if it exists. (Note: this
1876 doesn't resolve aliasing due to subst commands, or recognise hard
1878 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
1881 parse_root (fullname
, &p
);
1882 /* Normal W32 filesystems are still case insensitive. */
1889 /* MSVC stat function can't cope with UNC names and has other bugs, so
1890 replace it with our own. This also allows us to calculate consistent
1891 inode values without hacks in the main Emacs code. */
1893 stat (const char * path
, struct stat
* buf
)
1896 WIN32_FIND_DATA wfd
;
1901 int rootdir
= FALSE
;
1903 if (path
== NULL
|| buf
== NULL
)
1909 name
= (char *) map_w32_filename (path
, &path
);
1910 /* must be valid filename, no wild cards or other illegal characters */
1911 if (strpbrk (name
, "*?|<>\""))
1917 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
1918 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
1919 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
1924 /* Remove trailing directory separator, unless name is the root
1925 directory of a drive or UNC volume in which case ensure there
1926 is a trailing separator. */
1927 len
= strlen (name
);
1928 rootdir
= (path
>= name
+ len
- 1
1929 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
1930 name
= strcpy (alloca (len
+ 2), name
);
1932 if (is_unc_volume (name
))
1934 DWORD attrs
= unc_volume_file_attributes (name
);
1939 memset (&wfd
, 0, sizeof (wfd
));
1940 wfd
.dwFileAttributes
= attrs
;
1941 wfd
.ftCreationTime
= utc_base_ft
;
1942 wfd
.ftLastAccessTime
= utc_base_ft
;
1943 wfd
.ftLastWriteTime
= utc_base_ft
;
1944 strcpy (wfd
.cFileName
, name
);
1948 if (!IS_DIRECTORY_SEP (name
[len
-1]))
1949 strcat (name
, "\\");
1950 if (GetDriveType (name
) < 2)
1955 memset (&wfd
, 0, sizeof (wfd
));
1956 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1957 wfd
.ftCreationTime
= utc_base_ft
;
1958 wfd
.ftLastAccessTime
= utc_base_ft
;
1959 wfd
.ftLastWriteTime
= utc_base_ft
;
1960 strcpy (wfd
.cFileName
, name
);
1964 if (IS_DIRECTORY_SEP (name
[len
-1]))
1967 /* (This is hacky, but helps when doing file completions on
1968 network drives.) Optimize by using information available from
1969 active readdir if possible. */
1970 len
= strlen (dir_pathname
);
1971 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
1973 if (dir_find_handle
!= INVALID_HANDLE_VALUE
1974 && strnicmp (name
, dir_pathname
, len
) == 0
1975 && IS_DIRECTORY_SEP (name
[len
])
1976 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
1978 /* This was the last entry returned by readdir. */
1979 wfd
= dir_find_data
;
1983 fh
= FindFirstFile (name
, &wfd
);
1984 if (fh
== INVALID_HANDLE_VALUE
)
1993 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1995 buf
->st_mode
= _S_IFDIR
;
1996 buf
->st_nlink
= 2; /* doesn't really matter */
1997 fake_inode
= 0; /* this doesn't either I think */
1999 else if (!NILP (Vw32_get_true_file_attributes
)
2000 /* No access rights required to get info. */
2001 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
, 0, NULL
))
2002 != INVALID_HANDLE_VALUE
)
2004 /* This is more accurate in terms of gettting the correct number
2005 of links, but is quite slow (it is noticable when Emacs is
2006 making a list of file name completions). */
2007 BY_HANDLE_FILE_INFORMATION info
;
2009 if (GetFileInformationByHandle (fh
, &info
))
2011 buf
->st_nlink
= info
.nNumberOfLinks
;
2012 /* Might as well use file index to fake inode values, but this
2013 is not guaranteed to be unique unless we keep a handle open
2014 all the time (even then there are situations where it is
2015 not unique). Reputedly, there are at most 48 bits of info
2016 (on NTFS, presumably less on FAT). */
2017 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2025 switch (GetFileType (fh
))
2027 case FILE_TYPE_DISK
:
2028 buf
->st_mode
= _S_IFREG
;
2030 case FILE_TYPE_PIPE
:
2031 buf
->st_mode
= _S_IFIFO
;
2033 case FILE_TYPE_CHAR
:
2034 case FILE_TYPE_UNKNOWN
:
2036 buf
->st_mode
= _S_IFCHR
;
2042 /* Don't bother to make this information more accurate. */
2043 buf
->st_mode
= _S_IFREG
;
2049 /* Not sure if there is any point in this. */
2050 if (!NILP (Vw32_generate_fake_inodes
))
2051 fake_inode
= generate_inode_val (name
);
2052 else if (fake_inode
== 0)
2054 /* For want of something better, try to make everything unique. */
2055 static DWORD gen_num
= 0;
2056 fake_inode
= ++gen_num
;
2060 /* MSVC defines _ino_t to be short; other libc's might not. */
2061 if (sizeof (buf
->st_ino
) == 2)
2062 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2064 buf
->st_ino
= fake_inode
;
2066 /* consider files to belong to current user */
2067 buf
->st_uid
= the_passwd
.pw_uid
;
2068 buf
->st_gid
= the_passwd
.pw_gid
;
2070 /* volume_info is set indirectly by map_w32_filename */
2071 buf
->st_dev
= volume_info
.serialnum
;
2072 buf
->st_rdev
= volume_info
.serialnum
;
2075 buf
->st_size
= wfd
.nFileSizeLow
;
2077 /* Convert timestamps to Unix format. */
2078 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2079 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2080 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2081 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2082 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2084 /* determine rwx permissions */
2085 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2086 permission
= _S_IREAD
;
2088 permission
= _S_IREAD
| _S_IWRITE
;
2090 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2091 permission
|= _S_IEXEC
;
2092 else if (is_exec (name
))
2093 permission
|= _S_IEXEC
;
2095 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2100 /* Provide fstat and utime as well as stat for consistent handling of
2103 fstat (int desc
, struct stat
* buf
)
2105 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2106 BY_HANDLE_FILE_INFORMATION info
;
2110 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2112 case FILE_TYPE_DISK
:
2113 buf
->st_mode
= _S_IFREG
;
2114 if (!GetFileInformationByHandle (fh
, &info
))
2120 case FILE_TYPE_PIPE
:
2121 buf
->st_mode
= _S_IFIFO
;
2123 case FILE_TYPE_CHAR
:
2124 case FILE_TYPE_UNKNOWN
:
2126 buf
->st_mode
= _S_IFCHR
;
2128 memset (&info
, 0, sizeof (info
));
2129 info
.dwFileAttributes
= 0;
2130 info
.ftCreationTime
= utc_base_ft
;
2131 info
.ftLastAccessTime
= utc_base_ft
;
2132 info
.ftLastWriteTime
= utc_base_ft
;
2135 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2137 buf
->st_mode
= _S_IFDIR
;
2138 buf
->st_nlink
= 2; /* doesn't really matter */
2139 fake_inode
= 0; /* this doesn't either I think */
2143 buf
->st_nlink
= info
.nNumberOfLinks
;
2144 /* Might as well use file index to fake inode values, but this
2145 is not guaranteed to be unique unless we keep a handle open
2146 all the time (even then there are situations where it is
2147 not unique). Reputedly, there are at most 48 bits of info
2148 (on NTFS, presumably less on FAT). */
2149 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2152 /* MSVC defines _ino_t to be short; other libc's might not. */
2153 if (sizeof (buf
->st_ino
) == 2)
2154 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2156 buf
->st_ino
= fake_inode
;
2158 /* consider files to belong to current user */
2162 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2163 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2165 buf
->st_size
= info
.nFileSizeLow
;
2167 /* Convert timestamps to Unix format. */
2168 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2169 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2170 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2171 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2172 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2174 /* determine rwx permissions */
2175 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2176 permission
= _S_IREAD
;
2178 permission
= _S_IREAD
| _S_IWRITE
;
2180 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2181 permission
|= _S_IEXEC
;
2184 #if 0 /* no way of knowing the filename */
2185 char * p
= strrchr (name
, '.');
2187 (stricmp (p
, ".exe") == 0 ||
2188 stricmp (p
, ".com") == 0 ||
2189 stricmp (p
, ".bat") == 0 ||
2190 stricmp (p
, ".cmd") == 0))
2191 permission
|= _S_IEXEC
;
2195 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2201 utime (const char *name
, struct utimbuf
*times
)
2203 struct utimbuf deftime
;
2210 deftime
.modtime
= deftime
.actime
= time (NULL
);
2214 /* Need write access to set times. */
2215 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2216 0, OPEN_EXISTING
, 0, NULL
);
2219 convert_from_time_t (times
->actime
, &atime
);
2220 convert_from_time_t (times
->modtime
, &mtime
);
2221 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2239 /* Wrappers for winsock functions to map between our file descriptors
2240 and winsock's handles; also set h_errno for convenience.
2242 To allow Emacs to run on systems which don't have winsock support
2243 installed, we dynamically link to winsock on startup if present, and
2244 otherwise provide the minimum necessary functionality
2245 (eg. gethostname). */
2247 /* function pointers for relevant socket functions */
2248 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2249 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2250 int (PASCAL
*pfn_WSAGetLastError
) (void);
2251 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2252 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2253 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2254 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2255 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2256 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2257 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2258 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2259 int (PASCAL
*pfn_WSACleanup
) (void);
2261 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2262 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2263 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2264 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2265 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2266 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2268 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2269 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2270 #ifndef HANDLE_FLAG_INHERIT
2271 #define HANDLE_FLAG_INHERIT 1
2275 static int winsock_inuse
;
2280 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2282 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2283 after WSAStartup returns successfully, but it seems reasonable
2284 to allow unloading winsock anyway in that case. */
2285 if (pfn_WSACleanup () == 0 ||
2286 pfn_WSAGetLastError () == WSAENETDOWN
)
2288 if (FreeLibrary (winsock_lib
))
2297 init_winsock (int load_now
)
2299 WSADATA winsockData
;
2301 if (winsock_lib
!= NULL
)
2304 pfn_SetHandleInformation
= NULL
;
2305 pfn_SetHandleInformation
2306 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2307 "SetHandleInformation");
2309 winsock_lib
= LoadLibrary ("wsock32.dll");
2311 if (winsock_lib
!= NULL
)
2313 /* dynamically link to socket functions */
2315 #define LOAD_PROC(fn) \
2316 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2319 LOAD_PROC( WSAStartup
);
2320 LOAD_PROC( WSASetLastError
);
2321 LOAD_PROC( WSAGetLastError
);
2322 LOAD_PROC( socket
);
2324 LOAD_PROC( connect
);
2325 LOAD_PROC( ioctlsocket
);
2328 LOAD_PROC( closesocket
);
2329 LOAD_PROC( shutdown
);
2332 LOAD_PROC( inet_addr
);
2333 LOAD_PROC( gethostname
);
2334 LOAD_PROC( gethostbyname
);
2335 LOAD_PROC( getservbyname
);
2336 LOAD_PROC( WSACleanup
);
2340 /* specify version 1.1 of winsock */
2341 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2343 if (winsockData
.wVersion
!= 0x101)
2348 /* Report that winsock exists and is usable, but leave
2349 socket functions disabled. I am assuming that calling
2350 WSAStartup does not require any network interaction,
2351 and in particular does not cause or require a dial-up
2352 connection to be established. */
2355 FreeLibrary (winsock_lib
);
2363 FreeLibrary (winsock_lib
);
2373 /* function to set h_errno for compatability; map winsock error codes to
2374 normal system codes where they overlap (non-overlapping definitions
2375 are already in <sys/socket.h> */
2376 static void set_errno ()
2378 if (winsock_lib
== NULL
)
2381 h_errno
= pfn_WSAGetLastError ();
2385 case WSAEACCES
: h_errno
= EACCES
; break;
2386 case WSAEBADF
: h_errno
= EBADF
; break;
2387 case WSAEFAULT
: h_errno
= EFAULT
; break;
2388 case WSAEINTR
: h_errno
= EINTR
; break;
2389 case WSAEINVAL
: h_errno
= EINVAL
; break;
2390 case WSAEMFILE
: h_errno
= EMFILE
; break;
2391 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2392 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2397 static void check_errno ()
2399 if (h_errno
== 0 && winsock_lib
!= NULL
)
2400 pfn_WSASetLastError (0);
2403 /* Extend strerror to handle the winsock-specific error codes. */
2407 } _wsa_errlist
[] = {
2408 WSAEINTR
, "Interrupted function call",
2409 WSAEBADF
, "Bad file descriptor",
2410 WSAEACCES
, "Permission denied",
2411 WSAEFAULT
, "Bad address",
2412 WSAEINVAL
, "Invalid argument",
2413 WSAEMFILE
, "Too many open files",
2415 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2416 WSAEINPROGRESS
, "Operation now in progress",
2417 WSAEALREADY
, "Operation already in progress",
2418 WSAENOTSOCK
, "Socket operation on non-socket",
2419 WSAEDESTADDRREQ
, "Destination address required",
2420 WSAEMSGSIZE
, "Message too long",
2421 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2422 WSAENOPROTOOPT
, "Bad protocol option",
2423 WSAEPROTONOSUPPORT
, "Protocol not supported",
2424 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2425 WSAEOPNOTSUPP
, "Operation not supported",
2426 WSAEPFNOSUPPORT
, "Protocol family not supported",
2427 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2428 WSAEADDRINUSE
, "Address already in use",
2429 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2430 WSAENETDOWN
, "Network is down",
2431 WSAENETUNREACH
, "Network is unreachable",
2432 WSAENETRESET
, "Network dropped connection on reset",
2433 WSAECONNABORTED
, "Software caused connection abort",
2434 WSAECONNRESET
, "Connection reset by peer",
2435 WSAENOBUFS
, "No buffer space available",
2436 WSAEISCONN
, "Socket is already connected",
2437 WSAENOTCONN
, "Socket is not connected",
2438 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2439 WSAETOOMANYREFS
, "Too many references", /* not sure */
2440 WSAETIMEDOUT
, "Connection timed out",
2441 WSAECONNREFUSED
, "Connection refused",
2442 WSAELOOP
, "Network loop", /* not sure */
2443 WSAENAMETOOLONG
, "Name is too long",
2444 WSAEHOSTDOWN
, "Host is down",
2445 WSAEHOSTUNREACH
, "No route to host",
2446 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2447 WSAEPROCLIM
, "Too many processes",
2448 WSAEUSERS
, "Too many users", /* not sure */
2449 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2450 WSAESTALE
, "Data is stale", /* not sure */
2451 WSAEREMOTE
, "Remote error", /* not sure */
2453 WSASYSNOTREADY
, "Network subsystem is unavailable",
2454 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2455 WSANOTINITIALISED
, "Winsock not initialized successfully",
2456 WSAEDISCON
, "Graceful shutdown in progress",
2458 WSAENOMORE
, "No more operations allowed", /* not sure */
2459 WSAECANCELLED
, "Operation cancelled", /* not sure */
2460 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2461 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2462 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2463 WSASYSCALLFAILURE
, "System call failured",
2464 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2465 WSATYPE_NOT_FOUND
, "Class type not found",
2466 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2467 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2468 WSAEREFUSED
, "Operation refused", /* not sure */
2471 WSAHOST_NOT_FOUND
, "Host not found",
2472 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2473 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2474 WSANO_DATA
, "Valid name, no data record of requested type",
2480 sys_strerror(int error_no
)
2483 static char unknown_msg
[40];
2485 if (error_no
>= 0 && error_no
< _sys_nerr
)
2486 return _sys_errlist
[error_no
];
2488 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2489 if (_wsa_errlist
[i
].errnum
== error_no
)
2490 return _wsa_errlist
[i
].msg
;
2492 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
2496 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2497 but I believe the method of keeping the socket handle separate (and
2498 insuring it is not inheritable) is the correct one. */
2500 //#define SOCK_REPLACE_HANDLE
2502 #ifdef SOCK_REPLACE_HANDLE
2503 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2505 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2509 sys_socket(int af
, int type
, int protocol
)
2515 if (winsock_lib
== NULL
)
2518 return INVALID_SOCKET
;
2523 /* call the real socket function */
2524 s
= (long) pfn_socket (af
, type
, protocol
);
2526 if (s
!= INVALID_SOCKET
)
2528 /* Although under NT 3.5 _open_osfhandle will accept a socket
2529 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2530 that does not work under NT 3.1. However, we can get the same
2531 effect by using a backdoor function to replace an existing
2532 descriptor handle with the one we want. */
2534 /* allocate a file descriptor (with appropriate flags) */
2535 fd
= _open ("NUL:", _O_RDWR
);
2538 #ifdef SOCK_REPLACE_HANDLE
2539 /* now replace handle to NUL with our socket handle */
2540 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
2542 _set_osfhnd (fd
, s
);
2543 /* setmode (fd, _O_BINARY); */
2545 /* Make a non-inheritable copy of the socket handle. */
2548 HANDLE new_s
= INVALID_HANDLE_VALUE
;
2550 parent
= GetCurrentProcess ();
2552 /* Apparently there is a bug in NT 3.51 with some service
2553 packs, which prevents using DuplicateHandle to make a
2554 socket handle non-inheritable (causes WSACleanup to
2555 hang). The work-around is to use SetHandleInformation
2556 instead if it is available and implemented. */
2557 if (!pfn_SetHandleInformation
2558 || !pfn_SetHandleInformation ((HANDLE
) s
,
2559 HANDLE_FLAG_INHERIT
,
2562 DuplicateHandle (parent
,
2568 DUPLICATE_SAME_ACCESS
);
2569 pfn_closesocket (s
);
2572 fd_info
[fd
].hnd
= (HANDLE
) s
;
2576 /* set our own internal flags */
2577 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
2583 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2585 /* attach child_process to fd_info */
2586 if (fd_info
[ fd
].cp
!= NULL
)
2588 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
2592 fd_info
[ fd
].cp
= cp
;
2595 winsock_inuse
++; /* count open sockets */
2602 pfn_closesocket (s
);
2612 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
2614 if (winsock_lib
== NULL
)
2617 return SOCKET_ERROR
;
2621 if (fd_info
[s
].flags
& FILE_SOCKET
)
2623 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
2624 if (rc
== SOCKET_ERROR
)
2629 return SOCKET_ERROR
;
2634 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
2636 if (winsock_lib
== NULL
)
2639 return SOCKET_ERROR
;
2643 if (fd_info
[s
].flags
& FILE_SOCKET
)
2645 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
2646 if (rc
== SOCKET_ERROR
)
2651 return SOCKET_ERROR
;
2655 sys_htons (u_short hostshort
)
2657 return (winsock_lib
!= NULL
) ?
2658 pfn_htons (hostshort
) : hostshort
;
2662 sys_ntohs (u_short netshort
)
2664 return (winsock_lib
!= NULL
) ?
2665 pfn_ntohs (netshort
) : netshort
;
2669 sys_inet_addr (const char * cp
)
2671 return (winsock_lib
!= NULL
) ?
2672 pfn_inet_addr (cp
) : INADDR_NONE
;
2676 sys_gethostname (char * name
, int namelen
)
2678 if (winsock_lib
!= NULL
)
2679 return pfn_gethostname (name
, namelen
);
2681 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
2682 return !GetComputerName (name
, &namelen
);
2685 return SOCKET_ERROR
;
2689 sys_gethostbyname(const char * name
)
2691 struct hostent
* host
;
2693 if (winsock_lib
== NULL
)
2700 host
= pfn_gethostbyname (name
);
2707 sys_getservbyname(const char * name
, const char * proto
)
2709 struct servent
* serv
;
2711 if (winsock_lib
== NULL
)
2718 serv
= pfn_getservbyname (name
, proto
);
2725 sys_shutdown (int s
, int how
)
2729 if (winsock_lib
== NULL
)
2732 return SOCKET_ERROR
;
2736 if (fd_info
[s
].flags
& FILE_SOCKET
)
2738 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
2739 if (rc
== SOCKET_ERROR
)
2744 return SOCKET_ERROR
;
2747 #endif /* HAVE_SOCKETS */
2750 /* Shadow main io functions: we need to handle pipes and sockets more
2751 intelligently, and implement non-blocking mode as well. */
2758 if (fd
< 0 || fd
>= MAXDESC
)
2766 child_process
* cp
= fd_info
[fd
].cp
;
2768 fd_info
[fd
].cp
= NULL
;
2770 if (CHILD_ACTIVE (cp
))
2772 /* if last descriptor to active child_process then cleanup */
2774 for (i
= 0; i
< MAXDESC
; i
++)
2778 if (fd_info
[i
].cp
== cp
)
2784 if (fd_info
[fd
].flags
& FILE_SOCKET
)
2786 #ifndef SOCK_REPLACE_HANDLE
2787 if (winsock_lib
== NULL
) abort ();
2789 pfn_shutdown (SOCK_HANDLE (fd
), 2);
2790 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
2792 winsock_inuse
--; /* count open sockets */
2800 /* Note that sockets do not need special treatment here (at least on
2801 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
2802 closesocket is equivalent to CloseHandle, which is to be expected
2803 because socket handles are fully fledged kernel handles. */
2807 fd_info
[fd
].flags
= 0;
2820 /* duplicate our internal info as well */
2821 fd_info
[new_fd
] = fd_info
[fd
];
2828 sys_dup2 (int src
, int dst
)
2832 if (dst
< 0 || dst
>= MAXDESC
)
2838 /* make sure we close the destination first if it's a pipe or socket */
2839 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
2842 rc
= _dup2 (src
, dst
);
2845 /* duplicate our internal info as well */
2846 fd_info
[dst
] = fd_info
[src
];
2851 /* Unix pipe() has only one arg */
2853 sys_pipe (int * phandles
)
2859 /* make pipe handles non-inheritable; when we spawn a child, we
2860 replace the relevant handle with an inheritable one. Also put
2861 pipes into binary mode; we will do text mode translation ourselves
2863 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
2867 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
2868 fd_info
[phandles
[0]].flags
= flags
;
2870 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
2871 fd_info
[phandles
[1]].flags
= flags
;
2878 extern Lisp_Object Vw32_pipe_read_delay
;
2880 /* Function to do blocking read of one byte, needed to implement
2881 select. It is only allowed on sockets and pipes. */
2883 _sys_read_ahead (int fd
)
2888 if (fd
< 0 || fd
>= MAXDESC
)
2889 return STATUS_READ_ERROR
;
2891 cp
= fd_info
[fd
].cp
;
2893 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
2894 return STATUS_READ_ERROR
;
2896 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
2897 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
2899 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
2903 cp
->status
= STATUS_READ_IN_PROGRESS
;
2905 if (fd_info
[fd
].flags
& FILE_PIPE
)
2907 rc
= _read (fd
, &cp
->chr
, sizeof (char));
2909 /* Give subprocess time to buffer some more output for us before
2910 reporting that input is available; we need this because Windows 95
2911 connects DOS programs to pipes by making the pipe appear to be
2912 the normal console stdout - as a result most DOS programs will
2913 write to stdout without buffering, ie. one character at a
2914 time. Even some W32 programs do this - "dir" in a command
2915 shell on NT is very slow if we don't do this. */
2918 int wait
= XINT (Vw32_pipe_read_delay
);
2924 /* Yield remainder of our time slice, effectively giving a
2925 temporary priority boost to the child process. */
2930 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
2931 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
2934 if (rc
== sizeof (char))
2935 cp
->status
= STATUS_READ_SUCCEEDED
;
2937 cp
->status
= STATUS_READ_FAILED
;
2943 sys_read (int fd
, char * buffer
, unsigned int count
)
2948 char * orig_buffer
= buffer
;
2950 if (fd
< 0 || fd
>= MAXDESC
)
2956 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
2958 child_process
*cp
= fd_info
[fd
].cp
;
2960 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
2968 /* re-read CR carried over from last read */
2969 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
2971 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
2975 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
2978 /* presence of a child_process structure means we are operating in
2979 non-blocking mode - otherwise we just call _read directly.
2980 Note that the child_process structure might be missing because
2981 reap_subprocess has been called; in this case the pipe is
2982 already broken, so calling _read on it is okay. */
2985 int current_status
= cp
->status
;
2987 switch (current_status
)
2989 case STATUS_READ_FAILED
:
2990 case STATUS_READ_ERROR
:
2991 /* report normal EOF if nothing in buffer */
2993 fd_info
[fd
].flags
|= FILE_AT_EOF
;
2996 case STATUS_READ_READY
:
2997 case STATUS_READ_IN_PROGRESS
:
2998 DebPrint (("sys_read called when read is in progress\n"));
2999 errno
= EWOULDBLOCK
;
3002 case STATUS_READ_SUCCEEDED
:
3003 /* consume read-ahead char */
3004 *buffer
++ = cp
->chr
;
3007 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
3008 ResetEvent (cp
->char_avail
);
3010 case STATUS_READ_ACKNOWLEDGED
:
3014 DebPrint (("sys_read: bad status %d\n", current_status
));
3019 if (fd_info
[fd
].flags
& FILE_PIPE
)
3021 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3022 to_read
= min (waiting
, (DWORD
) count
);
3025 nchars
+= _read (fd
, buffer
, to_read
);
3028 else /* FILE_SOCKET */
3030 if (winsock_lib
== NULL
) abort ();
3032 /* do the equivalent of a non-blocking read */
3033 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3034 if (waiting
== 0 && nchars
== 0)
3036 h_errno
= errno
= EWOULDBLOCK
;
3042 /* always use binary mode for sockets */
3043 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3044 if (res
== SOCKET_ERROR
)
3046 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3047 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3058 int nread
= _read (fd
, buffer
, count
);
3061 else if (nchars
== 0)
3066 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3067 /* Perform text mode translation if required. */
3068 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3070 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3071 /* If buffer contains only CR, return that. To be absolutely
3072 sure we should attempt to read the next char, but in
3073 practice a CR to be followed by LF would not appear by
3074 itself in the buffer. */
3075 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3077 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3083 nchars
= _read (fd
, buffer
, count
);
3088 /* For now, don't bother with a non-blocking mode */
3090 sys_write (int fd
, const void * buffer
, unsigned int count
)
3094 if (fd
< 0 || fd
>= MAXDESC
)
3100 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3102 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3108 /* Perform text mode translation if required. */
3109 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3111 char * tmpbuf
= alloca (count
* 2);
3112 unsigned char * src
= (void *)buffer
;
3113 unsigned char * dst
= tmpbuf
;
3118 unsigned char *next
;
3119 /* copy next line or remaining bytes */
3120 next
= _memccpy (dst
, src
, '\n', nbytes
);
3123 /* copied one line ending with '\n' */
3124 int copied
= next
- dst
;
3127 /* insert '\r' before '\n' */
3134 /* copied remaining partial line -> now finished */
3142 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3144 if (winsock_lib
== NULL
) abort ();
3145 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3146 if (nchars
== SOCKET_ERROR
)
3148 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3149 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3155 nchars
= _write (fd
, buffer
, count
);
3161 check_windows_init_file ()
3163 extern int noninteractive
, inhibit_window_system
;
3165 /* A common indication that Emacs is not installed properly is when
3166 it cannot find the Windows installation file. If this file does
3167 not exist in the expected place, tell the user. */
3169 if (!noninteractive
&& !inhibit_window_system
)
3171 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3172 Lisp_Object objs
[2];
3173 Lisp_Object full_load_path
;
3174 Lisp_Object init_file
;
3177 objs
[0] = Vload_path
;
3178 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3179 full_load_path
= Fappend (2, objs
);
3180 init_file
= build_string ("term/w32-win");
3181 fd
= openp (full_load_path
, init_file
, ".el:.elc", NULL
, 0);
3184 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3185 char *init_file_name
= XSTRING (init_file
)->data
;
3186 char *load_path
= XSTRING (load_path_print
)->data
;
3187 char *buffer
= alloca (1024);
3190 "The Emacs Windows initialization file \"%s.el\" "
3191 "could not be found in your Emacs installation. "
3192 "Emacs checked the following directories for this file:\n"
3194 "When Emacs cannot find this file, it usually means that it "
3195 "was not installed properly, or its distribution file was "
3196 "not unpacked properly.\nSee the README.W32 file in the "
3197 "top-level Emacs directory for more information.",
3198 init_file_name
, load_path
);
3201 "Emacs Abort Dialog",
3202 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3203 /* Use the low-level Emacs abort. */
3218 /* shutdown the socket interface if necessary */
3227 /* Initialise the socket interface now if available and requested by
3228 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3229 delayed until open-network-stream is called (w32-has-winsock can
3230 also be used to dynamically load or reload winsock).
3232 Conveniently, init_environment is called before us, so
3233 PRELOAD_WINSOCK can be set in the registry. */
3235 /* Always initialize this correctly. */
3238 if (getenv ("PRELOAD_WINSOCK") != NULL
)
3239 init_winsock (TRUE
);
3242 /* Initial preparation for subprocess support: replace our standard
3243 handles with non-inheritable versions. */
3246 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
3247 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
3248 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
3250 parent
= GetCurrentProcess ();
3252 /* ignore errors when duplicating and closing; typically the
3253 handles will be invalid when running as a gui program. */
3254 DuplicateHandle (parent
,
3255 GetStdHandle (STD_INPUT_HANDLE
),
3260 DUPLICATE_SAME_ACCESS
);
3262 DuplicateHandle (parent
,
3263 GetStdHandle (STD_OUTPUT_HANDLE
),
3268 DUPLICATE_SAME_ACCESS
);
3270 DuplicateHandle (parent
,
3271 GetStdHandle (STD_ERROR_HANDLE
),
3276 DUPLICATE_SAME_ACCESS
);
3282 if (stdin_save
!= INVALID_HANDLE_VALUE
)
3283 _open_osfhandle ((long) stdin_save
, O_TEXT
);
3285 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
3288 if (stdout_save
!= INVALID_HANDLE_VALUE
)
3289 _open_osfhandle ((long) stdout_save
, O_TEXT
);
3291 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3294 if (stderr_save
!= INVALID_HANDLE_VALUE
)
3295 _open_osfhandle ((long) stderr_save
, O_TEXT
);
3297 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3301 /* unfortunately, atexit depends on implementation of malloc */
3302 /* atexit (term_ntproc); */
3303 signal (SIGABRT
, term_ntproc
);
3305 /* determine which drives are fixed, for GetCachedVolumeInformation */
3307 /* GetDriveType must have trailing backslash. */
3308 char drive
[] = "A:\\";
3310 /* Loop over all possible drive letters */
3311 while (*drive
<= 'Z')
3313 /* Record if this drive letter refers to a fixed drive. */
3314 fixed_drives
[DRIVE_INDEX (*drive
)] =
3315 (GetDriveType (drive
) == DRIVE_FIXED
);
3321 /* Check to see if Emacs has been installed correctly. */
3322 check_windows_init_file ();