src/ngircd/resolve.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
   4  *
   5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
   6  * der GNU General Public License (GPL), wie von der Free Software Foundation
   7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
   8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
   9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
  10  * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
  11  *
  12  * $Id: resolve.c,v 1.1 2002/05/27 11:23:27 alex Exp $
  13  *
  14  * resolve.c: asyncroner Resolver
  15  */
  16
  17
  18 #include "portab.h"
  19
  20 #include "imp.h"
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <sys/socket.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29 #include <netdb.h>
  30
  31 #include "conn.h"
  32 #include "defines.h"
  33 #include "log.h"
  34
  35 #include "exp.h"
  36 #include "resolve.h"
  37
  38
  39 LOCAL VOID Do_ResolveAddr PARAMS(( struct sockaddr_in *Addr, INT w_fd ));
  40 LOCAL VOID Do_ResolveName PARAMS(( CHAR *Host, INT w_fd ));
  41
  42 #ifdef h_errno
  43 LOCAL CHAR *Resolve_Error PARAMS(( INT H_Error ));
  44 #endif
  45
  46
  47 GLOBAL VOID
  48 Resolve_Init( VOID )
  49 {
  50         /* Modul initialisieren */
  51
  52         FD_ZERO( &Resolver_FDs );
  53 } /* Resolve_Init */
  54
  55
  56 GLOBAL RES_STAT *
  57 Resolve_Addr( struct sockaddr_in *Addr )
  58 {
  59         /* IP (asyncron!) aufloesen. Bei Fehler, z.B. wenn der
  60          * Child-Prozess nicht erzeugt werden kann, wird NULL geliefert.
  61          * Der Host kann dann nicht aufgeloest werden. */
  62
  63         RES_STAT *s;
  64         INT pid;
  65
  66         /* Speicher anfordern */
  67         s = malloc( sizeof( RES_STAT ));
  68         if( ! s )
  69         {
  70                 Log( LOG_EMERG, "Resolver: Can't allocate memory!" );
  71                 return NULL;
  72         }
  73
  74         /* Pipe fuer Antwort initialisieren */
  75         if( pipe( s->pipe ) != 0 )
  76         {
  77                 free( s );
  78                 Log( LOG_ALERT, "Resolver: Can't create output pipe: %s!", strerror( errno ));
  79                 return NULL;
  80         }
  81
  82         /* Sub-Prozess erzeugen */
  83         pid = fork( );
  84         if( pid > 0 )
  85         {
  86                 /* Haupt-Prozess */
  87                 Log( LOG_DEBUG, "Resolver for %s created (PID %d).", inet_ntoa( Addr->sin_addr ), pid );
  88                 FD_SET( s->pipe[0], &Resolver_FDs );
  89                 if( s->pipe[0] > Conn_MaxFD ) Conn_MaxFD = s->pipe[0];
  90                 s->pid = pid;
  91                 return s;
  92         }
  93         else if( pid == 0 )
  94         {
  95                 /* Sub-Prozess */
  96                 Log_Init_Resolver( );
  97                 Do_ResolveAddr( Addr, s->pipe[1] );
  98                 Log_Exit_Resolver( );
  99                 exit( 0 );
 100         }
 101         else
 102         {
 103                 /* Fehler */
 104                 free( s );
 105                 Log( LOG_CRIT, "Resolver: Can't fork: %s!", strerror( errno ));
 106                 return NULL;
 107         }
 108 } /* Resolve_Addr */
 109
 110
 111 GLOBAL RES_STAT *
 112 Resolve_Name( CHAR *Host )
 113 {
 114         /* Hostnamen (asyncron!) aufloesen. Bei Fehler, z.B. wenn der
 115          * Child-Prozess nicht erzeugt werden kann, wird NULL geliefert.
 116          * Der Host kann dann nicht aufgeloest werden. */
 117
 118         RES_STAT *s;
 119         INT pid;
 120
 121         /* Speicher anfordern */
 122         s = malloc( sizeof( RES_STAT ));
 123         if( ! s )
 124         {
 125                 Log( LOG_EMERG, "Resolver: Can't allocate memory!" );
 126                 return NULL;
 127         }
 128
 129         /* Pipe fuer Antwort initialisieren */
 130         if( pipe( s->pipe ) != 0 )
 131         {
 132                 free( s );
 133                 Log( LOG_ALERT, "Resolver: Can't create output pipe: %s!", strerror( errno ));
 134                 return NULL;
 135         }
 136
 137         /* Sub-Prozess erzeugen */
 138         pid = fork( );
 139         if( pid > 0 )
 140         {
 141                 /* Haupt-Prozess */
 142                 Log( LOG_DEBUG, "Resolver for \"%s\" created (PID %d).", Host, pid );
 143                 FD_SET( s->pipe[0], &Resolver_FDs );
 144                 if( s->pipe[0] > Conn_MaxFD ) Conn_MaxFD = s->pipe[0];
 145                 s->pid = pid;
 146                 return s;
 147         }
 148         else if( pid == 0 )
 149         {
 150                 /* Sub-Prozess */
 151                 Log_Init_Resolver( );
 152                 Do_ResolveName( Host, s->pipe[1] );
 153                 Log_Exit_Resolver( );
 154                 exit( 0 );
 155         }
 156         else
 157         {
 158                 /* Fehler */
 159                 free( s );
 160                 Log( LOG_CRIT, "Resolver: Can't fork: %s!", strerror( errno ));
 161                 return NULL;
 162         }
 163 } /* Resolve_Name */
 164
 165
 166 LOCAL VOID
 167 Do_ResolveAddr( struct sockaddr_in *Addr, INT w_fd )
 168 {
 169         /* Resolver Sub-Prozess: IP aufloesen und Ergebnis in Pipe schreiben. */
 170
 171         CHAR hostname[HOST_LEN];
 172         struct hostent *h;
 173
 174         Log_Resolver( LOG_DEBUG, "Now resolving %s ...", inet_ntoa( Addr->sin_addr ));
 175
 176         /* Namen aufloesen */
 177         h = gethostbyaddr( (CHAR *)&Addr->sin_addr, sizeof( Addr->sin_addr ), AF_INET );
 178         if( h ) strcpy( hostname, h->h_name );
 179         else
 180         {
 181 #ifdef h_errno
 182                 Log_Resolver( LOG_WARNING, "Can't resolve address \"%s\": %s!", inet_ntoa( Addr->sin_addr ), Get_Error( h_errno ));
 183 #else
 184                 Log_Resolver( LOG_WARNING, "Can't resolve address \"%s\"!", inet_ntoa( Addr->sin_addr ));
 185 #endif
 186                 strcpy( hostname, inet_ntoa( Addr->sin_addr ));
 187         }
 188
 189         /* Antwort an Parent schreiben */
 190         if( write( w_fd, hostname, strlen( hostname ) + 1 ) != ( strlen( hostname ) + 1 ))
 191         {
 192                 Log_Resolver( LOG_CRIT, "Resolver: Can't write to parent: %s!", strerror( errno ));
 193                 close( w_fd );
 194                 return;
 195         }
 196
 197         Log_Resolver( LOG_DEBUG, "Ok, translated %s to \"%s\".", inet_ntoa( Addr->sin_addr ), hostname );
 198 } /* Do_ResolveAddr */
 199
 200
 201 LOCAL VOID
 202 Do_ResolveName( CHAR *Host, INT w_fd )
 203 {
 204         /* Resolver Sub-Prozess: Name aufloesen und Ergebnis in Pipe schreiben. */
 205
 206         CHAR ip[16];
 207         struct hostent *h;
 208         struct in_addr *addr;
 209
 210         Log_Resolver( LOG_DEBUG, "Now resolving \"%s\" ...", Host );
 211
 212         /* Namen aufloesen */
 213         h = gethostbyname( Host );
 214         if( h )
 215         {
 216                 addr = (struct in_addr *)h->h_addr;
 217                 strcpy( ip, inet_ntoa( *addr ));
 218         }
 219         else
 220         {
 221 #ifdef h_errno
 222                 Log_Resolver( LOG_WARNING, "Can't resolve \"%s\": %s!", Host, Get_Error( h_errno ));
 223 #else
 224                 Log_Resolver( LOG_WARNING, "Can't resolve \"%s\"!", Host );
 225 #endif
 226                 strcpy( ip, "" );
 227         }
 228
 229         /* Antwort an Parent schreiben */
 230         if( write( w_fd, ip, strlen( ip ) + 1 ) != ( strlen( ip ) + 1 ))
 231         {
 232                 Log_Resolver( LOG_CRIT, "Resolver: Can't write to parent: %s!", strerror( errno ));
 233                 close( w_fd );
 234                 return;
 235         }
 236
 237         if( ip[0] ) Log_Resolver( LOG_DEBUG, "Ok, translated \"%s\" to %s.", Host, ip );
 238 } /* Do_ResolveName */
 239
 240
 241 #ifdef h_errno
 242
 243 LOCAL CHAR *
 244 Get_Error( INT H_Error )
 245 {
 246         /* Fehlerbeschreibung fuer H_Error liefern */
 247
 248         switch( H_Error )
 249         {
 250                 case HOST_NOT_FOUND:
 251                         return "host not found";
 252                 case NO_DATA:
 253                         return "name valid but no IP address defined";
 254                 case NO_RECOVERY:
 255                         return "name server error";
 256                 case TRY_AGAIN:
 257                         return "name server temporary not available";
 258                 default:
 259                         return "unknown error";
 260         }
 261 } /* Get_Error */
 262
 263 #endif
 264
 265
 266 /* -eof- */