Formerly io.c.~3~

1 files changed, 252 insertions, 128 deletions

diff --git a/pflocal/io.c b/pflocal/io.c
index 278f6e30..9dbdecce 100644
--- a/pflocal/io.c
+++ b/pflocal/io.c
@@ -28,32 +28,47 @@ S_io_read (struct sock_user *user,
 	   char **data, mach_msg_type_number_t *data_len,
 	   off_t offset, mach_msg_type_number_t amount)
 {
-  error_t err = 0;
-  unsigned readable;
+  error_t err;
   struct pipe *pipe;
 
   if (!user)
     return EOPNOTSUPP;
 
-  pipe = sock_aquire_read_pipe (user->sock);
-  if (pipe == NULL)
-    return EBADF;
-  
-  while ((readable = pipe_readable (pipe)) == 0 && pipe->writer)
+  err = sock_aquire_read_pipe (user->sock, &pipe);
+  if (!err && pipe)
     {
-      unsigned seq_num = pipe->interrupt_seq_num;
-      condition_wait (&pipe->pending_reads, &pipe->lock);
-      if (seq_num != pipe->interrupt_seq_num)
-	{
-	  pipe_release (pipe);
-	  return EINTR;
-	}
+      err =
+	pipe_read (pipe, sock->flags & SOCK_NONBLOCK, data, data_len, amount);
+      pipe_release (pipe);
     }
+  else
+    /* Return EOF [harmless if there's an error].  */
+    *data_len = 0;
 
-  if (readable)
-    err = pipe_read (pipe, data, data_len, amount);
-  if (readable && !err)
-    timestamp (&pipe->read_time);
+  return err;
+}
+
+/* Write data to an IO object.  If offset is -1, write at the object
+   maintained file pointer.  If the object is not seekable, offset is
+   ignored.  The amount successfully written is returned in amount.  A
+   given user should not have more than one outstanding io_write on an
+   object at a time; servers implement congestion control by delaying
+   responses to io_write.  Servers may drop data (returning ENOBUFS)
+   if they recevie more than one write when not prepared for it.  */
+error_t
+S_io_write (struct sock_user *user,
+	    char *data, mach_msg_type_number_t data_len,
+	    off_t offset, mach_msg_type_number_t *amount)
+{
+  error_t err;
+  struct pipe *pipe;
+
+  if (!user)
+    return EOPNOTSUPP;
+
+  err = sock_aquire_write_pipe (user->sock, &pipe);
+  if (!err)
+    err = pipe_write (pipe, data, data_len, amount);
 
   pipe_release (pipe);
   return err;
@@ -71,33 +86,16 @@ S_interrupt_operation (struct sock_user *user)
 
   /* Interrupt pending reads on this socket.  We don't bother with writes
      since they never block.  */
-  pipe = sock_aquire_read_pipe (user->sock);
-  if (pipe != NULL)
+  if (sock_aquire_read_pipe (user->sock, &pipe) == 0 && pipe != NULL)
     {
       /* Indicate to currently waiting threads they've been interrupted.  */
       pipe->interrupt_seq_num++;
-
-      /* Now wake them all up for the bad news... */
-      condition_broadcast (&pipe->pending_reads, &pipe->lock);
-      mutex_lock (&pipe->lock);	/* Get back the lock on PIPE.  */
-      condition_broadcast (&pipe->pending_selects, &pipe->lock);
-      mutex_lock (&pipe->lock);	/* Get back the lock on PIPE.  */
-
+      pipe_kick (pipe);
       pipe_release (pipe);
     }
 
   return 0;
 }
