apr-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Bill Stoddard" <b...@wstoddard.com>
Subject Re: [RFC] Network Abstraction Layer - redux
Date Wed, 13 Jun 2001 05:35:18 GMT
I need to catch up on the other messages in this thread so I conceed you may be right, but
one thing I -think- this proposal helps us avoid is replicating a lot of code in the
core_filters (in and out) just to access a different network i/o primitive.  Mucking with
the core filters seems a clunky way to do what the NAL does.

Bill

----- Original Message -----
From: <rbb@covalent.net>
To: "Bill Stoddard" <bill@wstoddard.com>
Cc: <striker@samba-tng.org>; <dev@apr.apache.org>; <lkcl@samba-tng.org>;
<elrond@samba-tng.org>
Sent: Tuesday, June 12, 2001 11:41 PM
Subject: Re: [RFC] Network Abstraction Layer - redux


>
> I was under the impression that we had already decided, the last time this
> thread surfaced, that all of this was possible with filters.  We can
> redirect to different kinds of network primitives with a different "core"
> filter.  The "core" filters don't even need to use sockets, they can store
> their own communication medium in the conn_rec, and just use that.  The
> only drawback, is that Apache will still require a single socket to
> operate, but I am not sure that can't be worked around.  A REALLY QUICK
> grep through the source has us referencing the client socket 28 times
> directly from the conn_rec.  I am not convinced that some of those can't
> just be moved to inside a filter.
>
> I guess I am asking what this is supposed to accomplish.
>
> Ryan
>
> On Tue, 12 Jun 2001, Bill Stoddard wrote:
>
> > Missed this thread earlier.  I am quite interested in this proposal.  It is similar
to
> > Dean Gaudet's iol work in early Apache 2.0 and is pretty much in line with what
I was
> > needing/thinking as well.  Any interest in reviving this?  The implementation should
be
> > quite straightforward. I'll start working on pieces if there is general agreement
this
is
> > a good thing to do (I think it is).
> >
> > Bill Stoddard
> >
> > ----- Original Message -----
> > From: "Sander Striker" <striker@samba-tng.org>
> > To: <dev@apr.apache.org>
> > Cc: <lkcl@samba-tng.org>; <elrond@samba-tng.org>
> > Sent: Wednesday, February 28, 2001 6:47 AM
> > Subject: [RFC] Network Abstraction Layer
> >
> >
> > > Hi,
> > >
> > > Before I start throwing stuff at you, I'll introduce myself.
> > > I'm Sander Striker, one of the Samba TNG team members. We have
> > > been looking at the APR a bit to find out if we can use it in
> > > our code.
> > >
> > > It looks all very promissing and that's why we want to contribute
> > > some ideas to (from our point of view) improve the APR. The first
> > > thing we are going to need is a higher level of abstraction for
> > > the network layer. We have a complicated (to explain to outsiders)
> > > protocol stack in which protocols can be called upon from several
> > > layers.
> > > Example:
> > >
> > >  +-------------------+
> > >  |         D         |
> > >  +---------+         |
> > >  |    C    |         |
> > >  |    +----+----+    |
> > >  |    |    B    |    |
> > >  +----+----+---------+
> > >  |         A         |
> > >  +-------------------+
> > >
> > > In short:
> > >
> > > A <> B
> > > A <> B <> C
> > > A <> B <> C <> D
> > > A <> C
> > > A <> C <> D
> > > A <> D
> > >
> > > To make it even more complex B can run over other things than A...
> > >
> > > But, I'm boring you guys, so I'll proceed.
> > >
> > > Below is a simple draft of the NAL. The goal is to be able to
> > > add transports easily, even when not present in the kernel.
> > > Also this allows an easy way of protocol/transport stacking.
> > > A 'transport' can also do buffering, authentication, filtering.
> > >
> > > Ignore name clashes with current APR code please.
> > > Also, I haven't looked into the apr_pool package to understand
> > > how it works quite yet. I want it to be _possible_ to tie transports
> > > to memory management (so we can dump all memory that we used for:
> > > a session, a request, a reply, etc).
> > >
> > > I'll post a memory management draft aswell in a few days. It will
> > > be similar to this when it comes abstraction.
> > >
> > > Thanks,
> > >
> > > Sander
> > >
> > >
> > > /* typedefs */
> > >
> > > typedef struct apr_socket_t apr_socket_t;
> > > typedef struct apr_transport_t apr_transport_t;
> > >
> > > typedef int apr_transport_id_t;
> > > /* maybe this should be a string?? So you can
> > >  * do apr_socket_create("smb", &socket, some_pool) */
> > >
> > >
> > > typedef apr_status_t (*apr_socket_create_fn_t)  (apr_socket_t **socket,
> > >                                                  apr_pool_t *context);
> > >
> > > typedef apr_status_t (*apr_socket_bind_fn_t)    (apr_socket_t *socket,
> > >                                                  apr_sockaddr_t *sa);
> > >
> > > typedef apr_status_t (*apr_socket_connect_fn_t) (apr_socket_t *socket,
> > >                                                  apr_sockaddr_t *sa);
> > >
> > > typedef apr_status_t (*apr_socket_listen_fn_t)  (apr_socket_t *socket,
> > >                                                  apr_int32_t backlog);
> > >
> > > typedef apr_status_t (*apr_socket_accept_fn_t)  (apr_socket_t
> > > **client_socket,
> > >                                                  apr_socket_t *socket,
> > >                                                  apr_pool_t
> > > *connection_pool);
> > >
> > > typedef apr_status_t (*apr_socket_close_fn_t)   (apr_socket_t *socket);
> > >
> > > typedef apr_status_t (*apr_socket_setopt_fn_t)  (apr_socket_t *socket,
> > >                                                  apr_int32_t opt,
> > >                                                  apr_int32_t on);
> > >
> > > typedef apr_status_t (*apr_socket_getopt_fn_t)  (apr_socket_t *socket,
> > >                                                  apr_int32_t opt,
> > >                                                  apr_int32_t *on);
> > >
> > > typedef apr_status_t (*apr_socket_send_fn_t)    (apr_socket_t *socket,
> > >                                                  const char *buf,
> > >                                                  apr_size_t *len);
> > >
> > > typedef apr_status_t (*apr_socket_recv_fn_t)    (apr_socket_t *socket,
> > >                                                  char *buf,
> > >                                                  apr_size_t *len);
> > >
> > > typedef apr_status_t (*apr_socket_shutdown_fn_t)(apr_socket_t *socket,
> > >                                                  apr_shutdown_how_e how);
> > >
> > >
> > >   /* more functions that I possibly left out */
> > >
> > >
> > >
> > > /* structures */
> > >
> > > struct apr_transport_t
> > > {
> > >   apr_transport_id_t        transport_id;
> > >   apr_socket_create_fn_t    socket_create;
> > >   apr_socket_bind_fn_t      socket_bind;
> > >   apr_socket_connect_fn_t   socket_connect;
> > >   apr_socket_listen_fn_t    socket_listen;
> > >   apr_socket_accept_fn_t    socket_accept;
> > >   apr_socket_close_fn_t     socket_close;
> > >   apr_socket_setopt_fn_t    socket_setopt;
> > >   apr_socket_getopt_fn_t    socket_getopt;
> > >   apr_socket_send_fn_t      socket_send;
> > >   apr_socket_recv_fn_t      socket_recv;
> > >   apr_socket_shutdown_fn_t  socket_shutdown;
> > >   /* again, more functions that I possibly left out */
> > >
> > > };
> > >
> > > struct apr_socket_t
> > > {
> > >   apr_transport_t *transport;
> > >   /* transport specific socket implementation follows (should be
> > >      defined by transport implementors) */
> > >
> > > };
> > >
> > > /* functions */
> > >
> > > apr_status_t    apr_transport_add(apr_transport_t *transport);
> > > apr_status_t    apr_transport_remove(apr_transport_t *transport);
> > > apr_transport_t apr_transport_find(apr_transport_id_t transport_id);
> > >
> > >
> > > /* XXX: maybe do the create using apr_transport_id_t?? */
> > > apr_status_t    apr_socket_create(apr_transport_t *transport,
> > >                                   apr_socket_t **socket,
> > >                                   apr_pool_t *context);
> > >
> > > apr_status_t    apr_socket_bind(apr_socket_t *socket,
> > >                                 apr_sockaddr_t *sa);
> > >
> > > apr_status_t    apr_socket_connect(apr_socket_t *socket,
> > >                                    apr_sockaddr_t *sa);
> > >
> > > apr_status_t    apr_socket_listen(apr_socket_t *socket,
> > >                                   apr_int32_t backlog);
> > >
> > > apr_status_t    apr_socket_accept(apr_socket_t **client_socket,
> > >                                   apr_socket_t *socket,
> > >                                   apr_pool_t *connection_pool);
> > >
> > > apr_status_t    apr_socket_close(apr_socket_t *socket);
> > >
> > > apr_status_t    apr_socket_setopt(apr_socket_t *socket,
> > >                                   apr_int32_t opt,
> > >                                   apr_int32_t on);
> > >
> > > apr_status_t    apr_socket_getopt(apr_socket_t *socket,
> > >                                   apr_int32_t opt,
> > >                                   apr_int32_t *on);
> > >
> > > apr_status_t    apr_socket_send(apr_socket_t *socket,
> > >                                 const char *buf,
> > >                                 apr_size_t *len);
> > >
> > > apr_status_t    apr_socket_recv(apr_socket_t *socket,
> > >                                 char *buf,
> > >                                 apr_size_t *len);
> > >
> > > apr_status_t    apr_socket_shutdown(apr_socket_t *socket,
> > >                                     apr_shutdown_how_e how);
> > >
> > >
> > > /* implementation */
> > >
> > > /* XXX: maybe do the create using apr_transport_id_t?? */
> > > apr_status_t apr_socket_create(apr_transport_t *transport,
> > >                                apr_socket_t **socket,
> > >                                apr_pool_t *context)
> > > {
> > >   assert(transport != NULL);
> > >   assert(transport->apr_socket_create != NULL);
> > >
> > >   return transport->apr_socket_create(socket, context);
> > > }
> > >
> > > apr_status_t apr_socket_bind(apr_socket_t *socket,
> > >                                 apr_sockaddr_t *sa)
> > > {
> > >   assert(socket != NULL);
> > >   assert(socket->transport != NULL);
> > >   assert(socket->transport->socket_bind != NULL);
> > >
> > >   return socket->transport->socket_bind(socket, sa);
> > > }
> > >
> > > /* rest of high level implementation is trivially the same */
> > >
> >
> >
>
>
> _______________________________________________________________________________
> Ryan Bloom                        rbb@apache.org
> 406 29th St.
> San Francisco, CA 94131
> -------------------------------------------------------------------------------
>


Mime
View raw message