diff options
Diffstat (limited to 'pflocal')
-rw-r--r-- | pflocal/connq.h | 250 |
1 files changed, 6 insertions, 244 deletions
diff --git a/pflocal/connq.h b/pflocal/connq.h index a858d019..9db693e7 100644 --- a/pflocal/connq.h +++ b/pflocal/connq.h @@ -1,4 +1,4 @@ -/* A server for local sockets, of type PF_LOCAL +/* Connection queues Copyright (C) 1995 Free Software Foundation, Inc. @@ -18,225 +18,13 @@ 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 */ - -/* A port on SOCK. Multiple sock_user's can point to the same socket. */ -struct sock_user -{ - struct port_info pi; - struct sock *sock; -}; - -/* An endpoint for a possible I/O stream. */ -struct sock -{ - int refs; - struct mutex lock; - - /* Reads from this socket come from READ_PIPE, writes go to WRITE_PIPE. - A sock always has a read pipe, and a write pipe when it's connected to - another socket. */ - struct pipe *read_pipe, *write_pipe; - - /* FLAGS from SOCK_*, below. */ - unsigned flags; - - /* An identifying number for the socket. */ - unsigned id; - /* Last time the socket got frobbed. */ - time_value_t change_time; - - /* This socket's local address. Note that we don't hold any references on - ADDR, and depend on the addr zeroing our pointer if it goes away (which - is ok, as we can then just make up another address if necessary, and no - one could tell anyway). */ - struct addr *addr; - - /* If this sock has been connected to another sock, then WRITE_ADDR is the - addr of that sock. We *do* hold a reference to this addr. */ - struct addr *write_addr; - - /* A connection queue to listen for incoming connections on. Once a socket - has one of these, it always does, and can never again be used for - anything but accepting incoming connections. */ - struct connq *connq; -}; - -/* Socket flags */ -#define SOCK_CONNECTED 0x1 /* A connected connection-oriented sock. */ -#define SOCK_NONBLOCK 0x2 /* Don't block on I/O. */ -#define SOCK_SHUTDOWN_READ 0x4 /* The read-half has been shutdown. */ -#define SOCK_SHUTDOWN_WRITE 0x8 /* The write-half has been shutdown. */ - -/* Returns the pipe that SOCK is reading from in PIPE, locked and with an - additional reference, or an error saying why it's not possible. NULL may - also be returned in PIPE with a 0 error, meaning that EOF should be - returned. SOCK mustn't be locked. */ -error_t sock_aquire_read_pipe (struct sock *sock, struct pipe **pipe); - -/* Returns the pipe that SOCK is writing to in PIPE, locked and with an - additional reference, or an error saying why it's not possible. SOCK - mustn't be locked. */ -error_t sock_aquire_write_pipe (struct sock *sock, struct pipe **pipe); - -/* Connect together the previously unconnected sockets SOCK1 and SOCK2. */ -error_t sock_connect (struct sock *sock1, struct sock *sock2) - -/* Return a new socket with the given pipe class in SOCK. */ -error_t sock_create (struct pipe_class *pipe_class, struct sock **sock); - -/* Return a new socket just like TEMPLATE in SOCK. */ -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); - -/* ---------------------------------------------------------------- */ +#ifndef __CONNQ_H__ +#define __CONNQ_H__ +/* Unknown types */ struct connq; struct connq_request; +struct sock; /* 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 @@ -264,31 +52,5 @@ error_t connq_set_length (struct connq *cq, int length); 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 /* __CONNQ_H__ */ |