-
-S_io_get_openmodes (struct sock_user *user, int *bits)
-{
-  if (!user)
-    return EOPNOTSUPP;
-  *bits =
-    (user->sock->read_pipe ? O_READ : 0)
-      | (user->sock->write_pipe ? O_WRITE : 0);
-  return 0;
-}
 
 /* Tell how much data can be read from the object without blocking for
    a "long time" (this should be the same meaning of "long time" used
@@ -105,17 +103,21 @@ S_io_get_openmodes (struct sock_user *user, int *bits)
 error_t 
 S_io_readable (struct sock_user *user, mach_msg_type_number_t *amount)
 {
-  error_t err = 0;
+  error_t err;
+  struct pipe *pipe;
 
   if (!user)
     return EOPNOTSUPP;
 
-  mutex_lock (&user->sock->lock);
-  if (user->sock->read_pipe)
-    *amount = pipe_readable (user->sock->read_pipe);
-  else
-    err = EBADF;
-  mutex_unlock (&user->sock->lock);
+  err = sock_aquire_read_pipe (user->sock, &pipe);
+  if (!err)
+    if (pipe == NULL)
+      *amount = 0;
+    else
+      {
+	*amount = pipe_readable (user->sock->read_pipe);
+	pipe_release (pipe);
+      }
 
   return err;
 }
@@ -155,51 +157,6 @@ S_io_duplicate (struct sock_user *user,
   return 0;
 }
 
-/* Write data to an IO object.  If offset is -1, write at the object
-   maintained file pointer.  If the object is not seekable, offset is
-   ignored.  The amount successfully written is returned in amount.  A
-   given user should not have more than one outstanding io_write on an
-   object at a time; servers implement congestion control by delaying
-   responses to io_write.  Servers may drop data (returning ENOBUFS)
-   if they recevie more than one write when not prepared for it.  */
-error_t
-S_io_write (struct sock_user *user,
-	    char *data, mach_msg_type_number_t data_len,
-	    off_t offset, mach_msg_type_number_t *amount)
-{
-  error_t err = 0;
-  struct pipe *pipe;
-
-  if (!user)
-    return EOPNOTSUPP;
-
-  pipe = sock_aquire_write_pipe (user->sock);
-  if (pipe == NULL)
-    return EBADF;
-  
-  if (pipe->reader == NULL)
-    err = EPIPE;
-  if (!err)
-    err = pipe_write(pipe, data, data_len, amount);
-  if (!err)
-    {
-      timestamp (&pipe->write_time);
-      
-      /* And wakeup anyone that might be interested in it.  */
-      condition_signal (&pipe->pending_reads, &pipe->lock);
-      mutex_lock (&pipe->lock);	/* Get back the lock on PIPE.  */
-      
-      /* Only wakeup selects if there's still data available.  */
-      if (pipe_readable (pipe))
-	{
-	  condition_signal (&pipe->pending_selects, &pipe->lock);
-	  mutex_lock (&pipe->lock); /* Get back the lock on PIPE.  */
-	}
-    }
-
-  pipe_release (pipe);
-  return 0;
-}
 
 /* SELECT_TYPE is the bitwise OR of SELECT_READ, SELECT_WRITE, and SELECT_URG.
    Block until one of the indicated types of i/o can be done "quickly", and
@@ -209,61 +166,74 @@ S_io_write (struct sock_user *user,
 error_t
 S_io_select (struct sock_user *user, int *select_type, int *id_tag)
 {
+  error_t err = 0;
   struct sock *sock;
 
   if (!user)
     return EOPNOTSUPP;
 
+  *select_type |= ~SELECT_URG;	/* We never return these.  */
+
   sock = user->sock;
   mutex_lock (&sock->lock);
 
-  *select_type |= ~SELECT_URG;
-
-  if ((*select_type & SELECT_WRITE) && !sock->write_pipe)
-    {
-      mutex_unlock (&sock->lock);
-      return EBADF;
-    }
-  /* Otherwise, pipes are always writable... */
-
-  if (*select_type & SELECT_READ)
+  if (sock->connq)
+    /* Sock is used for accepting connections, not I/O.  For these, you can
+       only select for reading, which will block until a connection request
+       comes along.  */
     {
-      struct pipe *pipe = sock->read_pipe;
-      if (pipe)
-	pipe_aquire (pipe);
-
-      /* We unlock SOCK here, as it's not subsequently used, and we might
-	 go to sleep waiting for readable data.  */
       mutex_unlock (&sock->lock);
 
-      if (!pipe)
+      if (*select_type & SELECT_WRITE)
+	/* Meaningless for a non-i/o socket.  */
 	return EBADF;
 
-      if (! pipe_readable (pipe))
-	/* Nothing to read on PIPE yet...  */
-	if (*select_type & ~SELECT_READ)
-	  /* But there's other stuff to report, so return that.  */
-	  *select_type &= ~SELECT_READ;
-	else
-	  /* The user only cares about reading, so wait until something is
-	     readable.  */
-	  while (! pipe_readable (pipe) && pipe->writer)
-	    {
-	      unsigned seq_num = pipe->interrupt_seq_num;
-	      condition_wait (&pipe->pending_reads, &pipe->lock);
-	      if (seq_num != pipe->interrupt_seq_num)
-		{
-		  pipe_release (pipe);
-		  return EINTR;
-		}
-	    }
-
-      pipe_release (pipe);
+      if (*select_type & SELECT_READ)
+	/* Wait for a connect.  Passing in NULL for REQ means that the
+	   request won't be dequeued.  */
+	return 
+	  connq_listen (sock->connq, sock->flags & SOCK_NONBLOCK, NULL, NULL);
     }
   else
