Introduce name resolution interface and named socket opener.
[people/dverkamp/gpxe.git] / src / core / resolv.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
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.
8  *
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.
13  *
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., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <gpxe/in.h>
24 #include <gpxe/xfer.h>
25 #include <gpxe/open.h>
26 #include <gpxe/process.h>
27 #include <gpxe/resolv.h>
28
29 /** @file
30  *
31  * Name resolution
32  *
33  */
34
35 /***************************************************************************
36  *
37  * Name resolution interfaces
38  *
39  ***************************************************************************
40  */
41
42 /**
43  * Name resolution completed
44  *
45  * @v resolv            Name resolution interface
46  * @v sa                Completed socket address (if successful)
47  * @v rc                Final status code
48  */
49 void resolv_done ( struct resolv_interface *resolv, struct sockaddr *sa,
50                    int rc ) {
51         struct resolv_interface *dest = resolv_get_dest ( resolv );
52
53         dest->op->done ( dest, sa, rc );
54         resolv_unplug ( resolv );
55         resolv_put ( dest );
56 }
57
58 /**
59  * Ignore name resolution done() event
60  *
61  * @v resolv            Name resolution interface
62  * @v sa                Completed socket address (if successful)
63  * @v rc                Final status code
64  */
65 void ignore_resolv_done ( struct resolv_interface *resolv __unused,
66                           struct sockaddr *sa __unused, int rc __unused ) {
67         /* Do nothing */
68 }
69
70 /** Null name resolution interface operations */
71 struct resolv_interface_operations null_resolv_ops = {
72         .done           = ignore_resolv_done,
73 };
74
75 /** Null name resolution interface */
76 struct resolv_interface null_resolv = {
77         .intf = {
78                 .dest = &null_resolv.intf,
79                 .refcnt = NULL,
80         },
81         .op = &null_resolv_ops,
82 };
83
84 /***************************************************************************
85  *
86  * Numeric name resolver
87  *
88  ***************************************************************************
89  */
90
91 /** A numeric name resolver */
92 struct numeric_resolv {
93         /** Reference counter */
94         struct refcnt refcnt;
95         /** Name resolution interface */
96         struct resolv_interface resolv;
97         /** Process */
98         struct process process;
99         /** Completed socket address */
100         struct sockaddr sa;
101         /** Overall status code */
102         int rc;
103 };
104
105 static void numeric_step ( struct process *process ) {
106         struct numeric_resolv *numeric =
107                 container_of ( process, struct numeric_resolv, process );
108         
109         resolv_done ( &numeric->resolv, &numeric->sa, numeric->rc );
110         process_del ( process );
111 }
112
113 static int numeric_resolv ( struct resolv_interface *resolv,
114                             const char *name, struct sockaddr *sa ) {
115         struct numeric_resolv *numeric;
116         struct sockaddr_in *sin;
117
118         /* Allocate and initialise structure */
119         numeric = malloc ( sizeof ( *numeric ) );
120         if ( ! numeric )
121                 return -ENOMEM;
122         memset ( numeric, 0, sizeof ( *numeric ) );
123         resolv_init ( &numeric->resolv, &null_resolv_ops, &numeric->refcnt );
124         process_init ( &numeric->process, numeric_step, &numeric->refcnt );
125         memcpy ( &numeric->sa, sa, sizeof ( numeric->sa ) );
126
127         DBGC ( numeric, "NUMERIC %p attempting to resolve \"%s\"\n",
128                numeric, name );
129
130         /* Attempt to resolve name */
131         sin = ( ( struct sockaddr_in * ) &numeric->sa );
132         sin->sin_family = AF_INET;
133         if ( inet_aton ( name, &sin->sin_addr ) == 0 )
134                 numeric->rc = -EINVAL;
135
136         /* Attach to parent interface, mortalise self, and return */
137         resolv_plug_plug ( &numeric->resolv, resolv );
138         ref_put ( &numeric->refcnt );
139         return 0;
140 }
141
142 struct resolver numeric_resolver __resolver ( RESOLV_NUMERIC ) = {
143         .name = "NUMERIC",
144         .resolv = numeric_resolv,
145 };
146
147 /***************************************************************************
148  *
149  * Name resolution multiplexer
150  *
151  ***************************************************************************
152  */
153
154 /** Registered name resolvers */
155 static struct resolver resolvers[0]
156         __table_start ( struct resolver, resolvers );
157 static struct resolver resolvers_end[0]
158         __table_end ( struct resolver, resolvers );
159
160 /** A name resolution multiplexer */
161 struct resolv_mux {
162         /** Reference counter */
163         struct refcnt refcnt;
164         /** Parent name resolution interface */
165         struct resolv_interface parent;
166
167         /** Child name resolution interface */
168         struct resolv_interface child;
169         /** Current child resolver */
170         struct resolver *resolver;
171
172         /** Socket address to complete */
173         struct sockaddr sa;
174         /** Name to be resolved
175          *
176          * Must be at end of structure
177          */
178         char name[0];
179 };
180
181 /**
182  * Try current child name resolver
183  *
184  * @v mux               Name resolution multiplexer
185  * @ret rc              Return status code
186  */
187 static int resolv_mux_try ( struct resolv_mux *mux ) {
188         struct resolver *resolver = mux->resolver;
189         int rc;
190
191         DBGC ( mux, "RESOLV %p trying method %s\n", mux, resolver->name );
192
193         if ( ( rc = resolver->resolv ( &mux->child, mux->name,
194                                        &mux->sa ) ) != 0 ) {
195                 DBGC ( mux, "RESOLV %p could not use method %s: %s\n",
196                        mux, resolver->name, strerror ( rc ) );
197                 return rc;
198         }
199
200         return 0;
201 }
202
203 /**
204  * Handle done() event from child name resolver
205  *
206  * @v resolv            Child name resolution interface
207  * @v sa                Completed socket address (if successful)
208  * @v rc                Final status code
209  */
210 static void resolv_mux_done ( struct resolv_interface *resolv,
211                               struct sockaddr *sa, int rc ) {
212         struct resolv_mux *mux =
213                 container_of ( resolv, struct resolv_mux, child );
214
215         /* Unplug child */
216         resolv_unplug ( &mux->child );
217
218         /* If this resolution succeeded, stop now */
219         if ( rc == 0 ) {
220                 DBGC ( mux, "RESOLV %p succeeded using method %s\n",
221                        mux, mux->resolver->name );
222                 goto finished;
223         }
224
225         /* Attempt next child resolver, if possible */
226         mux->resolver++;
227         if ( mux->resolver >= resolvers_end ) {
228                 DBGC ( mux, "RESOLV %p failed to resolve name\n", mux );
229                 goto finished;
230         }
231         if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
232                 goto finished;
233
234         /* Next resolver is now running */
235         return;
236         
237  finished:
238         resolv_done ( &mux->parent, sa, rc );
239 }
240
241 /** Name resolution multiplexer operations */
242 static struct resolv_interface_operations resolv_mux_child_ops = {
243         .done           = resolv_mux_done,
244 };
245
246 /**
247  * Start name resolution
248  *
249  * @v resolv            Name resolution interface
250  * @v name              Name to resolve
251  * @v sa                Socket address to complete
252  * @ret rc              Return status code
253  */
254 int resolv ( struct resolv_interface *resolv, const char *name,
255              struct sockaddr *sa ) {
256         struct resolv_mux *mux;
257         size_t name_len = ( strlen ( name ) + 1 );
258         int rc;
259
260         /* Allocate and initialise structure */
261         mux = malloc ( sizeof ( *mux ) + name_len );
262         if ( ! mux )
263                 return -ENOMEM;
264         memset ( mux, 0, sizeof ( *mux ) );
265         resolv_init ( &mux->parent, &null_resolv_ops, &mux->refcnt );
266         resolv_init ( &mux->child, &resolv_mux_child_ops, &mux->refcnt );
267         mux->resolver = resolvers;
268         memcpy ( &mux->sa, sa, sizeof ( mux->sa ) );
269         memcpy ( mux->name, name, name_len );
270
271         DBGC ( mux, "RESOLV %p attempting to resolve \"%s\"\n", mux, name );
272
273         /* Start first resolver in chain.  There will always be at
274          * least one resolver (the numeric resolver), so no need to
275          * check for the zero-resolvers-available case.
276          */
277         if ( ( rc = resolv_mux_try ( mux ) ) != 0 )
278                 goto err;
279
280         /* Attach parent interface, mortalise self, and return */
281         resolv_plug_plug ( &mux->parent, resolv );
282         ref_put ( &mux->refcnt );
283         return 0;
284
285  err:
286         ref_put ( &mux->refcnt );
287         return rc;      
288 }
289
290 /***************************************************************************
291  *
292  * Named socket opening
293  *
294  ***************************************************************************
295  */
296
297 /** A named socket */
298 struct named_socket {
299         /** Reference counter */
300         struct refcnt refcnt;
301         /** Data transfer interface */
302         struct xfer_interface xfer;
303         /** Name resolution interface */
304         struct resolv_interface resolv;
305         /** Communication semantics (e.g. SOCK_STREAM) */
306         int semantics;
307         /** Stored local socket address, if applicable */
308         struct sockaddr local;
309         /** Stored local socket address exists */
310         int have_local;
311 };
312
313 /**
314  * Handle seek() event
315  *
316  * @v xfer              Data transfer interface
317  * @v offset            Offset to new position
318  * @v whence            Basis for new position
319  * @ret rc              Return status code
320  */
321 static int resolv_xfer_seek ( struct xfer_interface *xfer __unused,
322                               off_t offset __unused, int whence __unused ) {
323         /* Never ready to accept data */
324         return -EAGAIN;
325 }
326
327 /** Named socket opener data transfer interface operations */
328 static struct xfer_interface_operations named_xfer_ops = {
329         .close          = ignore_xfer_close,
330         .vredirect      = ignore_xfer_vredirect,
331         .request        = ignore_xfer_request,
332         .seek           = resolv_xfer_seek,
333         .alloc_iob      = default_xfer_alloc_iob,
334         .deliver_iob    = xfer_deliver_as_raw,
335         .deliver_raw    = ignore_xfer_deliver_raw,
336 };
337
338 /**
339  * Handle done() event
340  *
341  * @v resolv            Name resolution interface
342  * @v sa                Completed socket address (if successful)
343  * @v rc                Final status code
344  */
345 static void named_resolv_done ( struct resolv_interface *resolv,
346                                 struct sockaddr *sa, int rc ) {
347         struct named_socket *named =
348                 container_of ( resolv, struct named_socket, resolv );
349
350         /* Unplug resolver and nullify data transfer interface */
351         resolv_unplug ( &named->resolv );
352         xfer_nullify ( &named->xfer );
353
354         /* Redirect if name resolution was successful */
355         if ( rc == 0 ) {
356                 rc = xfer_redirect ( &named->xfer, LOCATION_SOCKET,
357                                      named->semantics, sa,
358                                      ( named->have_local ?
359                                        &named->local : NULL ) );
360         }
361
362         /* Close data transfer interface if redirection failed */
363         if ( rc != 0 )
364                 xfer_close ( &named->xfer, rc );
365
366         /* Unplug data transfer interface */
367         xfer_unplug ( &named->xfer );
368 }
369
370 /** Named socket opener name resolution interface operations */
371 static struct resolv_interface_operations named_resolv_ops = {
372         .done           = named_resolv_done,
373 };
374
375 /**
376  * Open named socket
377  *
378  * @v semantics         Communication semantics (e.g. SOCK_STREAM)
379  * @v peer              Peer socket address to complete
380  * @v name              Name to resolve
381  * @v local             Local socket address, or NULL
382  * @ret rc              Return status code
383  */
384 int xfer_open_named_socket ( struct xfer_interface *xfer, int semantics,
385                              struct sockaddr *peer, const char *name,
386                              struct sockaddr *local ) {
387         struct named_socket *named;
388         int rc;
389
390         /* Allocate and initialise structure */
391         named = malloc ( sizeof ( *named ) );
392         if ( ! named )
393                 return -ENOMEM;
394         memset ( named, 0, sizeof ( *named ) );
395         xfer_init ( &named->xfer, &named_xfer_ops, &named->refcnt );
396         resolv_init ( &named->resolv, &named_resolv_ops, &named->refcnt );
397         named->semantics = semantics;
398         if ( local ) {
399                 memcpy ( &named->local, local, sizeof ( named->local ) );
400                 named->have_local = 1;
401         }
402
403         DBGC ( named, "RESOLV %p opening named socket \"%s\"\n",
404                named, name );
405
406         /* Start name resolution */
407         if ( ( rc = resolv ( &named->resolv, name, peer ) ) != 0 )
408                 goto err;
409
410         /* Attach parent interface, mortalise self, and return */
411         xfer_plug_plug ( &named->xfer, xfer );
412         ref_put ( &named->refcnt );
413         return 0;
414
415  err:
416         ref_put ( &named->refcnt );
417         return rc;
418 }