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/resolv.h>
  25
  26 /** @file
  27  *
  28  * Name resolution
  29  *
  30  */
  31
  32 static struct async_operations resolv_async_operations;
  33
  34 /** Registered name resolvers */
  35 static struct resolver resolvers[0]
  36         __table_start ( struct resolver, resolvers );
  37 static struct resolver resolvers_end[0]
  38         __table_end ( struct resolver, resolvers );
  39
  40 /**
  41  * Start name resolution
  42  *
  43  * @v name              Host name to resolve
  44  * @v sa                Socket address to fill in
  45  * @v parent            Parent asynchronous operation
  46  * @ret rc              Return status code
  47  */
  48 int resolv ( const char *name, struct sockaddr *sa, struct async *parent ) {
  49         struct resolution *resolution;
  50         struct resolver *resolver;
  51         struct sockaddr_in *sin = ( struct sockaddr_in * ) sa;
  52         struct in_addr in;
  53         int rc = -ENXIO;
  54
  55         /* Allocate and populate resolution structure */
  56         resolution = malloc ( sizeof ( *resolution ) );
  57         if ( ! resolution )
  58                 return -ENOMEM;
  59         async_init ( &resolution->async, &resolv_async_operations, parent );
  60
  61         /* Check for a dotted quad IP address first */
  62         if ( inet_aton ( name, &in ) != 0 ) {
  63                 DBGC ( resolution, "RESOLV %p saw valid IP address %s\n",
  64                        resolution, name );
  65                 sin->sin_family = AF_INET;
  66                 sin->sin_addr = in;
  67                 async_done ( &resolution->async, 0 );
  68                 return 0;
  69         }
  70
  71         /* Start up all resolvers */
  72         for ( resolver = resolvers ; resolver < resolvers_end ; resolver++ ) {
  73                 if ( ( rc = resolver->resolv ( name, sa,
  74                                                &resolution->async ) ) != 0 ) {
  75                         DBGC ( resolution, "RESOLV %p could not start %s: "
  76                                "%s\n", resolution, resolver->name,
  77                                strerror ( rc ) );
  78                         /* Continue to try other resolvers */
  79                         continue;
  80                 }
  81                 (resolution->pending)++;
  82         }
  83         if ( ! resolution->pending )
  84                 goto err;
  85
  86         return 0;
  87
  88  err:
  89         async_uninit ( &resolution->async );
  90         free ( resolution );
  91         return rc;
  92 }
  93
  94 /**
  95  * Handle child name resolution completion
  96  *
  97  * @v async             Name resolution asynchronous operation
  98  * @v signal            SIGCHLD
  99  */
 100 static void resolv_sigchld ( struct async *async,
 101                              enum signal signal __unused ) {
 102         struct resolution *resolution =
 103                 container_of ( async, struct resolution, async );
 104         int rc;
 105
 106         /* If this child succeeded, kill all the others and return */
 107         async_wait ( async, &rc, 1 );
 108         if ( rc == 0 ) {
 109                 async_signal_children ( async, SIGKILL );
 110                 async_done ( async, 0 );
 111                 return;
 112         }
 113
 114         /* If we have no children left, return failure */
 115         if ( --(resolution->pending) == 0 )
 116                 async_done ( async, -ENXIO );
 117 }
 118
 119 /**
 120  * Free name resolution structure
 121  *
 122  * @v async             Asynchronous operation
 123  */
 124 static void resolv_reap ( struct async *async ) {
 125         free ( container_of ( async, struct resolution, async ) );
 126 }
 127
 128 /** Name resolution asynchronous operations */
 129 static struct async_operations resolv_async_operations = {
 130         .reap = resolv_reap,
 131         .signal = {
 132                 [SIGCHLD] = resolv_sigchld,
 133         },
 134 };