diff options
Diffstat (limited to 'pflocal')
| -rw-r--r-- | pflocal/sock.h | 212 |
1 files changed, 9 insertions, 203 deletions
diff --git a/pflocal/sock.h b/pflocal/sock.h index a858d019..6b6cc68e 100644 --- a/pflocal/sock.h +++ b/pflocal/sock.h @@ -1,4 +1,4 @@ -/* A server for local sockets, of type PF_LOCAL +/* Internal sockets Copyright (C) 1995 Free Software Foundation, Inc. @@ -18,12 +18,14 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#ifndef __PFLOCAL_H__ -#define __PFLOCAL_H__ - -/* ---------------------------------------------------------------- */ -/* Sockets */ +#ifndef __SOCK_H__ +#define __SOCK_H__ + +#include <hurd/ports.h> +#include <cthreads.h> /* For mutexes */ +struct pipe; + /* A port on SOCK. Multiple sock_user's can point to the same socket. */ struct sock_user { @@ -94,201 +96,5 @@ error_t sock_create (struct sock *template, struct sock **sock); /* Return a new user port on SOCK in PORT. */ error_t sock_create_port (struct sock *sock, mach_port_t *port); - -/* ---------------------------------------------------------------- */ -/* Pipes */ - -/* A description of a class of pipes and how to operate on them. */ -struct pipe_class -{ - /* What sort of socket this corresponds too. */ - int sock_type; - - /* Flags, from PIPE_CLASS_*, below. */ - unsigned flags; - - /* Operations: */ - - /* Read from BUF into DATA &c. */ - error_t (*read)(void *buf, char **data, unsigned *data_len, unsigned amount); - /* Write DATA &c into BUF. */ - error_t (*write)(void *buf, char *data, unsigned data_len, unsigned *amount); - /* Return the number of readable characters in BUF. */ - unsigned (*readable)(void *buf); - /* Clear out any data. */ - error_t (*drain)(void *buf); - /* Initialize *BUF or return an error. */ - error_t (*init)(void **buf); - /* Cleanup BUF, freeing all resources. */ - void (*cleanup)(void *buf); -}; - -/* pipe_class flags */ -#define PIPE_CLASS_CONNECTIONLESS 0x1 /* A non-stream protocol. */ - -/* Some pre-defined pipe_classes. */ -struct pipe_class *stream_pipe_class; -struct pipe_class *dgram_pipe_class; -struct pipe_class *seqpacket_pipe_class; - -/* ---------------------------------------------------------------- */ - -/* A unidirectional data pipe; it transfers data from READER to WRITER. */ -struct pipe -{ - /* What kind of pipe we are. */ - struct pipe_class *class; - - /* We use this to keep track of active threads using this pipe, so that - while a thread is waiting to read from a pipe and that pipe gets - deallocated (say by socket_shutdown), it doesn't actually go away until - the reader realizes what happened. It is normally frobbed using - pipe_aquire & pipe_release, which do locking as well.. */ - unsigned refs; - - /* Various flags, from PIPE_* below. */ - unsigned flags; - - /* Various timestamps for this pipe. */ - time_value_t read_time; - time_value_t write_time; - - struct condition pending_reads; - struct condition pending_selects; - - struct mutex lock; - - /* When interrupt_operation is called on a socket, we want to wake up all - pending read threads, and have them realize they've been interrupted; - reads that happen after the interrupt shouldn't return EINTR. When a - thread waits on this pipe's PENDING_READS condition, it remembers this - sequence number; any interrupt bumps this number and broadcasts on the - condition. A reader thread will try to read from the pipe only if the - sequence number is the same as when it went to sleep. */ - unsigned long interrupt_seq_num; - - /* The actual data, and how to access it. */ - void *data; -}; - -/* Pipe flags. */ -#define PIPE_BROKEN 0x1 /* This pipe isn't connected. */ - -/* Lock PIPE and increment its ref count. */ -extern inline void -pipe_aquire (struct pipe *pipe) -{ - mutex_lock (&pipe->lock); - pipe->refs++; -} - -/* Decrement PIPE's (which should be locked) ref count and unlock it. If the - ref count goes to zero, PIPE will be destroyed. */ -extern inline void -pipe_release (struct pipe *pipe) -{ - if (--pipe->refs == 0) - pipe_free (pipe); - else - mutex_unlock (&pipe->lock); -} - -/* Returns the number of characters quickly readable from PIPE. */ -extern inline unsigned -pipe_readable (struct pipe *pipe) -{ - return (*pipe->class->readable)(pipe->data); -} - -/* Empty out PIPE of any data. */ -extern inline void -pipe_drain (struct pipe *pipe) -{ - (*pipe->class->drain)(pipe->data); -} - -/* Writes up to LEN bytes of DATA, to PIPE, and returns the amount written in - AMOUNT. If an error is returned, nothing is done. */ -error_t -pipe_write (struct pipe *pipe, char *data, unsigned len, unsigned *amount); - -/* Reads up to AMOUNT bytes from PIPE, which should be locked, into DATA, and - returns the amount written in LEN. If NOBLOCK is true, EWOULDBLOCK is - returned instead of block when no data is immediately available. If an - error is returned, nothing is done. */ -error_t pipe_read (struct pipe *pipe, int noblock, - char **data, unsigned *len, unsigned amount); - -/* Waits for PIPE to be readable, or an error to occurr. If NOBLOCK is true, - this operation will return EWOULDBLOCK instead of blocking when no data is - immediately available. */ -error_t pipe_wait (struct pipe *pipe, int noblock); - -/* Wake up all threads waiting on PIPE, which should be locked. */ -void pipe_kick (struct pipe *pipe); - -/* Creates a new pipe of class CLASS and returns it in RESULT. */ -error_t pipe_create (struct pipe_class *class, struct pipe **pipe); - -/* Free PIPE and any resources it holds. */ -void pipe_free (struct pipe *pipe); - -/* ---------------------------------------------------------------- */ - -struct connq; -struct connq_request; - -/* Create a new listening queue, returning it in CQ. The resulting queue - will be of zero length, that is it won't allow connections unless someone - is already listening (change this with connq_set_length). */ -error_t connq_create (struct connq **cq); - -/* Wait for a connection attempt to be made on CQ, and return the connecting - socket in SOCK, and a request tag in REQ. If REQ is NULL, the request is - left in the queue, otherwise connq_request_complete must be called on REQ - to allow the requesting thread to continue. If NOBLOCK is true, - EWOULDBLOCK is returned when there are no immediate connections - available. */ -error_t connq_listen (struct connq *cq, int noblock, - struct connq_request **req, struct sock **sock); - -/* Return the error code ERR to the thread that made the listen request REQ, - returned from a previous connq_listen. */ -void connq_request_complete (struct connq_request *req, error_t err); - -/* Set CQ's queue length to LENGTH. Any sockets already waiting for a - connections that are past the new length will fail with ECONNREFUSED. */ -error_t connq_set_length (struct connq *cq, int length); - -/* Try to connect SOCK with the socket listening on CQ. If NOBLOCK is true, - then return EWOULDBLOCK immediately when there are no immediate - connections available. */ -error_t connq_connect (struct connq *cq, int noblock, struct sock *sock); - -/* ---------------------------------------------------------------- */ -/* Addresses */ - -struct addr -{ - struct port_info pi; - struct mutex lock; - - /* Which socket is at this address. */ - struct sock *sock; -}; - -/* Create a new address. */ -error_t addr_create (struct addr **addr); - -/* Set ADDR's socket to SOCK, possibly discarding a previous binding. */ -error_t addr_set_sock (struct addr *addr, struct sock *sock); - -/* ---------------------------------------------------------------- */ - -extern inline void -timestamp (time_value_t *stamp) -{ - host_get_time (mach_host_self (), stamp); -} -#endif /* __PFLOCAL_H__ */ +#endif /* __SOCK_H__ */ |