-/* Utility and Unix shadow routines for GNU Emacs on Windows NT.
- Copyright (C) 1994, 1995 Free Software Foundation, Inc.
-
- This file is part of GNU Emacs.
-
- GNU Emacs is free software; you can redistribute it and/or modify it
- under the terms of the GNU General Public License as published by the
- Free Software Foundation; either version 2, or (at your option) any later
- version.
-
- GNU Emacs is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- more details.
-
- You should have received a copy of the GNU General Public License along
- with GNU Emacs; see the file COPYING. If not, write to the Free Software
- Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Geoff Voelker (voelker@cs.washington.edu) 7-29-94
-*/
-
-/* Define stat before including config.h. */
-#include <string.h>
-#include <sys/stat.h>
-int
-nt_stat (char *filename, struct stat *statbuf)
-{
- int r, l = strlen (filename);
- char *str = NULL;
- extern long *xmalloc ();
- extern void xfree ();
-
- /* stat has a bug when passed a name of a directory with a trailing
- backslash (but a trailing forward slash works fine). */
- if (filename[l - 1] == '\\')
- {
- str = (char *) xmalloc (l + 1);
- strcpy (str, filename);
- str[l - 1] = '/';
- r = stat (str, statbuf);
- xfree (str);
- return r;
- }
- else
- return stat (filename, statbuf);
-}
-
-/* Place a wrapper around the NT version of ctime. It returns NULL
- on network directories, so we handle that case here.
- Define it before including config.h. (Ulrich Leodolter, 1/11/95). */
-char *
-nt_ctime (const time_t *t)
-{
- char *str = (char *) ctime (t);
- return (str ? str : "Sun Jan 01 00:00:00 1970");
-}
-
-#include <windows.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <io.h>
-#include <fcntl.h>
-#include <ctype.h>
-
-#include "config.h"
-#define getwd _getwd
-#include "lisp.h"
-#undef getwd
-
-#include <pwd.h>
-
-#include "ndir.h"
-#include "ntheap.h"
-
-extern int report_file_error (char *, Lisp_Object);
-
-/* Get the current working directory. */
-int
-getwd (char *dir)
-{
- return GetCurrentDirectory (MAXPATHLEN, dir);
-}
-
-/* Emulate gethostname. */
-int
-gethostname (char *buffer, int size)
-{
- /* NT only allows small host names, so the buffer is
- certainly large enough. */
- return !GetComputerName (buffer, &size);
-}
-
-/* Emulate getloadavg. */
-int
-getloadavg (double loadavg[], int nelem)
-{
- int i;
-
- /* A faithful emulation is going to have to be saved for a rainy day. */
- for (i = 0; i < nelem; i++)
- {
- loadavg[i] = 0.0;
- }
- return i;
-}
-
-/* Emulate sleep...we could have done this with a define, but that
- would necessitate including windows.h in the files that used it.
- This is much easier. */
-void
-nt_sleep (int seconds)
-{
- Sleep (seconds * 1000);
-}
-
-/* Emulate the Unix directory procedures opendir, closedir,
- and readdir. We can't use the procedures supplied in sysdep.c,
- so we provide them here. */
-
-struct direct dir_static; /* simulated directory contents */
-static int dir_finding;
-static HANDLE dir_find_handle;
-
-DIR *
-opendir (char *filename)
-{
- DIR *dirp;
-
- /* Opening is done by FindFirstFile. However, a read is inherent to
- this operation, so we have a flag to handle the open at read
- time. This flag essentially means "there is a find-handle open and
- it needs to be closed." */
-
- if (!(dirp = (DIR *) malloc (sizeof (DIR))))
- {
- return 0;
- }
-
- dirp->dd_fd = 0;
- dirp->dd_loc = 0;
- dirp->dd_size = 0;
-
- /* This is tacky, but we need the directory name for our
- implementation of readdir. */
- strncpy (dirp->dd_buf, filename, DIRBLKSIZ);
- return dirp;
-}
-
-void
-closedir (DIR *dirp)
-{
- /* If we have a find-handle open, close it. */
- if (dir_finding)
- {
- FindClose (dir_find_handle);
- dir_finding = 0;
- }
- xfree ((char *) dirp);
-}
-
-struct direct *
-readdir (DIR *dirp)
-{
- WIN32_FIND_DATA find_data;
-
- /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
- if (!dir_finding)
- {
- char filename[MAXNAMLEN + 3];
- int ln;
-
- strncpy (filename, dirp->dd_buf, MAXNAMLEN);
- ln = strlen (filename)-1;
- if (filename[ln] != '\\' && filename[ln] != ':')
- strcat (filename, "\\");
- strcat (filename, "*.*");
-
- dir_find_handle = FindFirstFile (filename, &find_data);
-
- if (dir_find_handle == INVALID_HANDLE_VALUE)
- return NULL;
-
- dir_finding = 1;
- }
- else
- {
- if (!FindNextFile (dir_find_handle, &find_data))
- return NULL;
- }
-
- /* NT's unique ID for a file is 64 bits, so we have to fake it here.
- This should work as long as we never use 0. */
- dir_static.d_ino = 1;
-
- dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
- dir_static.d_namlen - dir_static.d_namlen % 4;
-
- dir_static.d_namlen = strlen (find_data.cFileName);
- strncpy (dir_static.d_name, find_data.cFileName, MAXNAMLEN);
-
- return &dir_static;
-}
-
-/* Emulate getpwuid and getpwnam. */
-
-int getuid (); /* forward declaration */
-
-static char the_passwd_name[256];
-static char the_passwd_passwd[256];
-static char the_passwd_gecos[256];
-static char the_passwd_dir[256];
-static char the_passwd_shell[256];
-
-static struct passwd the_passwd =
-{
- the_passwd_name,
- the_passwd_passwd,
- 0,
- 0,
- 0,
- the_passwd_gecos,
- the_passwd_dir,
- the_passwd_shell,
-};
-
-struct passwd *
-getpwuid (int uid)
-{
- int size = 256;
-
- if (!GetUserName (the_passwd.pw_name, &size))
- return NULL;
-
- the_passwd.pw_passwd[0] = '\0';
- the_passwd.pw_uid = 0;
- the_passwd.pw_gid = 0;
- strcpy (the_passwd.pw_gecos, the_passwd.pw_name);
- the_passwd.pw_dir[0] = '\0';
- the_passwd.pw_shell[0] = '\0';
-
- return &the_passwd;
-}
-
-struct passwd *
-getpwnam (char *name)
-{
- struct passwd *pw;
-
- pw = getpwuid (getuid ());
- if (!pw)
- return pw;
-
- if (strcmp (name, pw->pw_name))
- return NULL;
-
- return pw;
-}
-
-
-/* We don't have scripts to automatically determine the system configuration
- for Emacs before it's compiled, and we don't want to have to make the
- user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
- routine. */
-
-static char configuration_buffer[16];
-
-char *
-get_emacs_configuration (void)
-{
- char *arch, *oem;
-
- /* Determine the processor type. */
- switch (get_processor_type ())
- {
- case PROCESSOR_INTEL_386:
- case PROCESSOR_INTEL_486:
- case PROCESSOR_INTEL_PENTIUM:
- arch = "i386";
- break;
- case PROCESSOR_INTEL_860:
- arch = "i860";
- break;
- case PROCESSOR_MIPS_R2000:
- case PROCESSOR_MIPS_R3000:
- case PROCESSOR_MIPS_R4000:
- arch = "mips";
- break;
- case PROCESSOR_ALPHA_21064:
- arch = "alpha";
- break;
- default:
- arch = "unknown";
- break;
- }
-
- /* Let oem be "*" until we figure out how to decode the OEM field. */
- oem = "*";
-
- sprintf (configuration_buffer, "%s-%s-nt%d.%d", arch, oem,
- get_nt_major_version (), get_nt_minor_version ());
- return configuration_buffer;
-}
-
-/* Conjure up inode and device numbers that will serve the purpose
- of Emacs. Return 1 upon success, 0 upon failure. */
-int
-get_inode_and_device_vals (Lisp_Object filename, Lisp_Object *p_inode,
- Lisp_Object *p_device)
-{
- /* File uids on NT are found using a handle to a file, which
- implies that it has been opened. Since we want to be able
- to stat an arbitrary file, we must open it, get the info,
- and then close it.
-
- Also, NT file uids are 64-bits. This is a problem. */
-
- HANDLE handle;
- BOOL result;
- DWORD attrs;
- BY_HANDLE_FILE_INFORMATION info;
-
- /* We have to stat files and directories differently, so check
- to see what filename references. */
- attrs = GetFileAttributes (XSTRING (filename)->data);
- if (attrs == 0xFFFFFFFF) {
- return 0;
- }
- if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
- /* Conjure up bogus, but unique, values. */
- attrs = GetTickCount ();
- *p_inode = make_number (attrs);
- *p_device = make_number (attrs);
- return 1;
- }
-
- /* FIXME: It shouldn't be opened without READ access, but NT on x86
- doesn't allow GetFileInfo in that case (NT on mips does). */
-
- handle = CreateFile (XSTRING (filename)->data,
- GENERIC_READ,
- FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL,
- NULL);
- if (handle == INVALID_HANDLE_VALUE)
- return 0;
-
- result = GetFileInformationByHandle (handle, &info);
- CloseHandle (handle);
- if (!result)
- return 0;
-
- *p_inode = make_number (info.nFileIndexLow); /* use the low value */
- *p_device = make_number (info.dwVolumeSerialNumber);
-
- return 1;
-}
-
-/* The following pipe routines are used to support our fork emulation.
- Since NT's crt dup always creates inherited handles, we
- must be careful in setting up pipes. First create
- non-inherited pipe handles, then create an inherited handle
- to the write end by dup-ing it, and then close the non-inherited
- end that was just duped. This gives us one non-inherited handle
- on the read end and one inherited handle to the write end. As
- the parent, we close the inherited handle to the write end after
- spawning the child. */
-
-/* From callproc.c */
-extern Lisp_Object Vbinary_process_input;
-extern Lisp_Object Vbinary_process_output;
-
-void
-pipe_with_inherited_out (int fds[2])
-{
- int inherit_out;
- unsigned int flags = _O_NOINHERIT;
-
- if (!NILP (Vbinary_process_output))
- flags |= _O_BINARY;
-
- _pipe (fds, 0, flags);
- inherit_out = dup (fds[1]);
- close (fds[1]);
- fds[1] = inherit_out;
-}
-
-void
-pipe_with_inherited_in (int fds[2])
-{
- int inherit_in;
- unsigned int flags = _O_NOINHERIT;
-
- if (!NILP (Vbinary_process_input))
- flags |= _O_BINARY;
-
- _pipe (fds, 0, flags);
- inherit_in = dup (fds[0]);
- close (fds[0]);
- fds[0] = inherit_in;
-}
-
-/* The following two routines are used to manipulate stdin, stdout, and
- stderr of our child processes.
-
- Assuming that in, out, and err are inherited, we make them stdin,
- stdout, and stderr of the child as follows:
-
- - Save the parent's current standard handles.
- - Set the parent's standard handles to the handles being passed in.
- (Note that _get_osfhandle is an io.h procedure that
- maps crt file descriptors to NT file handles.)
- - Spawn the child, which inherits in, out, and err as stdin,
- stdout, and stderr. (see Spawnve)
- - Reset the parent's standard handles to the saved handles.
- (see reset_standard_handles)
- We assume that the caller closes in, out, and err after calling us. */
-
-void
-prepare_standard_handles (int in, int out, int err, HANDLE handles[4])
-{
- HANDLE parent, stdin_save, stdout_save, stderr_save, err_handle;
-
- parent = GetCurrentProcess ();
- if (!DuplicateHandle (parent,
- GetStdHandle (STD_INPUT_HANDLE),
- parent,
- &stdin_save,
- 0,
- FALSE,
- DUPLICATE_SAME_ACCESS))
- report_file_error ("Duplicating parent's input handle", Qnil);
-
- if (!DuplicateHandle (parent,
- GetStdHandle (STD_OUTPUT_HANDLE),
- parent,
- &stdout_save,
- 0,
- FALSE,
- DUPLICATE_SAME_ACCESS))
- report_file_error ("Duplicating parent's output handle", Qnil);
-
- if (!DuplicateHandle (parent,
- GetStdHandle (STD_ERROR_HANDLE),
- parent,
- &stderr_save,
- 0,
- FALSE,
- DUPLICATE_SAME_ACCESS))
- report_file_error ("Duplicating parent's error handle", Qnil);
-
- if (!SetStdHandle (STD_INPUT_HANDLE, (HANDLE) _get_osfhandle (in)))
- report_file_error ("Changing stdin handle", Qnil);
-
- if (!SetStdHandle (STD_OUTPUT_HANDLE, (HANDLE) _get_osfhandle (out)))
- report_file_error ("Changing stdout handle", Qnil);
-
- /* We lose data if we use the same handle to the pipe for stdout and
- stderr, so make a duplicate. This took a while to find. */
- if (out == err)
- {
- if (!DuplicateHandle (parent,
- (HANDLE) _get_osfhandle (err),
- parent,
- &err_handle,
- 0,
- TRUE,
- DUPLICATE_SAME_ACCESS))
- report_file_error ("Duplicating out handle to make err handle.",
- Qnil);
- }
- else
- {
- err_handle = (HANDLE) _get_osfhandle (err);
- }
-
- if (!SetStdHandle (STD_ERROR_HANDLE, err_handle))
- report_file_error ("Changing stderr handle", Qnil);
-
- handles[0] = stdin_save;
- handles[1] = stdout_save;
- handles[2] = stderr_save;
- handles[3] = err_handle;
-}
-
-void
-reset_standard_handles (int in, int out, int err, HANDLE handles[4])
-{
- HANDLE stdin_save = handles[0];
- HANDLE stdout_save = handles[1];
- HANDLE stderr_save = handles[2];
- HANDLE err_handle = handles[3];
-
- if (!SetStdHandle (STD_INPUT_HANDLE, stdin_save))
- report_file_error ("Resetting input handle", Qnil);
-
- if (!SetStdHandle (STD_OUTPUT_HANDLE, stdout_save))
- report_file_error ("Resetting output handle", Qnil);
-
- if (!SetStdHandle (STD_ERROR_HANDLE, stderr_save))
- report_file_error ("Resetting error handle", Qnil);
-
- if (out == err)
- {
- /* If out and err are the same handle, then we duplicated out
- and stuck it in err_handle. Close the duplicate to clean up. */
- if (!CloseHandle (err_handle))
- report_file_error ("Closing error handle duplicated from out.",
- Qnil);
- }
-}
-
-int
-random ()
-{
- /* rand () on NT gives us 15 random bits...hack together 30 bits. */
- return ((rand () << 15) | rand ());
-}
-
-void
-srandom (int seed)
-{
- srand (seed);
-}
-
-/* Destructively turn backslashes into slashes. */
-void
-dostounix_filename (p)
- register char *p;
-{
- while (*p)
- {
- if (*p == '\\')
- *p = '/';
- p++;
- }
-}
-
-/* Routines that are no-ops on NT but are defined to get Emacs to compile. */
-
-
-int
-sigsetmask (int signal_mask)
-{
- return 0;
-}
-
-int
-sigblock (int sig)
-{
- return 0;
-}
-
-int
-kill (int pid, int signal)
-{
- return 0;
-}
-
-int
-setpgrp (int pid, int gid)
-{
- return 0;
-}
-
-int
-alarm (int seconds)
-{
- return 0;
-}
-
-int
-unrequest_sigio (void)
-{
- return 0;
-}
-
-int
-request_sigio (void)
-{
- return 0;
-}
-
-int
-getuid ()
-{
- return 0;
-}
-
-int
-geteuid ()
-{
- return 0;
-}
-
-/* Remove all CR's that are followed by a LF.
- (From msdos.c...probably should figure out a way to share it,
- although this code isn't going to ever change.) */
-int
-crlf_to_lf (n, buf)
- register int n;
- register unsigned char *buf;
-{
- unsigned char *np = buf;
- unsigned char *startp = buf;
- unsigned char *endp = buf + n;
-
- if (n == 0)
- return n;
- while (buf < endp - 1)
- {
- if (*buf == 0x0d)
- {
- if (*(++buf) != 0x0a)
- *np++ = 0x0d;
- }
- else
- *np++ = *buf++;
- }
- if (buf < endp)
- *np++ = *buf++;
- return np - startp;
-}
-
-#ifdef HAVE_TIMEVAL
-#include <sys/timeb.h>
-
-/* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
-void
-gettimeofday (struct timeval *tv, struct timezone *tz)
-{
- struct _timeb tb;
- _ftime (&tb);
-
- tv->tv_sec = tb.time;
- tv->tv_usec = tb.millitm * 1000L;
- if (tz)
- {
- tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
- tz->tz_dsttime = tb.dstflag; /* type of dst correction */
- }
-}
-#endif /* HAVE_TIMEVAL */
-
-
-#ifdef PIGSFLY
-Keep this around...we might need it later.
-#ifdef WINDOWSNT
-{
- /*
- * Find the user's real name by opening the process token and looking
- * up the name associated with the user-sid in that token.
- */
-
- char b[256], Name[256], RefD[256];
- DWORD length = 256, rlength = 256, trash;
- HANDLE Token;
- SID_NAME_USE User;
-
- if (1)
- Vuser_real_name = build_string ("foo");
- else if (!OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &Token))
- {
- Vuser_real_name = build_string ("unknown");
- }
- else if (!GetTokenInformation (Token, TokenUser, (PVOID)b, 256,
- &trash))
- {
- CloseHandle (Token);
- Vuser_real_name = build_string ("unknown");
- }
- else if (!LookupAccountSid ((void *)0, (PSID)b, Name, &length, RefD,
- &rlength, &User))
- {
- CloseHandle (Token);
- Vuser_real_name = build_string ("unknown");
- }
- else
- Vuser_real_name = build_string (Name);
-}
-#else /* not WINDOWSNT */
-#endif /* not WINDOWSNT */
-#endif /* PIGSFLY */
+/* Utility and Unix shadow routines for GNU Emacs on Windows NT.
+ Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+ Geoff Voelker (voelker@cs.washington.edu) 7-29-94
+*/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <io.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <signal.h>
+#include <sys/time.h>
+
+/* must include CRT headers *before* config.h */
+#include "config.h"
+#undef access
+#undef chdir
+#undef chmod
+#undef creat
+#undef ctime
+#undef fopen
+#undef link
+#undef mkdir
+#undef mktemp
+#undef open
+#undef rename
+#undef rmdir
+#undef unlink
+
+#undef close
+#undef dup
+#undef dup2
+#undef pipe
+#undef read
+#undef write
+
+#define getwd _getwd
+#include "lisp.h"
+#undef getwd
+
+#include <pwd.h>
+
+#include <windows.h>
+
+#ifdef HAVE_SOCKETS /* TCP connection support, if kernel can do it */
+#include <sys/socket.h>
+#undef socket
+#undef bind
+#undef connect
+#undef htons
+#undef ntohs
+#undef inet_addr
+#undef gethostname
+#undef gethostbyname
+#undef getservbyname
+#endif
+
+#include "nt.h"
+#include "ndir.h"
+#include "ntheap.h"
+
+/* Get the current working directory. */
+char *
+getwd (char *dir)
+{
+ if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
+ return dir;
+ return NULL;
+}
+
+#ifndef HAVE_SOCKETS
+/* Emulate gethostname. */
+int
+gethostname (char *buffer, int size)
+{
+ /* NT only allows small host names, so the buffer is
+ certainly large enough. */
+ return !GetComputerName (buffer, &size);
+}
+#endif /* HAVE_SOCKETS */
+
+/* Emulate getloadavg. */
+int
+getloadavg (double loadavg[], int nelem)
+{
+ int i;
+
+ /* A faithful emulation is going to have to be saved for a rainy day. */
+ for (i = 0; i < nelem; i++)
+ {
+ loadavg[i] = 0.0;
+ }
+ return i;
+}
+
+/* Emulate the Unix directory procedures opendir, closedir,
+ and readdir. We can't use the procedures supplied in sysdep.c,
+ so we provide them here. */
+
+struct direct dir_static; /* simulated directory contents */
+static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
+static int dir_is_fat;
+static char dir_pathname[MAXPATHLEN+1];
+
+extern Lisp_Object Vwin32_downcase_file_names;
+
+DIR *
+opendir (char *filename)
+{
+ DIR *dirp;
+
+ /* Opening is done by FindFirstFile. However, a read is inherent to
+ this operation, so we defer the open until read time. */
+
+ if (!(dirp = (DIR *) malloc (sizeof (DIR))))
+ return NULL;
+ if (dir_find_handle != INVALID_HANDLE_VALUE)
+ return NULL;
+
+ dirp->dd_fd = 0;
+ dirp->dd_loc = 0;
+ dirp->dd_size = 0;
+
+ strncpy (dir_pathname, filename, MAXPATHLEN);
+ dir_pathname[MAXPATHLEN] = '\0';
+ dir_is_fat = is_fat_volume (filename, NULL);
+
+ return dirp;
+}
+
+void
+closedir (DIR *dirp)
+{
+ /* If we have a find-handle open, close it. */
+ if (dir_find_handle != INVALID_HANDLE_VALUE)
+ {
+ FindClose (dir_find_handle);
+ dir_find_handle = INVALID_HANDLE_VALUE;
+ }
+ xfree ((char *) dirp);
+}
+
+struct direct *
+readdir (DIR *dirp)
+{
+ WIN32_FIND_DATA find_data;
+
+ /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
+ if (dir_find_handle == INVALID_HANDLE_VALUE)
+ {
+ char filename[MAXNAMLEN + 3];
+ int ln;
+
+ strcpy (filename, dir_pathname);
+ ln = strlen (filename) - 1;
+ if (!IS_DIRECTORY_SEP (filename[ln]))
+ strcat (filename, "\\");
+ strcat (filename, "*");
+
+ dir_find_handle = FindFirstFile (filename, &find_data);
+
+ if (dir_find_handle == INVALID_HANDLE_VALUE)
+ return NULL;
+ }
+ else
+ {
+ if (!FindNextFile (dir_find_handle, &find_data))
+ return NULL;
+ }
+
+ /* Emacs never uses this value, so don't bother making it match
+ value returned by stat(). */
+ dir_static.d_ino = 1;
+
+ dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
+ dir_static.d_namlen - dir_static.d_namlen % 4;
+
+ dir_static.d_namlen = strlen (find_data.cFileName);
+ strcpy (dir_static.d_name, find_data.cFileName);
+ if (dir_is_fat)
+ _strlwr (dir_static.d_name);
+ else if (!NILP (Vwin32_downcase_file_names))
+ {
+ register char *p;
+ for (p = dir_static.d_name; *p; p++)
+ if (*p >= 'a' && *p <= 'z')
+ break;
+ if (!*p)
+ _strlwr (dir_static.d_name);
+ }
+
+ return &dir_static;
+}
+
+/* Emulate getpwuid, getpwnam and others. */
+
+#define PASSWD_FIELD_SIZE 256
+
+static char the_passwd_name[PASSWD_FIELD_SIZE];
+static char the_passwd_passwd[PASSWD_FIELD_SIZE];
+static char the_passwd_gecos[PASSWD_FIELD_SIZE];
+static char the_passwd_dir[PASSWD_FIELD_SIZE];
+static char the_passwd_shell[PASSWD_FIELD_SIZE];
+
+static struct passwd the_passwd =
+{
+ the_passwd_name,
+ the_passwd_passwd,
+ 0,
+ 0,
+ 0,
+ the_passwd_gecos,
+ the_passwd_dir,
+ the_passwd_shell,
+};
+
+int
+getuid ()
+{
+ return the_passwd.pw_uid;
+}
+
+int
+geteuid ()
+{
+ /* I could imagine arguing for checking to see whether the user is
+ in the Administrators group and returning a UID of 0 for that
+ case, but I don't know how wise that would be in the long run. */
+ return getuid ();
+}
+
+int
+getgid ()
+{
+ return the_passwd.pw_gid;
+}
+
+int
+getegid ()
+{
+ return getgid ();
+}
+
+struct passwd *
+getpwuid (int uid)
+{
+ if (uid == the_passwd.pw_uid)
+ return &the_passwd;
+ return NULL;
+}
+
+struct passwd *
+getpwnam (char *name)
+{
+ struct passwd *pw;
+
+ pw = getpwuid (getuid ());
+ if (!pw)
+ return pw;
+
+ if (stricmp (name, pw->pw_name))
+ return NULL;
+
+ return pw;
+}
+
+void
+init_user_info ()
+{
+ /* Find the user's real name by opening the process token and
+ looking up the name associated with the user-sid in that token.
+
+ Use the relative portion of the identifier authority value from
+ the user-sid as the user id value (same for group id using the
+ primary group sid from the process token). */
+
+ char user_sid[256], name[256], domain[256];
+ DWORD length = sizeof (name), dlength = sizeof (domain), trash;
+ HANDLE token = NULL;
+ SID_NAME_USE user_type;
+
+ if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &token)
+ && GetTokenInformation (token, TokenUser,
+ (PVOID) user_sid, sizeof (user_sid), &trash)
+ && LookupAccountSid (NULL, *((PSID *) user_sid), name, &length,
+ domain, &dlength, &user_type))
+ {
+ strcpy (the_passwd.pw_name, name);
+ /* Determine a reasonable uid value. */
+ if (stricmp ("administrator", name) == 0)
+ {
+ the_passwd.pw_uid = 0;
+ the_passwd.pw_gid = 0;
+ }
+ else
+ {
+ SID_IDENTIFIER_AUTHORITY * pSIA;
+
+ pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
+ /* I believe the relative portion is the last 4 bytes (of 6)
+ with msb first. */
+ the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
+ (pSIA->Value[3] << 16) +
+ (pSIA->Value[4] << 8) +
+ (pSIA->Value[5] << 0));
+ /* restrict to conventional uid range for normal users */
+ the_passwd.pw_uid = the_passwd.pw_uid % 60001;
+
+ /* Get group id */
+ if (GetTokenInformation (token, TokenPrimaryGroup,
+ (PVOID) user_sid, sizeof (user_sid), &trash))
+ {
+ SID_IDENTIFIER_AUTHORITY * pSIA;
+
+ pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
+ the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
+ (pSIA->Value[3] << 16) +
+ (pSIA->Value[4] << 8) +
+ (pSIA->Value[5] << 0));
+ /* I don't know if this is necessary, but for safety... */
+ the_passwd.pw_gid = the_passwd.pw_gid % 60001;
+ }
+ else
+ the_passwd.pw_gid = the_passwd.pw_uid;
+ }
+ }
+ /* If security calls are not supported (presumably because we
+ are running under Windows 95), fallback to this. */
+ else if (GetUserName (name, &length))
+ {
+ strcpy (the_passwd.pw_name, name);
+ if (stricmp ("administrator", name) == 0)
+ the_passwd.pw_uid = 0;
+ else
+ the_passwd.pw_uid = 123;
+ the_passwd.pw_gid = the_passwd.pw_uid;
+ }
+ else
+ {
+ strcpy (the_passwd.pw_name, "unknown");
+ the_passwd.pw_uid = 123;
+ the_passwd.pw_gid = 123;
+ }
+
+ /* Ensure HOME and SHELL are defined. */
+ if (getenv ("HOME") == NULL)
+ putenv ("HOME=c:/");
+ if (getenv ("SHELL") == NULL)
+ putenv ((GetVersion () & 0x80000000) ? "SHELL=command" : "SHELL=cmd");
+
+ /* Set dir and shell from environment variables. */
+ strcpy (the_passwd.pw_dir, getenv ("HOME"));
+ strcpy (the_passwd.pw_shell, getenv ("SHELL"));
+
+ if (token)
+ CloseHandle (token);
+}
+
+int
+random ()
+{
+ /* rand () on NT gives us 15 random bits...hack together 30 bits. */
+ return ((rand () << 15) | rand ());
+}
+
+void
+srandom (int seed)
+{
+ srand (seed);
+}
+
+/* Normalize filename by converting all path separators to
+ the specified separator. Also conditionally convert upper
+ case path name components to lower case. */
+
+static void
+normalize_filename (fp, path_sep)
+ register char *fp;
+ char path_sep;
+{
+ char sep;
+ char *elem;
+
+ if (NILP (Vwin32_downcase_file_names))
+ {
+ while (*fp)
+ {
+ if (*fp == '/' || *fp == '\\')
+ *fp = path_sep;
+ fp++;
+ }
+ return;
+ }
+
+ sep = path_sep; /* convert to this path separator */
+ elem = fp; /* start of current path element */
+
+ do {
+ if (*fp >= 'a' && *fp <= 'z')
+ elem = 0; /* don't convert this element */
+
+ if (*fp == 0 || *fp == ':')
+ {
+ sep = *fp; /* restore current separator (or 0) */
+ *fp = '/'; /* after conversion of this element */
+ }
+
+ if (*fp == '/' || *fp == '\\')
+ {
+ if (elem && elem != fp)
+ {
+ *fp = 0; /* temporary end of string */
+ _strlwr (elem); /* while we convert to lower case */
+ }
+ *fp = sep; /* convert (or restore) path separator */
+ elem = fp + 1; /* next element starts after separator */
+ sep = path_sep;
+ }
+ } while (*fp++);
+}
+
+/* Destructively turn backslashes into slashes. */
+void
+dostounix_filename (p)
+ register char *p;
+{
+ normalize_filename (p, '/');
+}
+
+/* Destructively turn slashes into backslashes. */
+void
+unixtodos_filename (p)
+ register char *p;
+{
+ normalize_filename (p, '\\');
+}
+
+/* Remove all CR's that are followed by a LF.
+ (From msdos.c...probably should figure out a way to share it,
+ although this code isn't going to ever change.) */
+int
+crlf_to_lf (n, buf)
+ register int n;
+ register unsigned char *buf;
+{
+ unsigned char *np = buf;
+ unsigned char *startp = buf;
+ unsigned char *endp = buf + n;
+
+ if (n == 0)
+ return n;
+ while (buf < endp - 1)
+ {
+ if (*buf == 0x0d)
+ {
+ if (*(++buf) != 0x0a)
+ *np++ = 0x0d;
+ }
+ else
+ *np++ = *buf++;
+ }
+ if (buf < endp)
+ *np++ = *buf++;
+ return np - startp;
+}
+
+/* Routines that are no-ops on NT but are defined to get Emacs to compile. */
+
+int
+sigsetmask (int signal_mask)
+{
+ return 0;
+}
+
+int
+sigblock (int sig)
+{
+ return 0;
+}
+
+int
+setpgrp (int pid, int gid)
+{
+ return 0;
+}
+
+int
+alarm (int seconds)
+{
+ return 0;
+}
+
+int
+unrequest_sigio (void)
+{
+ return 0;
+}
+
+int
+request_sigio (void)
+{
+ return 0;
+}
+
+#define REG_ROOT "SOFTWARE\\GNU\\Emacs"
+
+LPBYTE
+nt_get_resource (key, lpdwtype)
+ char *key;
+ LPDWORD lpdwtype;
+{
+ LPBYTE lpvalue;
+ HKEY hrootkey = NULL;
+ DWORD cbData;
+ BOOL ok = FALSE;
+
+ /* Check both the current user and the local machine to see if
+ we have any resources. */
+
+ if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
+ {
+ lpvalue = NULL;
+
+ if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
+ && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
+ && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
+ {
+ return (lpvalue);
+ }
+
+ if (lpvalue) xfree (lpvalue);
+
+ RegCloseKey (hrootkey);
+ }
+
+ if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
+ {
+ lpvalue = NULL;
+
+ if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS &&
+ (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL &&
+ RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
+ {
+ return (lpvalue);
+ }
+
+ if (lpvalue) xfree (lpvalue);
+
+ RegCloseKey (hrootkey);
+ }
+
+ return (NULL);
+}
+
+void
+init_environment ()
+{
+ /* Check for environment variables and use registry if they don't exist */
+ {
+ int i;
+ LPBYTE lpval;
+ DWORD dwType;
+
+ static char * env_vars[] =
+ {
+ "HOME",
+ "emacs_dir",
+ "EMACSLOADPATH",
+ "SHELL",
+ "EMACSDATA",
+ "EMACSPATH",
+ "EMACSLOCKDIR",
+ "INFOPATH",
+ "EMACSDOC",
+ "TERM",
+ };
+
+ for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++)
+ {
+ if (!getenv (env_vars[i]) &&
+ (lpval = nt_get_resource (env_vars[i], &dwType)) != NULL)
+ {
+ if (dwType == REG_EXPAND_SZ)
+ {
+ char buf1[500], buf2[500];
+
+ ExpandEnvironmentStrings ((LPSTR) lpval, buf1, 500);
+ _snprintf (buf2, 499, "%s=%s", env_vars[i], buf1);
+ putenv (strdup (buf2));
+ }
+ else if (dwType == REG_SZ)
+ {
+ char buf[500];
+
+ _snprintf (buf, 499, "%s=%s", env_vars[i], lpval);
+ putenv (strdup (buf));
+ }
+
+ xfree (lpval);
+ }
+ }
+ }
+
+ init_user_info ();
+}
+
+/* We don't have scripts to automatically determine the system configuration
+ for Emacs before it's compiled, and we don't want to have to make the
+ user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
+ routine. */
+
+static char configuration_buffer[32];
+
+char *
+get_emacs_configuration (void)
+{
+ char *arch, *oem, *os;
+
+ /* Determine the processor type. */
+ switch (get_processor_type ())
+ {
+
+#ifdef PROCESSOR_INTEL_386
+ case PROCESSOR_INTEL_386:
+ case PROCESSOR_INTEL_486:
+ case PROCESSOR_INTEL_PENTIUM:
+ arch = "i386";
+ break;
+#endif
+
+#ifdef PROCESSOR_INTEL_860
+ case PROCESSOR_INTEL_860:
+ arch = "i860";
+ break;
+#endif
+
+#ifdef PROCESSOR_MIPS_R2000
+ case PROCESSOR_MIPS_R2000:
+ case PROCESSOR_MIPS_R3000:
+ case PROCESSOR_MIPS_R4000:
+ arch = "mips";
+ break;
+#endif
+
+#ifdef PROCESSOR_ALPHA_21064
+ case PROCESSOR_ALPHA_21064:
+ arch = "alpha";
+ break;
+#endif
+
+ default:
+ arch = "unknown";
+ break;
+ }
+
+ /* Let oem be "*" until we figure out how to decode the OEM field. */
+ oem = "*";
+
+ os = (GetVersion () & 0x80000000) ? "win95" : "nt";
+
+ sprintf (configuration_buffer, "%s-%s-%s%d.%d", arch, oem, os,
+ get_nt_major_version (), get_nt_minor_version ());
+ return configuration_buffer;
+}
+
+#include <sys/timeb.h>
+
+/* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
+void
+gettimeofday (struct timeval *tv, struct timezone *tz)
+{
+ struct _timeb tb;
+ _ftime (&tb);
+
+ tv->tv_sec = tb.time;
+ tv->tv_usec = tb.millitm * 1000L;
+ if (tz)
+ {
+ tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
+ tz->tz_dsttime = tb.dstflag; /* type of dst correction */
+ }
+}
+
+/* ------------------------------------------------------------------------- */
+/* IO support and wrapper functions for Win32 API. */
+/* ------------------------------------------------------------------------- */
+
+/* Place a wrapper around the MSVC version of ctime. It returns NULL
+ on network directories, so we handle that case here.
+ (Ulrich Leodolter, 1/11/95). */
+char *
+sys_ctime (const time_t *t)
+{
+ char *str = (char *) ctime (t);
+ return (str ? str : "Sun Jan 01 00:00:00 1970");
+}
+
+/* Emulate sleep...we could have done this with a define, but that
+ would necessitate including windows.h in the files that used it.
+ This is much easier. */
+void
+sys_sleep (int seconds)
+{
+ Sleep (seconds * 1000);
+}
+
+/* Internal MSVC data and functions for low-level descriptor munging */
+#if (_MSC_VER == 900)
+extern char _osfile[];
+#endif
+extern int __cdecl _set_osfhnd (int fd, long h);
+extern int __cdecl _free_osfhnd (int fd);
+
+/* parallel array of private info on file handles */
+filedesc fd_info [ MAXDESC ];
+
+static struct {
+ DWORD serialnum;
+ DWORD maxcomp;
+ DWORD flags;
+ char name[32];
+ char type[32];
+} volume_info;
+
+/* Get information on the volume where name is held; set path pointer to
+ start of pathname in name (past UNC header\volume header if present). */
+int
+get_volume_info (const char * name, const char ** pPath)
+{
+ char temp[MAX_PATH];
+ char *rootname = NULL; /* default to current volume */
+
+ if (name == NULL)
+ return FALSE;
+
+ /* find the root name of the volume if given */
+ if (isalpha (name[0]) && name[1] == ':')
+ {
+ rootname = temp;
+ temp[0] = *name++;
+ temp[1] = *name++;
+ temp[2] = '\\';
+ temp[3] = 0;
+ }
+ else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
+ {
+ char *str = temp;
+ int slashes = 4;
+ rootname = temp;
+ do
+ {
+ if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
+ break;
+ *str++ = *name++;
+ }
+ while ( *name );
+
+ *str++ = '\\';
+ *str = 0;
+ }
+
+ if (pPath)
+ *pPath = name;
+
+ if (GetVolumeInformation (rootname,
+ volume_info.name, 32,
+ &volume_info.serialnum,
+ &volume_info.maxcomp,
+ &volume_info.flags,
+ volume_info.type, 32))
+ {
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/* Determine if volume is FAT format (ie. only supports short 8.3
+ names); also set path pointer to start of pathname in name. */
+int
+is_fat_volume (const char * name, const char ** pPath)
+{
+ if (get_volume_info (name, pPath))
+ return (volume_info.maxcomp == 12);
+ return FALSE;
+}
+
+/* Map filename to a legal 8.3 name if necessary. */
+const char *
+map_win32_filename (const char * name, const char ** pPath)
+{
+ static char shortname[MAX_PATH];
+ char * str = shortname;
+ char c;
+ char * path;
+
+ if (is_fat_volume (name, &path)) /* truncate to 8.3 */
+ {
+ register int left = 8; /* maximum number of chars in part */
+ register int extn = 0; /* extension added? */
+ register int dots = 2; /* maximum number of dots allowed */
+
+ while (name < path)
+ *str++ = *name++; /* skip past UNC header */
+
+ while ((c = *name++))
+ {
+ switch ( c )
+ {
+ case '\\':
+ case '/':
+ *str++ = '\\';
+ extn = 0; /* reset extension flags */
+ dots = 2; /* max 2 dots */
+ left = 8; /* max length 8 for main part */
+ break;
+ case ':':
+ *str++ = ':';
+ extn = 0; /* reset extension flags */
+ dots = 2; /* max 2 dots */
+ left = 8; /* max length 8 for main part */
+ break;
+ case '.':
+ if ( dots )
+ {
+ /* Convert path components of the form .xxx to _xxx,
+ but leave . and .. as they are. This allows .emacs
+ to be read as _emacs, for example. */
+
+ if (! *name ||
+ *name == '.' ||
+ IS_DIRECTORY_SEP (*name))
+ {
+ *str++ = '.';
+ dots--;
+ }
+ else
+ {
+ *str++ = '_';
+ left--;
+ dots = 0;
+ }
+ }
+ else if ( !extn )
+ {
+ *str++ = '.';
+ extn = 1; /* we've got an extension */
+ left = 3; /* 3 chars in extension */
+ }
+ else
+ {
+ /* any embedded dots after the first are converted to _ */
+ *str++ = '_';
+ }
+ break;
+ case '~':
+ case '#': /* don't lose these, they're important */
+ if ( ! left )
+ str[-1] = c; /* replace last character of part */
+ /* FALLTHRU */
+ default:
+ if ( left )
+ {
+ *str++ = tolower (c); /* map to lower case (looks nicer) */
+ left--;
+ dots = 0; /* started a path component */
+ }
+ break;
+ }
+ }
+ *str = '\0';
+ }
+ else
+ {
+ strcpy (shortname, name);
+ unixtodos_filename (shortname);
+ }
+
+ if (pPath)
+ *pPath = shortname + (path - name);
+
+ return shortname;
+}
+
+
+/* Shadow some MSVC runtime functions to map requests for long filenames
+ to reasonable short names if necessary. This was originally added to
+ permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
+ long file names. */
+
+int
+sys_access (const char * path, int mode)
+{
+ return _access (map_win32_filename (path, NULL), mode);
+}
+
+int
+sys_chdir (const char * path)
+{
+ return _chdir (map_win32_filename (path, NULL));
+}
+
+int
+sys_chmod (const char * path, int mode)
+{
+ return _chmod (map_win32_filename (path, NULL), mode);
+}
+
+int
+sys_creat (const char * path, int mode)
+{
+ return _creat (map_win32_filename (path, NULL), mode);
+}
+
+FILE *
+sys_fopen(const char * path, const char * mode)
+{
+ int fd;
+ int oflag;
+ const char * mode_save = mode;
+
+ /* Force all file handles to be non-inheritable. This is necessary to
+ ensure child processes don't unwittingly inherit handles that might
+ prevent future file access. */
+
+ if (mode[0] == 'r')
+ oflag = O_RDONLY;
+ else if (mode[0] == 'w' || mode[0] == 'a')
+ oflag = O_WRONLY | O_CREAT | O_TRUNC;
+ else
+ return NULL;
+
+ /* Only do simplistic option parsing. */
+ while (*++mode)
+ if (mode[0] == '+')
+ {
+ oflag &= ~(O_RDONLY | O_WRONLY);
+ oflag |= O_RDWR;
+ }
+ else if (mode[0] == 'b')
+ {
+ oflag &= ~O_TEXT;
+ oflag |= O_BINARY;
+ }
+ else if (mode[0] == 't')
+ {
+ oflag &= ~O_BINARY;
+ oflag |= O_TEXT;
+ }
+ else break;
+
+ fd = _open (map_win32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
+ if (fd < 0)
+ return NULL;
+
+ return fdopen (fd, mode_save);
+}
+
+int
+sys_link (const char * path1, const char * path2)
+{
+ errno = EINVAL;
+ return -1;
+}
+
+int
+sys_mkdir (const char * path)
+{
+ return _mkdir (map_win32_filename (path, NULL));
+}
+
+char *
+sys_mktemp (char * template)
+{
+ return (char *) map_win32_filename ((const char *) _mktemp (template), NULL);
+}
+
+int
+sys_open (const char * path, int oflag, int mode)
+{
+ /* Force all file handles to be non-inheritable. */
+ return _open (map_win32_filename (path, NULL), oflag | _O_NOINHERIT, mode);
+}
+
+int
+sys_rename (const char * oldname, const char * newname)
+{
+ char temp[MAX_PATH];
+
+ /* MoveFile on Win95 doesn't correctly change the short file name
+ alias when oldname has a three char extension and newname has the
+ same first three chars in its extension. To avoid problems, on
+ Win95 we rename to a temporary name first. */
+
+ strcpy (temp, map_win32_filename (oldname, NULL));
+
+ if (GetVersion () & 0x80000000)
+ {
+ char * p;
+
+ unixtodos_filename (temp);
+ if (p = strrchr (temp, '\\'))
+ p++;
+ else
+ p = temp;
+ strcpy (p, "__XXXXXX");
+ _mktemp (temp);
+ if (rename (map_win32_filename (oldname, NULL), temp) < 0)
+ return -1;
+ }
+
+ /* Emulate Unix behaviour - newname is deleted if it already exists
+ (at least if it is a file; don't do this for directories). */
+ newname = map_win32_filename (newname, NULL);
+ if (GetFileAttributes (newname) != -1)
+ {
+ _chmod (newname, 0666);
+ _unlink (newname);
+ }
+
+ return rename (temp, newname);
+}
+
+int
+sys_rmdir (const char * path)
+{
+ return _rmdir (map_win32_filename (path, NULL));
+}
+
+int
+sys_unlink (const char * path)
+{
+ return _unlink (map_win32_filename (path, NULL));
+}
+
+static FILETIME utc_base_ft;
+static long double utc_base;
+static int init = 0;
+
+static time_t
+convert_time (FILETIME ft)
+{
+ long double ret;
+
+ if (!init)
+ {
+ /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
+ SYSTEMTIME st;
+
+ st.wYear = 1970;
+ st.wMonth = 1;
+ st.wDay = 1;
+ st.wHour = 0;
+ st.wMinute = 0;
+ st.wSecond = 0;
+ st.wMilliseconds = 0;
+
+ SystemTimeToFileTime (&st, &utc_base_ft);
+ utc_base = (long double) utc_base_ft.dwHighDateTime
+ * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
+ init = 1;
+ }
+
+ if (CompareFileTime (&ft, &utc_base_ft) < 0)
+ return 0;
+
+ ret = (long double) ft.dwHighDateTime * 4096 * 1024 * 1024 + ft.dwLowDateTime;
+ ret -= utc_base;
+ return (time_t) (ret * 1e-7);
+}
+
+#if 0
+/* in case we ever have need of this */
+void
+convert_from_time_t (time_t time, FILETIME * pft)
+{
+ long double tmp;
+
+ if (!init)
+ {
+ /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
+ SYSTEMTIME st;
+
+ st.wYear = 1970;
+ st.wMonth = 1;
+ st.wDay = 1;
+ st.wHour = 0;
+ st.wMinute = 0;
+ st.wSecond = 0;
+ st.wMilliseconds = 0;
+
+ SystemTimeToFileTime (&st, &utc_base_ft);
+ utc_base = (long double) utc_base_ft.dwHighDateTime
+ * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
+ init = 1;
+ }
+
+ /* time in 100ns units since 1-Jan-1601 */
+ tmp = (long double) time * 1e7 + utc_base;
+ pft->dwHighDateTime = (DWORD) (tmp / (4096.0 * 1024 * 1024));
+ pft->dwLowDateTime = (DWORD) (tmp - pft->dwHighDateTime);
+}
+#endif
+
+/* "PJW" algorithm (see the "Dragon" compiler book). */
+static unsigned
+hashval (const char * str)
+{
+ unsigned h = 0;
+ unsigned g;
+ while (*str)
+ {
+ h = (h << 4) + *str++;
+ if ((g = h & 0xf0000000) != 0)
+ h = (h ^ (g >> 24)) & 0x0fffffff;
+ }
+ return h;
+}
+
+/* Return the hash value of the canonical pathname, excluding the
+ drive/UNC header, to get a hopefully unique inode number. */
+static _ino_t
+generate_inode_val (const char * name)
+{
+ char fullname[ MAX_PATH ];
+ char * p;
+ unsigned hash;
+
+ GetFullPathName (name, sizeof (fullname), fullname, &p);
+ get_volume_info (fullname, &p);
+ /* Normal Win32 filesystems are still case insensitive. */
+ _strlwr (p);
+ hash = hashval (p);
+ return (_ino_t) (hash ^ (hash >> 16));
+}
+
+/* MSVC stat function can't cope with UNC names and has other bugs, so
+ replace it with our own. This also allows us to calculate consistent
+ inode values without hacks in the main Emacs code. */
+int
+stat (const char * path, struct stat * buf)
+{
+ char * name;
+ WIN32_FIND_DATA wfd;
+ HANDLE fh;
+ int permission;
+ int len;
+ int rootdir = FALSE;
+
+ if (path == NULL || buf == NULL)
+ {
+ errno = EFAULT;
+ return -1;
+ }
+
+ name = (char *) map_win32_filename (path, &path);
+ /* must be valid filename, no wild cards */
+ if (strchr (name, '*') || strchr (name, '?'))
+ {
+ errno = ENOENT;
+ return -1;
+ }
+
+ /* Remove trailing directory separator, unless name is the root
+ directory of a drive or UNC volume in which case ensure there
+ is a trailing separator. */
+ len = strlen (name);
+ rootdir = (path >= name + len - 1
+ && (IS_DIRECTORY_SEP (*path) || *path == 0));
+ name = strcpy (alloca (len + 2), name);
+
+ if (rootdir)
+ {
+ if (!IS_DIRECTORY_SEP (name[len-1]))
+ strcat (name, "\\");
+ if (GetDriveType (name) < 2)
+ {
+ errno = ENOENT;
+ return -1;
+ }
+ memset (&wfd, 0, sizeof (wfd));
+ wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
+ wfd.ftCreationTime = utc_base_ft;
+ wfd.ftLastAccessTime = utc_base_ft;
+ wfd.ftLastWriteTime = utc_base_ft;
+ strcpy (wfd.cFileName, name);
+ }
+ else
+ {
+ if (IS_DIRECTORY_SEP (name[len-1]))
+ name[len - 1] = 0;
+ fh = FindFirstFile (name, &wfd);
+ if (fh == INVALID_HANDLE_VALUE)
+ {
+ errno = ENOENT;
+ return -1;
+ }
+ FindClose (fh);
+ }
+
+ if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+ {
+ buf->st_mode = _S_IFDIR;
+ buf->st_nlink = 2; /* doesn't really matter */
+ }
+ else
+ {
+#if 0
+ /* This is more accurate in terms of gettting the correct number
+ of links, but is quite slow (it is noticable when Emacs is
+ making a list of file name completions). */
+ BY_HANDLE_FILE_INFORMATION info;
+
+ fh = CreateFile (name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+ if (GetFileInformationByHandle (fh, &info))
+ {
+ switch (GetFileType (fh))
+ {
+ case FILE_TYPE_DISK:
+ buf->st_mode = _S_IFREG;
+ break;
+ case FILE_TYPE_PIPE:
+ buf->st_mode = _S_IFIFO;
+ break;
+ case FILE_TYPE_CHAR:
+ case FILE_TYPE_UNKNOWN:
+ default:
+ buf->st_mode = _S_IFCHR;
+ }
+ buf->st_nlink = info.nNumberOfLinks;
+ /* Could use file index, but this is not guaranteed to be
+ unique unless we keep a handle open all the time. */
+ /* buf->st_ino = info.nFileIndexLow ^ info.nFileIndexHigh; */
+ CloseHandle (fh);
+ }
+ else
+ {
+ errno = EACCES;
+ return -1;
+ }
+#else
+ buf->st_mode = _S_IFREG;
+ buf->st_nlink = 1;
+#endif
+ }
+
+ /* consider files to belong to current user */
+ buf->st_uid = the_passwd.pw_uid;
+ buf->st_gid = the_passwd.pw_gid;
+
+ /* volume_info is set indirectly by map_win32_filename */
+ buf->st_dev = volume_info.serialnum;
+ buf->st_rdev = volume_info.serialnum;
+
+ buf->st_ino = generate_inode_val (name);
+
+ buf->st_size = wfd.nFileSizeLow;
+
+ /* Convert timestamps to Unix format. */
+ buf->st_mtime = convert_time (wfd.ftLastWriteTime);
+ buf->st_atime = convert_time (wfd.ftLastAccessTime);
+ if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
+ buf->st_ctime = convert_time (wfd.ftCreationTime);
+ if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
+
+ /* determine rwx permissions */
+ if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
+ permission = _S_IREAD;
+ else
+ permission = _S_IREAD | _S_IWRITE;
+
+ if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+ permission |= _S_IEXEC;
+ else
+ {
+ char * p = strrchr (name, '.');
+ if (p != NULL &&
+ (stricmp (p, ".exe") == 0 ||
+ stricmp (p, ".com") == 0 ||
+ stricmp (p, ".bat") == 0 ||
+ stricmp (p, ".cmd") == 0))
+ permission |= _S_IEXEC;
+ }
+
+ buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
+
+ return 0;
+}
+
+#ifdef HAVE_SOCKETS
+
+/* Wrappers for winsock functions to map between our file descriptors
+ and winsock's handles; also set h_errno for convenience.
+
+ To allow Emacs to run on systems which don't have winsock support
+ installed, we dynamically link to winsock on startup if present, and
+ otherwise provide the minimum necessary functionality
+ (eg. gethostname). */
+
+/* function pointers for relevant socket functions */
+int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
+void (PASCAL *pfn_WSASetLastError) (int iError);
+int (PASCAL *pfn_WSAGetLastError) (void);
+int (PASCAL *pfn_socket) (int af, int type, int protocol);
+int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
+int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
+int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
+int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
+int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
+int (PASCAL *pfn_closesocket) (SOCKET s);
+int (PASCAL *pfn_shutdown) (SOCKET s, int how);
+int (PASCAL *pfn_WSACleanup) (void);
+
+u_short (PASCAL *pfn_htons) (u_short hostshort);
+u_short (PASCAL *pfn_ntohs) (u_short netshort);
+unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
+int (PASCAL *pfn_gethostname) (char * name, int namelen);
+struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
+struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
+
+static int have_winsock;
+static HANDLE winsock_lib;
+
+static void
+term_winsock (void)
+{
+ if (have_winsock)
+ {
+ pfn_WSACleanup ();
+ FreeLibrary (winsock_lib);
+ }
+}
+
+static void
+init_winsock ()
+{
+ WSADATA winsockData;
+
+ winsock_lib = LoadLibrary ("wsock32.dll");
+
+ if (winsock_lib != NULL)
+ {
+ /* dynamically link to socket functions */
+
+#define LOAD_PROC(fn) \
+ if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
+ goto fail;
+
+ LOAD_PROC( WSAStartup );
+ LOAD_PROC( WSASetLastError );
+ LOAD_PROC( WSAGetLastError );
+ LOAD_PROC( socket );
+ LOAD_PROC( bind );
+ LOAD_PROC( connect );
+ LOAD_PROC( ioctlsocket );
+ LOAD_PROC( recv );
+ LOAD_PROC( send );
+ LOAD_PROC( closesocket );
+ LOAD_PROC( shutdown );
+ LOAD_PROC( htons );
+ LOAD_PROC( ntohs );
+ LOAD_PROC( inet_addr );
+ LOAD_PROC( gethostname );
+ LOAD_PROC( gethostbyname );
+ LOAD_PROC( getservbyname );
+ LOAD_PROC( WSACleanup );
+
+ /* specify version 1.1 of winsock */
+ if (pfn_WSAStartup (0x101, &winsockData) == 0)
+ {
+ have_winsock = TRUE;
+ return;
+ }
+
+ fail:
+ FreeLibrary (winsock_lib);
+ }
+ have_winsock = FALSE;
+}
+
+
+int h_errno = 0;
+
+/* function to set h_errno for compatability; map winsock error codes to
+ normal system codes where they overlap (non-overlapping definitions
+ are already in <sys/socket.h> */
+static void set_errno ()
+{
+ if (!have_winsock)
+ h_errno = EINVAL;
+ else
+ h_errno = pfn_WSAGetLastError ();
+
+ switch (h_errno)
+ {
+ case WSAEACCES: h_errno = EACCES; break;
+ case WSAEBADF: h_errno = EBADF; break;
+ case WSAEFAULT: h_errno = EFAULT; break;
+ case WSAEINTR: h_errno = EINTR; break;
+ case WSAEINVAL: h_errno = EINVAL; break;
+ case WSAEMFILE: h_errno = EMFILE; break;
+ case WSAENAMETOOLONG: h_errno = ENAMETOOLONG; break;
+ case WSAENOTEMPTY: h_errno = ENOTEMPTY; break;
+ }
+ errno = h_errno;
+}
+
+static void check_errno ()
+{
+ if (h_errno == 0 && have_winsock)
+ pfn_WSASetLastError (0);
+}
+
+/* [andrewi 3-May-96] I've had conflicting results using both methods,
+ but I believe the method of keeping the socket handle separate (and
+ insuring it is not inheritable) is the correct one. */
+
+//#define SOCK_REPLACE_HANDLE
+
+#ifdef SOCK_REPLACE_HANDLE
+#define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
+#else
+#define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
+#endif
+
+int
+sys_socket(int af, int type, int protocol)
+{
+ int fd;
+ long s;
+ child_process * cp;
+
+ if (!have_winsock)
+ {
+ h_errno = ENETDOWN;
+ return INVALID_SOCKET;
+ }
+
+ check_errno ();
+
+ /* call the real socket function */
+ s = (long) pfn_socket (af, type, protocol);
+
+ if (s != INVALID_SOCKET)
+ {
+ /* Although under NT 3.5 _open_osfhandle will accept a socket
+ handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
+ that does not work under NT 3.1. However, we can get the same
+ effect by using a backdoor function to replace an existing
+ descriptor handle with the one we want. */
+
+ /* allocate a file descriptor (with appropriate flags) */
+ fd = _open ("NUL:", _O_RDWR);
+ if (fd >= 0)
+ {
+#ifdef SOCK_REPLACE_HANDLE
+ /* now replace handle to NUL with our socket handle */
+ CloseHandle ((HANDLE) _get_osfhandle (fd));
+ _free_osfhnd (fd);
+ _set_osfhnd (fd, s);
+ /* setmode (fd, _O_BINARY); */
+#else
+ /* Make a non-inheritable copy of the socket handle. */
+ {
+ HANDLE parent;
+ HANDLE new_s = INVALID_HANDLE_VALUE;
+
+ parent = GetCurrentProcess ();
+
+ DuplicateHandle (parent,
+ (HANDLE) s,
+ parent,
+ &new_s,
+ 0,
+ FALSE,
+ DUPLICATE_SAME_ACCESS);
+ pfn_closesocket (s);
+ fd_info[fd].hnd = new_s;
+ s = (SOCKET) new_s;
+ }
+#endif
+
+ /* set our own internal flags */
+ fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
+
+ cp = new_child ();
+ if (cp)
+ {
+ cp->fd = fd;
+ cp->status = STATUS_READ_ACKNOWLEDGED;
+
+ /* attach child_process to fd_info */
+ if (fd_info[ fd ].cp != NULL)
+ {
+ DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
+ abort ();
+ }
+
+ fd_info[ fd ].cp = cp;
+
+ /* success! */
+ return fd;
+ }
+
+ /* clean up */
+ _close (fd);
+ }
+ pfn_closesocket (s);
+ h_errno = EMFILE;
+ }
+ set_errno ();
+
+ return -1;
+}
+
+
+int
+sys_bind (int s, const struct sockaddr * addr, int namelen)
+{
+ if (!have_winsock)
+ {
+ h_errno = ENOTSOCK;
+ return SOCKET_ERROR;
+ }
+
+ check_errno ();
+ if (fd_info[s].flags & FILE_SOCKET)
+ {
+ int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
+ if (rc == SOCKET_ERROR)
+ set_errno ();
+ return rc;
+ }
+ h_errno = ENOTSOCK;
+ return SOCKET_ERROR;
+}
+
+
+int
+sys_connect (int s, const struct sockaddr * name, int namelen)
+{
+ if (!have_winsock)
+ {
+ h_errno = ENOTSOCK;
+ return SOCKET_ERROR;
+ }
+
+ check_errno ();
+ if (fd_info[s].flags & FILE_SOCKET)
+ {
+ int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
+ if (rc == SOCKET_ERROR)
+ set_errno ();
+ return rc;
+ }
+ h_errno = ENOTSOCK;
+ return SOCKET_ERROR;
+}
+
+u_short
+sys_htons (u_short hostshort)
+{
+ return (have_winsock) ?
+ pfn_htons (hostshort) : hostshort;
+}
+
+u_short
+sys_ntohs (u_short netshort)
+{
+ return (have_winsock) ?
+ pfn_ntohs (netshort) : netshort;
+}
+
+unsigned long
+sys_inet_addr (const char * cp)
+{
+ return (have_winsock) ?
+ pfn_inet_addr (cp) : INADDR_NONE;
+}
+
+int
+sys_gethostname (char * name, int namelen)
+{
+ if (have_winsock)
+ return pfn_gethostname (name, namelen);
+
+ if (namelen > MAX_COMPUTERNAME_LENGTH)
+ return !GetComputerName (name, &namelen);
+
+ h_errno = EFAULT;
+ return SOCKET_ERROR;
+}
+
+struct hostent *
+sys_gethostbyname(const char * name)
+{
+ struct hostent * host;
+
+ if (!have_winsock)
+ {
+ h_errno = ENETDOWN;
+ return NULL;
+ }
+
+ check_errno ();
+ host = pfn_gethostbyname (name);
+ if (!host)
+ set_errno ();
+ return host;
+}
+
+struct servent *
+sys_getservbyname(const char * name, const char * proto)
+{
+ struct servent * serv;
+
+ if (!have_winsock)
+ {
+ h_errno = ENETDOWN;
+ return NULL;
+ }
+
+ check_errno ();
+ serv = pfn_getservbyname (name, proto);
+ if (!serv)
+ set_errno ();
+ return serv;
+}
+
+#endif /* HAVE_SOCKETS */
+
+
+/* Shadow main io functions: we need to handle pipes and sockets more
+ intelligently, and implement non-blocking mode as well. */
+
+int
+sys_close (int fd)
+{
+ int rc;
+
+ if (fd < 0 || fd >= MAXDESC)
+ {
+ errno = EBADF;
+ return -1;
+ }
+
+ if (fd_info[fd].cp)
+ {
+ child_process * cp = fd_info[fd].cp;
+
+ fd_info[fd].cp = NULL;
+
+ if (CHILD_ACTIVE (cp))
+ {
+ /* if last descriptor to active child_process then cleanup */
+ int i;
+ for (i = 0; i < MAXDESC; i++)
+ {
+ if (i == fd)
+ continue;
+ if (fd_info[i].cp == cp)
+ break;
+ }
+ if (i == MAXDESC)
+ {
+#if defined (HAVE_SOCKETS) && !defined (SOCK_REPLACE_HANDLE)
+ if (fd_info[fd].flags & FILE_SOCKET)
+ {
+ if (!have_winsock) abort ();
+
+ pfn_shutdown (SOCK_HANDLE (fd), 2);
+ rc = pfn_closesocket (SOCK_HANDLE (fd));
+ }
+#endif
+ delete_child (cp);
+ }
+ }
+ }
+
+ /* Note that sockets do not need special treatment here (at least on
+ NT and Win95 using the standard tcp/ip stacks) - it appears that
+ closesocket is equivalent to CloseHandle, which is to be expected
+ because socket handles are fully fledged kernel handles. */
+ rc = _close (fd);
+
+ if (rc == 0)
+ fd_info[fd].flags = 0;
+
+ return rc;
+}
+
+int
+sys_dup (int fd)
+{
+ int new_fd;
+
+ new_fd = _dup (fd);
+ if (new_fd >= 0)
+ {
+ /* duplicate our internal info as well */
+ fd_info[new_fd] = fd_info[fd];
+ }
+ return new_fd;
+}
+
+
+int
+sys_dup2 (int src, int dst)
+{
+ int rc;
+
+ if (dst < 0 || dst >= MAXDESC)
+ {
+ errno = EBADF;
+ return -1;
+ }
+
+ /* make sure we close the destination first if it's a pipe or socket */
+ if (src != dst && fd_info[dst].flags != 0)
+ sys_close (dst);
+
+ rc = _dup2 (src, dst);
+ if (rc == 0)
+ {
+ /* duplicate our internal info as well */
+ fd_info[dst] = fd_info[src];
+ }
+ return rc;
+}
+
+/* From callproc.c */
+extern Lisp_Object Vbinary_process_input;
+extern Lisp_Object Vbinary_process_output;
+
+/* Unix pipe() has only one arg */
+int
+sys_pipe (int * phandles)
+{
+ int rc;
+ unsigned flags;
+ child_process * cp;
+
+ /* make pipe handles non-inheritable; when we spawn a child,
+ we replace the relevant handle with an inheritable one. */
+ rc = _pipe (phandles, 0, _O_NOINHERIT);
+
+ if (rc == 0)
+ {
+ /* set internal flags, and put read and write handles into binary
+ mode as necessary; if not in binary mode, set the MSVC internal
+ FDEV (0x40) flag to prevent _read from treating ^Z as eof (this
+ could otherwise allow Emacs to hang because it then waits
+ indefinitely for the child process to exit, when it might not be
+ finished). */
+ flags = FILE_PIPE | FILE_READ;
+ if (!NILP (Vbinary_process_output))
+ {
+ flags |= FILE_BINARY;
+ setmode (phandles[0], _O_BINARY);
+ }
+#if (_MSC_VER == 900)
+ else
+ _osfile[phandles[0]] |= 0x40;
+#endif
+
+ fd_info[phandles[0]].flags = flags;
+
+ flags = FILE_PIPE | FILE_WRITE;
+ if (!NILP (Vbinary_process_input))
+ {
+ flags |= FILE_BINARY;
+ setmode (phandles[1], _O_BINARY);
+ }
+#if (_MSC_VER == 900)
+ else
+ _osfile[phandles[1]] |= 0x40;
+#endif
+
+ fd_info[phandles[1]].flags = flags;
+ }
+
+ return rc;
+}
+
+/* From ntproc.c */
+extern Lisp_Object Vwin32_pipe_read_delay;
+
+/* Function to do blocking read of one byte, needed to implement
+ select. It is only allowed on sockets and pipes. */
+int
+_sys_read_ahead (int fd)
+{
+ child_process * cp;
+ int rc;
+
+ if (fd < 0 || fd >= MAXDESC)
+ return STATUS_READ_ERROR;
+
+ cp = fd_info[fd].cp;
+
+ if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
+ return STATUS_READ_ERROR;
+
+ if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
+ || (fd_info[fd].flags & FILE_READ) == 0)
+ {
+ DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd));
+ abort ();
+ }
+
+ cp->status = STATUS_READ_IN_PROGRESS;
+
+ if (fd_info[fd].flags & FILE_PIPE)
+ {
+ /* Use read to get CRLF translation */
+ rc = _read (fd, &cp->chr, sizeof (char));
+
+ /* Give subprocess time to buffer some more output for us before
+ reporting that input is available; we need this because Win95
+ connects DOS programs to pipes by making the pipe appear to be
+ the normal console stdout - as a result most DOS programs will
+ write to stdout without buffering, ie. one character at a
+ time. Even some Win32 programs do this - "dir" in a command
+ shell on NT is very slow if we don't do this. */
+ if (rc > 0)
+ {
+ int wait = XINT (Vwin32_pipe_read_delay);
+
+ if (wait > 0)
+ Sleep (wait);
+ else if (wait < 0)
+ while (++wait <= 0)
+ /* Yield remainder of our time slice, effectively giving a
+ temporary priority boost to the child process. */
+ Sleep (0);
+ }
+ }
+#ifdef HAVE_SOCKETS
+ else if (fd_info[fd].flags & FILE_SOCKET)
+ rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
+#endif
+
+ if (rc == sizeof (char))
+ cp->status = STATUS_READ_SUCCEEDED;
+ else
+ cp->status = STATUS_READ_FAILED;
+
+ return cp->status;
+}
+
+int
+sys_read (int fd, char * buffer, unsigned int count)
+{
+ int nchars;
+ int extra = 0;
+ int to_read;
+ DWORD waiting;
+
+ if (fd < 0 || fd >= MAXDESC)
+ {
+ errno = EBADF;
+ return -1;
+ }
+
+ if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
+ {
+ child_process *cp = fd_info[fd].cp;
+
+ if ((fd_info[fd].flags & FILE_READ) == 0)
+ {
+ errno = EBADF;
+ return -1;
+ }
+
+ /* presence of a child_process structure means we are operating in
+ non-blocking mode - otherwise we just call _read directly.
+ Note that the child_process structure might be missing because
+ reap_subprocess has been called; in this case the pipe is
+ already broken, so calling _read on it is okay. */
+ if (cp)
+ {
+ int current_status = cp->status;
+
+ switch (current_status)
+ {
+ case STATUS_READ_FAILED:
+ case STATUS_READ_ERROR:
+ /* report normal EOF */
+ return 0;
+
+ case STATUS_READ_READY:
+ case STATUS_READ_IN_PROGRESS:
+ DebPrint (("sys_read called when read is in progress\n"));
+ errno = EWOULDBLOCK;
+ return -1;
+
+ case STATUS_READ_SUCCEEDED:
+ /* consume read-ahead char */
+ *buffer++ = cp->chr;
+ count--;
+ extra = 1;
+ cp->status = STATUS_READ_ACKNOWLEDGED;
+ ResetEvent (cp->char_avail);
+
+ case STATUS_READ_ACKNOWLEDGED:
+ break;
+
+ default:
+ DebPrint (("sys_read: bad status %d\n", current_status));
+ errno = EBADF;
+ return -1;
+ }
+
+ if (fd_info[fd].flags & FILE_PIPE)
+ {
+ PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
+ to_read = min (waiting, (DWORD) count);
+
+ /* Use read to get CRLF translation */
+ nchars = _read (fd, buffer, to_read);
+ }
+#ifdef HAVE_SOCKETS
+ else /* FILE_SOCKET */
+ {
+ if (!have_winsock) abort ();
+
+ /* do the equivalent of a non-blocking read */
+ pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
+ if (waiting == 0 && extra == 0)
+ {
+ h_errno = errno = EWOULDBLOCK;
+ return -1;
+ }
+
+ nchars = 0;
+ if (waiting)
+ {
+ /* always use binary mode for sockets */
+ nchars = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
+ if (nchars == SOCKET_ERROR)
+ {
+ DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
+ pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
+ if (extra == 0)
+ {
+ set_errno ();
+ return -1;
+ }
+ nchars = 0;
+ }
+ }
+ }
+#endif
+ }
+ else
+ nchars = _read (fd, buffer, count);
+ }
+ else
+ nchars = _read (fd, buffer, count);
+
+ return nchars + extra;
+}
+
+/* For now, don't bother with a non-blocking mode */
+int
+sys_write (int fd, const void * buffer, unsigned int count)
+{
+ int nchars;
+
+ if (fd < 0 || fd >= MAXDESC)
+ {
+ errno = EBADF;
+ return -1;
+ }
+
+ if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
+ if ((fd_info[fd].flags & FILE_WRITE) == 0)
+ {
+ errno = EBADF;
+ return -1;
+ }
+#ifdef HAVE_SOCKETS
+ if (fd_info[fd].flags & FILE_SOCKET)
+ {
+ if (!have_winsock) abort ();
+ nchars = pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
+ if (nchars == SOCKET_ERROR)
+ {
+ DebPrint(("sys_read.send failed with error %d on socket %ld\n",
+ pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
+ set_errno ();
+ }
+ }
+ else
+#endif
+ nchars = _write (fd, buffer, count);
+
+ return nchars;
+}
+
+
+void
+term_ntproc ()
+{
+#ifdef HAVE_SOCKETS
+ /* shutdown the socket interface if necessary */
+ term_winsock ();
+#endif
+}
+
+extern BOOL can_run_dos_process;
+extern BOOL dos_process_running;
+
+void
+init_ntproc ()
+{
+#ifdef HAVE_SOCKETS
+ /* initialise the socket interface if available */
+ init_winsock ();
+#endif
+
+ /* Initial preparation for subprocess support: replace our standard
+ handles with non-inheritable versions. */
+ {
+ HANDLE parent;
+ HANDLE stdin_save = INVALID_HANDLE_VALUE;
+ HANDLE stdout_save = INVALID_HANDLE_VALUE;
+ HANDLE stderr_save = INVALID_HANDLE_VALUE;
+
+ parent = GetCurrentProcess ();
+
+ /* ignore errors when duplicating and closing; typically the
+ handles will be invalid when running as a gui program. */
+ DuplicateHandle (parent,
+ GetStdHandle (STD_INPUT_HANDLE),
+ parent,
+ &stdin_save,
+ 0,
+ FALSE,
+ DUPLICATE_SAME_ACCESS);
+
+ DuplicateHandle (parent,
+ GetStdHandle (STD_OUTPUT_HANDLE),
+ parent,
+ &stdout_save,
+ 0,
+ FALSE,
+ DUPLICATE_SAME_ACCESS);
+
+ DuplicateHandle (parent,
+ GetStdHandle (STD_ERROR_HANDLE),
+ parent,
+ &stderr_save,
+ 0,
+ FALSE,
+ DUPLICATE_SAME_ACCESS);
+
+ fclose (stdin);
+ fclose (stdout);
+ fclose (stderr);
+
+ if (stdin_save != INVALID_HANDLE_VALUE)
+ _open_osfhandle ((long) stdin_save, O_TEXT);
+ else
+ open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
+ fdopen (0, "r");
+
+ if (stdout_save != INVALID_HANDLE_VALUE)
+ _open_osfhandle ((long) stdout_save, O_TEXT);
+ else
+ open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
+ fdopen (1, "w");
+
+ if (stderr_save != INVALID_HANDLE_VALUE)
+ _open_osfhandle ((long) stderr_save, O_TEXT);
+ else
+ open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
+ fdopen (2, "w");
+ }
+
+ /* Only allow Emacs to run DOS programs on Win95. */
+ can_run_dos_process = (GetVersion () & 0x80000000);
+ dos_process_running = FALSE;
+
+ /* unfortunately, atexit depends on implementation of malloc */
+ /* atexit (term_ntproc); */
+ signal (SIGABRT, term_ntproc);
+}
+
+/* end of nt.c */
HCoop / bpt / emacs.git / blobdiff