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