import winsup-2000-02-17 snapshot

1 files changed, 1939 insertions, 0 deletions

diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
new file mode 100644
index 000000000..650f71566
--- /dev/null
+++ b/winsup/cygwin/syscalls.cc
@@ -0,0 +1,1939 @@
+/* syscalls.cc: syscalls
+
+   Copyright 1996, 1997, 1998, 1999, 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <sys/stat.h>
+#include <sys/vfs.h> /* needed for statfs */
+#include <fcntl.h>
+#include <pwd.h>
+#include <grp.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <process.h>
+#include <utmp.h>
+#include <sys/uio.h>
+#include <errno.h>
+#include <limits.h>
+#include "winsup.h"
+#include <lmcons.h> /* for UNLEN */
+#include <unistd.h>
+
+extern BOOL allow_ntsec;
+
+/* Close all files and process any queued deletions.
+   Lots of unix style applications will open a tmp file, unlink it,
+   but never call close.  This function is called by _exit to
+   ensure we don't leave any such files lying around.  */
+
+void __stdcall
+close_all_files (void)
+{
+  for (int i = 0; i < (int)dtable.size; i++)
+    if (!dtable.not_open (i))
+      _close (i);
+
+  cygwin_shared->delqueue.process_queue ();
+}
+
+extern "C"
+int
+_unlink (const char *ourname)
+{
+  int res = -1;
+
+  path_conv win32_name (ourname, SYMLINK_NOFOLLOW);
+
+  if (win32_name.error)
+    {
+      set_errno (win32_name.error);
+      goto done;
+    }
+
+  syscall_printf ("_unlink (%s)", win32_name.get_win32 ());
+
+  DWORD atts;
+  atts = win32_name.file_attributes ();
+  if (atts != 0xffffffff && atts & FILE_ATTRIBUTE_DIRECTORY)
+    {
+      syscall_printf ("unlinking a directory");
+      set_errno (EPERM);
+      goto done;
+    }
+
+  /* Windows won't check the directory mode, so we do that ourselves.  */
+  if (! writable_directory (win32_name.get_win32 ()))
+    {
+      syscall_printf ("non-writable directory");
+      goto done;
+    }
+
+  if (DeleteFileA (win32_name.get_win32 ()))
+    res = 0;
+  else
+    {
+      res = GetLastError ();
+
+      /* if access denied, chmod to be writable in case it is not
+	 and try again */
+      /* FIXME!!! Should check whether ourname is directory or file
+	 and only try again if permissions are not sufficient */
+      if (res == ERROR_ACCESS_DENIED)
+	{
+	  /* chmod ourname to be writable here */
+	  res = chmod (ourname, 0777);
+
+	  if (DeleteFileA (win32_name.get_win32 ()))
+	    {
+	      res = 0;
+	      goto done;
+	    }
+	  res = GetLastError ();
+	}
+
+      /* If we get ERROR_SHARING_VIOLATION, the file may still be open -
+	 Windows NT doesn't support deleting a file while it's open.  */
+      if (res == ERROR_SHARING_VIOLATION)
+	{
+	  cygwin_shared->delqueue.queue_file (win32_name.get_win32 ());
+	  res = 0;
+	}
+      else
+	{
+	  __seterrno ();
+	  res = -1;
+	}
+    }
+
+done:
+  syscall_printf ("%d = unlink (%s)", res, ourname);
+  return res;
+}
+
+extern "C"
+pid_t
+_getpid ()
+{
+  return myself->pid;
+}
+
+/* getppid: POSIX 4.1.1.1 */
+extern "C"
+pid_t
+getppid ()
+{
+  return myself->ppid;
+}
+
+/* setsid: POSIX 4.3.2.1 */
+extern "C"
+pid_t
+setsid (void)
+{
+  /* FIXME: for now */
+  if (myself->pgid != _getpid ())
+    {
+      myself->ctty = -1;
+      myself->sid = _getpid ();
+      myself->pgid = _getpid ();
+      syscall_printf ("sid %d, pgid %d, ctty %d", myself->sid, myself->pgid, myself->ctty);
+      return myself->sid;
+    }
+  set_errno (EPERM);
+  return -1;
+}
+
+static int
+read_handler (int fd, void *ptr, size_t len, int blocksigs)
+{
+  int res;
+  fhandler_base *fh = dtable[fd];
+
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      return -1;
+    }
+
+  if ((fh->get_flags() & (O_NONBLOCK | O_NDELAY)) && !fh->ready_for_read (fd, 0, 0))
+    {
+      syscall_printf ("nothing to read");
+      set_errno (EAGAIN);
+      return -1;
+    }
+
+  /* Check to see if this is a background read from a "tty",
+     sending a SIGTTIN, if appropriate */
+  res = fh->bg_check (SIGTTIN, blocksigs);
+  if (res > 0)
+    {
+      myself->process_state |= PID_TTYIN;
+      res = fh->read (ptr, len);
+      myself->process_state &= ~PID_TTYIN;
+    }
+  syscall_printf ("%d = read (%d<%s>, %p, %d)", res, fd, fh->get_name (), ptr, len);
+  return res;
+}
+
+extern "C" int
+_read (int fd, void *ptr, size_t len)
+{
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      return -1;
+    }
+
+  fhandler_base *fh = dtable[fd];
+
+  /* Could block, so let user know we at least got here.  */
+  syscall_printf ("read (%d, %p, %d)", fd, ptr, len);
+
+  if (!fh->is_slow () || (fh->get_flags () & (O_NONBLOCK | O_NDELAY)) ||
+      fh->get_r_no_interrupt ())
+    {
+      debug_printf ("non-interruptible read\n");
+      return read_handler (fd, ptr, len, 0);
+    }
+
+  if (fh->ready_for_read (fd, INFINITE, 0))
+    return read_handler (fd, ptr, len, 1);
+
+  set_sig_errno (EINTR);
+  syscall_printf ("%d = read (%d<%s>, %p, %d), errno %d", -1, fd, fh->get_name (),
+		  ptr, len, get_errno ());
+  MALLOC_CHECK;
+  return -1;
+}
+
+extern "C"
+int
+_write (int fd, const void *ptr, size_t len)
+{
+  int res = -1;
+
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      goto done;
+    }
+
+  /* Could block, so let user know we at least got here.  */
+  if (fd == 1 || fd == 2)
+    paranoid_printf ("write (%d, %p, %d)", fd, ptr, len);
+  else
+    syscall_printf  ("write (%d, %p, %d)", fd, ptr, len);
+
+  fhandler_base *fh;
+  fh = dtable[fd];
+
+  res = fh->bg_check (SIGTTOU, 0);
+  if (res > 0)
+    {
+      myself->process_state |= PID_TTYOU;
+      res = fh->write (ptr, len);
+      myself->process_state &= ~PID_TTYOU;
+    }
+
+done:
+  if (fd == 1 || fd == 2)
+    paranoid_printf ("%d = write (%d, %p, %d)", res, fd, ptr, len);
+  else
+    syscall_printf ("%d = write (%d, %p, %d)", res, fd, ptr, len);
+
+  MALLOC_CHECK;
+  return (ssize_t)res;
+}
+
+/*
+ * FIXME - should really move this interface into fhandler, and implement
+ * write in terms of it. There are devices in Win32 that could do this with
+ * overlapped I/O much more efficiently - we should eventually use
+ * these.
+ */
+
+extern "C"
+ssize_t
+writev (int fd, const struct iovec *iov, int iovcnt)
+{
+  int i;
+  ssize_t len, total;
+  char *base;
+
+  if (iovcnt < 1 || iovcnt > IOV_MAX)
+    {
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  /* Ensure that the sum of the iov_len values is less than
+     SSIZE_MAX (per spec), if so, we must fail with no output (per spec).
+  */
+  total = 0;
+  for (i = 0; i < iovcnt; ++i)
+    {
+    total += iov[i].iov_len;
+    if (total > SSIZE_MAX)
+      {
+      set_errno (EINVAL);
+      return -1;
+      }
+    }
+  /* Now write the data */
+  for (i = 0, total = 0; i < iovcnt; i++, iov++)
+    {
+      len = iov->iov_len;
+      base = iov->iov_base;
+      while (len > 0)
+	{
+	  register int nbytes;
+	  nbytes = write (fd, base, len);
+	  if (nbytes < 0 && total == 0)
+	    return -1;
+	  if (nbytes <= 0)
+	    return total;
+	  len -= nbytes;
+	  total += nbytes;
+	  base += nbytes;
+	}
+    }
+  return total;
+}
+
+/*
+ * FIXME - should really move this interface into fhandler, and implement
+ * read in terms of it. There are devices in Win32 that could do this with
+ * overlapped I/O much more efficiently - we should eventually use
+ * these.
+ */
+
+extern "C"
+ssize_t
+readv (int fd, const struct iovec *iov, int iovcnt)
+{
+  int i;
+  ssize_t len, total;
+  char *base;
+
+  for (i = 0, total = 0; i < iovcnt; i++, iov++)
+    {
+      len = iov->iov_len;
+      base = iov->iov_base;
+      while (len > 0)
+	{
+	  register int nbytes;
+	  nbytes = read (fd, base, len);
+	  if (nbytes < 0 && total == 0)
+	    return -1;
+	  if (nbytes <= 0)
+	    return total;
+	  len -= nbytes;
+	  total += nbytes;
+	  base += nbytes;
+	}
+    }
+  return total;
+}
+
+/* _open */
+/* newlib's fcntl.h defines _open as taking variable args so we must
+   correspond.  The third arg if it exists is: mode_t mode. */
+extern "C"
+int
+_open (const char *unix_path, int flags, ...)
+{
+  int fd;
+  int res = -1;
+  va_list ap;
+  mode_t mode = 0;
+  fhandler_base *fh;
+
+  syscall_printf ("open (%s, %p)", unix_path, flags);
+  if (!check_null_empty_path_errno(unix_path))
+    {
+      SetResourceLock(LOCK_FD_LIST,WRITE_LOCK|READ_LOCK," open ");
+
+      /* check for optional mode argument */
+      va_start (ap, flags);
+      mode = va_arg (ap, mode_t);
+      va_end (ap);
+
+      fd = dtable.find_unused_handle ();
+
+      if (fd < 0)
+	set_errno (ENMFILE);
+      else if ((fh = dtable.build_fhandler (fd, unix_path, NULL)) == NULL)
+	res = -1;		// errno already set
+      else if (!fh->open (unix_path, flags, (mode & 0777) & ~myself->umask))
+	{
+	  dtable.release (fd);
+	  res = -1;
+	}
+      else if ((res = fd) <= 2)
+	set_std_handle (res);
+      ReleaseResourceLock(LOCK_FD_LIST,WRITE_LOCK|READ_LOCK," open");
+    }
+
+  syscall_printf ("%d = open (%s, %p)", res, unix_path, flags);
+  return res;
+}
+
+extern "C"
+off_t
+_lseek (int fd, off_t pos, int dir)
+{
+  off_t res;
+
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      res = -1;
+    }
+  else
+    {
+      res = dtable[fd]->lseek (pos, dir);
+    }
+  syscall_printf ("%d = lseek (%d, %d, %d)", res, fd, pos, dir);
+
+  return res;
+}
+
+extern "C"
+int
+_close (int fd)
+{
+  int res;
+
+  syscall_printf ("close (%d)", fd);
+
+  MALLOC_CHECK;
+  if (dtable.not_open (fd))
+    {
+      debug_printf ("handle %d not open", fd);
+      set_errno (EBADF);
+      res = -1;
+    }
+  else
+    {
+      SetResourceLock(LOCK_FD_LIST,WRITE_LOCK|READ_LOCK," close");
+      res = dtable[fd]->close ();
+      dtable.release (fd);
+      ReleaseResourceLock(LOCK_FD_LIST,WRITE_LOCK|READ_LOCK," close");
+    }
+
+  syscall_printf ("%d = close (%d)", res, fd);
+  MALLOC_CHECK;
+  return res;
+}
+
+extern "C"
+int
+isatty (int fd)
+{
+  int res;
+
+  if (dtable.not_open (fd))
+    {
+      syscall_printf ("0 = isatty (%d)", fd);
+      return 0;
+    }
+
+  res = dtable[fd]->is_tty ();
+  syscall_printf ("%d = isatty (%d)", res, fd);
+  return res;
+}
+
+/* Under NT, try to make a hard link using backup API.  If that
+   fails or we are Win 95, just copy the file.
+   FIXME: We should actually be checking partition type, not OS.
+   Under NTFS, we should support hard links.  On FAT partitions,
+   we should just copy the file.
+*/
+
+extern "C"
+int
+_link (const char *a, const char *b)
+{
+  int res = -1;
+  path_conv real_a (a, SYMLINK_NOFOLLOW);
+
+  if (real_a.error)
+    {
+      set_errno (real_a.error);
+      syscall_printf ("-1 = link (%s, %s)", a, b);
+      return -1;
+    }
+
+  path_conv real_b (b, SYMLINK_NOFOLLOW);
+
+  if (real_b.error)
+    {
+      set_errno (real_b.error);
+      syscall_printf ("-1 = link (%s, %s)", a, b);
+      return -1;
+    }
+
+  /* Try to make hard link first on Windows NT */
+  if (os_being_run == winNT)
+    {
+      HANDLE hFileSource;
+
+      WIN32_STREAM_ID StreamId;
+      DWORD dwBytesWritten;
+      LPVOID lpContext;
+      DWORD cbPathLen;
+      DWORD StreamSize;
+      WCHAR wbuf[MAX_PATH];
+      char buf[MAX_PATH];
+
+      BOOL bSuccess;
+
+      hFileSource = CreateFile (
+	real_a.get_win32 (),
+	FILE_WRITE_ATTRIBUTES,
+	FILE_SHARE_READ | FILE_SHARE_WRITE /*| FILE_SHARE_DELETE*/,
+	&sec_none_nih, // sa
+	OPEN_EXISTING,
+	0,
+	NULL
+	);
+
+      if (hFileSource == INVALID_HANDLE_VALUE)
+	{
+	  syscall_printf ("cannot open source, %E");
+	  goto docopy;
+	}
+
+      lpContext = NULL;
+      cygwin_conv_to_full_win32_path (real_b.get_win32 (), buf);
+      OemToCharW (buf, wbuf);
+      cbPathLen = (strlen (buf) + 1) * sizeof (WCHAR);
+
+      StreamId.dwStreamId = BACKUP_LINK;
+      StreamId.dwStreamAttributes = 0;
+      StreamId.dwStreamNameSize = 0;
+      StreamId.Size.HighPart = 0;
+      StreamId.Size.LowPart = cbPathLen;
+
+      StreamSize = sizeof (WIN32_STREAM_ID) - sizeof (WCHAR**) +
+					    StreamId.dwStreamNameSize;
+
+      /* Write the WIN32_STREAM_ID */
+      bSuccess = BackupWrite (
+	hFileSource,
+	(LPBYTE) &StreamId,	// buffer to write
+	StreamSize,		// number of bytes to write
+	&dwBytesWritten,
+	FALSE,			// don't abort yet
+	FALSE,			// don't process security
+	&lpContext);
+
+      if (bSuccess)
+	{
+	  /* write the buffer containing the path */
+	  /* FIXME: BackupWrite sometimes traps if linkname is invalid.
+	     Need to handle. */
+	  bSuccess = BackupWrite (
+		hFileSource,
+		(LPBYTE) wbuf,	// buffer to write
+		cbPathLen,	// number of bytes to write
+		&dwBytesWritten,
+		FALSE,		// don't abort yet
+		FALSE,		// don't process security
+		&lpContext
+		);
+
+	  if (!bSuccess)
+	    syscall_printf ("cannot write linkname, %E");
+
+	  /* Free context */
+	  BackupWrite (
+	    hFileSource,
+	    NULL,		// buffer to write
+	    0,			// number of bytes to write
+	    &dwBytesWritten,
+	    TRUE,		// abort
+	    FALSE,		// don't process security
+	    &lpContext
+	    );
+	}
+      else
+	syscall_printf ("cannot write streamId, %E");
+
+      CloseHandle (hFileSource);
+
+      if (!bSuccess)
+	goto docopy;
+
+      res = 0;
+      goto done;
+    }
+docopy:
+  /* do this with a copy */
+  if (CopyFileA (real_a.get_win32 (), real_b.get_win32 (), 1))
+    res = 0;
+  else
+    __seterrno ();
+
+done:
+  syscall_printf ("%d = link (%s, %s)", res, a, b);
+  return res;
+}
+
+#if 0
+static BOOL
+rel2abssd (PSECURITY_DESCRIPTOR psd_rel, PSECURITY_DESCRIPTOR psd_abs,
+		DWORD abslen)
+{
+#ifdef _MT_SAFE
+  struct _winsup_t *r=_reent_winsup();
+  char *dacl_buf=r->_dacl_buf;
+  char *sacl_buf=r->_sacl_buf;
+  char *ownr_buf=r->_ownr_buf;
+  char *grp_buf=r->_grp_buf;
+#else
+  static char dacl_buf[1024];
+  static char sacl_buf[1024];
+  static char ownr_buf[1024];
+  static char grp_buf[1024];
+#endif
+  DWORD dacl_len = 1024;
+  DWORD sacl_len = 1024;
+  DWORD ownr_len = 1024;
+  DWORD grp_len = 1024;
+
+  BOOL res = MakeAbsoluteSD (psd_rel, psd_abs, &abslen, (PACL) dacl_buf,
+			     &dacl_len, (PACL) sacl_buf, &sacl_len,
+			     (PSID) ownr_buf, &ownr_len, (PSID) grp_buf,
+			     &grp_len);
+
+  syscall_printf ("%d = rel2abssd (...)", res);
+  return res;
+}
+#endif
+
+/* chown: POSIX 5.6.5.1 */
+/*
+ * chown() is only implemented for Windows NT.  Under other operating
+ * systems, it is only a stub that always returns zero.
+ *
+ * Note: the SetFileSecurity API in NT can only set the current
+ * user as file owner so we have to use the Backup API instead.
+ */
+extern "C"
+int
+chown (const char * name, uid_t uid, gid_t gid)
+{
+  int res;
+
+  if (os_being_run != winNT)    // real chown only works on NT
+    res = 0;			// return zero (and do nothing) under Windows 9x
+  else
+    {
+      /* we need Win32 path names because of usage of Win32 API functions */
+      path_conv win32_path (name);
+
+      if (win32_path.error)
+	{
+	  set_errno (win32_path.error);
+	  res = -1;
+	  goto done;
+	}
+
+      /* FIXME: This makes chown on a device succeed always.  Someday we'll want
+	 to actually allow chown to work properly on devices. */
+      if (win32_path.is_device ())
+	{
+	  res = 0;
+	  goto done;
+	}
+
+      DWORD attrib = 0;
+      if (win32_path.file_attributes () & FILE_ATTRIBUTE_DIRECTORY)
+        attrib |= S_IFDIR;
+      int has_acls;
+      has_acls = allow_ntsec && win32_path.has_acls ();
+      res = get_file_attribute (has_acls, win32_path.get_win32 (), (int *) &attrib);
+      if (!res)
+	res = set_file_attribute (win32_path.has_acls (),
+                                  win32_path.get_win32 (),
+				  uid, gid, attrib,
+                                  myself->logsrv);
+
+      if (res != 0 && get_errno () == ENOSYS)
+      {
+        /* fake - if not supported, pretend we're like win95
+           where it just works */
+        res = 0;
+      }
+    }
+
+done:
+  syscall_printf ("%d = chown (%s,...)", res, name);
+  return res;
+}
+
+/* umask: POSIX 5.3.3.1 */
+extern "C"
+mode_t
+umask (mode_t mask)
+{
+  mode_t oldmask;
+
+  oldmask = myself->umask;
+  myself->umask = mask & 0777;
+  return oldmask;
+}
+
+/* chmod: POSIX 5.6.4.1 */
+extern "C"
+int
+chmod (const char *path, mode_t mode)
+{
+  int res = -1;
+
+  path_conv win32_path (path);
+
+  if (win32_path.error)
+    {
+      set_errno (win32_path.error);
+      goto done;
+    }
+
+  /* FIXME: This makes chmod on a device succeed always.  Someday we'll want
+     to actually allow chmod to work properly on devices. */
+  if (win32_path.is_device ())
+    {
+      res = 0;
+      goto done;
+    }
+
+  if (win32_path.file_attributes () == (DWORD)-1)
+    __seterrno ();
+  else
+    {
+      DWORD attr = win32_path.file_attributes ();
+      /* temporary erase read only bit, to be able to set file security */
+      SetFileAttributesA (win32_path.get_win32 (),
+			  attr & ~FILE_ATTRIBUTE_READONLY);
+
+      int has_acls = allow_ntsec && win32_path.has_acls ();
+      uid_t uid = get_file_owner (has_acls, win32_path.get_win32 ());
+      if (! set_file_attribute (has_acls, win32_path.get_win32 (),
+				uid,
+				get_file_group (has_acls,
+                                                win32_path.get_win32 ()),
+				mode,
+                                myself->logsrv)
+	  && allow_ntsec)
+	res = 0;
+
+      /* if the mode we want has any write bits set, we can't
+	 be read only. */
+      if (mode & (S_IWUSR | S_IWGRP | S_IWOTH))
+	attr &= ~FILE_ATTRIBUTE_READONLY;
+      else
+	attr |= FILE_ATTRIBUTE_READONLY;
+
+      if (S_ISLNK (mode) || S_ISSOCK (mode))
+	attr |= FILE_ATTRIBUTE_SYSTEM;
+
+      if (!SetFileAttributesA (win32_path.get_win32 (), attr))
+	__seterrno ();
+      else
+	{
+	  /* Correct NTFS security attributes have higher priority */
+	  if (res == 0 || !allow_ntsec)
+	    res = 0;
+	}
+    }
+
+done:
+  syscall_printf ("%d = chmod (%s, %p)", res, path, mode);
+  return res;
+}
+
+/* fchmod: P96 5.6.4.1 */
+
+extern "C"
+int
+fchmod (int fd, mode_t mode)
+{
+  if (dtable.not_open (fd))
+    {
+      syscall_printf ("-1 = fchmod (%d, 0%o)", fd, mode);
+      set_errno (EBADF);
+      return -1;
+    }
+
+  const char *path = dtable[fd]->get_name ();
+
+  if (path == NULL)
+    {
+      syscall_printf ("-1 = fchmod (%d, 0%o) (no name)", fd, mode);
+      set_errno (ENOSYS);
+      return -1;
+    }
+
+  syscall_printf ("fchmod (%d, 0%o): calling chmod (%s, 0%o)",
+		  fd, mode, path, mode);
+  return chmod (path, mode);
+}
+
+/* Cygwin internal */
+static int
+num_entries (const char *win32_name)
+{
+  WIN32_FIND_DATA buf;
+  HANDLE handle;
+  char buf1[MAX_PATH];
+  int count = 0;
+
+  strcpy (buf1, win32_name);
+  int len = strlen (buf1);
+  if (len == 0 || isdirsep (buf1[len - 1]))
+    strcat (buf1, "*");
+  else
+    strcat (buf1, "/*");	/* */
+
+  handle = FindFirstFileA (buf1, &buf);
+
+  if (handle == INVALID_HANDLE_VALUE)
+    return 0;
+  count ++;
+  while (FindNextFileA (handle, &buf))
+    {
+      if ((buf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+	count ++;
+    }
+  FindClose (handle);
+  return count;
+}
+
+extern "C"
+int
+_fstat (int fd, struct stat *buf)
+{
+  int r;
+
+  if (dtable.not_open (fd))
+    {
+      syscall_printf ("-1 = fstat (%d, %p)", fd, buf);
+      set_errno (EBADF);
+      r = -1;
+    }
+  else
+    {
+      memset (buf, 0, sizeof (struct stat));
+      r = dtable[fd]->fstat (buf);
+      syscall_printf ("%d = fstat (%d, %x)", r,fd,buf);
+    }
+
+  return r;
+}
+
+/* fsync: P96 6.6.1.1 */
+extern "C"
+int
+fsync (int fd)
+{
+  if (dtable.not_open (fd))
+    {
+      syscall_printf ("-1 = fsync (%d)", fd);
+      set_errno (EBADF);
+      return -1;
+    }
+
+  HANDLE h = dtable[fd]->get_handle ();
+
+  if (FlushFileBuffers (h) == 0)
+    {
+      __seterrno ();
+      return -1;
+    }
+  return 0;
+}
+
+/* sync: standards? */
+extern "C"
+int
+sync ()
+{
+  return 0;
+}
+
+int __stdcall
+stat_dev (DWORD devn, int unit, unsigned long ino, struct stat *buf)
+{
+  switch (devn)
+    {
+    case FH_CONOUT:
+    case FH_PIPEW:
+      buf->st_mode = STD_WBITS;
+      break;
+    case FH_CONIN:
+    case FH_PIPER:
+      buf->st_mode = STD_RBITS;
+      break;
+    default:
+      buf->st_mode = STD_RBITS | S_IWUSR | S_IWGRP | S_IWOTH;
+      break;
+    }
+
+  buf->st_mode |= S_IFCHR;
+  buf->st_blksize = S_BLKSIZE;
+  buf->st_nlink = 1;
+  buf->st_dev = buf->st_rdev = FHDEVN (devn) << 8 | (unit & 0xff);
+  buf->st_ino = ino;
+  buf->st_atime = buf->st_mtime = buf->st_ctime = time (NULL);
+  return 0;
+}
+
+/* Cygwin internal */
+static int
+stat_worker (const char *caller, const char *name, struct stat *buf,
+	      int nofollow)
+{
+  int res = -1;
+  int atts;
+  char *win32_name;
+  char drive[4] = "X:\\";
+  MALLOC_CHECK;
+
+  debug_printf ("%s (%s, %p)", caller, name, buf);
+
+  path_conv real_path (name, nofollow ? SYMLINK_NOFOLLOW : SYMLINK_FOLLOW, 1);
+  if (real_path.error)
+    {
+      set_errno (real_path.error);
+      goto done;
+    }
+
+  memset (buf, 0, sizeof (struct stat));
+
+  win32_name = real_path.get_win32 ();
+  if (real_path.is_device ())
+    return stat_dev (real_path.get_devn (), real_path.get_unitn (),
+		     hash_path_name (0, win32_name), buf);
+
+  atts = real_path.file_attributes ();
+
+/* FIXME: this is of dubious merit and is fundamentally flawed.
+   E.g., what if the .exe file is a symlink?  This is not accounted
+   for here.  Also, what about all of the other special extensions?
+
+   This could be "fixed" by passing the appropriate extension list
+   to path_conv but I'm not sure that this is really justified.  */
+
+  /* If we can't find the name, try again with a .exe suffix
+     [but only if not already present].  */
+  if (atts == -1 && GetLastError () == ERROR_FILE_NOT_FOUND &&
+      !(strrchr (win32_name, '.') > strrchr (win32_name, '\\')))
+    {
+      debug_printf ("trying with .exe suffix");
+      strcat (win32_name, ".exe");
+      atts = (int) GetFileAttributesA (win32_name);
+      if (atts == -1)
+	strchr (win32_name, '\0')[4] = '\0';
+    }
+
+  debug_printf ("%d = GetFileAttributesA (%s)", atts, win32_name);
+
+  drive[0] = win32_name[0];
+  UINT dtype;
+
+  if (atts == -1 || !(atts & FILE_ATTRIBUTE_DIRECTORY) ||
+      (os_being_run == winNT
+       && (((dtype = GetDriveType (drive)) != DRIVE_NO_ROOT_DIR
+	     //&& dtype != DRIVE_REMOTE
+	     && dtype != DRIVE_UNKNOWN))))
+    {
+      fhandler_disk_file fh (NULL);
+
+      if (fh.open (real_path, O_RDONLY | O_BINARY | O_DIROPEN |
+			      (nofollow ? O_NOSYMLINK : 0), 0))
+	{
+	  res = fh.fstat (buf);
+	  fh.close ();
+	  if (atts != -1 && (atts & FILE_ATTRIBUTE_DIRECTORY))
+	    buf->st_nlink = num_entries (win32_name);
+	}
+    }
+  else
+    {
+      WIN32_FIND_DATA wfd;
+      HANDLE handle;
+      /* hmm, the number of links to a directory includes the
+	 number of entries in the directory, since all the things
+	 in the directory point to it */
+      buf->st_nlink += num_entries (win32_name);
+      buf->st_dev = FHDEVN(FH_DISK) << 8;
+      buf->st_ino = hash_path_name (0, real_path.get_win32 ());
+      buf->st_mode = S_IFDIR | STD_RBITS | STD_XBITS;
+      if ((atts & FILE_ATTRIBUTE_READONLY) == 0)
+	buf->st_mode |= STD_WBITS;
+
+      int has_acls = allow_ntsec && real_path.has_acls ();
+
+      buf->st_uid = get_file_owner (has_acls, real_path.get_win32 ());
+      buf->st_gid = get_file_group (has_acls, real_path.get_win32 ());
+
+      if ((handle = FindFirstFile (real_path.get_win32(), &wfd)) != INVALID_HANDLE_VALUE)
+	{
+	  buf->st_atime   = to_time_t (&wfd.ftLastAccessTime);
+	  buf->st_mtime   = to_time_t (&wfd.ftLastWriteTime);
+	  buf->st_ctime   = to_time_t (&wfd.ftCreationTime);
+	  buf->st_size    = wfd.nFileSizeLow;
+	  buf->st_blksize = S_BLKSIZE;
+	  buf->st_blocks  = (buf->st_size + S_BLKSIZE-1) / S_BLKSIZE;
+	  FindClose (handle);
+	}
+      res = 0;
+    }
+
+ done:
+  MALLOC_CHECK;
+  syscall_printf ("%d = %s (%s, %p)", res, caller, name, buf);
+  return res;
+}
+
+extern "C"
+int
+_stat (const char *name, struct stat *buf)
+{
+  return stat_worker ("stat", name, buf, 0);
+}
+
+/* lstat: Provided by SVR4 and 4.3+BSD, POSIX? */
+extern "C"
+int
+lstat (const char *name, struct stat *buf)
+{
+  return stat_worker ("lstat", name, buf, 1);
+}
+
+extern int acl_access (const char *, int);
+
+extern "C"
+int
+access (const char *fn, int flags)
+{
+  // flags were incorrectly specified
+  if (flags & ~(F_OK|R_OK|W_OK|X_OK))
+    {
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  if (allow_ntsec)
+    return acl_access (fn, flags);
+
+  struct stat st;
+  int r = stat (fn, &st);
+  if (r)
+    return -1;
+  r = -1;
+  if (flags & R_OK)
+    {
+      if (st.st_uid == myself->uid)
+        {
+          if (!(st.st_mode & S_IRUSR))
+            goto done;
+        }
+      else if (st.st_gid == myself->gid)
+        {
+          if (!(st.st_mode & S_IRGRP))
+            goto done;
+        }
+      else if (!(st.st_mode & S_IROTH))
+        goto done;
+    }
+  if (flags & W_OK)
+    {
+      if (st.st_uid == myself->uid)
+        {
+          if (!(st.st_mode & S_IWUSR))
+            goto done;
+        }
+      else if (st.st_gid == myself->gid)
+        {
+          if (!(st.st_mode & S_IWGRP))
+            goto done;
+        }
+      else if (!(st.st_mode & S_IWOTH))
+        goto done;
+    }
+  if (flags & X_OK)
+    {
+      if (st.st_uid == myself->uid)
+        {
+          if (!(st.st_mode & S_IXUSR))
+            goto done;
+        }
+      else if (st.st_gid == myself->gid)
+        {
+          if (!(st.st_mode & S_IXGRP))
+            goto done;
+        }
+      else if (!(st.st_mode & S_IXOTH))
+        goto done;
+    }
+  r = 0;
+done:
+  if (r)
+    set_errno (EACCES);
+  return r;
+}
+
+extern "C"
+int
+_rename (const char *oldpath, const char *newpath)
+{
+  int res = 0;
+
+  path_conv real_old (oldpath, SYMLINK_NOFOLLOW);
+
+  if (real_old.error)
+    {
+      set_errno (real_old.error);
+      syscall_printf ("-1 = rename (%s, %s)", oldpath, newpath);
+      return -1;
+    }
+
+  path_conv real_new (newpath, SYMLINK_NOFOLLOW);
+
+  if (real_new.error)
+    {
+      set_errno (real_new.error);
+      syscall_printf ("-1 = rename (%s, %s)", oldpath, newpath);
+      return -1;
+    }
+
+  if (! writable_directory (real_old.get_win32 ())
+      || ! writable_directory (real_new.get_win32 ()))
+    {
+      syscall_printf ("-1 = rename (%s, %s)", oldpath, newpath);
+      return -1;
+    }
+
+  int oldatts = GetFileAttributesA (real_old.get_win32 ());
+  int newatts = GetFileAttributesA (real_new.get_win32 ());
+
+  if (oldatts == -1) /* file to move doesn't exist */
+    {
+       syscall_printf ("file to move doesn't exist");
+       return (-1);
+    }
+
+  if (newatts != -1 && newatts & FILE_ATTRIBUTE_READONLY)
+    {
+      /* Destination file exists and is read only, change that or else
+	 the rename won't work. */
+      SetFileAttributesA (real_new.get_win32 (), newatts & ~ FILE_ATTRIBUTE_READONLY);
+    }
+
+  /* First make sure we have the permissions */
+  if (!MoveFileEx (real_old.get_win32 (), real_new.get_win32 (), MOVEFILE_REPLACE_EXISTING))
+    {
+      res = -1;
+
+      /* !!! fixme, check for windows version before trying this.. */
+      if (GetLastError () == ERROR_CALL_NOT_IMPLEMENTED)
+	{
+	  /* How sad, we must be on win95, try it the stupid way */
+	  syscall_printf ("try win95 hack");
+	  for (;;)
+	    {
+	      if (MoveFile (real_old.get_win32 (), real_new.get_win32 ()))
+		{
+		  res = 0;
+		  break;
+		}
+
+	      if (GetLastError () != ERROR_ALREADY_EXISTS)
+		{
+		  syscall_printf ("%s already_exists", real_new.get_win32 ());
+		  break;
+		}
+
+	      if (!DeleteFileA (real_new.get_win32 ()) &&
+		  GetLastError () != ERROR_FILE_NOT_FOUND)
+		{
+		  syscall_printf ("deleting %s to be paranoid",
+				  real_new.get_win32 ());
+		  break;
+		}
+	    }
+	}
+      if (res)
+	__seterrno ();
+    }
+
+  if (res == 0)
+    {
+      /* make the new file have the permissions of the old one */
+      SetFileAttributesA (real_new.get_win32 (), oldatts);
+    }
+
+  syscall_printf ("%d = rename (%s, %s)", res, real_old.get_win32 (),
+		  real_new.get_win32 ());
+
+  return res;
+}
+
+extern "C"
+int
+system (const char *cmdstring)
+{
+  int res;
+  const char* command[4];
+  _sig_func_ptr oldint, oldquit;
+  sigset_t child_block, old_mask;
+
+  if (cmdstring == (const char *) NULL)
+	return 1;
+
+  oldint = signal (SIGINT, SIG_IGN);
+  oldquit = signal (SIGQUIT, SIG_IGN);
+  sigemptyset (&child_block);
+  sigaddset (&child_block, SIGCHLD);
+  (void) sigprocmask (SIG_BLOCK, &child_block, &old_mask);
+
+  command[0] = "sh";
+  command[1] = "-c";
+  command[2] = cmdstring;
+  command[3] = (const char *) NULL;
+
+  if ((res = spawnvp (_P_WAIT, "sh", command)) == -1)
+    {
+      // when exec fails, return value should be as if shell
+      // executed exit (127)
+      res = 127;
+    }
+
+  signal (SIGINT, oldint);
+  signal (SIGQUIT, oldquit);
+  (void) sigprocmask (SIG_SETMASK, &old_mask, 0);
+  return res;
+}
+
+extern "C"
+void
+setdtablesize (int size)
+{
+  if (size > (int)dtable.size)
+    dtable.extend (size);
+}
+
+extern "C"
+int
+getdtablesize ()
+{
+  return dtable.size;
+}
+
+extern "C"
+size_t
+getpagesize ()
+{
+  return sysconf (_SC_PAGESIZE);
+}
+
+/* FIXME: not all values are correct... */
+extern "C"
+long int
+fpathconf (int fd, int v)
+{
+  switch (v)
+    {
+    case _PC_LINK_MAX:
+      return _POSIX_LINK_MAX;
+    case _PC_MAX_CANON:
+    case _PC_MAX_INPUT:
+      if (isatty (fd))
+	return _POSIX_MAX_CANON;
+      else
+	{
+	  set_errno (EBADF);
+	  return -1;
+	}
+    case _PC_NAME_MAX:
+    case _PC_PATH_MAX:
+      return PATH_MAX;
+    case _PC_PIPE_BUF:
+      return 4096;
+    case _PC_CHOWN_RESTRICTED:
+    case _PC_NO_TRUNC:
+      return -1;
+    case _PC_VDISABLE:
+      if (isatty (fd))
+	return -1;
+      else
+	{
+	  set_errno (EBADF);
+	  return -1;
+	}
+    default:
+      set_errno (EINVAL);
+      return -1;
+    }
+}
+
+extern "C"
+long int
+pathconf (const char *file, int v)
+{
+  switch (v)
+    {
+    case _PC_PATH_MAX:
+      return PATH_MAX - strlen (file);
+    case _PC_NAME_MAX:
+      return PATH_MAX;
+    case _PC_LINK_MAX:
+      return _POSIX_LINK_MAX;
+    case _PC_MAX_CANON:
+    case _PC_MAX_INPUT:
+	return _POSIX_MAX_CANON;
+    case _PC_PIPE_BUF:
+      return 4096;
+    case _PC_CHOWN_RESTRICTED:
+    case _PC_NO_TRUNC:
+      return -1;
+    case _PC_VDISABLE:
+	return -1;
+    default:
+      set_errno (EINVAL);
+      return -1;
+    }
+}
+
+extern "C"
+char *
+ctermid (char *str)
+{
+  static NO_COPY char buf[16];
+  if (str == NULL)
+    str = buf;
+  if (!tty_attached (myself))
+    strcpy (str, "/dev/conin");
+  else
+    __small_sprintf (str, "/dev/tty%d", myself->ctty);
+  return str;
+}
+
+extern "C"
+char *
+ttyname (int fd)
+{
+  if (dtable.not_open (fd) || !dtable[fd]->is_tty ())
+    {
+      return 0;
+    }
+  return (char *)(dtable[fd]->ttyname ());
+}
+
+/* Set a file descriptor into text or binary mode, returning the
+   previous mode.  */
+
+extern "C"
+int
+setmode (int fd, int mode)
+{
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      return -1;
+    }
+  if (mode != O_BINARY  && mode != O_TEXT)
+    {
+      set_errno (EINVAL);
+      return -1;
+    }
+
+  fhandler_base *p = dtable[fd];
+
+  /* Note that we have no way to indicate the case that writes are
+     binary but not reads, or vice-versa.  These cases can arise when
+     using the tty or console interface.  People using those
+     interfaces should not use setmode.  */
+
+  int res;
+  if (p->get_w_binary () && p->get_r_binary ())
+    res = O_BINARY;
+  else
+    res = O_TEXT;
+
+  if (mode & O_BINARY)
+    {
+      p->set_w_binary (1);
+      p->set_r_binary (1);
+    }
+  else
+    {
+      p->set_w_binary (0);
+      p->set_r_binary (0);
+    }
+
+  return res;
+}
+
+/* ftruncate: P96 5.6.7.1 */
+extern "C"
+int
+ftruncate (int fd, off_t length)
+{
+  int res = -1;
+
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+    }
+  else
+    {
+      HANDLE h = dtable[fd]->get_handle ();
+      off_t prev_loc;
+
+      if (h)
+	{
+	  /* remember curr file pointer location */
+	  prev_loc = dtable[fd]->lseek (0, SEEK_CUR);
+
+	  dtable[fd]->lseek (length, SEEK_SET);
+	  if (!SetEndOfFile (h))
+	    {
+	      __seterrno ();
+	    }
+	  else
+	    res = 0;
+
+	  /* restore original file pointer location */
+	  dtable[fd]->lseek (prev_loc, 0);
+	}
+    }
+  syscall_printf ("%d = ftruncate (%d, %d)", res, fd, length);
+
+  return res;
+}
+
+/* truncate: Provided by SVR4 and 4.3+BSD.  Not part of POSIX.1 or XPG3 */
+/* FIXME: untested */
+extern "C"
+int
+truncate (const char *pathname, off_t length)
+{
+  int fd;
+  int res = -1;
+
+  fd = open (pathname, O_RDWR);
+
+  if (fd == -1)
+    {
+      set_errno (EBADF);
+    }
+  else
+    {
+      res = ftruncate (fd, length);
+      close (fd);
+    }
+  syscall_printf ("%d = truncate (%s, %d)", res, pathname, length);
+
+  return res;
+}
+
+extern "C"
+long
+get_osfhandle (int fd)
+{
+  long res = -1;
+
+  if (dtable.not_open (fd))
+    {
+      set_errno ( EBADF);
+    }
+  else
+    {
+      res = (long) dtable[fd]->get_handle ();
+    }
+  syscall_printf ("%d = get_osfhandle(%d)", res, fd);
+
+  return res;
+}
+
+extern "C"
+int
+statfs (const char *fname, struct statfs *sfs)
+{
+  char full_path[MAX_PATH];
+
+  if (!sfs)
+    {
+      set_errno (EFAULT);
+      return -1;
+    }
+  cygwin_conv_to_full_win32_path (fname, full_path);
+
+  char *root = rootdir (full_path);
+
+  syscall_printf ("statfs %s", root);
+
+  DWORD spc, bps, freec, totalc;
+
+  if (!GetDiskFreeSpace (root, &spc, &bps, &freec, &totalc))
+    {
+      __seterrno ();
+      return -1;
+    }
+
+  DWORD vsn, maxlen, flags;
+
+  if (!GetVolumeInformation (root, NULL, 0, &vsn, &maxlen, &flags, NULL, 0))
+    {
+      __seterrno ();
+      return -1;
+    }
+  sfs->f_type = flags;
+  sfs->f_bsize = spc*bps;
+  sfs->f_blocks = totalc;
+  sfs->f_bfree = sfs->f_bavail = freec;
+  sfs->f_files = -1;
+  sfs->f_ffree = -1;
+  sfs->f_fsid = vsn;
+  sfs->f_namelen = maxlen;
+  return 0;
+}
+
+extern "C"
+int
+fstatfs (int fd, struct statfs *sfs)
+{
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      return -1;
+    }
+  fhandler_disk_file *f = (fhandler_disk_file *) dtable[fd];
+  return statfs (f->get_name (), sfs);
+}
+
+/* setpgid: POSIX 4.3.3.1 */
+extern "C"
+int
+setpgid (pid_t pid, pid_t pgid)
+{
+  int res = -1;
+  if (pid == 0)
+    pid = getpid ();
+  if (pgid == 0)
+    pgid = pid;
+
+  if (pgid < 0)
+    {
+      set_errno (EINVAL);
+      goto out;
+    }
+  pinfo *p;
+  p = procinfo (pid);
+  if (p == NULL)
+    {
+      set_errno (ESRCH);
+      goto out;
+    }
+  /* A process may only change the process group of itself and its children */
+  if (p == myself || p->ppid == myself->pid)
+    {
+      p->pgid = pgid;
+      res = 0;
+    }
+  else
+    {
+      set_errno (EPERM);
+      goto out;
+    }
+out:
+  syscall_printf ("pid %d, pgid %d, res %d", pid, pgid, res);
+  return res;
+}
+
+extern "C"
+pid_t
+getpgid (pid_t pid)
+{
+  if (pid == 0)
+    pid = getpid ();
+
+  pinfo *p = procinfo (pid);
+  if (p == 0)
+    {
+      set_errno (ESRCH);
+      return -1;
+    }
+  return p->pgid;
+}
+
+extern "C"
+int
+setpgrp (void)
+{
+  return setpgid (0, 0);
+}
+
+extern "C"
+pid_t
+getpgrp (void)
+{
+  return getpgid (0);
+}
+
+extern "C"
+char *
+ptsname (int fd)
+{
+  if (dtable.not_open (fd))
+    {
+      set_errno (EBADF);
+      return 0;
+    }
+  return (char *)(dtable[fd]->ptsname ());
+}
+
+/* FIXME: what is this? */
+extern "C"
+int
+regfree ()
+{
+  return 0;
+}
+
+/* mknod was the call to create directories before the introduction
+   of mkdir in 4.2BSD and SVR3.  Use of mknod required superuser privs
+   so the mkdir command had to be setuid root.
+   Although mknod hasn't been implemented yet, some GNU tools (e.g. the
+   fileutils) assume its existence so we must provide a stub that always
+   fails. */
+extern "C"
+int
+mknod ()
+{
+  set_errno (ENOSYS);
+  return -1;
+}
+
+/* setgid: POSIX 4.2.2.1 */
+/* FIXME: unimplemented! */
+extern "C"
+int
+setgid (gid_t a)
+{
+  set_errno (ENOSYS);
+  return 0;
+}
+
+/* setuid: POSIX 4.2.2.1 */
+/* FIXME: unimplemented! */
+extern "C"
+int
+setuid (uid_t b)
+{
+  set_errno (ENOSYS);
+  return 0;
+}
+
+/* seteuid: standards? */
+extern "C"
+int
+seteuid (uid_t c)
+{
+  set_errno (ENOSYS);
+  return 0;
+}
+
+/* setegid: from System V.  */
+extern "C"
+int
+setegid (gid_t a)
+{
+  set_errno (ENOSYS);
+  return 0;
+}
+
+/* chroot: privileged Unix system call.  */
+extern "C"
+int
+chroot (const char *path)
+{
+  set_errno (ENOSYS);
+  return -1;
+}
+
+extern "C"
+int
+creat (const char *path, mode_t mode)
+{
+  return open (path, O_WRONLY | O_CREAT | O_TRUNC, mode);
+}
+
+extern "C"
+void
+__assertfail ()
+{
+  exit (99);
+}
+
+extern "C"
+int
+getw (FILE *fp)
+{
+  int w, ret;
+  ret = fread (&w, sizeof (int), 1, fp);
+  return ret != 1 ? EOF : w;
+}
+
+extern "C"
+int
+putw (int w, FILE *fp)
+{
+  int ret;
+  ret = fwrite (&w, sizeof (int), 1, fp);
+  if (feof (fp) || ferror (fp))
+    return -1;
+  return 0;
+}
+
+extern "C"
+int
+wcscmp (wchar_t *s1, wchar_t *s2)
+{
+  while (*s1  && *s1 == *s2)
+    {
+      s1++;
+      s2++;
+    }
+
+  return (*(unsigned short *) s1) - (*(unsigned short *) s2);
+}
+
+extern "C"
+int
+wcslen (wchar_t *s1)
+{
+  int l = 0;
+  while (s1[l])
+    l++;
+  return l;
+}
+
+/* FIXME: to do this right, maybe work out the usoft va_list machine
+   and use wsvprintfW instead?
+*/
+extern "C"
+int
+wprintf (const char *fmt, ...)
+{
+  va_list ap;
+  int ret;
+
+  va_start (ap, fmt);
+  ret = vprintf (fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+extern "C"
+int
+vhangup ()
+{
+  set_errno (ENOSYS);
+  return -1;
+}
+
+extern "C"
+_PTR
+memccpy (_PTR out, const _PTR in, int c, size_t len)
+{
+  const char *inc = (char *) in;
+  char *outc = (char *) out;
+
+  while (len)
+    {
+      char x = *inc++;
+      *outc++ = x;
+      if (x == c)
+	return outc;
+      len --;
+    }
+  return 0;
+}
+
+extern "C"
+int
+nice (int incr)
+{
+  DWORD priority[] =
+    {
+      IDLE_PRIORITY_CLASS,
+      IDLE_PRIORITY_CLASS,
+      NORMAL_PRIORITY_CLASS,
+      HIGH_PRIORITY_CLASS,
+      REALTIME_PRIORITY_CLASS,
+      REALTIME_PRIORITY_CLASS
+    };
+  int curr = 2;
+
+  switch (GetPriorityClass (hMainProc))
+    {
+      case IDLE_PRIORITY_CLASS:
+	curr = 1;
+	break;
+      case NORMAL_PRIORITY_CLASS:
+	curr = 2;
+	break;
+      case HIGH_PRIORITY_CLASS:
+	curr = 3;
+	break;
+      case REALTIME_PRIORITY_CLASS:
+	curr = 4;
+	break;
+    }
+  if (incr > 0)
+    incr = -1;
+  else if (incr < 0)
+    incr = 1;
+
+  if (SetPriorityClass (hMainProc, priority[curr + incr]) == FALSE)
+    {
+      __seterrno ();
+      return -1;
+    }
+
+  return 0;
+}
+
+/*
+ * Find the first bit set in I.
+ */
+
+extern "C"
+int
+ffs (int i)
+{
+  static const unsigned char table[] =
+    {
+      0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+      7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+      8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+      8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+      8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+      8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
+    };
+  unsigned long int a;
+  unsigned long int x = i & -i;
+
+  a = x <= 0xffff ? (x <= 0xff ? 0 : 8) : (x <= 0xffffff ?  16 : 24);
+
+  return table[x >> a] + a;
+}
+
+extern "C"
+void
+swab (const void *src, void *dst, ssize_t n)
+{
+  const char *from = (const char *) src;
+  char *to = (char *) dst;
+
+  while (n > 1)
+    {
+      const char b0 = from[--n], b1 = from[--n];
+      to[n] = b0;
+      to[n + 1] = b1;
+    }
+}
+
+extern "C"
+void
+login (struct utmp *ut)
+{
+  register int fd;
+  int currtty = ttyslot ();
+
+  if (currtty >= 0 && (fd = open (_PATH_UTMP, O_WRONLY | O_CREAT | O_BINARY,
+					 0644)) >= 0)
+    {
+      (void) lseek (fd, (long) (currtty * sizeof (struct utmp)), SEEK_SET);
+      (void) write (fd, (char *) ut, sizeof (struct utmp));
+      (void) close (fd);
+    }
+  if ((fd = open (_PATH_WTMP, O_WRONLY | O_APPEND | O_BINARY, 0)) >= 0)
+    {
+      (void) write (fd, (char *) ut, sizeof (struct utmp));
+      (void) close (fd);
+    }
+}
+
+/* It isn't possible to use unix-style I/O function in logout code because
+cygwin's I/O subsystem may be inaccessible at logout() call time.
+*/
+extern "C"
+int
+logout (char *line)
+{
+  int res = 0;
+  HANDLE ut_fd;
+  static const char path_utmp[] = _PATH_UTMP;
+
+  path_conv win32_path (path_utmp);
+  if (win32_path.error)
+    return 0;
+
+  ut_fd = CreateFile (win32_path.get_win32 (),
+			GENERIC_READ | GENERIC_WRITE,
+			FILE_SHARE_READ | FILE_SHARE_WRITE,
+			&sec_none_nih,
+			OPEN_EXISTING,
+			FILE_ATTRIBUTE_NORMAL,
+			NULL);
+  if (ut_fd != INVALID_HANDLE_VALUE)
+    {
+      struct utmp *ut;
+      struct utmp ut_buf[100];
+      off_t pos = 0;		/* Position in file */
+      DWORD rd;
+
+      while (!res && ReadFile (ut_fd, ut_buf, sizeof ut_buf, &rd, NULL)
+	     && rd != 0)
+	{
+	  struct utmp *ut_end = (struct utmp *) ((char *) ut_buf + rd);
+
+	  for (ut = ut_buf; ut < ut_end; ut++, pos += sizeof (*ut))
+	    if (ut->ut_name[0]
+		&& strncmp (ut->ut_line, line, sizeof (ut->ut_line)) == 0)
+	      /* Found the entry for LINE; mark it as logged out.  */
+	      {
+		/* Zero out entries describing who's logged in.  */
+		bzero (ut->ut_name, sizeof (ut->ut_name));
+		bzero (ut->ut_host, sizeof (ut->ut_host));
+		time (&ut->ut_time);
+
+		/* Now seek back to the position in utmp at which UT occured,
+		   and write the new version of UT there.  */
+		if ((SetFilePointer (ut_fd, pos, 0, FILE_BEGIN) != 0xFFFFFFFF)
+		    && (WriteFile (ut_fd, (char *) ut, sizeof (*ut),
+				   &rd, NULL)))
+		  {
+		    res = 1;
+		    break;
+		  }
+	      }
+	}
+
+      CloseHandle (ut_fd);
+    }
+
+  return res;
+}