2 * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 FILE_LICENCE ( GPL2_OR_LATER );
26 #include <ipxe/xfer.h>
27 #include <ipxe/open.h>
28 #include <ipxe/process.h>
29 #include <ipxe/socket.h>
30 #include <ipxe/resolv.h>
38 /***************************************************************************
40 * Name resolution interfaces
42 ***************************************************************************
48 * @v intf Object interface
49 * @v sa Completed socket address (if successful)
51 void resolv_done ( struct interface *intf, struct sockaddr *sa ) {
52 struct interface *dest;
53 resolv_done_TYPE ( void * ) *op =
54 intf_get_dest_op ( intf, resolv_done, &dest );
55 void *object = intf_object ( dest );
57 DBGC ( INTF_COL ( intf ), "INTF " INTF_INTF_FMT " resolv_done\n",
58 INTF_INTF_DBG ( intf, dest ) );
63 /* Default is to ignore resolutions */
69 /***************************************************************************
71 * Numeric name resolver
73 ***************************************************************************
76 /** A numeric name resolver */
77 struct numeric_resolv {
78 /** Reference counter */
80 /** Name resolution interface */
81 struct interface resolv;
83 struct process process;
84 /** Completed socket address */
86 /** Overall status code */
90 static void numeric_step ( struct numeric_resolv *numeric ) {
92 if ( numeric->rc == 0 )
93 resolv_done ( &numeric->resolv, &numeric->sa );
94 intf_shutdown ( &numeric->resolv, numeric->rc );
97 static struct process_descriptor numeric_process_desc =
98 PROC_DESC_ONCE ( struct numeric_resolv, process, numeric_step );
100 static int numeric_resolv ( struct interface *resolv,
101 const char *name, struct sockaddr *sa ) {
102 struct numeric_resolv *numeric;
104 /* Allocate and initialise structure */
105 numeric = zalloc ( sizeof ( *numeric ) );
108 ref_init ( &numeric->refcnt, NULL );
109 intf_init ( &numeric->resolv, &null_intf_desc, &numeric->refcnt );
110 process_init ( &numeric->process, &numeric_process_desc,
112 memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
114 /* Attempt to resolve name */
115 numeric->rc = sock_aton ( name, &numeric->sa );
117 /* Attach to parent interface, mortalise self, and return */
118 intf_plug_plug ( &numeric->resolv, resolv );
119 ref_put ( &numeric->refcnt );
123 struct resolver numeric_resolver __resolver ( RESOLV_NUMERIC ) = {
125 .resolv = numeric_resolv,
128 /***************************************************************************
130 * Name resolution multiplexer
132 ***************************************************************************
135 /** A name resolution multiplexer */
137 /** Reference counter */
138 struct refcnt refcnt;
139 /** Parent name resolution interface */
140 struct interface parent;
142 /** Child name resolution interface */
143 struct interface child;
144 /** Current child resolver */
145 struct resolver *resolver;
147 /** Socket address to complete */
149 /** Name to be resolved
151 * Must be at end of structure
157 * Try current child name resolver
159 * @v mux Name resolution multiplexer
160 * @ret rc Return status code
162 static int resmux_try ( struct resolv_mux *mux ) {
163 struct resolver *resolver = mux->resolver;
166 DBGC ( mux, "RESOLV %p trying method %s\n", mux, resolver->name );
168 if ( ( rc = resolver->resolv ( &mux->child, mux->name,
169 &mux->sa ) ) != 0 ) {
170 DBGC ( mux, "RESOLV %p could not use method %s: %s\n",
171 mux, resolver->name, strerror ( rc ) );
179 * Child resolved name
181 * @v mux Name resolution multiplexer
182 * @v sa Completed socket address
184 static void resmux_child_resolv_done ( struct resolv_mux *mux,
185 struct sockaddr *sa ) {
187 DBGC ( mux, "RESOLV %p resolved \"%s\" to %s using method %s\n",
188 mux, mux->name, sock_ntoa ( sa ), mux->resolver->name );
190 /* Pass resolution to parent */
191 resolv_done ( &mux->parent, sa );
195 * Child finished resolution
197 * @v mux Name resolution multiplexer
198 * @v rc Return status code
200 static void resmux_child_close ( struct resolv_mux *mux, int rc ) {
202 /* Restart child interface */
203 intf_restart ( &mux->child, rc );
205 /* If this resolution succeeded, stop now */
207 DBGC ( mux, "RESOLV %p succeeded using method %s\n",
208 mux, mux->resolver->name );
212 /* Attempt next child resolver, if possible */
214 if ( mux->resolver >= table_end ( RESOLVERS ) ) {
215 DBGC ( mux, "RESOLV %p failed to resolve name\n", mux );
218 if ( ( rc = resmux_try ( mux ) ) != 0 )
221 /* Next resolver is now running */
225 intf_shutdown ( &mux->parent, rc );
228 /** Name resolution multiplexer child interface operations */
229 static struct interface_operation resmux_child_op[] = {
230 INTF_OP ( resolv_done, struct resolv_mux *, resmux_child_resolv_done ),
231 INTF_OP ( intf_close, struct resolv_mux *, resmux_child_close ),
234 /** Name resolution multiplexer child interface descriptor */
235 static struct interface_descriptor resmux_child_desc =
236 INTF_DESC ( struct resolv_mux, child, resmux_child_op );
239 * Start name resolution
241 * @v resolv Name resolution interface
242 * @v name Name to resolve
243 * @v sa Socket address to complete
244 * @ret rc Return status code
246 int resolv ( struct interface *resolv, const char *name,
247 struct sockaddr *sa ) {
248 struct resolv_mux *mux;
249 size_t name_len = ( strlen ( name ) + 1 );
252 /* Allocate and initialise structure */
253 mux = zalloc ( sizeof ( *mux ) + name_len );
256 ref_init ( &mux->refcnt, NULL );
257 intf_init ( &mux->parent, &null_intf_desc, &mux->refcnt );
258 intf_init ( &mux->child, &resmux_child_desc, &mux->refcnt );
259 mux->resolver = table_start ( RESOLVERS );
261 memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
262 memcpy ( mux->name, name, name_len );
264 DBGC ( mux, "RESOLV %p attempting to resolve \"%s\"\n", mux, name );
266 /* Start first resolver in chain. There will always be at
267 * least one resolver (the numeric resolver), so no need to
268 * check for the zero-resolvers-available case.
270 if ( ( rc = resmux_try ( mux ) ) != 0 )
273 /* Attach parent interface, mortalise self, and return */
274 intf_plug_plug ( &mux->parent, resolv );
275 ref_put ( &mux->refcnt );
279 ref_put ( &mux->refcnt );
283 /***************************************************************************
285 * Named socket opening
287 ***************************************************************************
290 /** A named socket */
291 struct named_socket {
292 /** Reference counter */
293 struct refcnt refcnt;
294 /** Data transfer interface */
295 struct interface xfer;
296 /** Name resolution interface */
297 struct interface resolv;
298 /** Communication semantics (e.g. SOCK_STREAM) */
300 /** Stored local socket address, if applicable */
301 struct sockaddr local;
302 /** Stored local socket address exists */
307 * Terminate named socket opener
309 * @v named Named socket
310 * @v rc Reason for termination
312 static void named_close ( struct named_socket *named, int rc ) {
313 /* Shut down interfaces */
314 intf_shutdown ( &named->resolv, rc );
315 intf_shutdown ( &named->xfer, rc );
319 * Check flow control window
321 * @v named Named socket
322 * @ret len Length of window
324 static size_t named_window ( struct named_socket *named __unused ) {
325 /* Not ready for data until we have redirected away */
329 /** Named socket opener data transfer interface operations */
330 static struct interface_operation named_xfer_ops[] = {
331 INTF_OP ( xfer_window, struct named_socket *, named_window ),
332 INTF_OP ( intf_close, struct named_socket *, named_close ),
335 /** Named socket opener data transfer interface descriptor */
336 static struct interface_descriptor named_xfer_desc =
337 INTF_DESC ( struct named_socket, xfer, named_xfer_ops );
342 * @v named Named socket
343 * @v sa Completed socket address
345 static void named_resolv_done ( struct named_socket *named,
346 struct sockaddr *sa ) {
349 /* Nullify data transfer interface */
350 intf_nullify ( &named->xfer );
352 /* Redirect data-xfer interface */
353 if ( ( rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
354 named->semantics, sa,
355 ( named->have_local ?
356 &named->local : NULL ) ) ) != 0 ) {
357 /* Redirection failed - do not unplug data-xfer interface */
358 DBGC ( named, "NAMED %p could not redirect: %s\n",
359 named, strerror ( rc ) );
361 /* Redirection succeeded - unplug data-xfer interface */
362 DBGC ( named, "NAMED %p redirected successfully\n", named );
363 intf_unplug ( &named->xfer );
366 /* Terminate named socket opener */
367 named_close ( named, rc );
370 /** Named socket opener resolver interface operations */
371 static struct interface_operation named_resolv_op[] = {
372 INTF_OP ( intf_close, struct named_socket *, named_close ),
373 INTF_OP ( resolv_done, struct named_socket *, named_resolv_done ),
376 /** Named socket opener resolver interface descriptor */
377 static struct interface_descriptor named_resolv_desc =
378 INTF_DESC ( struct named_socket, resolv, named_resolv_op );
383 * @v semantics Communication semantics (e.g. SOCK_STREAM)
384 * @v peer Peer socket address to complete
385 * @v name Name to resolve
386 * @v local Local socket address, or NULL
387 * @ret rc Return status code
389 int xfer_open_named_socket ( struct interface *xfer, int semantics,
390 struct sockaddr *peer, const char *name,
391 struct sockaddr *local ) {
392 struct named_socket *named;
395 /* Allocate and initialise structure */
396 named = zalloc ( sizeof ( *named ) );
399 ref_init ( &named->refcnt, NULL );
400 intf_init ( &named->xfer, &named_xfer_desc, &named->refcnt );
401 intf_init ( &named->resolv, &named_resolv_desc, &named->refcnt );
402 named->semantics = semantics;
404 memcpy ( &named->local, local, sizeof ( named->local ) );
405 named->have_local = 1;
408 DBGC ( named, "NAMED %p opening \"%s\"\n",
411 /* Start name resolution */
412 if ( ( rc = resolv ( &named->resolv, name, peer ) ) != 0 )
415 /* Attach parent interface, mortalise self, and return */
416 intf_plug_plug ( &named->xfer, xfer );
417 ref_put ( &named->refcnt );
421 ref_put ( &named->refcnt );