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         memset ( resolution, 0, sizeof ( *resolution ) );
  60         async_init ( &resolution->async, &resolv_async_operations, parent );
  61
  62         /* Check for a dotted quad IP address first */
  63         if ( inet_aton ( name, &in ) != 0 ) {
  64                 DBGC ( resolution, "RESOLV %p saw valid IP address %s\n",
  65                        resolution, name );
  66                 sin->sin_family = AF_INET;
  67                 sin->sin_addr = in;
  68                 async_done ( &resolution->async, 0 );
  69                 return 0;
  70         }
  71
  72         /* Start up all resolvers */
  73         for ( resolver = resolvers ; resolver < resolvers_end ; resolver++ ) {
  74                 if ( ( rc = resolver->resolv ( name, sa,
  75                                                &resolution->async ) ) != 0 ) {
  76                         DBGC ( resolution, "RESOLV %p could not start %s: "
  77                                "%s\n", resolution, resolver->name,
  78                                strerror ( rc ) );
  79                         /* Continue to try other resolvers */
  80                         continue;
  81                 }
  82                 (resolution->pending)++;
  83         }
  84         if ( ! resolution->pending )
  85                 goto err;
  86
  87         return 0;
  88
  89  err:
  90         async_uninit ( &resolution->async );
  91         free ( resolution );
  92         return rc;
  93 }
  94
  95 /**
  96  * Handle child name resolution completion
  97  *
  98  * @v async             Name resolution asynchronous operation
  99  * @v signal            SIGCHLD
 100  */
 101 static void resolv_sigchld ( struct async *async,
 102                              enum signal signal __unused ) {
 103         struct resolution *resolution =
 104                 container_of ( async, struct resolution, async );
 105         int rc;
 106
 107         /* Reap the child */
 108         async_wait ( async, &rc, 1 );
 109
 110         /* If this child succeeded, kill all the others.  They should
 111          * immediately die (invoking resolv_sigchld() again, which
 112          * won't do anything because the exit status is non-zero and
 113          * the pending count won't reach zero until this instance
 114          * completes).
 115          */
 116         if ( rc == 0 )
 117                 async_signal_children ( async, SIGKILL );
 118
 119         /* When we have no children left, exit */
 120         if ( --(resolution->pending) == 0 )
 121                 async_done ( async, rc );
 122 }
 123
 124 /**
 125  * Free name resolution structure
 126  *
 127  * @v async             Asynchronous operation
 128  */
 129 static void resolv_reap ( struct async *async ) {
 130         free ( container_of ( async, struct resolution, async ) );
 131 }
 132
 133 /** Name resolution asynchronous operations */
 134 static struct async_operations resolv_async_operations = {
 135         .reap = resolv_reap,
 136         .signal = {
 137                 [SIGKILL] = async_signal_children,
 138                 [SIGCHLD] = resolv_sigchld,
 139         },
 140 };