resolv.c File Reference

Name resolution. More...

#include <stdint.h>
#include <stdlib.h>
#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>

Go to the source code of this file.

Data Structures
struct	numeric_resolv
	A numeric name resolver. More...
struct	resolv_mux
	A name resolution multiplexer. More...
struct	named_socket
	A named socket. More...
Functions
	FILE_LICENCE (GPL2_OR_LATER)
void	resolv_done (struct resolv_interface *resolv, struct sockaddr *sa, int rc)
	Name resolution completed.
void	ignore_resolv_done (struct resolv_interface *resolv __unused, struct sockaddr *sa __unused, int rc __unused)
	Ignore name resolution done() event.
static void	numeric_step (struct process *process)
static int	numeric_resolv (struct resolv_interface *resolv, const char *name, struct sockaddr *sa)
struct resolver numeric_resolver	__resolver (RESOLV_NUMERIC)
static int	resolv_mux_try (struct resolv_mux *mux)
	Try current child name resolver.
static void	resolv_mux_done (struct resolv_interface *resolv, struct sockaddr *sa, int rc)
	Handle done() event from child name resolver.
int	resolv (struct resolv_interface *resolv, const char *name, struct sockaddr *sa)
	Start name resolution.
static void	named_done (struct named_socket *named, int rc)
	Finish using named socket.
static void	named_xfer_close (struct xfer_interface *xfer, int rc)
	Handle close() event.
static void	named_resolv_done (struct resolv_interface *resolv, struct sockaddr *sa, int rc)
	Handle done() event.
int	xfer_open_named_socket (struct xfer_interface *xfer, int semantics, struct sockaddr *peer, const char *name, struct sockaddr *local)
	Open named socket.
Variables
struct resolv_interface_operations	null_resolv_ops
	Null name resolution interface operations.
struct resolv_interface	null_resolv
	Null name resolution interface.
static struct resolv_interface_operations	resolv_mux_child_ops
	Name resolution multiplexer operations.
static struct xfer_interface_operations	named_xfer_ops
	Named socket opener data transfer interface operations.
static struct resolv_interface_operations	named_resolv_ops
	Named socket opener name resolution interface operations.

---

Detailed Description

Name resolution.

Definition in file resolv.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

void resolv_done	(	struct resolv_interface *	resolv,
		struct sockaddr *	sa,
		int	rc
	)

Name resolution completed.

Parameters:

	resolv	Name resolution interface
	sa	Completed socket address (if successful)
	rc	Final status code

Definition at line 51 of file resolv.c.

References dest, resolv_interface_operations::done, resolv_interface::op, resolv_get_dest(), resolv_put(), and resolv_unplug().

Referenced by dns_done(), numeric_step(), and resolv_mux_done().

                            {
        struct resolv_interface *dest = resolv_get_dest ( resolv );

        resolv_unplug ( resolv );
        dest->op->done ( dest, sa, rc );
        resolv_put ( dest );
}

void ignore_resolv_done	(	struct resolv_interface *resolv	__unused,
		struct sockaddr *sa	__unused,
		int rc	__unused
	)

Ignore name resolution done() event.

Parameters:

	resolv	Name resolution interface
	sa	Completed socket address (if successful)
	rc	Final status code

Definition at line 67 of file resolv.c.

                                                                          {
        /* Do nothing */
}

static void numeric_step

(

struct process *

process

)

[static]

Definition at line 107 of file resolv.c.

References container_of, process_del(), numeric_resolv::rc, numeric_resolv::resolv, resolv_done(), and numeric_resolv::sa.

Referenced by numeric_resolv().

                                                     {
        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
	)			[static]

Definition at line 115 of file resolv.c.

References AF_INET, DBGC, EINVAL, ENOMEM, inet_aton(), memcpy, numeric_step(), numeric_resolv::process, process_init(), numeric_resolv::rc, ref_put(), numeric_resolv::refcnt, numeric_resolv::resolv, resolv_init(), resolv_plug_plug(), numeric_resolv::sa, sockaddr_in::sin_addr, sockaddr_in::sin_family, and zalloc().

                                                                    {
        struct numeric_resolv *numeric;
        struct sockaddr_in *sin;

        /* Allocate and initialise structure */
        numeric = zalloc ( sizeof ( *numeric ) );
        if ( ! numeric )
                return -ENOMEM;
        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

)

[read]

static int resolv_mux_try

(

struct resolv_mux *

mux

)

[static]

Try current child name resolver.

Parameters:

mux

Name resolution multiplexer

Return values:

rc

Return status code

Definition at line 182 of file resolv.c.

References resolv_mux::child, DBGC, resolv_mux::name, resolver::name, resolver::resolv, resolv_mux::resolver, resolv_mux::sa, and strerror().

Referenced by resolv(), and resolv_mux_done().

                                                     {
        struct resolver *resolver = mux->resolver;
        int rc;

        DBGC ( mux, "RESOLV %p trying method %s\n", mux, resolver->name );

        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;
        }

        return 0;
}

static void resolv_mux_done	(	struct resolv_interface *	resolv,
		struct sockaddr *	sa,
		int	rc
	)			[static]

Handle done() event from child name resolver.

Parameters:

	resolv	Child name resolution interface
	sa	Completed socket address (if successful)
	rc	Final status code

Definition at line 205 of file resolv.c.

References resolv_mux::child, container_of, DBGC, resolver::name, resolv_mux::parent, resolv_done(), resolv_mux_try(), resolv_unplug(), resolv_mux::resolver, RESOLVERS, and table_end.

                                                            {
        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 >= table_end ( RESOLVERS ) ) {
                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 );
}

