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
34 /* must include CRT headers *before* config.h */
65 #ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
66 #include <sys/socket.h>
82 /* Get the current working directory. */
86 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
92 /* Emulate gethostname. */
94 gethostname (char *buffer
, int size
)
96 /* NT only allows small host names, so the buffer is
97 certainly large enough. */
98 return !GetComputerName (buffer
, &size
);
100 #endif /* HAVE_SOCKETS */
102 /* Emulate getloadavg. */
104 getloadavg (double loadavg
[], int nelem
)
108 /* A faithful emulation is going to have to be saved for a rainy day. */
109 for (i
= 0; i
< nelem
; i
++)
116 /* Emulate the Unix directory procedures opendir, closedir,
117 and readdir. We can't use the procedures supplied in sysdep.c,
118 so we provide them here. */
120 struct direct dir_static
; /* simulated directory contents */
121 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
122 static int dir_is_fat
;
123 static char dir_pathname
[MAXPATHLEN
+1];
125 extern Lisp_Object Vw32_downcase_file_names
;
128 opendir (char *filename
)
132 /* Opening is done by FindFirstFile. However, a read is inherent to
133 this operation, so we defer the open until read time. */
135 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
137 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
144 strncpy (dir_pathname
, filename
, MAXPATHLEN
);
145 dir_pathname
[MAXPATHLEN
] = '\0';
146 dir_is_fat
= is_fat_volume (filename
, NULL
);
154 /* If we have a find-handle open, close it. */
155 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
157 FindClose (dir_find_handle
);
158 dir_find_handle
= INVALID_HANDLE_VALUE
;
160 xfree ((char *) dirp
);
166 WIN32_FIND_DATA find_data
;
168 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
169 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
171 char filename
[MAXNAMLEN
+ 3];
174 strcpy (filename
, dir_pathname
);
175 ln
= strlen (filename
) - 1;
176 if (!IS_DIRECTORY_SEP (filename
[ln
]))
177 strcat (filename
, "\\");
178 strcat (filename
, "*");
180 dir_find_handle
= FindFirstFile (filename
, &find_data
);
182 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
187 if (!FindNextFile (dir_find_handle
, &find_data
))
191 /* Emacs never uses this value, so don't bother making it match
192 value returned by stat(). */
193 dir_static
.d_ino
= 1;
195 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
196 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
198 dir_static
.d_namlen
= strlen (find_data
.cFileName
);
199 strcpy (dir_static
.d_name
, find_data
.cFileName
);
201 _strlwr (dir_static
.d_name
);
202 else if (!NILP (Vw32_downcase_file_names
))
205 for (p
= dir_static
.d_name
; *p
; p
++)
206 if (*p
>= 'a' && *p
<= 'z')
209 _strlwr (dir_static
.d_name
);
215 /* Emulate getpwuid, getpwnam and others. */
217 #define PASSWD_FIELD_SIZE 256
219 static char the_passwd_name
[PASSWD_FIELD_SIZE
];
220 static char the_passwd_passwd
[PASSWD_FIELD_SIZE
];
221 static char the_passwd_gecos
[PASSWD_FIELD_SIZE
];
222 static char the_passwd_dir
[PASSWD_FIELD_SIZE
];
223 static char the_passwd_shell
[PASSWD_FIELD_SIZE
];
225 static struct passwd the_passwd
=
240 return the_passwd
.pw_uid
;
246 /* I could imagine arguing for checking to see whether the user is
247 in the Administrators group and returning a UID of 0 for that
248 case, but I don't know how wise that would be in the long run. */
255 return the_passwd
.pw_gid
;
267 if (uid
== the_passwd
.pw_uid
)
273 getpwnam (char *name
)
277 pw
= getpwuid (getuid ());
281 if (stricmp (name
, pw
->pw_name
))
290 /* Find the user's real name by opening the process token and
291 looking up the name associated with the user-sid in that token.
293 Use the relative portion of the identifier authority value from
294 the user-sid as the user id value (same for group id using the
295 primary group sid from the process token). */
297 char user_sid
[256], name
[256], domain
[256];
298 DWORD length
= sizeof (name
), dlength
= sizeof (domain
), trash
;
300 SID_NAME_USE user_type
;
302 if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY
, &token
)
303 && GetTokenInformation (token
, TokenUser
,
304 (PVOID
) user_sid
, sizeof (user_sid
), &trash
)
305 && LookupAccountSid (NULL
, *((PSID
*) user_sid
), name
, &length
,
306 domain
, &dlength
, &user_type
))
308 strcpy (the_passwd
.pw_name
, name
);
309 /* Determine a reasonable uid value. */
310 if (stricmp ("administrator", name
) == 0)
312 the_passwd
.pw_uid
= 0;
313 the_passwd
.pw_gid
= 0;
317 SID_IDENTIFIER_AUTHORITY
* pSIA
;
319 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
320 /* I believe the relative portion is the last 4 bytes (of 6)
322 the_passwd
.pw_uid
= ((pSIA
->Value
[2] << 24) +
323 (pSIA
->Value
[3] << 16) +
324 (pSIA
->Value
[4] << 8) +
325 (pSIA
->Value
[5] << 0));
326 /* restrict to conventional uid range for normal users */
327 the_passwd
.pw_uid
= the_passwd
.pw_uid
% 60001;
330 if (GetTokenInformation (token
, TokenPrimaryGroup
,
331 (PVOID
) user_sid
, sizeof (user_sid
), &trash
))
333 SID_IDENTIFIER_AUTHORITY
* pSIA
;
335 pSIA
= GetSidIdentifierAuthority (*((PSID
*) user_sid
));
336 the_passwd
.pw_gid
= ((pSIA
->Value
[2] << 24) +
337 (pSIA
->Value
[3] << 16) +
338 (pSIA
->Value
[4] << 8) +
339 (pSIA
->Value
[5] << 0));
340 /* I don't know if this is necessary, but for safety... */
341 the_passwd
.pw_gid
= the_passwd
.pw_gid
% 60001;
344 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
347 /* If security calls are not supported (presumably because we
348 are running under Windows 95), fallback to this. */
349 else if (GetUserName (name
, &length
))
351 strcpy (the_passwd
.pw_name
, name
);
352 if (stricmp ("administrator", name
) == 0)
353 the_passwd
.pw_uid
= 0;
355 the_passwd
.pw_uid
= 123;
356 the_passwd
.pw_gid
= the_passwd
.pw_uid
;
360 strcpy (the_passwd
.pw_name
, "unknown");
361 the_passwd
.pw_uid
= 123;
362 the_passwd
.pw_gid
= 123;
365 /* Ensure HOME and SHELL are defined. */
366 if (getenv ("HOME") == NULL
)
368 if (getenv ("SHELL") == NULL
)
369 putenv ((GetVersion () & 0x80000000) ? "SHELL=command" : "SHELL=cmd");
371 /* Set dir and shell from environment variables. */
372 strcpy (the_passwd
.pw_dir
, getenv ("HOME"));
373 strcpy (the_passwd
.pw_shell
, getenv ("SHELL"));
382 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
383 return ((rand () << 15) | rand ());
392 /* Normalize filename by converting all path separators to
393 the specified separator. Also conditionally convert upper
394 case path name components to lower case. */
397 normalize_filename (fp
, path_sep
)
404 /* Always lower-case drive letters a-z, even if the filesystem
405 preserves case in filenames.
406 This is so filenames can be compared by string comparison
407 functions that are case-sensitive. Even case-preserving filesystems
408 do not distinguish case in drive letters. */
409 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
415 if (NILP (Vw32_downcase_file_names
))
419 if (*fp
== '/' || *fp
== '\\')
426 sep
= path_sep
; /* convert to this path separator */
427 elem
= fp
; /* start of current path element */
430 if (*fp
>= 'a' && *fp
<= 'z')
431 elem
= 0; /* don't convert this element */
433 if (*fp
== 0 || *fp
== ':')
435 sep
= *fp
; /* restore current separator (or 0) */
436 *fp
= '/'; /* after conversion of this element */
439 if (*fp
== '/' || *fp
== '\\')
441 if (elem
&& elem
!= fp
)
443 *fp
= 0; /* temporary end of string */
444 _strlwr (elem
); /* while we convert to lower case */
446 *fp
= sep
; /* convert (or restore) path separator */
447 elem
= fp
+ 1; /* next element starts after separator */
453 /* Destructively turn backslashes into slashes. */
455 dostounix_filename (p
)
458 normalize_filename (p
, '/');
461 /* Destructively turn slashes into backslashes. */
463 unixtodos_filename (p
)
466 normalize_filename (p
, '\\');
469 /* Remove all CR's that are followed by a LF.
470 (From msdos.c...probably should figure out a way to share it,
471 although this code isn't going to ever change.) */
475 register unsigned char *buf
;
477 unsigned char *np
= buf
;
478 unsigned char *startp
= buf
;
479 unsigned char *endp
= buf
+ n
;
483 while (buf
< endp
- 1)
487 if (*(++buf
) != 0x0a)
498 /* Routines that are no-ops on NT but are defined to get Emacs to compile. */
501 sigsetmask (int signal_mask
)
513 setpgrp (int pid
, int gid
)
525 unrequest_sigio (void)
536 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
539 w32_get_resource (key
, lpdwtype
)
544 HKEY hrootkey
= NULL
;
548 /* Check both the current user and the local machine to see if
549 we have any resources. */
551 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
555 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
556 && (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
557 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
562 if (lpvalue
) xfree (lpvalue
);
564 RegCloseKey (hrootkey
);
567 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
571 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
&&
572 (lpvalue
= (LPBYTE
) xmalloc (cbData
)) != NULL
&&
573 RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
578 if (lpvalue
) xfree (lpvalue
);
580 RegCloseKey (hrootkey
);
586 char *get_emacs_configuration (void);
587 extern Lisp_Object Vsystem_configuration
;
592 /* Check for environment variables and use registry if they don't exist */
598 static char * env_vars
[] =
613 for (i
= 0; i
< (sizeof (env_vars
) / sizeof (env_vars
[0])); i
++)
615 if (!getenv (env_vars
[i
]) &&
616 (lpval
= w32_get_resource (env_vars
[i
], &dwType
)) != NULL
)
618 if (dwType
== REG_EXPAND_SZ
)
620 char buf1
[500], buf2
[500];
622 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, 500);
623 _snprintf (buf2
, 499, "%s=%s", env_vars
[i
], buf1
);
624 putenv (strdup (buf2
));
626 else if (dwType
== REG_SZ
)
630 _snprintf (buf
, 499, "%s=%s", env_vars
[i
], lpval
);
631 putenv (strdup (buf
));
639 /* Rebuild system configuration to reflect invoking system. */
640 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
645 /* We don't have scripts to automatically determine the system configuration
646 for Emacs before it's compiled, and we don't want to have to make the
647 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
650 static char configuration_buffer
[32];
653 get_emacs_configuration (void)
655 char *arch
, *oem
, *os
;
657 /* Determine the processor type. */
658 switch (get_processor_type ())
661 #ifdef PROCESSOR_INTEL_386
662 case PROCESSOR_INTEL_386
:
663 case PROCESSOR_INTEL_486
:
664 case PROCESSOR_INTEL_PENTIUM
:
669 #ifdef PROCESSOR_INTEL_860
670 case PROCESSOR_INTEL_860
:
675 #ifdef PROCESSOR_MIPS_R2000
676 case PROCESSOR_MIPS_R2000
:
677 case PROCESSOR_MIPS_R3000
:
678 case PROCESSOR_MIPS_R4000
:
683 #ifdef PROCESSOR_ALPHA_21064
684 case PROCESSOR_ALPHA_21064
:
694 /* Let oem be "*" until we figure out how to decode the OEM field. */
697 os
= (GetVersion () & 0x80000000) ? "windows95" : "nt";
699 sprintf (configuration_buffer
, "%s-%s-%s%d.%d", arch
, oem
, os
,
700 get_w32_major_version (), get_w32_minor_version ());
701 return configuration_buffer
;
704 #include <sys/timeb.h>
706 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
708 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
713 tv
->tv_sec
= tb
.time
;
714 tv
->tv_usec
= tb
.millitm
* 1000L;
717 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
718 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
722 /* ------------------------------------------------------------------------- */
723 /* IO support and wrapper functions for W32 API. */
724 /* ------------------------------------------------------------------------- */
726 /* Place a wrapper around the MSVC version of ctime. It returns NULL
727 on network directories, so we handle that case here.
728 (Ulrich Leodolter, 1/11/95). */
730 sys_ctime (const time_t *t
)
732 char *str
= (char *) ctime (t
);
733 return (str
? str
: "Sun Jan 01 00:00:00 1970");
736 /* Emulate sleep...we could have done this with a define, but that
737 would necessitate including windows.h in the files that used it.
738 This is much easier. */
740 sys_sleep (int seconds
)
742 Sleep (seconds
* 1000);
745 /* Internal MSVC data and functions for low-level descriptor munging */
746 #if (_MSC_VER == 900)
747 extern char _osfile
[];
749 extern int __cdecl
_set_osfhnd (int fd
, long h
);
750 extern int __cdecl
_free_osfhnd (int fd
);
752 /* parallel array of private info on file handles */
753 filedesc fd_info
[ MAXDESC
];
763 /* Get information on the volume where name is held; set path pointer to
764 start of pathname in name (past UNC header\volume header if present). */
766 get_volume_info (const char * name
, const char ** pPath
)
769 char *rootname
= NULL
; /* default to current volume */
774 /* find the root name of the volume if given */
775 if (isalpha (name
[0]) && name
[1] == ':')
783 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
790 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
803 if (GetVolumeInformation (rootname
,
804 volume_info
.name
, 32,
805 &volume_info
.serialnum
,
806 &volume_info
.maxcomp
,
808 volume_info
.type
, 32))
815 /* Determine if volume is FAT format (ie. only supports short 8.3
816 names); also set path pointer to start of pathname in name. */
818 is_fat_volume (const char * name
, const char ** pPath
)
820 if (get_volume_info (name
, pPath
))
821 return (volume_info
.maxcomp
== 12);
825 /* Map filename to a legal 8.3 name if necessary. */
827 map_w32_filename (const char * name
, const char ** pPath
)
829 static char shortname
[MAX_PATH
];
830 char * str
= shortname
;
834 if (is_fat_volume (name
, &path
)) /* truncate to 8.3 */
836 register int left
= 8; /* maximum number of chars in part */
837 register int extn
= 0; /* extension added? */
838 register int dots
= 2; /* maximum number of dots allowed */
841 *str
++ = *name
++; /* skip past UNC header */
843 while ((c
= *name
++))
850 extn
= 0; /* reset extension flags */
851 dots
= 2; /* max 2 dots */
852 left
= 8; /* max length 8 for main part */
856 extn
= 0; /* reset extension flags */
857 dots
= 2; /* max 2 dots */
858 left
= 8; /* max length 8 for main part */
863 /* Convert path components of the form .xxx to _xxx,
864 but leave . and .. as they are. This allows .emacs
865 to be read as _emacs, for example. */
869 IS_DIRECTORY_SEP (*name
))
884 extn
= 1; /* we've got an extension */
885 left
= 3; /* 3 chars in extension */
889 /* any embedded dots after the first are converted to _ */
894 case '#': /* don't lose these, they're important */
896 str
[-1] = c
; /* replace last character of part */
901 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
903 dots
= 0; /* started a path component */
912 strcpy (shortname
, name
);
913 unixtodos_filename (shortname
);
917 *pPath
= shortname
+ (path
- name
);
923 /* Shadow some MSVC runtime functions to map requests for long filenames
924 to reasonable short names if necessary. This was originally added to
925 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
929 sys_access (const char * path
, int mode
)
931 return _access (map_w32_filename (path
, NULL
), mode
);
935 sys_chdir (const char * path
)
937 return _chdir (map_w32_filename (path
, NULL
));
941 sys_chmod (const char * path
, int mode
)
943 return _chmod (map_w32_filename (path
, NULL
), mode
);
947 sys_creat (const char * path
, int mode
)
949 return _creat (map_w32_filename (path
, NULL
), mode
);
953 sys_fopen(const char * path
, const char * mode
)
957 const char * mode_save
= mode
;
959 /* Force all file handles to be non-inheritable. This is necessary to
960 ensure child processes don't unwittingly inherit handles that might
961 prevent future file access. */
965 else if (mode
[0] == 'w' || mode
[0] == 'a')
966 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
970 /* Only do simplistic option parsing. */
974 oflag
&= ~(O_RDONLY
| O_WRONLY
);
977 else if (mode
[0] == 'b')
982 else if (mode
[0] == 't')
989 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
993 return fdopen (fd
, mode_save
);
997 sys_link (const char * path1
, const char * path2
)
1004 sys_mkdir (const char * path
)
1006 return _mkdir (map_w32_filename (path
, NULL
));
1009 /* Because of long name mapping issues, we need to implement this
1010 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
1011 a unique name, instead of setting the input template to an empty
1014 Standard algorithm seems to be use pid or tid with a letter on the
1015 front (in place of the 6 X's) and cycle through the letters to find a
1016 unique name. We extend that to allow any reasonable character as the
1017 first of the 6 X's. */
1019 sys_mktemp (char * template)
1023 unsigned uid
= GetCurrentThreadId ();
1024 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1026 if (template == NULL
)
1028 p
= template + strlen (template);
1030 /* replace up to the last 5 X's with uid in decimal */
1031 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
1033 p
[0] = '0' + uid
% 10;
1037 if (i
< 0 && p
[0] == 'X')
1042 int save_errno
= errno
;
1043 p
[0] = first_char
[i
];
1044 if (sys_access (template, 0) < 0)
1050 while (++i
< sizeof (first_char
));
1053 /* Template is badly formed or else we can't generate a unique name,
1054 so return empty string */
1060 sys_open (const char * path
, int oflag
, int mode
)
1062 /* Force all file handles to be non-inheritable. */
1063 return _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, mode
);
1067 sys_rename (const char * oldname
, const char * newname
)
1069 char temp
[MAX_PATH
];
1072 /* MoveFile on Windows 95 doesn't correctly change the short file name
1073 alias in a number of circumstances (it is not easy to predict when
1074 just by looking at oldname and newname, unfortunately). In these
1075 cases, renaming through a temporary name avoids the problem.
1077 A second problem on Windows 95 is that renaming through a temp name when
1078 newname is uppercase fails (the final long name ends up in
1079 lowercase, although the short alias might be uppercase) UNLESS the
1080 long temp name is not 8.3.
1082 So, on Windows 95 we always rename through a temp name, and we make sure
1083 the temp name has a long extension to ensure correct renaming. */
1085 strcpy (temp
, map_w32_filename (oldname
, NULL
));
1087 if (GetVersion () & 0x80000000)
1091 if (p
= strrchr (temp
, '\\'))
1095 strcpy (p
, "__XXXXXX");
1097 /* Force temp name to require a manufactured 8.3 alias - this
1098 seems to make the second rename work properly. */
1099 strcat (temp
, ".long");
1100 if (rename (map_w32_filename (oldname
, NULL
), temp
) < 0)
1104 /* Emulate Unix behaviour - newname is deleted if it already exists
1105 (at least if it is a file; don't do this for directories).
1106 However, don't do this if we are just changing the case of the file
1107 name - we will end up deleting the file we are trying to rename! */
1108 newname
= map_w32_filename (newname
, NULL
);
1109 if (stricmp (newname
, temp
) != 0
1110 && (attr
= GetFileAttributes (newname
)) != -1
1111 && (attr
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
1113 _chmod (newname
, 0666);
1117 return rename (temp
, newname
);
1121 sys_rmdir (const char * path
)
1123 return _rmdir (map_w32_filename (path
, NULL
));
1127 sys_unlink (const char * path
)
1129 return _unlink (map_w32_filename (path
, NULL
));
1132 static FILETIME utc_base_ft
;
1133 static long double utc_base
;
1134 static int init
= 0;
1137 convert_time (FILETIME ft
)
1143 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1152 st
.wMilliseconds
= 0;
1154 SystemTimeToFileTime (&st
, &utc_base_ft
);
1155 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1156 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1160 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
1163 ret
= (long double) ft
.dwHighDateTime
* 4096 * 1024 * 1024 + ft
.dwLowDateTime
;
1165 return (time_t) (ret
* 1e-7);
1169 /* in case we ever have need of this */
1171 convert_from_time_t (time_t time
, FILETIME
* pft
)
1177 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1186 st
.wMilliseconds
= 0;
1188 SystemTimeToFileTime (&st
, &utc_base_ft
);
1189 utc_base
= (long double) utc_base_ft
.dwHighDateTime
1190 * 4096 * 1024 * 1024 + utc_base_ft
.dwLowDateTime
;
1194 /* time in 100ns units since 1-Jan-1601 */
1195 tmp
= (long double) time
* 1e7
+ utc_base
;
1196 pft
->dwHighDateTime
= (DWORD
) (tmp
/ (4096.0 * 1024 * 1024));
1197 pft
->dwLowDateTime
= (DWORD
) (tmp
- pft
->dwHighDateTime
);
1201 /* "PJW" algorithm (see the "Dragon" compiler book). */
1203 hashval (const char * str
)
1209 h
= (h
<< 4) + *str
++;
1210 if ((g
= h
& 0xf0000000) != 0)
1211 h
= (h
^ (g
>> 24)) & 0x0fffffff;
1216 /* Return the hash value of the canonical pathname, excluding the
1217 drive/UNC header, to get a hopefully unique inode number. */
1219 generate_inode_val (const char * name
)
1221 char fullname
[ MAX_PATH
];
1225 GetFullPathName (name
, sizeof (fullname
), fullname
, &p
);
1226 get_volume_info (fullname
, &p
);
1227 /* Normal W32 filesystems are still case insensitive. */
1230 return (_ino_t
) (hash
^ (hash
>> 16));
1233 /* MSVC stat function can't cope with UNC names and has other bugs, so
1234 replace it with our own. This also allows us to calculate consistent
1235 inode values without hacks in the main Emacs code. */
1237 stat (const char * path
, struct stat
* buf
)
1240 WIN32_FIND_DATA wfd
;
1244 int rootdir
= FALSE
;
1246 if (path
== NULL
|| buf
== NULL
)
1252 name
= (char *) map_w32_filename (path
, &path
);
1253 /* must be valid filename, no wild cards */
1254 if (strchr (name
, '*') || strchr (name
, '?'))
1260 /* Remove trailing directory separator, unless name is the root
1261 directory of a drive or UNC volume in which case ensure there
1262 is a trailing separator. */
1263 len
= strlen (name
);
1264 rootdir
= (path
>= name
+ len
- 1
1265 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
1266 name
= strcpy (alloca (len
+ 2), name
);
1270 if (!IS_DIRECTORY_SEP (name
[len
-1]))
1271 strcat (name
, "\\");
1272 if (GetDriveType (name
) < 2)
1277 memset (&wfd
, 0, sizeof (wfd
));
1278 wfd
.dwFileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1279 wfd
.ftCreationTime
= utc_base_ft
;
1280 wfd
.ftLastAccessTime
= utc_base_ft
;
1281 wfd
.ftLastWriteTime
= utc_base_ft
;
1282 strcpy (wfd
.cFileName
, name
);
1286 if (IS_DIRECTORY_SEP (name
[len
-1]))
1288 fh
= FindFirstFile (name
, &wfd
);
1289 if (fh
== INVALID_HANDLE_VALUE
)
1297 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1299 buf
->st_mode
= _S_IFDIR
;
1300 buf
->st_nlink
= 2; /* doesn't really matter */
1305 /* This is more accurate in terms of gettting the correct number
1306 of links, but is quite slow (it is noticable when Emacs is
1307 making a list of file name completions). */
1308 BY_HANDLE_FILE_INFORMATION info
;
1310 fh
= CreateFile (name
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1311 NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1313 if (GetFileInformationByHandle (fh
, &info
))
1315 switch (GetFileType (fh
))
1317 case FILE_TYPE_DISK
:
1318 buf
->st_mode
= _S_IFREG
;
1320 case FILE_TYPE_PIPE
:
1321 buf
->st_mode
= _S_IFIFO
;
1323 case FILE_TYPE_CHAR
:
1324 case FILE_TYPE_UNKNOWN
:
1326 buf
->st_mode
= _S_IFCHR
;
1328 buf
->st_nlink
= info
.nNumberOfLinks
;
1329 /* Could use file index, but this is not guaranteed to be
1330 unique unless we keep a handle open all the time. */
1331 /* buf->st_ino = info.nFileIndexLow ^ info.nFileIndexHigh; */
1340 buf
->st_mode
= _S_IFREG
;
1345 /* consider files to belong to current user */
1346 buf
->st_uid
= the_passwd
.pw_uid
;
1347 buf
->st_gid
= the_passwd
.pw_gid
;
1349 /* volume_info is set indirectly by map_w32_filename */
1350 buf
->st_dev
= volume_info
.serialnum
;
1351 buf
->st_rdev
= volume_info
.serialnum
;
1353 buf
->st_ino
= generate_inode_val (name
);
1355 buf
->st_size
= wfd
.nFileSizeLow
;
1357 /* Convert timestamps to Unix format. */
1358 buf
->st_mtime
= convert_time (wfd
.ftLastWriteTime
);
1359 buf
->st_atime
= convert_time (wfd
.ftLastAccessTime
);
1360 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
1361 buf
->st_ctime
= convert_time (wfd
.ftCreationTime
);
1362 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
1364 /* determine rwx permissions */
1365 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
1366 permission
= _S_IREAD
;
1368 permission
= _S_IREAD
| _S_IWRITE
;
1370 if (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
1371 permission
|= _S_IEXEC
;
1374 char * p
= strrchr (name
, '.');
1376 (stricmp (p
, ".exe") == 0 ||
1377 stricmp (p
, ".com") == 0 ||
1378 stricmp (p
, ".bat") == 0 ||
1379 stricmp (p
, ".cmd") == 0))
1380 permission
|= _S_IEXEC
;
1383 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
1390 /* Wrappers for winsock functions to map between our file descriptors
1391 and winsock's handles; also set h_errno for convenience.
1393 To allow Emacs to run on systems which don't have winsock support
1394 installed, we dynamically link to winsock on startup if present, and
1395 otherwise provide the minimum necessary functionality
1396 (eg. gethostname). */
1398 /* function pointers for relevant socket functions */
1399 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
1400 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
1401 int (PASCAL
*pfn_WSAGetLastError
) (void);
1402 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
1403 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
1404 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
1405 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
1406 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
1407 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
1408 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
1409 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
1410 int (PASCAL
*pfn_WSACleanup
) (void);
1412 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
1413 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
1414 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
1415 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
1416 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
1417 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
1419 /* SetHandleInformation is only needed to make sockets non-inheritable. */
1420 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
1421 #ifndef HANDLE_FLAG_INHERIT
1422 #define HANDLE_FLAG_INHERIT 1
1426 static int winsock_inuse
;
1431 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
1433 /* Not sure what would cause WSAENETDOWN, or even if it can happen
1434 after WSAStartup returns successfully, but it seems reasonable
1435 to allow unloading winsock anyway in that case. */
1436 if (pfn_WSACleanup () == 0 ||
1437 pfn_WSAGetLastError () == WSAENETDOWN
)
1439 if (FreeLibrary (winsock_lib
))
1448 init_winsock (int load_now
)
1450 WSADATA winsockData
;
1452 if (winsock_lib
!= NULL
)
1455 pfn_SetHandleInformation
= NULL
;
1456 pfn_SetHandleInformation
1457 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
1458 "SetHandleInformation");
1460 winsock_lib
= LoadLibrary ("wsock32.dll");
1462 if (winsock_lib
!= NULL
)
1464 /* dynamically link to socket functions */
1466 #define LOAD_PROC(fn) \
1467 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
1470 LOAD_PROC( WSAStartup
);
1471 LOAD_PROC( WSASetLastError
);
1472 LOAD_PROC( WSAGetLastError
);
1473 LOAD_PROC( socket
);
1475 LOAD_PROC( connect
);
1476 LOAD_PROC( ioctlsocket
);
1479 LOAD_PROC( closesocket
);
1480 LOAD_PROC( shutdown
);
1483 LOAD_PROC( inet_addr
);
1484 LOAD_PROC( gethostname
);
1485 LOAD_PROC( gethostbyname
);
1486 LOAD_PROC( getservbyname
);
1487 LOAD_PROC( WSACleanup
);
1491 /* specify version 1.1 of winsock */
1492 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
1494 if (winsockData
.wVersion
!= 0x101)
1499 /* Report that winsock exists and is usable, but leave
1500 socket functions disabled. I am assuming that calling
1501 WSAStartup does not require any network interaction,
1502 and in particular does not cause or require a dial-up
1503 connection to be established. */
1506 FreeLibrary (winsock_lib
);
1514 FreeLibrary (winsock_lib
);
1524 /* function to set h_errno for compatability; map winsock error codes to
1525 normal system codes where they overlap (non-overlapping definitions
1526 are already in <sys/socket.h> */
1527 static void set_errno ()
1529 if (winsock_lib
== NULL
)
1532 h_errno
= pfn_WSAGetLastError ();
1536 case WSAEACCES
: h_errno
= EACCES
; break;
1537 case WSAEBADF
: h_errno
= EBADF
; break;
1538 case WSAEFAULT
: h_errno
= EFAULT
; break;
1539 case WSAEINTR
: h_errno
= EINTR
; break;
1540 case WSAEINVAL
: h_errno
= EINVAL
; break;
1541 case WSAEMFILE
: h_errno
= EMFILE
; break;
1542 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
1543 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
1548 static void check_errno ()
1550 if (h_errno
== 0 && winsock_lib
!= NULL
)
1551 pfn_WSASetLastError (0);
1554 /* [andrewi 3-May-96] I've had conflicting results using both methods,
1555 but I believe the method of keeping the socket handle separate (and
1556 insuring it is not inheritable) is the correct one. */
1558 //#define SOCK_REPLACE_HANDLE
1560 #ifdef SOCK_REPLACE_HANDLE
1561 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
1563 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
1567 sys_socket(int af
, int type
, int protocol
)
1573 if (winsock_lib
== NULL
)
1576 return INVALID_SOCKET
;
1581 /* call the real socket function */
1582 s
= (long) pfn_socket (af
, type
, protocol
);
1584 if (s
!= INVALID_SOCKET
)
1586 /* Although under NT 3.5 _open_osfhandle will accept a socket
1587 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
1588 that does not work under NT 3.1. However, we can get the same
1589 effect by using a backdoor function to replace an existing
1590 descriptor handle with the one we want. */
1592 /* allocate a file descriptor (with appropriate flags) */
1593 fd
= _open ("NUL:", _O_RDWR
);
1596 #ifdef SOCK_REPLACE_HANDLE
1597 /* now replace handle to NUL with our socket handle */
1598 CloseHandle ((HANDLE
) _get_osfhandle (fd
));
1600 _set_osfhnd (fd
, s
);
1601 /* setmode (fd, _O_BINARY); */
1603 /* Make a non-inheritable copy of the socket handle. */
1606 HANDLE new_s
= INVALID_HANDLE_VALUE
;
1608 parent
= GetCurrentProcess ();
1610 /* Apparently there is a bug in NT 3.51 with some service
1611 packs, which prevents using DuplicateHandle to make a
1612 socket handle non-inheritable (causes WSACleanup to
1613 hang). The work-around is to use SetHandleInformation
1614 instead if it is available and implemented. */
1615 if (!pfn_SetHandleInformation
1616 || !pfn_SetHandleInformation ((HANDLE
) s
,
1617 HANDLE_FLAG_INHERIT
,
1618 HANDLE_FLAG_INHERIT
))
1620 DuplicateHandle (parent
,
1626 DUPLICATE_SAME_ACCESS
);
1627 pfn_closesocket (s
);
1630 fd_info
[fd
].hnd
= (HANDLE
) s
;
1634 /* set our own internal flags */
1635 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
1641 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
1643 /* attach child_process to fd_info */
1644 if (fd_info
[ fd
].cp
!= NULL
)
1646 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
1650 fd_info
[ fd
].cp
= cp
;
1653 winsock_inuse
++; /* count open sockets */
1660 pfn_closesocket (s
);
1670 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
1672 if (winsock_lib
== NULL
)
1675 return SOCKET_ERROR
;
1679 if (fd_info
[s
].flags
& FILE_SOCKET
)
1681 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
1682 if (rc
== SOCKET_ERROR
)
1687 return SOCKET_ERROR
;
1692 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
1694 if (winsock_lib
== NULL
)
1697 return SOCKET_ERROR
;
1701 if (fd_info
[s
].flags
& FILE_SOCKET
)
1703 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
1704 if (rc
== SOCKET_ERROR
)
1709 return SOCKET_ERROR
;
1713 sys_htons (u_short hostshort
)
1715 return (winsock_lib
!= NULL
) ?
1716 pfn_htons (hostshort
) : hostshort
;
1720 sys_ntohs (u_short netshort
)
1722 return (winsock_lib
!= NULL
) ?
1723 pfn_ntohs (netshort
) : netshort
;
1727 sys_inet_addr (const char * cp
)
1729 return (winsock_lib
!= NULL
) ?
1730 pfn_inet_addr (cp
) : INADDR_NONE
;
1734 sys_gethostname (char * name
, int namelen
)
1736 if (winsock_lib
!= NULL
)
1737 return pfn_gethostname (name
, namelen
);
1739 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
1740 return !GetComputerName (name
, &namelen
);
1743 return SOCKET_ERROR
;
1747 sys_gethostbyname(const char * name
)
1749 struct hostent
* host
;
1751 if (winsock_lib
== NULL
)
1758 host
= pfn_gethostbyname (name
);
1765 sys_getservbyname(const char * name
, const char * proto
)
1767 struct servent
* serv
;
1769 if (winsock_lib
== NULL
)
1776 serv
= pfn_getservbyname (name
, proto
);
1782 #endif /* HAVE_SOCKETS */
1785 /* Shadow main io functions: we need to handle pipes and sockets more
1786 intelligently, and implement non-blocking mode as well. */
1793 if (fd
< 0 || fd
>= MAXDESC
)
1801 child_process
* cp
= fd_info
[fd
].cp
;
1803 fd_info
[fd
].cp
= NULL
;
1805 if (CHILD_ACTIVE (cp
))
1807 /* if last descriptor to active child_process then cleanup */
1809 for (i
= 0; i
< MAXDESC
; i
++)
1813 if (fd_info
[i
].cp
== cp
)
1819 if (fd_info
[fd
].flags
& FILE_SOCKET
)
1821 #ifndef SOCK_REPLACE_HANDLE
1822 if (winsock_lib
== NULL
) abort ();
1824 pfn_shutdown (SOCK_HANDLE (fd
), 2);
1825 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
1827 winsock_inuse
--; /* count open sockets */
1835 /* Note that sockets do not need special treatment here (at least on
1836 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
1837 closesocket is equivalent to CloseHandle, which is to be expected
1838 because socket handles are fully fledged kernel handles. */
1842 fd_info
[fd
].flags
= 0;
1855 /* duplicate our internal info as well */
1856 fd_info
[new_fd
] = fd_info
[fd
];
1863 sys_dup2 (int src
, int dst
)
1867 if (dst
< 0 || dst
>= MAXDESC
)
1873 /* make sure we close the destination first if it's a pipe or socket */
1874 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
1877 rc
= _dup2 (src
, dst
);
1880 /* duplicate our internal info as well */
1881 fd_info
[dst
] = fd_info
[src
];
1886 /* From callproc.c */
1887 extern Lisp_Object Vbinary_process_input
;
1888 extern Lisp_Object Vbinary_process_output
;
1890 /* Unix pipe() has only one arg */
1892 sys_pipe (int * phandles
)
1898 /* make pipe handles non-inheritable; when we spawn a child,
1899 we replace the relevant handle with an inheritable one. */
1900 rc
= _pipe (phandles
, 0, _O_NOINHERIT
);
1904 /* set internal flags, and put read and write handles into binary
1905 mode as necessary; if not in binary mode, set the MSVC internal
1906 FDEV (0x40) flag to prevent _read from treating ^Z as eof (this
1907 could otherwise allow Emacs to hang because it then waits
1908 indefinitely for the child process to exit, when it might not be
1910 flags
= FILE_PIPE
| FILE_READ
;
1911 if (!NILP (Vbinary_process_output
))
1913 flags
|= FILE_BINARY
;
1914 setmode (phandles
[0], _O_BINARY
);
1916 #if (_MSC_VER == 900)
1918 _osfile
[phandles
[0]] |= 0x40;
1921 fd_info
[phandles
[0]].flags
= flags
;
1923 flags
= FILE_PIPE
| FILE_WRITE
;
1924 if (!NILP (Vbinary_process_input
))
1926 flags
|= FILE_BINARY
;
1927 setmode (phandles
[1], _O_BINARY
);
1929 #if (_MSC_VER == 900)
1931 _osfile
[phandles
[1]] |= 0x40;
1934 fd_info
[phandles
[1]].flags
= flags
;
1941 extern Lisp_Object Vw32_pipe_read_delay
;
1943 /* Function to do blocking read of one byte, needed to implement
1944 select. It is only allowed on sockets and pipes. */
1946 _sys_read_ahead (int fd
)
1951 if (fd
< 0 || fd
>= MAXDESC
)
1952 return STATUS_READ_ERROR
;
1954 cp
= fd_info
[fd
].cp
;
1956 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
1957 return STATUS_READ_ERROR
;
1959 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
)) == 0
1960 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
1962 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd
));
1966 cp
->status
= STATUS_READ_IN_PROGRESS
;
1968 if (fd_info
[fd
].flags
& FILE_PIPE
)
1970 /* Use read to get CRLF translation */
1971 rc
= _read (fd
, &cp
->chr
, sizeof (char));
1973 /* Give subprocess time to buffer some more output for us before
1974 reporting that input is available; we need this because Windows 95
1975 connects DOS programs to pipes by making the pipe appear to be
1976 the normal console stdout - as a result most DOS programs will
1977 write to stdout without buffering, ie. one character at a
1978 time. Even some W32 programs do this - "dir" in a command
1979 shell on NT is very slow if we don't do this. */
1982 int wait
= XINT (Vw32_pipe_read_delay
);
1988 /* Yield remainder of our time slice, effectively giving a
1989 temporary priority boost to the child process. */
1994 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
1995 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
1998 if (rc
== sizeof (char))
1999 cp
->status
= STATUS_READ_SUCCEEDED
;
2001 cp
->status
= STATUS_READ_FAILED
;
2007 sys_read (int fd
, char * buffer
, unsigned int count
)
2014 if (fd
< 0 || fd
>= MAXDESC
)
2020 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
2022 child_process
*cp
= fd_info
[fd
].cp
;
2024 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
2030 /* presence of a child_process structure means we are operating in
2031 non-blocking mode - otherwise we just call _read directly.
2032 Note that the child_process structure might be missing because
2033 reap_subprocess has been called; in this case the pipe is
2034 already broken, so calling _read on it is okay. */
2037 int current_status
= cp
->status
;
2039 switch (current_status
)
2041 case STATUS_READ_FAILED
:
2042 case STATUS_READ_ERROR
:
2043 /* report normal EOF */
2046 case STATUS_READ_READY
:
2047 case STATUS_READ_IN_PROGRESS
:
2048 DebPrint (("sys_read called when read is in progress\n"));
2049 errno
= EWOULDBLOCK
;
2052 case STATUS_READ_SUCCEEDED
:
2053 /* consume read-ahead char */
2054 *buffer
++ = cp
->chr
;
2057 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
2058 ResetEvent (cp
->char_avail
);
2060 case STATUS_READ_ACKNOWLEDGED
:
2064 DebPrint (("sys_read: bad status %d\n", current_status
));
2069 if (fd_info
[fd
].flags
& FILE_PIPE
)
2071 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
2072 to_read
= min (waiting
, (DWORD
) count
);
2074 /* Use read to get CRLF translation */
2075 nchars
= _read (fd
, buffer
, to_read
);
2078 else /* FILE_SOCKET */
2080 if (winsock_lib
== NULL
) abort ();
2082 /* do the equivalent of a non-blocking read */
2083 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
2084 if (waiting
== 0 && extra
== 0)
2086 h_errno
= errno
= EWOULDBLOCK
;
2093 /* always use binary mode for sockets */
2094 nchars
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
2095 if (nchars
== SOCKET_ERROR
)
2097 DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
2098 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
2111 nchars
= _read (fd
, buffer
, count
);
2114 nchars
= _read (fd
, buffer
, count
);
2116 return nchars
+ extra
;
2119 /* For now, don't bother with a non-blocking mode */
2121 sys_write (int fd
, const void * buffer
, unsigned int count
)
2125 if (fd
< 0 || fd
>= MAXDESC
)
2131 if (fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
))
2132 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
2138 if (fd_info
[fd
].flags
& FILE_SOCKET
)
2140 if (winsock_lib
== NULL
) abort ();
2141 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
2142 if (nchars
== SOCKET_ERROR
)
2144 DebPrint(("sys_read.send failed with error %d on socket %ld\n",
2145 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
2151 nchars
= _write (fd
, buffer
, count
);
2161 /* shutdown the socket interface if necessary */
2166 extern BOOL dos_process_running
;
2172 /* Initialise the socket interface now if available and requested by
2173 the user by defining PRELOAD_WINSOCK; otherwise loading will be
2174 delayed until open-network-stream is called (w32-has-winsock can
2175 also be used to dynamically load or reload winsock).
2177 Conveniently, init_environment is called before us, so
2178 PRELOAD_WINSOCK can be set in the registry. */
2180 /* Always initialize this correctly. */
2183 if (getenv ("PRELOAD_WINSOCK") != NULL
)
2184 init_winsock (TRUE
);
2187 /* Initial preparation for subprocess support: replace our standard
2188 handles with non-inheritable versions. */
2191 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
2192 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
2193 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
2195 parent
= GetCurrentProcess ();
2197 /* ignore errors when duplicating and closing; typically the
2198 handles will be invalid when running as a gui program. */
2199 DuplicateHandle (parent
,
2200 GetStdHandle (STD_INPUT_HANDLE
),
2205 DUPLICATE_SAME_ACCESS
);
2207 DuplicateHandle (parent
,
2208 GetStdHandle (STD_OUTPUT_HANDLE
),
2213 DUPLICATE_SAME_ACCESS
);
2215 DuplicateHandle (parent
,
2216 GetStdHandle (STD_ERROR_HANDLE
),
2221 DUPLICATE_SAME_ACCESS
);
2227 if (stdin_save
!= INVALID_HANDLE_VALUE
)
2228 _open_osfhandle ((long) stdin_save
, O_TEXT
);
2230 open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
2233 if (stdout_save
!= INVALID_HANDLE_VALUE
)
2234 _open_osfhandle ((long) stdout_save
, O_TEXT
);
2236 open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
2239 if (stderr_save
!= INVALID_HANDLE_VALUE
)
2240 _open_osfhandle ((long) stderr_save
, O_TEXT
);
2242 open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
2246 /* Restrict Emacs to running only one DOS program at a time (with any
2247 number of W32 programs). This is to prevent the user from
2248 running into problems with DOS programs being run in the same VDM
2249 under both Windows 95 and Windows NT.
2251 Note that it is possible for Emacs to run DOS programs in separate
2252 VDMs, but unfortunately the pipe implementation on Windows 95 then
2253 fails to report when the DOS process exits (which is supposed to
2254 break the pipe). Until this bug is fixed, or we can devise a
2255 work-around, we must try to avoid letting the user start more than
2256 one DOS program if possible. */
2258 dos_process_running
= FALSE
;
2260 /* unfortunately, atexit depends on implementation of malloc */
2261 /* atexit (term_ntproc); */
2262 signal (SIGABRT
, term_ntproc
);