xNBA/src/core/resolv.c

/*
 * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

FILE_LICENCE ( GPL2_OR_LATER );

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/in.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/process.h>
#include <ipxe/resolv.h>

/** @file
 *
 * Name resolution
 *
 */

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

	resolv_unplug ( resolv );
	dest->op->done ( dest, sa, rc );
	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 = 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 ) = {
	.name = "NUMERIC",
	.resolv = numeric_resolv,
};

/***************************************************************************
 *
 * Name resolution multiplexer
 *
 ***************************************************************************
 */

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

/**
 * Try current child name resolver
 *
 * @v mux		Name resolution multiplexer
 * @ret rc		Return status code
 */
static int resolv_mux_try ( struct resolv_mux *mux ) {
	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;
}

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

/** Name resolution multiplexer operations */
static struct resolv_interface_operations resolv_mux_child_ops = {
	.done		= resolv_mux_done,
};

/**
 * Start name resolution
 *
 * @v resolv		Name resolution interface
 * @v name		Name to resolve
 * @v sa		Socket address to complete
 * @ret rc		Return status code
 */
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;

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

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

/**
 * Finish using named socket
 *
 * @v named		Named socket
 * @v rc		Reason for finish
 */
static void named_done ( struct named_socket *named, int rc ) {

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

/**
 * Handle close() event
 *
 * @v xfer		Data transfer interface
 * @v rc		Reason for close
 */
static void named_xfer_close ( struct xfer_interface *xfer, int rc ) {
	struct named_socket *named =
		container_of ( xfer, struct named_socket, xfer );

	named_done ( named, rc );
}

/** Named socket opener data transfer interface operations */
static struct xfer_interface_operations named_xfer_ops = {
	.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,
};

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

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

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