int resolv	(	struct resolv_interface *	resolv,
		const char *	name,
		struct sockaddr *	sa
	)

Start name resolution.

Parameters:

	resolv	Name resolution interface
	name	Name to resolve
	sa	Socket address to complete

Return values:

rc

Return status code

Definition at line 249 of file resolv.c.

References resolv_mux::child, DBGC, ENOMEM, memcpy, resolv_mux::name, resolv_mux::parent, ref_put(), resolv_mux::refcnt, resolv_init(), resolv_mux_try(), resolv_plug_plug(), resolv_mux::resolver, RESOLVERS, resolv_mux::sa, strlen(), table_start, and zalloc().

Referenced by comboot_resolv(), and xfer_open_named_socket().

                                   {
        struct resolv_mux *mux;
        size_t name_len = ( strlen ( name ) + 1 );
        int rc;

        /* Allocate and initialise structure */
        mux = zalloc ( sizeof ( *mux ) + name_len );
        if ( ! mux )
                return -ENOMEM;
        resolv_init ( &mux->parent, &null_resolv_ops, &mux->refcnt );
        resolv_init ( &mux->child, &resolv_mux_child_ops, &mux->refcnt );
        mux->resolver = table_start ( 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 );

        /* 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 = 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;

 err:
        ref_put ( &mux->refcnt );
        return rc;      
}

static void named_done	(	struct named_socket *	named,
		int	rc
	)			[static]

Finish using named socket.

Parameters:

	named	Named socket
	rc	Reason for finish

Definition at line 313 of file resolv.c.

References named_socket::resolv, resolv_nullify(), named_socket::xfer, and xfer_close().

Referenced by named_resolv_done(), and named_xfer_close().

                                                              {

        /* Close all interfaces */
        resolv_nullify ( &named->resolv );
        xfer_nullify ( &named->xfer );
        xfer_close ( &named->xfer, rc );
}

static void named_xfer_close	(	struct xfer_interface *	xfer,
		int	rc
	)			[static]

Handle close() event.

Parameters:

	xfer	Data transfer interface
	rc	Reason for close

Definition at line 327 of file resolv.c.

References container_of, and named_done().

                                                                     {
        struct named_socket *named =
                container_of ( xfer, struct named_socket, xfer );

        named_done ( named, rc );
}

static void named_resolv_done	(	struct resolv_interface *	resolv,
		struct sockaddr *	sa,
		int	rc
	)			[static]

Handle done() event.

Parameters:

	resolv	Name resolution interface
	sa	Completed socket address (if successful)
	rc	Final status code

Definition at line 351 of file resolv.c.

References container_of, named_socket::have_local, named_socket::local, LOCATION_SOCKET, named_done(), NULL, named_socket::semantics, named_socket::xfer, and xfer_redirect().

                                                              {
        struct named_socket *named =
                container_of ( resolv, struct named_socket, resolv );

        /* 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 ) );
        }

        /* Terminate resolution */
        named_done ( named, rc );
}

int xfer_open_named_socket	(	struct xfer_interface *	xfer,
		int	semantics,
		struct sockaddr *	peer,
		const char *	name,
		struct sockaddr *	local
	)

Open named socket.

Parameters:

	semantics	Communication semantics (e.g. SOCK_STREAM)
	peer	Peer socket address to complete
	name	Name to resolve
	local	Local socket address, or NULL

Return values:

rc

Return status code

Definition at line 382 of file resolv.c.

References DBGC, ENOMEM, named_socket::have_local, named_socket::local, memcpy, ref_put(), named_socket::refcnt, resolv(), named_socket::resolv, resolv_init(), named_socket::semantics, named_socket::xfer, xfer_init(), and zalloc().

Referenced by ftp_open(), http_open_filter(), iscsi_open_connection(), slam_open(), tcp_open_uri(), tftp_reopen(), and udp_open_uri().

                                                      {
        struct named_socket *named;
        int rc;

        /* Allocate and initialise structure */
        named = zalloc ( sizeof ( *named ) );
        if ( ! named )
                return -ENOMEM;
        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;
}

---

Variable Documentation

struct resolv_interface_operations null_resolv_ops [read]

Initial value:

 {
        .done           = ignore_resolv_done,
}

Null name resolution interface operations.

Definition at line 73 of file resolv.c.

Referenced by dns_resolv(), and resolv_nullify().

struct resolv_interface null_resolv [read]

Initial value:

 {
        .intf = {
                .dest = &null_resolv.intf,
                .refcnt = NULL,
        },
        .op = &null_resolv_ops,
}

Null name resolution interface.

Definition at line 78 of file resolv.c.

Referenced by resolv_init(), and resolv_unplug().

struct resolv_interface_operations resolv_mux_child_ops [static]

Initial value:

 {
        .done           = resolv_mux_done,
}

Name resolution multiplexer operations.

Definition at line 237 of file resolv.c.

struct xfer_interface_operations named_xfer_ops [static]

Initial value:

 {
        .close          = named_xfer_close,
        .vredirect      = ignore_xfer_vredirect,
        .window         = no_xfer_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = xfer_deliver_as_raw,
        .deliver_raw    = ignore_xfer_deliver_raw,
}

Named socket opener data transfer interface operations.

Definition at line 335 of file resolv.c.

struct resolv_interface_operations named_resolv_ops [static]

Initial value:

 {
        .done           = named_resolv_done,
}

Named socket opener name resolution interface operations.

Definition at line 369 of file resolv.c.