sysadmin/ipxe
1
0
Fork 0
mirror of https://github.com/ipxe/ipxe synced 2025-12-21 04:20:17 +03:00
Code Issues Packages Projects Releases Wiki Activity

[interface] Convert all name-resolution interfaces to generic interfaces

Browse Source 
Remove name-resolution as an interface type, and replace
name-resolution interfaces with generic interfaces supporting the
resolv_done() method.

Signed-off-by: Michael Brown <mcb30@ipxe.org>
This commit is contained in:
Michael Brown
2008-06-13 03:36:24 +01:00
parent a03dd97e6b
commit 7b4fbd93a5
4 changed files with 175 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
src/core/resolv.c
View File

@@ -42,47 +42,29 @@ FILE_LICENCE ( GPL2_OR_LATER );
*/
/**
* Name resolution completed
* Name resolved
*
* @v resolv Name resolution interface
* @v intf Object 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 );
void resolv_done ( struct interface *intf, struct sockaddr *sa ) {
struct interface *dest;
resolv_done_TYPE ( void * ) *op =
intf_get_dest_op ( intf, resolv_done, &dest );
void *object = intf_object ( dest );
resolv_unplug ( resolv );
dest->op->done ( dest, sa, rc );
resolv_put ( dest );
DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " resolv_done\n",
INTF_INTF_DBG ( intf, dest ) );
if ( op ) {
op ( object, sa );
} else {
/* Default is to ignore resolutions */
}
intf_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
@@ -95,7 +77,7 @@ struct numeric_resolv {
/** Reference counter */
struct refcnt refcnt;
/** Name resolution interface */
struct resolv_interface resolv;
struct interface resolv;
/** Process */
struct process process;
/** Completed socket address */
@@ -107,12 +89,14 @@ struct numeric_resolv {
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 );
if ( numeric->rc == 0 )
resolv_done ( &numeric->resolv, &numeric->sa );
intf_shutdown ( &numeric->resolv, numeric->rc );
}
static int numeric_resolv ( struct resolv_interface *resolv,
static int numeric_resolv ( struct interface *resolv,
const char *name, struct sockaddr *sa ) {
struct numeric_resolv *numeric;
struct sockaddr_in *sin;
@@ -122,7 +106,7 @@ static int numeric_resolv ( struct resolv_interface *resolv,
if ( ! numeric )
return -ENOMEM;
ref_init ( &numeric->refcnt, NULL );
resolv_init ( &numeric->resolv, &null_resolv_ops, &numeric->refcnt );
intf_init ( &numeric->resolv, &null_intf_desc, &numeric->refcnt );
process_init ( &numeric->process, numeric_step, &numeric->refcnt );
memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
@@ -131,12 +115,14 @@ static int numeric_resolv ( struct resolv_interface *resolv,
/* Attempt to resolve name */
sin = ( ( struct sockaddr_in * ) &numeric->sa );
sin->sin_family = AF_INET;
if ( inet_aton ( name, &sin->sin_addr ) == 0 )
if ( inet_aton ( name, &sin->sin_addr ) != 0 ) {
sin->sin_family = AF_INET;
} else {
numeric->rc = -EINVAL;
}
/* Attach to parent interface, mortalise self, and return */
resolv_plug_plug ( &numeric->resolv, resolv );
intf_plug_plug ( &numeric->resolv, resolv );
ref_put ( &numeric->refcnt );
return 0;
}
@@ -158,10 +144,10 @@ struct resolv_mux {
/** Reference counter */
struct refcnt refcnt;
/** Parent name resolution interface */
struct resolv_interface parent;
struct interface parent;
/** Child name resolution interface */
struct resolv_interface child;
struct interface child;
/** Current child resolver */
struct resolver *resolver;
@@ -180,7 +166,7 @@ struct resolv_mux {
* @v mux Name resolution multiplexer
* @ret rc Return status code
*/
static int resolv_mux_try ( struct resolv_mux *mux ) {
static int resmux_try ( struct resolv_mux *mux ) {
struct resolver *resolver = mux->resolver;
int rc;
@@ -197,19 +183,31 @@ static int resolv_mux_try ( struct resolv_mux *mux ) {
}
/**
* Handle done() event from child name resolver
* Child resolved name
*
* @v resolv Child name resolution interface
* @v sa Completed socket address (if successful)
* @v rc Final status code
* @v mux Name resolution multiplexer
* @v sa Completed socket address
*/
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 );
static void resmux_child_resolv_done ( struct resolv_mux *mux,
struct sockaddr *sa ) {
/* Unplug child */
resolv_unplug ( &mux->child );
DBGC ( mux, "RESOLV %p resolved \"%s\" using method %s\n",
mux, mux->name, mux->resolver->name );
/* Pass resolution to parent */
resolv_done ( &mux->parent, sa );
}
/**
* Child finished resolution
*
* @v mux Name resolution multiplexer
* @v rc Return status code
*/
static void resmux_child_close ( struct resolv_mux *mux, int rc ) {
/* Restart child interface */
intf_restart ( &mux->child, rc );
/* If this resolution succeeded, stop now */
if ( rc == 0 ) {
@@ -224,21 +222,26 @@ static void resolv_mux_done ( struct resolv_interface *resolv,
DBGC ( mux, "RESOLV %p failed to resolve name\n", mux );
goto finished;
}
if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
if ( ( rc = resmux_try ( mux ) ) != 0 )
goto finished;
/* Next resolver is now running */
return;
finished:
resolv_done ( &mux->parent, sa, rc );
intf_shutdown ( &mux->parent, rc );
}
/** Name resolution multiplexer operations */
static struct resolv_interface_operations resolv_mux_child_ops = {
.done = resolv_mux_done,
/** Name resolution multiplexer child interface operations */
static struct interface_operation resmux_child_op[] = {
INTF_OP ( resolv_done, struct resolv_mux *, resmux_child_resolv_done ),
INTF_OP ( intf_close, struct resolv_mux *, resmux_child_close ),
};
/** Name resolution multiplexer child interface descriptor */
static struct interface_descriptor resmux_child_desc =
INTF_DESC ( struct resolv_mux, child, resmux_child_op );
/**
* Start name resolution
*
@@ -247,7 +250,7 @@ static struct resolv_interface_operations resolv_mux_child_ops = {
* @v sa Socket address to complete
* @ret rc Return status code
*/
int resolv ( struct resolv_interface *resolv, const char *name,
int resolv ( struct interface *resolv, const char *name,
struct sockaddr *sa ) {
struct resolv_mux *mux;
size_t name_len = ( strlen ( name ) + 1 );
@@ -258,10 +261,11 @@ int resolv ( struct resolv_interface *resolv, const char *name,
if ( ! mux )
return -ENOMEM;
ref_init ( &mux->refcnt, NULL );
resolv_init ( &mux->parent, &null_resolv_ops, &mux->refcnt );
resolv_init ( &mux->child, &resolv_mux_child_ops, &mux->refcnt );
intf_init ( &mux->parent, &null_intf_desc, &mux->refcnt );
intf_init ( &mux->child, &resmux_child_desc, &mux->refcnt );
mux->resolver = table_start ( RESOLVERS );
memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
if ( sa )
memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
memcpy ( mux->name, name, name_len );
DBGC ( mux, "RESOLV %p attempting to resolve \"%s\"\n", mux, name );
@@ -270,11 +274,11 @@ int resolv ( struct resolv_interface *resolv, const char *name,
* least one resolver (the numeric resolver), so no need to
* check for the zero-resolvers-available case.
*/
if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
if ( ( rc = resmux_try ( mux ) ) != 0 )
goto err;
/* Attach parent interface, mortalise self, and return */
resolv_plug_plug ( &mux->parent, resolv );
intf_plug_plug ( &mux->parent, resolv );
ref_put ( &mux->refcnt );
return 0;
@@ -297,7 +301,7 @@ struct named_socket {
/** Data transfer interface */
struct xfer_interface xfer;
/** Name resolution interface */
struct resolv_interface resolv;
struct interface resolv;
/** Communication semantics (e.g. SOCK_STREAM) */
int semantics;
/** Stored local socket address, if applicable */
@@ -307,15 +311,14 @@ struct named_socket {
};
/**
* Finish using named socket
* Terminate named socket opener
*
* @v named Named socket
* @v rc Reason for finish
* @v rc Reason for termination
*/
static void named_done ( struct named_socket *named, int rc ) {
/* Close all interfaces */
resolv_nullify ( &named->resolv );
static void named_close ( struct named_socket *named, int rc ) {
/* Shut down interfaces */
intf_shutdown ( &named->resolv, rc );
xfer_nullify ( &named->xfer );
xfer_close ( &named->xfer, rc );
}
@@ -330,7 +333,7 @@ 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_close ( named, rc );
}
/** Named socket opener data transfer interface operations */
@@ -344,34 +347,46 @@ static struct xfer_interface_operations named_xfer_ops = {
};
/**
* Handle done() event
* Name resolved
*
* @v resolv Name resolution interface
* @v sa Completed socket address (if successful)
* @v rc Final status code
* @v named Named socket
* @v sa Completed socket address
*/
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 );
static void named_resolv_done ( struct named_socket *named,
struct sockaddr *sa ) {
int rc;
/* 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 ) );
/* Nullify data transfer interface */
xfer_nullify ( &named->xfer );
/* Redirect data-xfer interface */
if ( ( rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
named->semantics, sa,
( named->have_local ?
&named->local : NULL ) ) ) != 0 ) {
/* Redirection failed - do not unplug data-xfer interface */
DBGC ( named, "NAMED %p could not redirect: %s\n",
named, strerror ( rc ) );
} else {
/* Redirection succeeded - unplug data-xfer interface */
DBGC ( named, "NAMED %p redirected successfully\n", named );
xfer_unplug ( &named->xfer );
}
/* Terminate resolution */
named_done ( named, rc );
/* Terminate named socket opener */
named_close ( named, rc );
}
/** Named socket opener name resolution interface operations */
static struct resolv_interface_operations named_resolv_ops = {
.done = named_resolv_done,
/** Named socket opener resolver interface operations */
static struct interface_operation named_resolv_op[] = {
INTF_OP ( intf_close, struct named_socket *, named_close ),
INTF_OP ( resolv_done, struct named_socket *, named_resolv_done ),
};
/** Named socket opener resolver interface descriptor */
static struct interface_descriptor named_resolv_desc =
INTF_DESC ( struct named_socket, resolv, named_resolv_op );
/**
* Open named socket
*
@@ -393,14 +408,14 @@ int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
return -ENOMEM;
ref_init ( &named->refcnt, NULL );
xfer_init ( &named->xfer, &named_xfer_ops, &named->refcnt );
resolv_init ( &named->resolv, &named_resolv_ops, &named->refcnt );
intf_init ( &named->resolv, &named_resolv_desc, &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",
DBGC ( named, "NAMED %p opening \"%s\"\n",
named, name );
/* Start name resolution */