summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--pflocal/connq.c96
1 files changed, 48 insertions, 48 deletions
diff --git a/pflocal/connq.c b/pflocal/connq.c
index 2557db56..3011f634 100644
--- a/pflocal/connq.c
+++ b/pflocal/connq.c
@@ -23,7 +23,7 @@
#include "pflocal.h"
/* A queue for queueing incoming connections. */
-struct listenq
+struct connq
{
/* True if all connection requests should be treated as non-blocking. */
int noqueue;
@@ -31,7 +31,7 @@ struct listenq
/* The connection request queue. */
unsigned length;
unsigned head, tail;
- struct listenq_request *queue;
+ struct connq_request *queue;
/* Threads that have done an accept on this queue wait on this condition. */
struct condition listeners;
@@ -41,9 +41,9 @@ struct listenq
/* ---------------------------------------------------------------- */
-/* A data block allocated by a thread waiting on a listenq, which is used to
+/* A data block allocated by a thread waiting on a connq, which is used to
get information from and to the thread. */
-struct listenq_request
+struct connq_request
{
/* The socket that's waiting to connect. */
struct sock *sock;
@@ -62,24 +62,24 @@ struct listenq_request
};
static inline void
-listenq_request_init (struct sock *sock, struct listenq_request *lqr)
+connq_request_init (struct sock *sock, struct connq_request *req)
{
- lqr->err = 0;
- lqr->sock = sock;
- lqr->completed = 0;
- condition_init (&lqr->signal);
- mutex_init (&lqr->lock);
+ req->err = 0;
+ req->sock = sock;
+ req->completed = 0;
+ condition_init (&req->signal);
+ mutex_init (&req->lock);
}
/* ---------------------------------------------------------------- */
-/* Create a new listening queue, returning it in LQ. The resulting queue
+/* 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 listenq_set_length). */
+ is already listening (change this with connq_set_length). */
error_t
-listenq_create (struct listenq **lq)
+connq_create (struct connq **cq)
{
- struct listenq *new = malloc (sizeof (struct listenq));
+ struct connq *new = malloc (sizeof (struct connq));
if (!new)
return ENOMEM;
@@ -93,85 +93,85 @@ listenq_create (struct listenq **lq)
mutex_init (&new->lock);
condition_init (&new->listeners);
- *lq = new;
+ *cq = new;
return 0;
}
/* ---------------------------------------------------------------- */
-/* Wait for a connection attempt to be made on LQ, and return the connecting
- socket in SOCK, and a request tag in REQ. listenq_request_complete must be
+/* Wait for a connection attempt to be made on CQ, and return the connecting
+ socket in SOCK, and a request tag in REQ. connq_request_complete must be
call on REQ to allow the requesting thread to continue. If NOBLOCK is
true, then return EWOULDBLOCK immediately when there are no immediate
connections available. */
error_t
-listenq_listen (struct listenq *lq, int noblock,
- struct sock **sock, struct listenq_request **req)
+connq_listen (struct connq *cq, int noblock,
+ struct sock **sock, struct connq_request **req)
{
error_t err = 0;
- mutex_lock (&lq->lock);
+ mutex_lock (&cq->lock);
- if (noblock && lq->head == lq->tail)
+ if (noblock && cq->head == cq->tail)
return EWOULDBLOCK;
- lq->num_listeners++;
+ cq->num_listeners++;
- while (lq->head == lq->tail)
- condition_wait (&lq->listeners, &lq->lock);
+ while (cq->head == cq->tail)
+ condition_wait (&cq->listeners, &cq->lock);
/* Dequeue the next request. */
- *req = lq->queue[lq->tail];
- lq->tail = (lq->tail + 1 == lq->length ? 0 : lq->tail + 1);
+ *req = cq->queue[cq->tail];
+ cq->tail = (cq->tail + 1 == cq->length ? 0 : cq->tail + 1);
mutex_lock (&(*req)->lock);
- lq->num_listeners--;
+ cq->num_listeners--;
- mutex_unlock (&lq->lock);
+ mutex_unlock (&cq->lock);
*sock = (*req)->sock;
return 0;
}
/* Return the error code ERR to the thread that made the listen request REQ,
- returned from a previous listenq_listen. */
+ returned from a previous connq_listen. */
void
-listenq_request_complete (struct listenq_request *req, error_t err)
+connq_request_complete (struct connq_request *req, error_t err)
{
req->err = err;
req->complete = 1;
condition_signal (&req->signal, &req->lock);
}
-/* Try to connect SOCK with the socket listening on LQ. If NOBLOCK is true,
+/* 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
-listenq_connect (struct listenq *lq, int noblock, struct sock *sock)
+connq_connect (struct connq *cq, int noblock, struct sock *sock)
{
error_t err = 0;
- struct listenq_request req;
+ struct connq_request req;
unsigned next;
- mutex_lock (&lq->lock);
+ mutex_lock (&cq->lock);
- if ((noblock || lq->noqueue) && lq->num_listeners == 0)
+ if ((noblock || cq->noqueue) && cq->num_listeners == 0)
return EWOULDBLOCK;
- next = (lq->head + 1 == lq->length ? 0 : lq->head + 1);
- if (next == lq->tail)
+ next = (cq->head + 1 == cq->length ? 0 : cq->head + 1);
+ if (next == cq->tail)
err = ECONNREFUSED;
else
{
- lq->queue[lq->head] = &req;
- lq->head = next;
+ cq->queue[cq->head] = &req;
+ cq->head = next;
}
/* Hold REQ.LOCK before we signal the condition so that we're sure to be
woken up. */
mutex_lock (&req.lock);
- condition_signal (&lq->listeners, &lq->lock);
+ condition_signal (&cq->listeners, &cq->lock);
while (!req.completed)
condition_wait (&req.signal, &req.lock);
@@ -179,24 +179,24 @@ listenq_connect (struct listenq *lq, int noblock, struct sock *sock)
return req.err;
}
-/* Set LQ's queue length to LENGTH. Any sockets already waiting for a
+/* 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
-listenq_set_length (struct listenq *lq, int length)
+connq_set_length (struct connq *cq, int length)
{
int excess;
- mutex_lock (&lq->lock);
+ mutex_lock (&cq->lock);
- lq->noqueue = 0; /* Turn on queueing. */
+ cq->noqueue = 0; /* Turn on queueing. */
/* Force any excess requests to fail. */
- excess = lq->length - length;
+ excess = cq->length - length;
while (excess-- > 0)
{
- assert (lq->head != lq->tail);
- lq->head = (lq->head == 0 ? lq->length - 1 : lq->head - 1);
- listenq_request_complete (lq->queue[lq->head], ECONNREFUSED);
+ assert (cq->head != cq->tail);
+ cq->head = (cq->head == 0 ? cq->length - 1 : cq->head - 1);
+ connq_request_complete (cq->queue[cq->head], ECONNREFUSED);
}
/* ... */