Introduce name resolution interface and named socket opener.
authorMichael Brown <mcb30@etherboot.org>
Sun, 27 May 2007 01:07:00 +0000 (01:07 +0000)
committerMichael Brown <mcb30@etherboot.org>
Sun, 27 May 2007 01:07:00 +0000 (01:07 +0000)
src/core/resolv.c
src/include/gpxe/resolv.h
src/net/udp/dns.c

index b2fbc93..bee391a 100644 (file)
@@ -21,6 +21,9 @@
 #include <string.h>
 #include <errno.h>
 #include <gpxe/in.h>
+#include <gpxe/xfer.h>
+#include <gpxe/open.h>
+#include <gpxe/process.h>
 #include <gpxe/resolv.h>
 
 /** @file
  *
  */
 
-static struct async_operations resolv_async_operations;
+/***************************************************************************
+ *
+ * Name resolution interfaces
+ *
+ ***************************************************************************
+ */
+
+/**
+ * Name resolution completed
+ *
+ * @v resolv           Name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+void resolv_done ( struct resolv_interface *resolv, struct sockaddr *sa,
+                  int rc ) {
+       struct resolv_interface *dest = resolv_get_dest ( resolv );
+
+       dest->op->done ( dest, sa, rc );
+       resolv_unplug ( resolv );
+       resolv_put ( dest );
+}
+
+/**
+ * Ignore name resolution done() event
+ *
+ * @v resolv           Name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+void ignore_resolv_done ( struct resolv_interface *resolv __unused,
+                         struct sockaddr *sa __unused, int rc __unused ) {
+       /* Do nothing */
+}
+
+/** Null name resolution interface operations */
+struct resolv_interface_operations null_resolv_ops = {
+       .done           = ignore_resolv_done,
+};
+
+/** Null name resolution interface */
+struct resolv_interface null_resolv = {
+       .intf = {
+               .dest = &null_resolv.intf,
+               .refcnt = NULL,
+       },
+       .op = &null_resolv_ops,
+};
+
+/***************************************************************************
+ *
+ * Numeric name resolver
+ *
+ ***************************************************************************
+ */
+
+/** A numeric name resolver */
+struct numeric_resolv {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Name resolution interface */
+       struct resolv_interface resolv;
+       /** Process */
+       struct process process;
+       /** Completed socket address */
+       struct sockaddr sa;
+       /** Overall status code */
+       int rc;
+};
+
+static void numeric_step ( struct process *process ) {
+       struct numeric_resolv *numeric =
+               container_of ( process, struct numeric_resolv, process );
+       
+       resolv_done ( &numeric->resolv, &numeric->sa, numeric->rc );
+       process_del ( process );
+}
+
+static int numeric_resolv ( struct resolv_interface *resolv,
+                           const char *name, struct sockaddr *sa ) {
+       struct numeric_resolv *numeric;
+       struct sockaddr_in *sin;
+
+       /* Allocate and initialise structure */
+       numeric = malloc ( sizeof ( *numeric ) );
+       if ( ! numeric )
+               return -ENOMEM;
+       memset ( numeric, 0, sizeof ( *numeric ) );
+       resolv_init ( &numeric->resolv, &null_resolv_ops, &numeric->refcnt );
+       process_init ( &numeric->process, numeric_step, &numeric->refcnt );
+       memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
+
+       DBGC ( numeric, "NUMERIC %p attempting to resolve \"%s\"\n",
+              numeric, name );
+
+       /* Attempt to resolve name */
+       sin = ( ( struct sockaddr_in * ) &numeric->sa );
+       sin->sin_family = AF_INET;
+       if ( inet_aton ( name, &sin->sin_addr ) == 0 )
+               numeric->rc = -EINVAL;
+
+       /* Attach to parent interface, mortalise self, and return */
+       resolv_plug_plug ( &numeric->resolv, resolv );
+       ref_put ( &numeric->refcnt );
+       return 0;
+}
+
+struct resolver numeric_resolver __resolver ( RESOLV_NUMERIC ) = {
+       .name = "NUMERIC",
+       .resolv = numeric_resolv,
+};
+
+/***************************************************************************
+ *
+ * Name resolution multiplexer
+ *
+ ***************************************************************************
+ */
 
 /** Registered name resolvers */
 static struct resolver resolvers[0]
