granicus.if.org Git - apache/blob - support/logresolve.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * logresolve 2.0
  19  *
  20  * Tom Rathborne - tomr uunet.ca - http://www.uunet.ca/~tomr/
  21  * UUNET Canada, April 16, 1995
  22  *
  23  * Rewritten by David Robinson. (drtr ast.cam.ac.uk)
  24  * Rewritten again, and ported to APR by Colm MacCarthaigh
  25  *
  26  * Usage: logresolve [-s filename] [-c] < access_log > new_log
  27  *
  28  * Arguments:
  29  *    -s filename     name of a file to record statistics
  30  *    -c              check the DNS for a matching A record for the host.
  31  *
  32  * Notes:             (For historical interest)
  33  *
  34  * To generate meaningful statistics from an HTTPD log file, it's good
  35  * to have the domain name of each machine that accessed your site, but
  36  * doing this on the fly can slow HTTPD down.
  37  *
  38  * Compiling NCSA HTTPD with the -DMINIMAL_DNS flag turns IP#->hostname
  39  * resolution off. Before running your stats program, just run your log
  40  * file through this program (logresolve) and all of your IP numbers will
  41  * be resolved into hostnames (where possible).
  42  *
  43  * logresolve takes an HTTPD access log (in the COMMON log file format,
  44  * or any other format that has the IP number/domain name as the first
  45  * field for that matter), and outputs the same file with all of the
  46  * domain names looked up. Where no domain name can be found, the IP
  47  * number is left in.
  48  *
  49  * To minimize impact on your nameserver, logresolve has its very own
  50  * internal hash-table cache. This means that each IP number will only
  51  * be looked up the first time it is found in the log file.
  52  *
  53  * The -c option causes logresolve to apply the same check as httpd
  54  * compiled with -DMAXIMUM_DNS; after finding the hostname from the IP
  55  * address, it looks up the IP addresses for the hostname and checks
  56  * that one of these matches the original address.
  57  */
  58
  59 #include "apr.h"
  60 #include "apr_lib.h"
  61 #include "apr_hash.h"
  62 #include "apr_getopt.h"
  63 #include "apr_strings.h"
  64 #include "apr_file_io.h"
  65 #include "apr_network_io.h"
  66
  67 #if APR_HAVE_STDLIB_H
  68 #include <stdlib.h>
  69 #endif
  70
  71 #define READ_BUF_SIZE 10240
  72 #define WRITE_BUF_SIZE 10240
  73 #define LINE_BUF_SIZE 2048
  74
  75 static apr_file_t *errfile;
  76 static const char *shortname = "logresolve";
  77 static apr_hash_t *cache;
  78
  79 /* Statistics */
  80 static int cachehits = 0;
  81 static int cachesize = 0;
  82 static int entries = 0;
  83 static int resolves = 0;
  84 static int withname = 0;
  85 static int doublefailed = 0;
  86 static int noreverse = 0;
  87
  88 /*
  89  * prints various statistics to output
  90  */
  91 #define NL APR_EOL_STR
  92 static void print_statistics (apr_file_t *output)
  93 {
  94     apr_file_printf(output, "logresolve Statistics:" NL);
  95     apr_file_printf(output, "Entries: %d" NL, entries);
  96     apr_file_printf(output, "    With name   : %d" NL, withname);
  97     apr_file_printf(output, "    Resolves    : %d" NL, resolves);
  98
  99     if (noreverse) {
 100         apr_file_printf(output, "    - No reverse : %d" NL,
 101                         noreverse);
 102     }
 103
 104     if (doublefailed) {
 105         apr_file_printf(output, "    - Double lookup failed : %d" NL,
 106                         doublefailed);
 107     }
 108
 109     apr_file_printf(output, "Cache hits      : %d" NL, cachehits);
 110     apr_file_printf(output, "Cache size      : %d" NL, cachesize);
 111 }
 112
 113 /*
 114  * usage info
 115  */
 116 static void usage(void)
 117 {
 118     apr_file_printf(errfile,
 119     "%s -- Resolve IP-addresses to hostnames in Apache log files."           NL
 120     "Usage: %s [-s STATFILE] [-c]"                                           NL
 121                                                                              NL
 122     "Options:"                                                               NL
 123     "  -s   Record statistics to STATFILE when finished."                    NL
 124                                                                              NL
 125     "  -c   Perform double lookups when resolving IP addresses."            NL,
 126     shortname, shortname);
 127     exit(1);
 128 }
 129 #undef NL
 130
 131 int main(int argc, const char * const argv[])
 132 {
 133     apr_file_t * outfile;
 134     apr_file_t * infile;
 135     apr_getopt_t * o;
 136     apr_pool_t * pool;
 137     apr_pool_t *pline;
 138     apr_status_t status;
 139     const char * arg;
 140     char * stats = NULL;
 141 #if APR_MAJOR_VERSION > 1 || (APR_MAJOR_VERSION == 1 && APR_MINOR_VERSION >= 3)
 142     char * inbuffer;
 143     char * outbuffer;
 144 #endif
 145     char line[LINE_BUF_SIZE];
 146     int doublelookups = 0;
 147
 148     if (apr_app_initialize(&argc, &argv, NULL) != APR_SUCCESS) {
 149         return 1;
 150     }
 151     atexit(apr_terminate);
 152
 153     if (argc) {
 154         shortname = apr_filepath_name_get(argv[0]);
 155     }
 156
 157     if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
 158         return 1;
 159     }
 160     apr_file_open_stderr(&errfile, pool);
 161     apr_getopt_init(&o, pool, argc, argv);
 162
 163     while (1) {
 164         char opt;
 165         status = apr_getopt(o, "s:c", &opt, &arg);
 166         if (status == APR_EOF) {
 167             break;
 168         }
 169         else if (status != APR_SUCCESS) {
 170             usage();
 171         }
 172         else {
 173             switch (opt) {
 174             case 'c':
 175                 if (doublelookups) {
 176                     usage();
 177                 }
 178                 doublelookups = 1;
 179                 break;
 180             case 's':
 181                 if (stats) {
 182                     usage();
 183                 }
 184                 stats = apr_pstrdup(pool, arg);
 185                 break;
 186             } /* switch */
 187         } /* else */
 188     } /* while */
 189
 190     apr_file_open_stdout(&outfile, pool);
 191     apr_file_open_stdin(&infile, pool);
 192
 193 #if APR_MAJOR_VERSION > 1 || (APR_MAJOR_VERSION == 1 && APR_MINOR_VERSION >= 3)
 194     /* Allocate two new 10k file buffers */
 195     if ((outbuffer = apr_palloc(pool, WRITE_BUF_SIZE)) == NULL ||
 196         (inbuffer = apr_palloc(pool, READ_BUF_SIZE)) == NULL) {
 197         return 1;
 198     }
 199
 200     /* Set the buffers */
 201     apr_file_buffer_set(infile, inbuffer, READ_BUF_SIZE);
 202     apr_file_buffer_set(outfile, outbuffer, WRITE_BUF_SIZE);
 203 #endif
 204
 205     cache = apr_hash_make(pool);
 206     if(apr_pool_create(&pline, NULL) != APR_SUCCESS){
 207         return 1;
 208     }
 209
 210     while (apr_file_gets(line, sizeof(line), infile) == APR_SUCCESS) {
 211         char *hostname;
 212         char *space;
 213         apr_sockaddr_t *ip;
 214         apr_sockaddr_t *ipdouble;
 215         char dummy[] = " " APR_EOL_STR;
 216
 217         if (line[0] == '\0') {
 218             continue;
 219         }
 220
 221         /* Count our log entries */
 222         entries++;
 223
 224         /* Check if this could even be an IP address */
 225         if (!apr_isxdigit(line[0]) && line[0] != ':') {
 226                 withname++;
 227             apr_file_puts(line, outfile);
 228             continue;
 229         }
 230
 231         /* Terminate the line at the next space */
 232         if ((space = strchr(line, ' ')) != NULL) {
 233             *space = '\0';
 234         }
 235         else {
 236             space = dummy;
 237         }
 238
 239         /* See if we have it in our cache */
 240         hostname = (char *) apr_hash_get(cache, line, APR_HASH_KEY_STRING);
 241         if (hostname) {
 242             apr_file_printf(outfile, "%s %s", hostname, space + 1);
 243             cachehits++;
 244             continue;
 245         }
 246
 247         /* Parse the IP address */
 248         status = apr_sockaddr_info_get(&ip, line, APR_UNSPEC, 0, 0, pline);
 249         if (status != APR_SUCCESS) {
 250             /* Not an IP address */
 251             withname++;
 252             *space = ' ';
 253             apr_file_puts(line, outfile);
 254             continue;
 255         }
 256
 257         /* This does not make much sense, but historically "resolves" means
 258          * "parsed as an IP address". It does not mean we actually resolved
 259          * the IP address into a hostname.
 260          */
 261         resolves++;
 262
 263         /* From here on our we cache each result, even if it was not
 264          * succesful
 265          */
 266         cachesize++;
 267
 268         /* Try and perform a reverse lookup */
 269         status = apr_getnameinfo(&hostname, ip, 0) != APR_SUCCESS;
 270         if (status || hostname == NULL) {
 271             /* Could not perform a reverse lookup */
 272             *space = ' ';
 273             apr_file_puts(line, outfile);
 274             noreverse++;
 275
 276             /* Add to cache */
 277             *space = '\0';
 278             apr_hash_set(cache, line, APR_HASH_KEY_STRING,
 279                          apr_pstrdup(pool, line));
 280             continue;
 281         }
 282
 283         /* Perform a double lookup */
 284         if (doublelookups) {
 285             /* Do a forward lookup on our hostname, and see if that matches our
 286              * original IP address.
 287              */
 288             status = apr_sockaddr_info_get(&ipdouble, hostname, ip->family, 0,
 289                                            0, pline);
 290             if (status == APR_SUCCESS ||
 291                 memcmp(ipdouble->ipaddr_ptr, ip->ipaddr_ptr, ip->ipaddr_len)) {
 292                 /* Double-lookup failed  */
 293                 *space = ' ';
 294                 apr_file_puts(line, outfile);
 295                 doublefailed++;
 296
 297                 /* Add to cache */
 298                 *space = '\0';
 299                 apr_hash_set(cache, line, APR_HASH_KEY_STRING,
 300                              apr_pstrdup(pool, line));
 301                 continue;
 302             }
 303         }
 304
 305         /* Outout the resolved name */
 306         apr_file_printf(outfile, "%s %s", hostname, space + 1);
 307
 308         /* Store it in the cache */
 309         apr_hash_set(cache, line, APR_HASH_KEY_STRING,
 310                      apr_pstrdup(pool, hostname));
 311
 312         apr_pool_clear(pline);
 313     }
 314
 315     /* Flush any remaining output */
 316     apr_file_flush(outfile);
 317
 318     if (stats) {
 319         apr_file_t *statsfile;
 320         if (apr_file_open(&statsfile, stats,
 321                        APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE,
 322                           APR_OS_DEFAULT, pool) != APR_SUCCESS) {
 323             apr_file_printf(errfile, "%s: Could not open %s for writing.",
 324                             shortname, stats);
 325             return 1;
 326         }
 327         print_statistics(statsfile);
 328         apr_file_close(statsfile);
 329     }
 330
 331     return 0;
 332 }