-    mutex_unlock (&sock->lock);
+    /* Sock is a normal read/write socket.  */
+    {
+      if ((*select_type & SELECT_WRITE) && !sock->write_pipe)
+	{
+	  mutex_unlock (&sock->lock);
+	  return EBADF;
+	}
+      /* Otherwise, pipes are always writable... */
 
-  return 0;
+      if (*select_type & SELECT_READ)
+	{
+	  struct pipe *pipe = sock->read_pipe;
+	  if (pipe)
+	    pipe_aquire (pipe);
+
+	  /* We unlock SOCK here, as it's not subsequently used, and we might
+	     go to sleep waiting for readable data.  */
+	  mutex_unlock (&sock->lock);
+
+	  if (!pipe)
+	    return EBADF;
+
+	  if (! pipe_readable (pipe))
+	    /* Nothing to read on PIPE yet...  */
+	    if (*select_type & ~SELECT_READ)
+	      /* But there's other stuff to report, so return that.  */
+	      *select_type &= ~SELECT_READ;
+	    else
+	      /* The user only cares about reading, so wait until something is
+		 readable.  */
+	      err = pipe_wait (pipe, 0);
+
+	  pipe_release (pipe);
+	}
+      else
+	mutex_unlock (&sock->lock);
+    }
+
+  return err;
 }
 
 /* Return the current status of the object.  Not all the fields of the
@@ -303,3 +273,157 @@ S_io_stat (struct sock_user *user, struct stat *st)
 
   return 0;
 }
+
+error_t
+S_io_get_openmodes (struct sock_user *user, int *bits)
+{
+  unsigned flags;
+  if (!user)
+    return EOPNOTSUPP;
+  flags = user->sock->flags;
+  *bits =
+      (flags & SOCK_NONBLOCK ? O_NONBLOCK : 0)
+    | (flags & SOCK_SHUTDOWN_READ ? 0 : O_READ)
+    | (flags & SOCK_SHUTDOWN_WRITE ? 0 : O_WRITE);
+  return 0;
+}
+
+error_t
+S_io_set_all_openmodes (struct sock_user *user, int bits)
+{
+  if (!user)
+    return EOPNOTSUPP;
+  mutex_lock (&user->sock->lock);
+  if (bits & SOCK_NONBLOCK)
+    user->sock->flags |= SOCK_NONBLOCK;
+  else
+    user->sock->flags &= ~SOCK_NONBLOCK;
+  mutex_unlock (user->sock->lock);
+  return 0;
+}
+
+error_t
+S_io_set_some_openmodes (struct sock_user *user, int bits)
+{
+  if (!user)
+    return EOPNOTSUPP;
+  mutex_lock (&user->sock->lock);
+  if (bits & SOCK_NONBLOCK)
+    user->sock->flags |= SOCK_NONBLOCK;
+  mutex_unlock (user->sock->lock);
+  return 0;
+}
+
+error_t
+S_io_clear_some_openmodes (struct sock_user *user, int bits)
+{
+  if (!user)
+    return EOPNOTSUPP;
+  mutex_lock (&user->sock->lock);
+  if (bits & SOCK_NONBLOCK)
+    user->sock->flags &= ~SOCK_NONBLOCK;
+  mutex_unlock (user->sock->lock);
+  return 0;
+}
+
+/* Stubs for currently unsupported rpcs.  */
+
+error_t
+S_io_async(struct sock_user *user,
+	   mach_port_t notify_port,
+	   mach_port_t *async_id_port,
+	   mach_msg_type_name_t *async_id_port_type)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_mod_owner(struct sock_user *user, pid_t owner)
+{
+  return EOPNOTSUPP;
+}
+
+error_t 
+S_io_get_owner(struct sock_user *user, pid_t *owner)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_get_icky_async_id (struct sock_user *user,
+			mach_port_t *icky_async_id_port,
+			mach_msg_type_name_t *icky_async_id_port_type)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_map (struct sock_user *user,
+	  mach_port_t *memobj_rd, mach_msg_type_name_t *memobj_rd_type,
+	  mach_port_t *memobj_wt, mach_msg_type_name_t *memobj_wt_type)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_map_cntl (struct sock_user *user,
+	       mach_port_t *mem, mach_msg_type_name_t *mem_type)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_get_conch (struct sock_user *user)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_release_conch (struct sock_user *user)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_eofnotify (struct sock_user *user)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_prenotify (struct sock_user *user, vm_offset_t start, vm_offset_t end)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_postnotify (struct sock_user *user, vm_offset_t start, vm_offset_t end)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_readsleep (struct sock_user *user)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_readnotify (struct sock_user *user)
+{
+  return EOPNOTSUPP;
+}
+
+
+error_t
+S_io_sigio (struct sock_user *user)
+{
+  return EOPNOTSUPP;
+}
+
+error_t
+S_io_server_version (struct sock_user *user,
+		     char *name, int *maj, int *min, int *edit)
+{
+  return EOPNOTSUPP;
+}