@@ -37,104 +157,262 @@ static struct resolver resolvers[0]
 static struct resolver resolvers_end[0]
        __table_end ( struct resolver, resolvers );
 
+/** A name resolution multiplexer */
+struct resolv_mux {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Parent name resolution interface */
+       struct resolv_interface parent;
+
+       /** Child name resolution interface */
+       struct resolv_interface child;
+       /** Current child resolver */
+       struct resolver *resolver;
+
+       /** Socket address to complete */
+       struct sockaddr sa;
+       /** Name to be resolved
+        *
+        * Must be at end of structure
+        */
+       char name[0];
+};
+
 /**
- * Start name resolution
+ * Try current child name resolver
  *
- * @v name             Host name to resolve
- * @v sa               Socket address to fill in
- * @v parent           Parent asynchronous operation
+ * @v mux              Name resolution multiplexer
  * @ret rc             Return status code
  */
-int resolv ( const char *name, struct sockaddr *sa, struct async *parent ) {
-       struct resolution *resolution;
-       struct resolver *resolver;
-       struct sockaddr_in *sin = ( struct sockaddr_in * ) sa;
-       struct in_addr in;
-       int rc = -ENXIO;
+static int resolv_mux_try ( struct resolv_mux *mux ) {
+       struct resolver *resolver = mux->resolver;
+       int rc;
 
-       /* Allocate and populate resolution structure */
-       resolution = malloc ( sizeof ( *resolution ) );
-       if ( ! resolution )
-               return -ENOMEM;
-       memset ( resolution, 0, sizeof ( *resolution ) );
-       async_init ( &resolution->async, &resolv_async_operations, parent );
-
-       /* Check for a dotted quad IP address first */
-       if ( inet_aton ( name, &in ) != 0 ) {
-               DBGC ( resolution, "RESOLV %p saw valid IP address %s\n",
-                      resolution, name );
-               sin->sin_family = AF_INET;
-               sin->sin_addr = in;
-               async_done ( &resolution->async, 0 );
-               return 0;
-       }
+       DBGC ( mux, "RESOLV %p trying method %s\n", mux, resolver->name );
 
-       /* Start up all resolvers */
-       for ( resolver = resolvers ; resolver < resolvers_end ; resolver++ ) {
-               if ( ( rc = resolver->resolv ( name, sa,
-                                              &resolution->async ) ) != 0 ) {
-                       DBGC ( resolution, "RESOLV %p could not start %s: "
-                              "%s\n", resolution, resolver->name,
-                              strerror ( rc ) );
-                       /* Continue to try other resolvers */
-                       continue;
-               }
-               (resolution->pending)++;
+       if ( ( rc = resolver->resolv ( &mux->child, mux->name,
+                                      &mux->sa ) ) != 0 ) {
+               DBGC ( mux, "RESOLV %p could not use method %s: %s\n",
+                      mux, resolver->name, strerror ( rc ) );
+               return rc;
        }
-       if ( ! resolution->pending )
-               goto err;
 
        return 0;
+}
 
- err:
-       async_uninit ( &resolution->async );
-       free ( resolution );
-       return rc;
+/**
+ * Handle done() event from child name resolver
+ *
+ * @v resolv           Child name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+static void resolv_mux_done ( struct resolv_interface *resolv,
+                             struct sockaddr *sa, int rc ) {
+       struct resolv_mux *mux =
+               container_of ( resolv, struct resolv_mux, child );
+
+       /* Unplug child */
+       resolv_unplug ( &mux->child );
+
+       /* If this resolution succeeded, stop now */
+       if ( rc == 0 ) {
+               DBGC ( mux, "RESOLV %p succeeded using method %s\n",
+                      mux, mux->resolver->name );
+               goto finished;
+       }
+
+       /* Attempt next child resolver, if possible */
+       mux->resolver++;
+       if ( mux->resolver >= resolvers_end ) {
+               DBGC ( mux, "RESOLV %p failed to resolve name\n", mux );
+               goto finished;
+       }
+       if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
+               goto finished;
+
+       /* Next resolver is now running */
+       return;
+       
+ finished:
+       resolv_done ( &mux->parent, sa, rc );
 }
 
+/** Name resolution multiplexer operations */
+static struct resolv_interface_operations resolv_mux_child_ops = {
+       .done           = resolv_mux_done,
+};
+
 /**
- * Handle child name resolution completion
+ * Start name resolution
  *
- * @v async            Name resolution asynchronous operation
- * @v signal           SIGCHLD
+ * @v resolv           Name resolution interface
+ * @v name             Name to resolve
+ * @v sa               Socket address to complete
+ * @ret rc             Return status code
  */
-static void resolv_sigchld ( struct async *async,
-                            enum signal signal __unused ) {
-       struct resolution *resolution =
-               container_of ( async, struct resolution, async );
+int resolv ( struct resolv_interface *resolv, const char *name,
+            struct sockaddr *sa ) {
+       struct resolv_mux *mux;
+       size_t name_len = ( strlen ( name ) + 1 );
        int rc;
 
-       /* Reap the child */
-       async_wait ( async, &rc, 1 );
+       /* Allocate and initialise structure */
+       mux = malloc ( sizeof ( *mux ) + name_len );
+       if ( ! mux )
+               return -ENOMEM;
+       memset ( mux, 0, sizeof ( *mux ) );
+       resolv_init ( &mux->parent, &null_resolv_ops, &mux->refcnt );
+       resolv_init ( &mux->child, &resolv_mux_child_ops, &mux->refcnt );
+       mux->resolver = resolvers;
+       memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
+       memcpy ( mux->name, name, name_len );
+
+       DBGC ( mux, "RESOLV %p attempting to resolve \"%s\"\n", mux, name );
 
-       /* If this child succeeded, kill all the others.  They should
-        * immediately die (invoking resolv_sigchld() again, which
-        * won't do anything because the exit status is non-zero and
-        * the pending count won't reach zero until this instance
-        * completes).
+       /* Start first resolver in chain.  There will always be at
+        * least one resolver (the numeric resolver), so no need to
+        * check for the zero-resolvers-available case.
         */
-       if ( rc == 0 )
-               async_signal_children ( async, SIGKILL );
+       if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
+               goto err;
+
+       /* Attach parent interface, mortalise self, and return */
+       resolv_plug_plug ( &mux->parent, resolv );
+       ref_put ( &mux->refcnt );
+       return 0;
 
-       /* When we have no children left, exit */
-       if ( --(resolution->pending) == 0 )
-               async_done ( async, rc );
+ err:
+       ref_put ( &mux->refcnt );
+       return rc;      
 }
 
+/***************************************************************************
+ *
+ * Named socket opening
+ *
+ ***************************************************************************
+ */
+
+/** A named socket */
+struct named_socket {
+       /** Reference counter */
+       struct refcnt refcnt;
+       /** Data transfer interface */
+       struct xfer_interface xfer;
+       /** Name resolution interface */
+       struct resolv_interface resolv;
+       /** Communication semantics (e.g. SOCK_STREAM) */
+       int semantics;
+       /** Stored local socket address, if applicable */
+       struct sockaddr local;
+       /** Stored local socket address exists */
+       int have_local;
+};
+
 /**
- * Free name resolution structure
+ * Handle seek() event
  *
- * @v async            Asynchronous operation
+ * @v xfer             Data transfer interface
+ * @v offset           Offset to new position
+ * @v whence           Basis for new position
+ * @ret rc             Return status code
  */
-static void resolv_reap ( struct async *async ) {
-       free ( container_of ( async, struct resolution, async ) );
+static int resolv_xfer_seek ( struct xfer_interface *xfer __unused,
+                             off_t offset __unused, int whence __unused ) {
+       /* Never ready to accept data */
+       return -EAGAIN;
 }
 
-/** Name resolution asynchronous operations */
-static struct async_operations resolv_async_operations = {
-       .reap = resolv_reap,
-       .signal = {
-               [SIGKILL] = async_signal_children,
-               [SIGCHLD] = resolv_sigchld,
-       },
+/** Named socket opener data transfer interface operations */
+static struct xfer_interface_operations named_xfer_ops = {
+       .close          = ignore_xfer_close,
+       .vredirect      = ignore_xfer_vredirect,
+       .request        = ignore_xfer_request,
+       .seek           = resolv_xfer_seek,
+       .alloc_iob      = default_xfer_alloc_iob,
+       .deliver_iob    = xfer_deliver_as_raw,
+       .deliver_raw    = ignore_xfer_deliver_raw,
 };
+
+/**
+ * Handle done() event
+ *
+ * @v resolv           Name resolution interface
+ * @v sa               Completed socket address (if successful)
+ * @v rc               Final status code
+ */
+static void named_resolv_done ( struct resolv_interface *resolv,
+                               struct sockaddr *sa, int rc ) {
+       struct named_socket *named =
+               container_of ( resolv, struct named_socket, resolv );
+
+       /* Unplug resolver and nullify data transfer interface */
+       resolv_unplug ( &named->resolv );
+       xfer_nullify ( &named->xfer );
+
+       /* Redirect if name resolution was successful */
+       if ( rc == 0 ) {
+               rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
+                                    named->semantics, sa,
+                                    ( named->have_local ?
+                                      &named->local : NULL ) );
+       }
+
+       /* Close data transfer interface if redirection failed */
+       if ( rc != 0 )
+               xfer_close ( &named->xfer, rc );
+
+       /* Unplug data transfer interface */
+       xfer_unplug ( &named->xfer );
+}
+
+/** Named socket opener name resolution interface operations */
+static struct resolv_interface_operations named_resolv_ops = {
+       .done           = named_resolv_done,
+};
+
+/**
+ * Open named socket
+ *
+ * @v semantics                Communication semantics (e.g. SOCK_STREAM)
+ * @v peer             Peer socket address to complete
+ * @v name             Name to resolve
+ * @v local            Local socket address, or NULL
+ * @ret rc             Return status code
+ */
+int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
+                            struct sockaddr *peer, const char *name,
+                            struct sockaddr *local ) {
+       struct named_socket *named;
+       int rc;
+
+       /* Allocate and initialise structure */
+       named = malloc ( sizeof ( *named ) );
+       if ( ! named )
+               return -ENOMEM;
+       memset ( named, 0, sizeof ( *named ) );
+       xfer_init ( &named->xfer, &named_xfer_ops, &named->refcnt );
+       resolv_init ( &named->resolv, &named_resolv_ops, &named->refcnt );
+       named->semantics = semantics;
+       if ( local ) {
+               memcpy ( &named->local, local, sizeof ( named->local ) );
+               named->have_local = 1;
+       }
+
+       DBGC ( named, "RESOLV %p opening named socket \"%s\"\n",
+              named, name );
+
+       /* Start name resolution */
+       if ( ( rc = resolv ( &named->resolv, name, peer ) ) != 0 )
+               goto err;
+
+       /* Attach parent interface, mortalise self, and return */
+       xfer_plug_plug ( &named->xfer, xfer );
+       ref_put ( &named->refcnt );
+       return 0;
+
+ err:
+       ref_put ( &named->refcnt );
+       return rc;
+}
index 7136401..4a4de4c 100644 (file)
  *
  */
 
+#include <gpxe/refcnt.h>
+#include <gpxe/interface.h>
+#include <gpxe/tables.h>
+
 struct sockaddr;
+struct resolv_interface;
 
-#include <gpxe/async.h>
-#include <gpxe/tables.h>
+/** Name resolution interface operations */
+struct resolv_interface_operations {
+       /** Name resolution completed
+        *
+        * @v resolv            Name resolution interface
+        * @v sa                Completed socket address (if successful)
+        * @v rc                Final status code
+        */
+       void ( * done ) ( struct resolv_interface *resolv,
+                         struct sockaddr *sa, int rc );
+};
+
+/** A name resolution interface */
+struct resolv_interface {
+       /** Generic object communication interface */
+       struct interface intf;
+       /** Operations for received messages */
+       struct resolv_interface_operations *op;
+};
+
+extern struct resolv_interface null_resolv;
+extern struct resolv_interface_operations null_resolv_ops;
+
+/**
+ * Initialise a name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ * @v op               Name resolution interface operations
+ * @v refcnt           Containing object reference counter, or NULL
+ */
+static inline void resolv_init ( struct resolv_interface *resolv,
+                                struct resolv_interface_operations *op,
+                                struct refcnt *refcnt ) {
+       resolv->intf.dest = &null_resolv.intf;
+       resolv->intf.refcnt = refcnt;
+       resolv->op = op;
+}
+
+/**
+ * Get name resolution interface from generic object communication interface
+ *
+ * @v intf             Generic object communication interface
+ * @ret resolv         Name resolution interface
+ */
+static inline __attribute__ (( always_inline )) struct resolv_interface *
+intf_to_resolv ( struct interface *intf ) {
+       return container_of ( intf, struct resolv_interface, intf );
+}
+
+/**
+ * Get reference to destination name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ * @ret dest           Destination interface
+ */
+static inline __attribute__ (( always_inline )) struct resolv_interface *
+resolv_get_dest ( struct resolv_interface *resolv ) {
+       return intf_to_resolv ( intf_get ( resolv->intf.dest ) );
+}
+
+/**
+ * Drop reference to name resolution interface
+ *
+ * @v resolv           name resolution interface
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_put ( struct resolv_interface *resolv ) {
+       intf_put ( &resolv->intf );
+}
+
+/**
+ * Plug a name resolution interface into a new destination interface
+ *
+ * @v resolv           Name resolution interface
+ * @v dest             New destination interface
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_plug ( struct resolv_interface *resolv, struct resolv_interface *dest ) {
+       plug ( &resolv->intf, &dest->intf );
+}
+
+/**
+ * Plug two name resolution interfaces together
+ *
+ * @v a                        Name resolution interface A
+ * @v b                        Name resolution interface B
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_plug_plug ( struct resolv_interface *a, struct resolv_interface *b ) {
+       plug_plug ( &a->intf, &b->intf );
+}
+
+/**
+ * Unplug a name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ */
+static inline __attribute__ (( always_inline )) void
+resolv_unplug ( struct resolv_interface *resolv ) {
+       plug ( &resolv->intf, &null_resolv.intf );
+}
+
+/**
+ * Stop using a name resolution interface
+ *
+ * @v resolv           Name resolution interface
+ *
+ * After calling this method, no further messages will be received via
+ * the interface.
+ */
+static inline void resolv_nullify ( struct resolv_interface *resolv ) {
+       resolv->op = &null_resolv_ops;
+};
 
 /** A name resolver */
 struct resolver {
@@ -18,30 +134,26 @@ struct resolver {
        const char *name;
        /** Start name resolution
         *
-        * @v name              Host name to resolve
-        * @v sa                Socket address to fill in
-        * @v parent            Parent asynchronous operation
+        * @v resolv            Name resolution interface
+        * @v name              Name to resolve
+        * @v sa                Socket address to complete
         * @ret rc              Return status code
-        *
-        * The asynchronous process must be prepared to accept
-        * SIGKILL.
         */
-       int ( * resolv ) ( const char *name, struct sockaddr *sa,
-                          struct async *parent );
+       int ( * resolv ) ( struct resolv_interface *resolv, const char *name,
+                          struct sockaddr *sa );
 };
 
-/** A name resolution in progress */
-struct resolution {
-       /** Asynchronous operation */
-       struct async async;
-       /** Numner of active child resolvers */
-       unsigned int pending;
-};
+/** Numeric resolver priority */
+#define RESOLV_NUMERIC 01
+
+/** Normal resolver priority */
+#define RESOLV_NORMAL 02
 
 /** Register as a name resolver */
-#define __resolver __table ( struct resolver, resolvers, 01 )
+#define __resolver( resolv_order ) \
+       __table ( struct resolver, resolvers, resolv_order )
 
-extern int resolv ( const char *name, struct sockaddr *sa,
-                   struct async *parent );
+extern int resolv ( struct resolv_interface *resolv, const char *name,
+                   struct sockaddr *sa );
 
 #endif /* _GPXE_RESOLV_H */
index ee6a58b..2268052 100644 (file)
@@ -486,7 +486,7 @@ int dns_resolv ( const char *name, struct sockaddr *sa,
 }
 
 /** DNS name resolver */
-struct resolver dns_resolver __resolver = {
+struct resolver dns_resolver __resolver ( RESOLV_NORMAL ) = {
        .name = "DNS",
        .resolv = dns_resolv,
 };