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
)
567 setpgrp (int pid
, int gid
)
579 unrequest_sigio (void)
590 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
593 w32_get_resource (key
, lpdwtype
)
598 HKEY hrootkey
= NULL
;
602 /* Check both the current user and the local machine to see if
603 we have any resources. */
605 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
609 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
610 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
611 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
616 if (lpvalue
) xfree (lpvalue
);
618 RegCloseKey (hrootkey
);
621 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
625 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
626 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
627 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
632 if (lpvalue
) xfree (lpvalue
);
634 RegCloseKey (hrootkey
);
640 char *get_emacs_configuration (void);
641 extern Lisp_Object Vsystem_configuration
;
644 init_environment (char ** argv
)
647 static const char * const tempdirs
[] = {
648 "$TMPDIR", "$TEMP", "$TMP", "c:/"
651 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
653 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
654 temporary files and assume "/tmp" if $TMPDIR is unset, which
655 will break on DOS/Windows. Refuse to work if we cannot find
656 a directory, not even "c:/", usable for that purpose. */
657 for (i
= 0; i
< imax
; i
++)
659 const char *tmp
= tempdirs
[i
];
662 tmp
= getenv (tmp
+ 1);
663 /* Note that `access' can lie to us if the directory resides on a
664 read-only filesystem, like CD-ROM or a write-protected floppy.
665 The only way to be really sure is to actually create a file and
666 see if it succeeds. But I think that's too much to ask. */
667 if (tmp
&& access (tmp
, D_OK
) == 0)
669 char * var
= alloca (strlen (tmp
) + 8);
670 sprintf (var
, "TMPDIR=%s", tmp
);
678 Fcons (build_string ("no usable temporary directories found!!"),
680 "While setting TMPDIR: ");
682 /* Check for environment variables and use registry if they don't exist */
688 static char * env_vars
[] =
699 /* We no longer set INFOPATH because Info-default-directory-list
700 is then ignored. We use a hook in winnt.el instead. */
706 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
708 if (!getenv (env_vars
[i
])
709 && (lpval
= w32_get_resource (env_vars
[i
], &dwType
)) != NULL
)
711 if (dwType
== REG_EXPAND_SZ
)
713 char buf1
[500], buf2
[500];
715 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, 500);
716 _snprintf (buf2
, 499, "%s=%s", env_vars
[i
], buf1
);
717 putenv (strdup (buf2
));
719 else if (dwType
== REG_SZ
)
723 _snprintf (buf
, 499, "%s=%s", env_vars
[i
], lpval
);
724 putenv (strdup (buf
));
732 /* Rebuild system configuration to reflect invoking system. */
733 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
735 /* Another special case: on NT, the PATH variable is actually named
736 "Path" although cmd.exe (perhaps NT itself) arranges for
737 environment variable lookup and setting to be case insensitive.
738 However, Emacs assumes a fully case sensitive environment, so we
739 need to change "Path" to "PATH" to match the expectations of
740 various elisp packages. We do this by the sneaky method of
741 modifying the string in the C runtime environ entry.
743 The same applies to COMSPEC. */
747 for (envp
= environ
; *envp
; envp
++)
748 if (_strnicmp (*envp
, "PATH=", 5) == 0)
749 memcpy (*envp
, "PATH=", 5);
750 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
751 memcpy (*envp
, "COMSPEC=", 8);
754 /* Remember the initial working directory for getwd, then make the
755 real wd be the location of emacs.exe to avoid conflicts when
756 renaming or deleting directories. (We also don't call chdir when
757 running subprocesses for the same reason.) */
758 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
763 static char modname
[MAX_PATH
];
765 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
767 if ((p
= strrchr (modname
, '\\')) == NULL
)
771 SetCurrentDirectory (modname
);
773 /* Ensure argv[0] has the full path to Emacs. */
781 /* We don't have scripts to automatically determine the system configuration
782 for Emacs before it's compiled, and we don't want to have to make the
783 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
786 static char configuration_buffer
[32];
789 get_emacs_configuration (void)
791 char *arch
, *oem
, *os
;
794 /* Determine the processor type. */
795 switch (get_processor_type ())
798 #ifdef PROCESSOR_INTEL_386
799 case PROCESSOR_INTEL_386
:
800 case PROCESSOR_INTEL_486
:
801 case PROCESSOR_INTEL_PENTIUM
:
806 #ifdef PROCESSOR_INTEL_860
807 case PROCESSOR_INTEL_860
:
812 #ifdef PROCESSOR_MIPS_R2000
813 case PROCESSOR_MIPS_R2000
:
814 case PROCESSOR_MIPS_R3000
:
815 case PROCESSOR_MIPS_R4000
:
820 #ifdef PROCESSOR_ALPHA_21064
821 case PROCESSOR_ALPHA_21064
:
831 /* Let oem be "*" until we figure out how to decode the OEM field. */
834 switch (osinfo_cache
.dwPlatformId
) {
835 case VER_PLATFORM_WIN32_NT
:
837 build_num
= osinfo_cache
.dwBuildNumber
;
839 case VER_PLATFORM_WIN32_WINDOWS
:
840 if (osinfo_cache
.dwMinorVersion
== 0) {
845 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
847 case VER_PLATFORM_WIN32s
:
848 /* Not supported, should not happen. */
850 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
858 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
859 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
860 get_w32_major_version (), get_w32_minor_version (), build_num
);
862 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
865 return configuration_buffer
;
868 #include <sys/timeb.h>
870 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
872 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
877 tv
->tv_sec
= tb
.time
;
878 tv
->tv_usec
= tb
.millitm
* 1000L;
881 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
882 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
886 /* ------------------------------------------------------------------------- */
887 /* IO support and wrapper functions for W32 API. */
888 /* ------------------------------------------------------------------------- */
890 /* Place a wrapper around the MSVC version of ctime. It returns NULL
891 on network directories, so we handle that case here.
892 (Ulrich Leodolter, 1/11/95). */
894 sys_ctime (const time_t *t
)
896 char *str
= (char *) ctime (t
);
897 return (str
? str
: "Sun Jan 01 00:00:00 1970");
900 /* Emulate sleep...we could have done this with a define, but that
901 would necessitate including windows.h in the files that used it.
902 This is much easier. */
904 sys_sleep (int seconds
)
906 Sleep (seconds
* 1000);
909 /* Internal MSVC functions for low-level descriptor munging */
910 extern int __cdecl
_set_osfhnd (int fd
, long h
);
911 extern int __cdecl
_free_osfhnd (int fd
);
913 /* parallel array of private info on file handles */
914 filedesc fd_info
[ MAXDESC
];
916 typedef struct volume_info_data
{
917 struct volume_info_data
* next
;
919 /* time when info was obtained */
922 /* actual volume info */
931 /* Global referenced by various functions. */
932 static volume_info_data volume_info
;
934 /* Vector to indicate which drives are local and fixed (for which cached
935 data never expires). */
936 static BOOL fixed_drives
[26];
938 /* Consider cached volume information to be stale if older than 10s,
939 at least for non-local drives. Info for fixed drives is never stale. */
940 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
941 #define VOLINFO_STILL_VALID( root_dir, info ) \
942 ( ( isalpha (root_dir[0]) && \
943 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
944 || GetTickCount () - info->timestamp < 10000 )
946 /* Cache support functions. */
948 /* Simple linked list with linear search is sufficient. */
949 static volume_info_data
*volume_cache
= NULL
;
951 static volume_info_data
*
952 lookup_volume_info (char * root_dir
)
954 volume_info_data
* info
;
956 for (info
= volume_cache
; info
; info
= info
->next
)
957 if (stricmp (info
->root_dir
, root_dir
) == 0)
963 add_volume_info (char * root_dir
, volume_info_data
* info
)
965 info
->root_dir
= strdup (root_dir
);
966 info
->next
= volume_cache
;
971 /* Wrapper for GetVolumeInformation, which uses caching to avoid
972 performance penalty (~2ms on 486 for local drives, 7.5ms for local
973 cdrom drive, ~5-10ms or more for remote drives on LAN). */
975 GetCachedVolumeInformation (char * root_dir
)
977 volume_info_data
* info
;
978 char default_root
[ MAX_PATH
];
980 /* NULL for root_dir means use root from current directory. */
981 if (root_dir
== NULL
)
983 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
985 parse_root (default_root
, &root_dir
);
987 root_dir
= default_root
;
990 /* Local fixed drives can be cached permanently. Removable drives
991 cannot be cached permanently, since the volume name and serial
992 number (if nothing else) can change. Remote drives should be
993 treated as if they are removable, since there is no sure way to
994 tell whether they are or not. Also, the UNC association of drive
995 letters mapped to remote volumes can be changed at any time (even
996 by other processes) without notice.
998 As a compromise, so we can benefit from caching info for remote
999 volumes, we use a simple expiry mechanism to invalidate cache
1000 entries that are more than ten seconds old. */
1003 /* No point doing this, because WNetGetConnection is even slower than
1004 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1005 GetDriveType is about the only call of this type which does not
1006 involve network access, and so is extremely quick). */
1008 /* Map drive letter to UNC if remote. */
1009 if ( isalpha( root_dir
[0] ) && !fixed
[ DRIVE_INDEX( root_dir
[0] ) ] )
1011 char remote_name
[ 256 ];
1012 char drive
[3] = { root_dir
[0], ':' };
1014 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
1016 /* do something */ ;
1020 info
= lookup_volume_info (root_dir
);
1022 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
1030 /* Info is not cached, or is stale. */
1031 if (!GetVolumeInformation (root_dir
,
1032 name
, sizeof (name
),
1036 type
, sizeof (type
)))
1039 /* Cache the volume information for future use, overwriting existing
1040 entry if present. */
1043 info
= (volume_info_data
*) xmalloc (sizeof (volume_info_data
));
1044 add_volume_info (root_dir
, info
);
1052 info
->name
= strdup (name
);
1053 info
->serialnum
= serialnum
;
1054 info
->maxcomp
= maxcomp
;
1055 info
->flags
= flags
;
1056 info
->type
= strdup (type
);
1057 info
->timestamp
= GetTickCount ();
1063 /* Get information on the volume where name is held; set path pointer to
1064 start of pathname in name (past UNC header\volume header if present). */
1066 get_volume_info (const char * name
, const char ** pPath
)
1068 char temp
[MAX_PATH
];
1069 char *rootname
= NULL
; /* default to current volume */
1070 volume_info_data
* info
;
1075 /* find the root name of the volume if given */
1076 if (isalpha (name
[0]) && name
[1] == ':')
1084 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1091 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1104 info
= GetCachedVolumeInformation (rootname
);
1107 /* Set global referenced by other functions. */
1108 volume_info
= *info
;
1114 /* Determine if volume is FAT format (ie. only supports short 8.3
1115 names); also set path pointer to start of pathname in name. */
1117 is_fat_volume (const char * name
, const char ** pPath
)
1119 if (get_volume_info (name
, pPath
))
1120 return (volume_info
.maxcomp
== 12);
1124 /* Map filename to a legal 8.3 name if necessary. */
1126 map_w32_filename (const char * name
, const char ** pPath
)
1128 static char shortname
[MAX_PATH
];
1129 char * str
= shortname
;
1132 const char * save_name
= name
;
1134 if (is_fat_volume (name
, &path
)) /* truncate to 8.3 */
1136 register int left
= 8; /* maximum number of chars in part */
1137 register int extn
= 0; /* extension added? */
1138 register int dots
= 2; /* maximum number of dots allowed */
1141 *str
++ = *name
++; /* skip past UNC header */
1143 while ((c
= *name
++))
1150 extn
= 0; /* reset extension flags */
1151 dots
= 2; /* max 2 dots */
1152 left
= 8; /* max length 8 for main part */
1156 extn
= 0; /* reset extension flags */
1157 dots
= 2; /* max 2 dots */
1158 left
= 8; /* max length 8 for main part */
1163 /* Convert path components of the form .xxx to _xxx,
1164 but leave . and .. as they are. This allows .emacs
1165 to be read as _emacs, for example. */
1169 IS_DIRECTORY_SEP (*name
))
1184 extn
= 1; /* we've got an extension */
1185 left
= 3; /* 3 chars in extension */
1189 /* any embedded dots after the first are converted to _ */
1194 case '#': /* don't lose these, they're important */
1196 str
[-1] = c
; /* replace last character of part */
1201 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
1203 dots
= 0; /* started a path component */
1212 strcpy (shortname
, name
);
1213 unixtodos_filename (shortname
);
1217 *pPath
= shortname
+ (path
- save_name
);
1223 is_exec (const char * name
)
1225 char * p
= strrchr (name
, '.');
1228 && (stricmp (p
, ".exe") == 0 ||
1229 stricmp (p
, ".com") == 0 ||
1230 stricmp (p
, ".bat") == 0 ||
1231 stricmp (p
, ".cmd") == 0));
1234 /* Emulate the Unix directory procedures opendir, closedir,
1235 and readdir. We can't use the procedures supplied in sysdep.c,
1236 so we provide them here. */
1238 struct direct dir_static
; /* simulated directory contents */
1239 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
1240 static int dir_is_fat
;
1241 static char dir_pathname
[MAXPATHLEN
+1];
1242 static WIN32_FIND_DATA dir_find_data
;
1244 /* Support shares on a network resource as subdirectories of a read-only
1246 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1247 HANDLE
open_unc_volume (char *);
1248 char *read_unc_volume (HANDLE
, char *, int);
1249 void close_unc_volume (HANDLE
);
1252 opendir (char *filename
)
1256 /* Opening is done by FindFirstFile. However, a read is inherent to
1257 this operation, so we defer the open until read time. */
1259 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1261 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1264 if (is_unc_volume (filename
))
1266 wnet_enum_handle
= open_unc_volume (filename
);
1267 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
1271 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
1278 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
1279 dir_pathname
[MAXPATHLEN
] = '\0';
1280 dir_is_fat
= is_fat_volume (filename
, NULL
);
1286 closedir (DIR *dirp
)
1288 /* If we have a find-handle open, close it. */
1289 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
1291 FindClose (dir_find_handle
);
1292 dir_find_handle
= INVALID_HANDLE_VALUE
;
1294 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1296 close_unc_volume (wnet_enum_handle
);
1297 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
1299 xfree ((char *) dirp
);
1305 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
1307 if (!read_unc_volume (wnet_enum_handle
,
1308 dir_find_data
.cFileName
,
1312 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1313 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1315 char filename
[MAXNAMLEN
+ 3];
1318 strcpy (filename
, dir_pathname
);
1319 ln
= strlen (filename
) - 1;
1320 if (!IS_DIRECTORY_SEP (filename
[ln
]))
1321 strcat (filename
, "\\");
1322 strcat (filename
, "*");
1324 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
1326 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
1331 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
1335 /* Emacs never uses this value, so don't bother making it match
1336 value returned by stat(). */
1337 dir_static
.d_ino
= 1;
1339 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
1340 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
1342 dir_static
.d_namlen
= strlen (dir_find_data
.cFileName
);
1343 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
1345 _strlwr (dir_static
.d_name
);
1346 else if (!NILP (Vw32_downcase_file_names
))
1349 for (p
= dir_static
.d_name
; *p
; p
++)
1350 if (*p
>= 'a' && *p
<= 'z')
1353 _strlwr (dir_static
.d_name
);
1360 open_unc_volume (char *path
)
1366 nr
.dwScope
= RESOURCE_GLOBALNET
;
1367 nr
.dwType
= RESOURCETYPE_DISK
;
1368 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
1369 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
1370 nr
.lpLocalName
= NULL
;
1371 nr
.lpRemoteName
= map_w32_filename (path
, NULL
);
1372 nr
.lpComment
= NULL
;
1373 nr
.lpProvider
= NULL
;
1375 result
= WNetOpenEnum(RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
1376 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
1378 if (result
== NO_ERROR
)
1381 return INVALID_HANDLE_VALUE
;
1385 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
1394 buffer
= alloca (bufsize
);
1395 result
= WNetEnumResource (wnet_enum_handle
, &count
, buffer
, &bufsize
);
1396 if (result
!= NO_ERROR
)
1399 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1400 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
1402 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
1405 strncpy (readbuf
, ptr
, size
);
1410 close_unc_volume (HANDLE henum
)
1412 if (henum
!= INVALID_HANDLE_VALUE
)
1413 WNetCloseEnum (henum
);
1417 unc_volume_file_attributes (char *path
)
1422 henum
= open_unc_volume (path
);
1423 if (henum
== INVALID_HANDLE_VALUE
)
1426 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
1428 close_unc_volume (henum
);
1434 /* Shadow some MSVC runtime functions to map requests for long filenames
1435 to reasonable short names if necessary. This was originally added to
1436 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1440 sys_access (const char * path
, int mode
)
1444 /* MSVC implementation doesn't recognize D_OK. */
1445 path
= map_w32_filename (path
, NULL
);
1446 if (is_unc_volume (path
))
1448 attributes
= unc_volume_file_attributes (path
);
1449 if (attributes
== -1) {
1454 else if ((attributes
= GetFileAttributes (path
)) == -1)
1456 /* Should try mapping GetLastError to errno; for now just indicate
1457 that path doesn't exist. */
1461 if ((mode
& X_OK
) != 0 && !is_exec (path
))
1466 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
1471 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1480 sys_chdir (const char * path
)
1482 return _chdir (map_w32_filename (path
, NULL
));
1486 sys_chmod (const char * path
, int mode
)
1488 return _chmod (map_w32_filename (path
, NULL
), mode
);
1492 sys_creat (const char * path
, int mode
)
1494 return _creat (map_w32_filename (path
, NULL
), mode
);
1498 sys_fopen(const char * path
, const char * mode
)
1502 const char * mode_save
= mode
;
1504 /* Force all file handles to be non-inheritable. This is necessary to
1505 ensure child processes don't unwittingly inherit handles that might
1506 prevent future file access. */
1510 else if (mode
[0] == 'w' || mode
[0] == 'a')
1511 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
1515 /* Only do simplistic option parsing. */
1519 oflag
&= ~(O_RDONLY
| O_WRONLY
);
1522 else if (mode
[0] == 'b')
1527 else if (mode
[0] == 't')
1534 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
1538 return _fdopen (fd
, mode_save
);
1541 /* This only works on NTFS volumes, but is useful to have. */
1543 sys_link (const char * old
, const char * new)
1547 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
1549 if (old
== NULL
|| new == NULL
)
1555 strcpy (oldname
, map_w32_filename (old
, NULL
));
1556 strcpy (newname
, map_w32_filename (new, NULL
));
1558 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
1559 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
1560 if (fileh
!= INVALID_HANDLE_VALUE
)
1564 /* Confusingly, the "alternate" stream name field does not apply
1565 when restoring a hard link, and instead contains the actual
1566 stream data for the link (ie. the name of the link to create).
1567 The WIN32_STREAM_ID structure before the cStreamName field is
1568 the stream header, which is then immediately followed by the
1572 WIN32_STREAM_ID wid
;
1573 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
1576 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
1577 data
.wid
.cStreamName
, MAX_PATH
);
1580 LPVOID context
= NULL
;
1583 data
.wid
.dwStreamId
= BACKUP_LINK
;
1584 data
.wid
.dwStreamAttributes
= 0;
1585 data
.wid
.Size
.LowPart
= wlen
* sizeof(WCHAR
);
1586 data
.wid
.Size
.HighPart
= 0;
1587 data
.wid
.dwStreamNameSize
= 0;
1589 if (BackupWrite (fileh
, (LPBYTE
)&data
,
1590 offsetof (WIN32_STREAM_ID
, cStreamName
)
1591 + data
.wid
.Size
.LowPart
,
1592 &wbytes
, FALSE
, FALSE
, &context
)
1593 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
1600 /* Should try mapping GetLastError to errno; for now just
1601 indicate a general error (eg. links not supported). */
1602 errno
= EINVAL
; // perhaps EMLINK?
1606 CloseHandle (fileh
);
1615 sys_mkdir (const char * path
)
1617 return _mkdir (map_w32_filename (path
, NULL
));
1620 /* Because of long name mapping issues, we need to implement this
1621 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1622 a unique name, instead of setting the input template to an empty
1625 Standard algorithm seems to be use pid or tid with a letter on the
1626 front (in place of the 6 X's) and cycle through the letters to find a
1627 unique name. We extend that to allow any reasonable character as the
1628 first of the 6 X's. */
1630 sys_mktemp (char * template)
1634 unsigned uid
= GetCurrentThreadId ();
1635 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1637 if (template == NULL
)
1639 p
= template + strlen (template);
1641 /* replace up to the last 5 X's with uid in decimal */
1642 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1644 p
[0] = '0' + uid
% 10;
1648 if (i
< 0 && p
[0] == 'X')
1653 int save_errno
= errno
;
1654 p
[0] = first_char
[i
];
1655 if (sys_access (template, 0) < 0)
1661 while (++i
< sizeof (first_char
));
1664 /* Template is badly formed or else we can't generate a unique name,
1665 so return empty string */
1671 sys_open (const char * path
, int oflag
, int mode
)
1673 /* Force all file handles to be non-inheritable. */
1674 return _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, mode
);
1678 sys_rename (const char * oldname
, const char * newname
)
1681 char temp
[MAX_PATH
];
1683 /* MoveFile on Windows 95 doesn't correctly change the short file name
1684 alias in a number of circumstances (it is not easy to predict when
1685 just by looking at oldname and newname, unfortunately). In these
1686 cases, renaming through a temporary name avoids the problem.
1688 A second problem on Windows 95 is that renaming through a temp name when
1689 newname is uppercase fails (the final long name ends up in
1690 lowercase, although the short alias might be uppercase) UNLESS the
1691 long temp name is not 8.3.
1693 So, on Windows 95 we always rename through a temp name, and we make sure
1694 the temp name has a long extension to ensure correct renaming. */
1696 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1698 if (os_subtype
== OS_WIN95
)
1704 oldname
= map_w32_filename (oldname
, NULL
);
1705 if (o
= strrchr (oldname
, '\\'))
1708 o
= (char *) oldname
;
1710 if (p
= strrchr (temp
, '\\'))
1717 /* Force temp name to require a manufactured 8.3 alias - this
1718 seems to make the second rename work properly. */
1719 sprintf (p
, "_.%s.%u", o
, i
);
1721 result
= rename (oldname
, temp
);
1723 /* This loop must surely terminate! */
1724 while (result
< 0 && (errno
== EEXIST
|| errno
== EACCES
));
1729 /* Emulate Unix behaviour - newname is deleted if it already exists
1730 (at least if it is a file; don't do this for directories).
1732 Since we mustn't do this if we are just changing the case of the
1733 file name (we would end up deleting the file we are trying to
1734 rename!), we let rename detect if the destination file already
1735 exists - that way we avoid the possible pitfalls of trying to
1736 determine ourselves whether two names really refer to the same
1737 file, which is not always possible in the general case. (Consider
1738 all the permutations of shared or subst'd drives, etc.) */
1740 newname
= map_w32_filename (newname
, NULL
);
1741 result
= rename (temp
, newname
);
1744 && (errno
== EEXIST
|| errno
== EACCES
)
1745 && _chmod (newname
, 0666) == 0
1746 && _unlink (newname
) == 0)
1747 result
= rename (temp
, newname
);
1753 sys_rmdir (const char * path
)
1755 return _rmdir (map_w32_filename (path
, NULL
));
1759 sys_unlink (const char * path
)
1761 path
= map_w32_filename (path
, NULL
);
1763 /* On Unix, unlink works without write permission. */
1764 _chmod (path
, 0666);
1765 return _unlink (path
);
1768 static FILETIME utc_base_ft
;
1769 static long double utc_base
;
1770 static int init
= 0;
1773 convert_time (FILETIME ft
)
1779 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1788 st
.wMilliseconds
= 0;
1790 SystemTimeToFileTime (&st
, &utc_base_ft
);
1791 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1792 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1796 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1799 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1801 return (time_t) (ret
* 1e-7);
1805 convert_from_time_t (time_t time
, FILETIME
* pft
)
1811 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1820 st
.wMilliseconds
= 0;
1822 SystemTimeToFileTime (&st
, &utc_base_ft
);
1823 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1824 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1828 /* time in 100ns units since 1-Jan-1601 */
1829 tmp
= (long double) time
* 1e7
+ utc_base
;
1830 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
1831 pft
->dwLowDateTime
= (DWORD
) (tmp
- (4096.0 * 1024 * 1024) * pft
->dwHighDateTime
);
1835 /* No reason to keep this; faking inode values either by hashing or even
1836 using the file index from GetInformationByHandle, is not perfect and
1837 so by default Emacs doesn't use the inode values on Windows.
1838 Instead, we now determine file-truename correctly (except for
1839 possible drive aliasing etc). */
1841 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
1843 hashval (const unsigned char * str
)
1848 h
= (h
<< 4) + *str
++;
1854 /* Return the hash value of the canonical pathname, excluding the
1855 drive/UNC header, to get a hopefully unique inode number. */
1857 generate_inode_val (const char * name
)
1859 char fullname
[ MAX_PATH
];
1863 /* Get the truly canonical filename, if it exists. (Note: this
1864 doesn't resolve aliasing due to subst commands, or recognise hard
1866 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
1869 parse_root (fullname
, &p
);
1870 /* Normal W32 filesystems are still case insensitive. */
1877 /* MSVC stat function can't cope with UNC names and has other bugs, so
1878 replace it with our own. This also allows us to calculate consistent
1879 inode values without hacks in the main Emacs code. */
1881 stat (const char * path
, struct stat
* buf
)
1884 WIN32_FIND_DATA wfd
;
1889 int rootdir
= FALSE
;
1891 if (path
== NULL
|| buf
== NULL
)
1897 name
= (char *) map_w32_filename (path
, &path
);
1898 /* must be valid filename, no wild cards or other illegal characters */
1899 if (strpbrk (name
, "*?|<>\""))
1905 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
1906 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
1907 if (IS_DIRECTORY_SEP (r
[0]) && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
1912 /* Remove trailing directory separator, unless name is the root
1913 directory of a drive or UNC volume in which case ensure there
1914 is a trailing separator. */
1915 len
= strlen (name
);
1916 rootdir
= (path
>= name
+ len
- 1
1917 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
1918 name
= strcpy (alloca (len
+ 2), name
);
1920 if (is_unc_volume (name
))
1922 DWORD attrs
= unc_volume_file_attributes (name
);
1927 memset (&wfd
, 0, sizeof (wfd
));
1928 wfd
.dwFileAttributes
= attrs
;
1929 wfd
.ftCreationTime
= utc_base_ft
;
1930 wfd
.ftLastAccessTime
= utc_base_ft
;
1931 wfd
.ftLastWriteTime
= utc_base_ft
;
1932 strcpy (wfd
.cFileName
, name
);
1936 if (!IS_DIRECTORY_SEP (name
[len
-1]))
1937 strcat (name
, "\\");
1938 if (GetDriveType (name
) < 2)
1943 memset (&wfd
, 0, sizeof (wfd
));
1944 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1945 wfd
.ftCreationTime
= utc_base_ft
;
1946 wfd
.ftLastAccessTime
= utc_base_ft
;
1947 wfd
.ftLastWriteTime
= utc_base_ft
;
1948 strcpy (wfd
.cFileName
, name
);
1952 if (IS_DIRECTORY_SEP (name
[len
-1]))
1955 /* (This is hacky, but helps when doing file completions on
1956 network drives.) Optimize by using information available from
1957 active readdir if possible. */
1958 if (dir_find_handle
!= INVALID_HANDLE_VALUE
1959 && (len
= strlen (dir_pathname
)),
1960 strnicmp (name
, dir_pathname
, len
) == 0
1961 && IS_DIRECTORY_SEP (name
[len
])
1962 && stricmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
1964 /* This was the last entry returned by readdir. */
1965 wfd
= dir_find_data
;
1969 fh
= FindFirstFile (name
, &wfd
);
1970 if (fh
== INVALID_HANDLE_VALUE
)
1979 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1981 buf
->st_mode
= _S_IFDIR
;
1982 buf
->st_nlink
= 2; /* doesn't really matter */
1983 fake_inode
= 0; /* this doesn't either I think */
1985 else if (!NILP (Vw32_get_true_file_attributes
)
1986 /* No access rights required to get info. */
1987 && (fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
, 0, NULL
))
1988 != INVALID_HANDLE_VALUE
)
1990 /* This is more accurate in terms of gettting the correct number
1991 of links, but is quite slow (it is noticable when Emacs is
1992 making a list of file name completions). */
1993 BY_HANDLE_FILE_INFORMATION info
;
1995 if (GetFileInformationByHandle (fh
, &info
))
1997 buf
->st_nlink
= info
.nNumberOfLinks
;
1998 /* Might as well use file index to fake inode values, but this
1999 is not guaranteed to be unique unless we keep a handle open
2000 all the time (even then there are situations where it is
2001 not unique). Reputedly, there are at most 48 bits of info
2002 (on NTFS, presumably less on FAT). */
2003 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2011 switch (GetFileType (fh
))
2013 case FILE_TYPE_DISK
:
2014 buf
->st_mode
= _S_IFREG
;
2016 case FILE_TYPE_PIPE
:
2017 buf
->st_mode
= _S_IFIFO
;
2019 case FILE_TYPE_CHAR
:
2020 case FILE_TYPE_UNKNOWN
:
2022 buf
->st_mode
= _S_IFCHR
;
2028 /* Don't bother to make this information more accurate. */
2029 buf
->st_mode
= _S_IFREG
;
2035 /* Not sure if there is any point in this. */
2036 if (!NILP (Vw32_generate_fake_inodes
))
2037 fake_inode
= generate_inode_val (name
);
2038 else if (fake_inode
== 0)
2040 /* For want of something better, try to make everything unique. */
2041 static DWORD gen_num
= 0;
2042 fake_inode
= ++gen_num
;
2046 /* MSVC defines _ino_t to be short; other libc's might not. */
2047 if (sizeof (buf
->st_ino
) == 2)
2048 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2050 buf
->st_ino
= fake_inode
;
2052 /* consider files to belong to current user */
2053 buf
->st_uid
= the_passwd
.pw_uid
;
2054 buf
->st_gid
= the_passwd
.pw_gid
;
2056 /* volume_info is set indirectly by map_w32_filename */
2057 buf
->st_dev
= volume_info
.serialnum
;
2058 buf
->st_rdev
= volume_info
.serialnum
;
2061 buf
->st_size
= wfd
.nFileSizeLow
;
2063 /* Convert timestamps to Unix format. */
2064 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
2065 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
2066 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2067 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
2068 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2070 /* determine rwx permissions */
2071 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2072 permission
= _S_IREAD
;
2074 permission
= _S_IREAD
| _S_IWRITE
;
2076 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2077 permission
|= _S_IEXEC
;
2078 else if (is_exec (name
))
2079 permission
|= _S_IEXEC
;
2081 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2086 /* Provide fstat and utime as well as stat for consistent handling of
2089 fstat (int desc
, struct stat
* buf
)
2091 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
2092 BY_HANDLE_FILE_INFORMATION info
;
2096 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
2098 case FILE_TYPE_DISK
:
2099 buf
->st_mode
= _S_IFREG
;
2100 if (!GetFileInformationByHandle (fh
, &info
))
2106 case FILE_TYPE_PIPE
:
2107 buf
->st_mode
= _S_IFIFO
;
2109 case FILE_TYPE_CHAR
:
2110 case FILE_TYPE_UNKNOWN
:
2112 buf
->st_mode
= _S_IFCHR
;
2114 memset (&info
, 0, sizeof (info
));
2115 info
.dwFileAttributes
= 0;
2116 info
.ftCreationTime
= utc_base_ft
;
2117 info
.ftLastAccessTime
= utc_base_ft
;
2118 info
.ftLastWriteTime
= utc_base_ft
;
2121 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2123 buf
->st_mode
= _S_IFDIR
;
2124 buf
->st_nlink
= 2; /* doesn't really matter */
2125 fake_inode
= 0; /* this doesn't either I think */
2129 buf
->st_nlink
= info
.nNumberOfLinks
;
2130 /* Might as well use file index to fake inode values, but this
2131 is not guaranteed to be unique unless we keep a handle open
2132 all the time (even then there are situations where it is
2133 not unique). Reputedly, there are at most 48 bits of info
2134 (on NTFS, presumably less on FAT). */
2135 fake_inode
= info
.nFileIndexLow
^ info
.nFileIndexHigh
;
2138 /* MSVC defines _ino_t to be short; other libc's might not. */
2139 if (sizeof (buf
->st_ino
) == 2)
2140 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
2142 buf
->st_ino
= fake_inode
;
2144 /* consider files to belong to current user */
2148 buf
->st_dev
= info
.dwVolumeSerialNumber
;
2149 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
2151 buf
->st_size
= info
.nFileSizeLow
;
2153 /* Convert timestamps to Unix format. */
2154 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
2155 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
2156 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
2157 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
2158 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
2160 /* determine rwx permissions */
2161 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
2162 permission
= _S_IREAD
;
2164 permission
= _S_IREAD
| _S_IWRITE
;
2166 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
2167 permission
|= _S_IEXEC
;
2170 #if 0 /* no way of knowing the filename */
2171 char * p
= strrchr (name
, '.');
2173 (stricmp (p
, ".exe") == 0 ||
2174 stricmp (p
, ".com") == 0 ||
2175 stricmp (p
, ".bat") == 0 ||
2176 stricmp (p
, ".cmd") == 0))
2177 permission
|= _S_IEXEC
;
2181 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
2187 utime (const char *name
, struct utimbuf
*times
)
2189 struct utimbuf deftime
;
2196 deftime
.modtime
= deftime
.actime
= time (NULL
);
2200 /* Need write access to set times. */
2201 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2202 0, OPEN_EXISTING
, 0, NULL
);
2205 convert_from_time_t (times
->actime
, &atime
);
2206 convert_from_time_t (times
->modtime
, &mtime
);
2207 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
2225 /* Wrappers for winsock functions to map between our file descriptors
2226 and winsock's handles; also set h_errno for convenience.
2228 To allow Emacs to run on systems which don't have winsock support
2229 installed, we dynamically link to winsock on startup if present, and
2230 otherwise provide the minimum necessary functionality
2231 (eg. gethostname). */
2233 /* function pointers for relevant socket functions */
2234 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
2235 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
2236 int (PASCAL
*pfn_WSAGetLastError
) (void);
2237 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
2238 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2239 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
2240 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
2241 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
2242 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
2243 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
2244 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
2245 int (PASCAL
*pfn_WSACleanup
) (void);
2247 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
2248 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
2249 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
2250 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
2251 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
2252 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
2254 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2255 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
2256 #ifndef HANDLE_FLAG_INHERIT
2257 #define HANDLE_FLAG_INHERIT 1
2261 static int winsock_inuse
;
2266 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
2268 /* Not sure what would cause WSAENETDOWN, or even if it can happen
2269 after WSAStartup returns successfully, but it seems reasonable
2270 to allow unloading winsock anyway in that case. */
2271 if (pfn_WSACleanup () == 0 ||
2272 pfn_WSAGetLastError () == WSAENETDOWN
)
2274 if (FreeLibrary (winsock_lib
))
2283 init_winsock (int load_now
)
2285 WSADATA winsockData
;
2287 if (winsock_lib
!= NULL
)
2290 pfn_SetHandleInformation
= NULL
;
2291 pfn_SetHandleInformation
2292 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2293 "SetHandleInformation");
2295 winsock_lib
= LoadLibrary ("wsock32.dll");
2297 if (winsock_lib
!= NULL
)
2299 /* dynamically link to socket functions */
2301 #define LOAD_PROC(fn) \
2302 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2305 LOAD_PROC( WSAStartup
);
2306 LOAD_PROC( WSASetLastError
);
2307 LOAD_PROC( WSAGetLastError
);
2308 LOAD_PROC( socket
);
2310 LOAD_PROC( connect
);
2311 LOAD_PROC( ioctlsocket
);
2314 LOAD_PROC( closesocket
);
2315 LOAD_PROC( shutdown
);
2318 LOAD_PROC( inet_addr
);
2319 LOAD_PROC( gethostname
);
2320 LOAD_PROC( gethostbyname
);
2321 LOAD_PROC( getservbyname
);
2322 LOAD_PROC( WSACleanup
);
2326 /* specify version 1.1 of winsock */
2327 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
2329 if (winsockData
.wVersion
!= 0x101)
2334 /* Report that winsock exists and is usable, but leave
2335 socket functions disabled. I am assuming that calling
2336 WSAStartup does not require any network interaction,
2337 and in particular does not cause or require a dial-up
2338 connection to be established. */
2341 FreeLibrary (winsock_lib
);
2349 FreeLibrary (winsock_lib
);
2359 /* function to set h_errno for compatability; map winsock error codes to
2360 normal system codes where they overlap (non-overlapping definitions
2361 are already in <sys/socket.h> */
2362 static void set_errno ()
2364 if (winsock_lib
== NULL
)
2367 h_errno
= pfn_WSAGetLastError ();
2371 case WSAEACCES
: h_errno
= EACCES
; break;
2372 case WSAEBADF
: h_errno
= EBADF
; break;
2373 case WSAEFAULT
: h_errno
= EFAULT
; break;
2374 case WSAEINTR
: h_errno
= EINTR
; break;
2375 case WSAEINVAL
: h_errno
= EINVAL
; break;
2376 case WSAEMFILE
: h_errno
= EMFILE
; break;
2377 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
2378 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
2383 static void check_errno ()
2385 if (h_errno
== 0 && winsock_lib
!= NULL
)
2386 pfn_WSASetLastError (0);
2389 /* Extend strerror to handle the winsock-specific error codes. */
2393 } _wsa_errlist
[] = {
2394 WSAEINTR
, "Interrupted function call",
2395 WSAEBADF
, "Bad file descriptor",
2396 WSAEACCES
, "Permission denied",
2397 WSAEFAULT
, "Bad address",
2398 WSAEINVAL
, "Invalid argument",
2399 WSAEMFILE
, "Too many open files",
2401 WSAEWOULDBLOCK
, "Resource temporarily unavailable",
2402 WSAEINPROGRESS
, "Operation now in progress",
2403 WSAEALREADY
, "Operation already in progress",
2404 WSAENOTSOCK
, "Socket operation on non-socket",
2405 WSAEDESTADDRREQ
, "Destination address required",
2406 WSAEMSGSIZE
, "Message too long",
2407 WSAEPROTOTYPE
, "Protocol wrong type for socket",
2408 WSAENOPROTOOPT
, "Bad protocol option",
2409 WSAEPROTONOSUPPORT
, "Protocol not supported",
2410 WSAESOCKTNOSUPPORT
, "Socket type not supported",
2411 WSAEOPNOTSUPP
, "Operation not supported",
2412 WSAEPFNOSUPPORT
, "Protocol family not supported",
2413 WSAEAFNOSUPPORT
, "Address family not supported by protocol family",
2414 WSAEADDRINUSE
, "Address already in use",
2415 WSAEADDRNOTAVAIL
, "Cannot assign requested address",
2416 WSAENETDOWN
, "Network is down",
2417 WSAENETUNREACH
, "Network is unreachable",
2418 WSAENETRESET
, "Network dropped connection on reset",
2419 WSAECONNABORTED
, "Software caused connection abort",
2420 WSAECONNRESET
, "Connection reset by peer",
2421 WSAENOBUFS
, "No buffer space available",
2422 WSAEISCONN
, "Socket is already connected",
2423 WSAENOTCONN
, "Socket is not connected",
2424 WSAESHUTDOWN
, "Cannot send after socket shutdown",
2425 WSAETOOMANYREFS
, "Too many references", /* not sure */
2426 WSAETIMEDOUT
, "Connection timed out",
2427 WSAECONNREFUSED
, "Connection refused",
2428 WSAELOOP
, "Network loop", /* not sure */
2429 WSAENAMETOOLONG
, "Name is too long",
2430 WSAEHOSTDOWN
, "Host is down",
2431 WSAEHOSTUNREACH
, "No route to host",
2432 WSAENOTEMPTY
, "Buffer not empty", /* not sure */
2433 WSAEPROCLIM
, "Too many processes",
2434 WSAEUSERS
, "Too many users", /* not sure */
2435 WSAEDQUOT
, "Double quote in host name", /* really not sure */
2436 WSAESTALE
, "Data is stale", /* not sure */
2437 WSAEREMOTE
, "Remote error", /* not sure */
2439 WSASYSNOTREADY
, "Network subsystem is unavailable",
2440 WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range",
2441 WSANOTINITIALISED
, "Winsock not initialized successfully",
2442 WSAEDISCON
, "Graceful shutdown in progress",
2444 WSAENOMORE
, "No more operations allowed", /* not sure */
2445 WSAECANCELLED
, "Operation cancelled", /* not sure */
2446 WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider",
2447 WSAEINVALIDPROVIDER
, "Invalid service provider version number",
2448 WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider",
2449 WSASYSCALLFAILURE
, "System call failured",
2450 WSASERVICE_NOT_FOUND
, "Service not found", /* not sure */
2451 WSATYPE_NOT_FOUND
, "Class type not found",
2452 WSA_E_NO_MORE
, "No more resources available", /* really not sure */
2453 WSA_E_CANCELLED
, "Operation already cancelled", /* really not sure */
2454 WSAEREFUSED
, "Operation refused", /* not sure */
2457 WSAHOST_NOT_FOUND
, "Host not found",
2458 WSATRY_AGAIN
, "Authoritative host not found during name lookup",
2459 WSANO_RECOVERY
, "Non-recoverable error during name lookup",
2460 WSANO_DATA
, "Valid name, no data record of requested type",
2466 sys_strerror(int error_no
)
2469 static char unknown_msg
[40];
2471 if (error_no
>= 0 && error_no
< _sys_nerr
)
2472 return _sys_errlist
[error_no
];
2474 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
2475 if (_wsa_errlist
[i
].errnum
== error_no
)
2476 return _wsa_errlist
[i
].msg
;
2478 sprintf(unknown_msg
, "Unidentified error: %d", error_no
);
2482 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2483 but I believe the method of keeping the socket handle separate (and
2484 insuring it is not inheritable) is the correct one. */
2486 //#define SOCK_REPLACE_HANDLE
2488 #ifdef SOCK_REPLACE_HANDLE
2489 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2491 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2495 sys_socket(int af
, int type
, int protocol
)
2501 if (winsock_lib
== NULL
)
2504 return INVALID_SOCKET
;
2509 /* call the real socket function */
2510 s
= (long) pfn_socket (af
, type
, protocol
);
2512 if (s
!= INVALID_SOCKET
)
2514 /* Although under NT 3.5 _open_osfhandle will accept a socket
2515 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2516 that does not work under NT 3.1. However, we can get the same
2517 effect by using a backdoor function to replace an existing
2518 descriptor handle with the one we want. */
2520 /* allocate a file descriptor (with appropriate flags) */
2521 fd
= _open ("NUL:", _O_RDWR
);
2524 #ifdef SOCK_REPLACE_HANDLE
2525 /* now replace handle to NUL with our socket handle */
2526 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
2528 _set_osfhnd (fd
, s
);
2529 /* setmode (fd, _O_BINARY); */
2531 /* Make a non-inheritable copy of the socket handle. */
2534 HANDLE new_s
= INVALID_HANDLE_VALUE
;
2536 parent
= GetCurrentProcess ();
2538 /* Apparently there is a bug in NT 3.51 with some service
2539 packs, which prevents using DuplicateHandle to make a
2540 socket handle non-inheritable (causes WSACleanup to
2541 hang). The work-around is to use SetHandleInformation
2542 instead if it is available and implemented. */
2543 if (!pfn_SetHandleInformation
2544 || !pfn_SetHandleInformation ((HANDLE
) s
,
2545 HANDLE_FLAG_INHERIT
,
2548 DuplicateHandle (parent
,
2554 DUPLICATE_SAME_ACCESS
);
2555 pfn_closesocket (s
);
2558 fd_info
[fd
].hnd
= (HANDLE
) s
;
2562 /* set our own internal flags */
2563 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
2569 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2571 /* attach child_process to fd_info */
2572 if (fd_info
[ fd
].cp
!= NULL
)
2574 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
2578 fd_info
[ fd
].cp
= cp
;
2581 winsock_inuse
++; /* count open sockets */
2588 pfn_closesocket (s
);
2598 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
2600 if (winsock_lib
== NULL
)
2603 return SOCKET_ERROR
;
2607 if (fd_info
[s
].flags
& FILE_SOCKET
)
2609 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
2610 if (rc
== SOCKET_ERROR
)
2615 return SOCKET_ERROR
;
2620 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
2622 if (winsock_lib
== NULL
)
2625 return SOCKET_ERROR
;
2629 if (fd_info
[s
].flags
& FILE_SOCKET
)
2631 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
2632 if (rc
== SOCKET_ERROR
)
2637 return SOCKET_ERROR
;
2641 sys_htons (u_short hostshort
)
2643 return (winsock_lib
!= NULL
) ?
2644 pfn_htons (hostshort
) : hostshort
;
2648 sys_ntohs (u_short netshort
)
2650 return (winsock_lib
!= NULL
) ?
2651 pfn_ntohs (netshort
) : netshort
;
2655 sys_inet_addr (const char * cp
)
2657 return (winsock_lib
!= NULL
) ?
2658 pfn_inet_addr (cp
) : INADDR_NONE
;
2662 sys_gethostname (char * name
, int namelen
)
2664 if (winsock_lib
!= NULL
)
2665 return pfn_gethostname (name
, namelen
);
2667 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
2668 return !GetComputerName (name
, &namelen
);
2671 return SOCKET_ERROR
;
2675 sys_gethostbyname(const char * name
)
2677 struct hostent
* host
;
2679 if (winsock_lib
== NULL
)
2686 host
= pfn_gethostbyname (name
);
2693 sys_getservbyname(const char * name
, const char * proto
)
2695 struct servent
* serv
;
2697 if (winsock_lib
== NULL
)
2704 serv
= pfn_getservbyname (name
, proto
);
2711 sys_shutdown (int s
, int how
)
2715 if (winsock_lib
== NULL
)
2718 return SOCKET_ERROR
;
2722 if (fd_info
[s
].flags
& FILE_SOCKET
)
2724 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
2725 if (rc
== SOCKET_ERROR
)
2730 return SOCKET_ERROR
;
2733 #endif /* HAVE_SOCKETS */
2736 /* Shadow main io functions: we need to handle pipes and sockets more
2737 intelligently, and implement non-blocking mode as well. */
2744 if (fd
< 0 || fd
>= MAXDESC
)
2752 child_process
* cp
= fd_info
[fd
].cp
;
2754 fd_info
[fd
].cp
= NULL
;
2756 if (CHILD_ACTIVE (cp
))
2758 /* if last descriptor to active child_process then cleanup */
2760 for (i
= 0; i
< MAXDESC
; i
++)
2764 if (fd_info
[i
].cp
== cp
)
2770 if (fd_info
[fd
].flags
& FILE_SOCKET
)
2772 #ifndef SOCK_REPLACE_HANDLE
2773 if (winsock_lib
== NULL
) abort ();
2775 pfn_shutdown (SOCK_HANDLE (fd
), 2);
2776 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
2778 winsock_inuse
--; /* count open sockets */
2786 /* Note that sockets do not need special treatment here (at least on
2787 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
2788 closesocket is equivalent to CloseHandle, which is to be expected
2789 because socket handles are fully fledged kernel handles. */
2793 fd_info
[fd
].flags
= 0;
2806 /* duplicate our internal info as well */
2807 fd_info
[new_fd
] = fd_info
[fd
];
2814 sys_dup2 (int src
, int dst
)
2818 if (dst
< 0 || dst
>= MAXDESC
)
2824 /* make sure we close the destination first if it's a pipe or socket */
2825 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
2828 rc
= _dup2 (src
, dst
);
2831 /* duplicate our internal info as well */
2832 fd_info
[dst
] = fd_info
[src
];
2837 /* Unix pipe() has only one arg */
2839 sys_pipe (int * phandles
)
2845 /* make pipe handles non-inheritable; when we spawn a child, we
2846 replace the relevant handle with an inheritable one. Also put
2847 pipes into binary mode; we will do text mode translation ourselves
2849 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
2853 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
2854 fd_info
[phandles
[0]].flags
= flags
;
2856 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
2857 fd_info
[phandles
[1]].flags
= flags
;
2864 extern Lisp_Object Vw32_pipe_read_delay
;
2866 /* Function to do blocking read of one byte, needed to implement
2867 select. It is only allowed on sockets and pipes. */
2869 _sys_read_ahead (int fd
)
2874 if (fd
< 0 || fd
>= MAXDESC
)
2875 return STATUS_READ_ERROR
;
2877 cp
= fd_info
[fd
].cp
;
2879 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
2880 return STATUS_READ_ERROR
;
2882 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
2883 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
2885 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
2889 cp
->status
= STATUS_READ_IN_PROGRESS
;
2891 if (fd_info
[fd
].flags
& FILE_PIPE
)
2893 rc
= _read (fd
, &cp
->chr
, sizeof (char));
2895 /* Give subprocess time to buffer some more output for us before
2896 reporting that input is available; we need this because Windows 95
2897 connects DOS programs to pipes by making the pipe appear to be
2898 the normal console stdout - as a result most DOS programs will
2899 write to stdout without buffering, ie. one character at a
2900 time. Even some W32 programs do this - "dir" in a command
2901 shell on NT is very slow if we don't do this. */
2904 int wait
= XINT (Vw32_pipe_read_delay
);
2910 /* Yield remainder of our time slice, effectively giving a
2911 temporary priority boost to the child process. */
2916 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
2917 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
2920 if (rc
== sizeof (char))
2921 cp
->status
= STATUS_READ_SUCCEEDED
;
2923 cp
->status
= STATUS_READ_FAILED
;
2929 sys_read (int fd
, char * buffer
, unsigned int count
)
2934 char * orig_buffer
= buffer
;
2936 if (fd
< 0 || fd
>= MAXDESC
)
2942 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
2944 child_process
*cp
= fd_info
[fd
].cp
;
2946 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
2954 /* re-read CR carried over from last read */
2955 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
2957 if (fd_info
[fd
].flags
& FILE_BINARY
) abort ();
2961 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
2964 /* presence of a child_process structure means we are operating in
2965 non-blocking mode - otherwise we just call _read directly.
2966 Note that the child_process structure might be missing because
2967 reap_subprocess has been called; in this case the pipe is
2968 already broken, so calling _read on it is okay. */
2971 int current_status
= cp
->status
;
2973 switch (current_status
)
2975 case STATUS_READ_FAILED
:
2976 case STATUS_READ_ERROR
:
2977 /* report normal EOF if nothing in buffer */
2979 fd_info
[fd
].flags
|= FILE_AT_EOF
;
2982 case STATUS_READ_READY
:
2983 case STATUS_READ_IN_PROGRESS
:
2984 DebPrint (("sys_read called when read is in progress\n"));
2985 errno
= EWOULDBLOCK
;
2988 case STATUS_READ_SUCCEEDED
:
2989 /* consume read-ahead char */
2990 *buffer
++ = cp
->chr
;
2993 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2994 ResetEvent (cp
->char_avail
);
2996 case STATUS_READ_ACKNOWLEDGED
:
3000 DebPrint (("sys_read: bad status %d\n", current_status
));
3005 if (fd_info
[fd
].flags
& FILE_PIPE
)
3007 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
3008 to_read
= min (waiting
, (DWORD
) count
);
3011 nchars
+= _read (fd
, buffer
, to_read
);
3014 else /* FILE_SOCKET */
3016 if (winsock_lib
== NULL
) abort ();
3018 /* do the equivalent of a non-blocking read */
3019 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
3020 if (waiting
== 0 && nchars
== 0)
3022 h_errno
= errno
= EWOULDBLOCK
;
3028 /* always use binary mode for sockets */
3029 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
3030 if (res
== SOCKET_ERROR
)
3032 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3033 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3044 int nread
= _read (fd
, buffer
, count
);
3047 else if (nchars
== 0)
3052 fd_info
[fd
].flags
|= FILE_AT_EOF
;
3053 /* Perform text mode translation if required. */
3054 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3056 nchars
= crlf_to_lf (nchars
, orig_buffer
);
3057 /* If buffer contains only CR, return that. To be absolutely
3058 sure we should attempt to read the next char, but in
3059 practice a CR to be followed by LF would not appear by
3060 itself in the buffer. */
3061 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
3063 fd_info
[fd
].flags
|= FILE_LAST_CR
;
3069 nchars
= _read (fd
, buffer
, count
);
3074 /* For now, don't bother with a non-blocking mode */
3076 sys_write (int fd
, const void * buffer
, unsigned int count
)
3080 if (fd
< 0 || fd
>= MAXDESC
)
3086 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
3088 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
3094 /* Perform text mode translation if required. */
3095 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
3097 char * tmpbuf
= alloca (count
* 2);
3098 unsigned char * src
= (void *)buffer
;
3099 unsigned char * dst
= tmpbuf
;
3104 unsigned char *next
;
3105 /* copy next line or remaining bytes */
3106 next
= _memccpy (dst
, src
, '\n', nbytes
);
3109 /* copied one line ending with '\n' */
3110 int copied
= next
- dst
;
3113 /* insert '\r' before '\n' */
3120 /* copied remaining partial line -> now finished */
3128 if (fd_info
[fd
].flags
& FILE_SOCKET
)
3130 if (winsock_lib
== NULL
) abort ();
3131 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
3132 if (nchars
== SOCKET_ERROR
)
3134 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3135 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
3141 nchars
= _write (fd
, buffer
, count
);
3147 check_windows_init_file ()
3149 extern int noninteractive
, inhibit_window_system
;
3151 /* A common indication that Emacs is not installed properly is when
3152 it cannot find the Windows installation file. If this file does
3153 not exist in the expected place, tell the user. */
3155 if (!noninteractive
&& !inhibit_window_system
)
3157 extern Lisp_Object Vwindow_system
, Vload_path
, Qfile_exists_p
;
3158 Lisp_Object objs
[2];
3159 Lisp_Object full_load_path
;
3160 Lisp_Object init_file
;
3163 objs
[0] = Vload_path
;
3164 objs
[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3165 full_load_path
= Fappend (2, objs
);
3166 init_file
= build_string ("term/w32-win");
3167 fd
= openp (full_load_path
, init_file
, ".el:.elc", NULL
, 0);
3170 Lisp_Object load_path_print
= Fprin1_to_string (full_load_path
, Qnil
);
3171 char *init_file_name
= XSTRING (init_file
)->data
;
3172 char *load_path
= XSTRING (load_path_print
)->data
;
3173 char *buffer
= alloca (1024);
3176 "The Emacs Windows initialization file \"%s.el\" "
3177 "could not be found in your Emacs installation. "
3178 "Emacs checked the following directories for this file:\n"
3180 "When Emacs cannot find this file, it usually means that it "
3181 "was not installed properly, or its distribution file was "
3182 "not unpacked properly.\nSee the README.W32 file in the "
3183 "top-level Emacs directory for more information.",
3184 init_file_name
, load_path
);
3187 "Emacs Abort Dialog",
3188 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
3189 /* Use the low-level Emacs abort. */
3204 /* shutdown the socket interface if necessary */
3213 /* Initialise the socket interface now if available and requested by
3214 the user by defining PRELOAD_WINSOCK; otherwise loading will be
3215 delayed until open-network-stream is called (w32-has-winsock can
3216 also be used to dynamically load or reload winsock).
3218 Conveniently, init_environment is called before us, so
3219 PRELOAD_WINSOCK can be set in the registry. */
3221 /* Always initialize this correctly. */
3224 if (getenv ("PRELOAD_WINSOCK") != NULL
)
3225 init_winsock (TRUE
);
3228 /* Initial preparation for subprocess support: replace our standard
3229 handles with non-inheritable versions. */
3232 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
3233 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
3234 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
3236 parent
= GetCurrentProcess ();
3238 /* ignore errors when duplicating and closing; typically the
3239 handles will be invalid when running as a gui program. */
3240 DuplicateHandle (parent
,
3241 GetStdHandle (STD_INPUT_HANDLE
),
3246 DUPLICATE_SAME_ACCESS
);
3248 DuplicateHandle (parent
,
3249 GetStdHandle (STD_OUTPUT_HANDLE
),
3254 DUPLICATE_SAME_ACCESS
);
3256 DuplicateHandle (parent
,
3257 GetStdHandle (STD_ERROR_HANDLE
),
3262 DUPLICATE_SAME_ACCESS
);
3268 if (stdin_save
!= INVALID_HANDLE_VALUE
)
3269 _open_osfhandle ((long) stdin_save
, O_TEXT
);
3271 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
3274 if (stdout_save
!= INVALID_HANDLE_VALUE
)
3275 _open_osfhandle ((long) stdout_save
, O_TEXT
);
3277 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3280 if (stderr_save
!= INVALID_HANDLE_VALUE
)
3281 _open_osfhandle ((long) stderr_save
, O_TEXT
);
3283 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
3287 /* unfortunately, atexit depends on implementation of malloc */
3288 /* atexit (term_ntproc); */
3289 signal (SIGABRT
, term_ntproc
);
3291 /* determine which drives are fixed, for GetCachedVolumeInformation */
3293 /* GetDriveType must have trailing backslash. */
3294 char drive
[] = "A:\\";
3296 /* Loop over all possible drive letters */
3297 while (*drive
<= 'Z')
3299 /* Record if this drive letter refers to a fixed drive. */
3300 fixed_drives
[DRIVE_INDEX (*drive
)] =
3301 (GetDriveType (drive
) == DRIVE_FIXED
);
3307 /* Check to see if Emacs has been installed correctly. */
3308 check_windows_init_file ();