src/mod-sockcheck.c

   1 /* mod-sockcheck.c - insecure proxy checking
   2  * Copyright 2000-2006 srvx Development Team
   3  *
   4  * This file is part of srvx.
   5  *
   6  * srvx is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with srvx; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
  19  */
  20
  21 #include "conf.h"
  22 #include "gline.h"
  23 #include "ioset.h"
  24 #include "modcmd.h"
  25 #include "timeq.h"
  26
  27 #ifdef HAVE_SYS_SOCKET_H
  28 #include <sys/socket.h>
  29 #endif
  30 #ifdef HAVE_NETINET_IN_H
  31 #include <netinet/in.h>
  32 #endif
  33 #ifdef HAVE_ARPA_INET_H
  34 #include <arpa/inet.h>
  35 #endif
  36
  37 /* TODO, 1.3 or later: allow rules like "27374:" "reject:Subseven detected";
  38  * (For convenience; right now it assumes that there will be a state
  39  * rather than an immediate response upon connection.)
  40  */
  41
  42 #if !defined(SOCKCHECK_DEBUG)
  43 #define SOCKCHECK_DEBUG 0
  44 #endif
  45 #define SOCKCHECK_TEST_DB "sockcheck.conf"
  46
  47 enum sockcheck_decision {
  48     CHECKING,
  49     ACCEPT,
  50     REJECT
  51 };
  52
  53 typedef struct {
  54     irc_in_addr_t addr;
  55     const char *reason;
  56     unsigned long last_touched;
  57     enum sockcheck_decision decision;
  58     char hostname[IRC_NTOP_MAX_SIZE]; /* acts as key for checked_ip_dict */
  59 } *sockcheck_cache_info;
  60
  61 DECLARE_LIST(sci_list, sockcheck_cache_info);
  62 DEFINE_LIST(sci_list, sockcheck_cache_info)
  63
  64 /* Here's the list of hosts that need to be started on.
  65  */
  66 static struct sci_list pending_sci_list;
  67
  68 /* Map of previously checked IPs state (if we've accepted the address yet).
  69  * The data for each entry is a pointer to a sockcheck_cache_info.
  70  */
  71 static dict_t checked_ip_dict;
  72
  73 /* Each sockcheck template is formed as a Mealy state machine (that is,
  74  * the output on a state transition is a function of both the current
  75  * state and the input).  Mealy state machines require fewer states to
  76  * match the same input than Moore machines (where the output is only
  77  * a function of the current state).
  78  *
  79  * A state is characterized by sending some data (possibly nothing),
  80  * waiting a certain amount of time to receive one of zero or more
  81  * responses, and a decision (accept, reject, continue to another
  82  * state) based on the received response.
  83  */
  84
  85 struct sockcheck_response {
  86     const char *template;
  87     struct sockcheck_state *next;
  88 };
  89
  90 DECLARE_LIST(response_list, struct sockcheck_response *);
  91 DEFINE_LIST(response_list, struct sockcheck_response *)
  92 static unsigned int max_responses;
  93
  94 struct sockcheck_state {
  95     unsigned short port;
  96     unsigned short timeout;
  97     unsigned short reps;
  98     enum sockcheck_decision type;
  99     const char *template;
 100     struct response_list responses;
 101 };
 102
 103 struct sockcheck_list {
 104     unsigned int size, used, refs;
 105     struct sockcheck_state **list;
 106 };
 107
 108 /*
 109  * List of tests.
 110  */
 111 static struct sockcheck_list *tests;
 112
 113 /* Stuff to track client state, one instance per open connection. */
 114 struct sockcheck_client {
 115     struct io_fd *fd;
 116     struct sockcheck_list *tests;
 117     sockcheck_cache_info addr;
 118     unsigned int client_index;
 119     unsigned int test_index;
 120     unsigned short test_rep;
 121     struct sockcheck_state *state;
 122     unsigned int read_size, read_used, read_pos;
 123     char *read;
 124     const char **resp_state;
 125 };
 126
 127 static struct {
 128     unsigned int max_clients;
 129     unsigned int max_read;
 130     unsigned int gline_duration;
 131     unsigned int max_cache_age;
 132     struct sockaddr *local_addr;
 133     int local_addr_len;
 134 } sockcheck_conf;
 135
 136 static unsigned int sockcheck_num_clients;
 137 static struct sockcheck_client **client_list;
 138 static unsigned int proxies_detected, checked_ip_count;
 139 static struct module *sockcheck_module;
 140 static struct log_type *PC_LOG;
 141 const char *sockcheck_module_deps[] = { NULL };
 142
 143 static const struct message_entry msgtab[] = {
 144     { "PCMSG_PROXY_DEFINITION_FAILED", "Proxy definition failed: %s" },
 145     { "PCMSG_PROXY_DEFINITION_SUCCEEDED", "New proxy type defined." },
 146     { "PCMSG_UNSCANNABLE_IP", "%s has a spoofed, hidden or localnet IP." },
 147     { "PCMSG_ADDRESS_QUEUED", "$b%s$b is now queued to be proxy-checked." },
 148     { "PCMSG_ADDRESS_UNRESOLVED", "Unable to resolve $b%s$b to an IP address." },
 149     { "PCMSG_CHECKING_ADDRESS", "$b%s$b is currently being checked; unable to clear it." },
 150     { "PCMSG_NOT_REMOVED_FROM_CACHE", "$b%s$b was not cached and therefore was not cleared." },
 151     { "PCMSG_REMOVED_FROM_CACHE", "$b%s$b was cleared from the cached hosts list." },
 152     { "PCMSG_DISABLED", "Proxy scanning is $bdisabled$b." },
 153     { "PCMSG_NOT_CACHED", "No proxycheck records exist for IP %s." },
 154     { "PCMSG_STATUS_CHECKING", "IP %s proxycheck state: last touched %s ago, still checking" },
 155     { "PCMSG_STATUS_ACCEPTED", "IP %s proxycheck state: last touched %s ago, accepted" },
 156     { "PCMSG_STATUS_REJECTED", "IP %s proxycheck state: last touched %s ago, rejected: %s" },
 157     { "PCMSG_STATUS_UNKNOWN", "IP %s proxycheck state: last touched %s ago, invalid status" },
 158     { "PCMSG_STATISTICS", "Since booting, I have checked %d clients for illicit proxies, and detected %d proxy hosts.\nI am currently checking %d clients (out of %d max) and have a backlog of %d more to start on.\nI currently have %d hosts cached.\nI know how to detect %d kinds of proxies." },
 159     { NULL, NULL }
 160 };
 161
 162 static struct sockcheck_list *
 163 sockcheck_list_alloc(unsigned int size)
 164 {
 165     struct sockcheck_list *list = malloc(sizeof(*list));
 166     list->used = 0;
 167     list->refs = 1;
 168     list->size = size;
 169     list->list = malloc(list->size*sizeof(list->list[0]));
 170     return list;
 171 }
 172
 173 static void
 174 sockcheck_list_append(struct sockcheck_list *list, struct sockcheck_state *new_item)
 175 {
 176     if (list->used == list->size) {
 177         list->size <<= 1;
 178         list->list = realloc(list->list, list->size*sizeof(list->list[0]));
 179     }
 180     list->list[list->used++] = new_item;
 181 }
 182
 183 static struct sockcheck_list *
 184 sockcheck_list_clone(struct sockcheck_list *old_list)
 185 {
 186     struct sockcheck_list *new_list = malloc(sizeof(*new_list));
 187     new_list->used = old_list->used;
 188     new_list->refs = 1;
 189     new_list->size = old_list->size;
 190     new_list->list = malloc(new_list->size*sizeof(new_list->list[0]));
 191     memcpy(new_list->list, old_list->list, new_list->used*sizeof(new_list->list[0]));
 192     return new_list;
 193 }
 194
 195 static void
 196 sockcheck_list_unref(struct sockcheck_list *list)
 197 {
 198     if (!list || --list->refs > 0) return;
 199     free(list->list);
 200     free(list);
 201 }
 202
 203 static void
 204 sockcheck_issue_gline(sockcheck_cache_info sci)
 205 {
 206     char addr[IRC_NTOP_MAX_SIZE + 2] = {'*', '@', '\0'};
 207     irc_ntop(addr + 2, sizeof(addr) - 2, &sci->addr);
 208     log_module(PC_LOG, LOG_INFO, "Issuing gline for client at %s: %s", addr + 2, sci->reason);
 209     gline_add("ProxyCheck", addr, sockcheck_conf.gline_duration, sci->reason, now, now, 0, 1);
 210 }
 211
 212 static struct sockcheck_client *
 213 sockcheck_alloc_client(sockcheck_cache_info sci)
 214 {
 215     struct sockcheck_client *client;
 216     client = calloc(1, sizeof(*client));
 217     client->tests = tests;
 218     client->tests->refs++;
 219     client->addr = sci;
 220     client->read_size = sockcheck_conf.max_read;
 221     client->read = malloc(client->read_size);
 222     client->resp_state = malloc(max_responses * sizeof(client->resp_state[0]));
 223     return client;
 224 }
 225
 226 static void
 227 sockcheck_free_client(struct sockcheck_client *client)
 228 {
 229     if (SOCKCHECK_DEBUG) {
 230         log_module(PC_LOG, LOG_INFO, "Goodbye %s (%p)!  I set you free!", client->addr->hostname, (void*)client);
 231     }
 232     verify(client);
 233     ioset_close(client->fd, 1);
 234     client->fd = NULL;
 235     sockcheck_list_unref(client->tests);
 236     free(client->read);
 237     free(client->resp_state);
 238     free(client);
 239 }
 240
 241 static void sockcheck_start_client(unsigned int idx);
 242 static void sockcheck_begin_test(struct sockcheck_client *client);
 243 static void sockcheck_advance(struct sockcheck_client *client, unsigned int next_state);
 244
 245 static void
 246 sockcheck_timeout_client(void *data)
 247 {
 248     struct sockcheck_client *client = data;
 249     if (SOCKCHECK_DEBUG) {
 250         log_module(PC_LOG, LOG_INFO, "Client %s timed out.", client->addr->hostname);
 251     }
 252     verify(client);
 253     sockcheck_advance(client, client->state->responses.used-1);
 254 }
 255
 256 static void
 257 sockcheck_print_client(const struct sockcheck_client *client)
 258 {
 259     static const char *decs[] = {"CHECKING", "ACCEPT", "REJECT"};
 260     log_module(PC_LOG, LOG_INFO, "client %p: { addr = %p { decision = %s; last_touched = %lu; reason = %s; hostname = \"%s\" }; "
 261         "test_index = %d; state = %p { port = %d; type = %s; template = \"%s\"; ... }; "
 262         "fd = %p(%d); read = %p; read_size = %d; read_used = %d; read_pos = %d; }",
 263         (void*)client, (void*)client->addr, decs[client->addr->decision],
 264         client->addr->last_touched,
 265         client->addr->reason, client->addr->hostname,
 266         client->test_index, (void*)client->state,
 267         (client->state ? client->state->port : 0),
 268         (client->state ? decs[client->state->type] : "N/A"),
 269         (client->state ? client->state->template : "N/A"),
 270         (void*)client->fd, (client->fd ? client->fd->fd : 0),
 271         (void*)client->read, client->read_size, client->read_used, client->read_pos);
 272 }
 273
 274 static char hexvals[256] = {
 275     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0 */
 276     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16 */
 277     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 32 */
 278     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 48 */
 279     0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 64 */
 280     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 */
 281     0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 96 */
 282     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  /* 112 */
 283 };
 284
 285 static void
 286 expand_var(const struct sockcheck_client *client, char var, char **p_expansion, unsigned int *p_exp_length)
 287 {
 288     extern struct cManagerNode cManager;
 289     const char *expansion;
 290     unsigned int exp_length;
 291     uint32_t exp4;
 292     uint16_t exp2;
 293
 294     /* expand variable */
 295     switch (var) {
 296     case 'c':
 297         expansion = client->addr->hostname;
 298         exp_length = strlen(expansion);
 299         break;
 300     case 'i':
 301         exp4 = client->addr->addr.in6_32[3];
 302         exp_length = sizeof(exp4);
 303         expansion = (char*)&exp4;
 304         break;
 305     case 'p':
 306         exp2 = htons(client->state->port);
 307         exp_length = sizeof(exp2);
 308         expansion = (char*)&exp2;
 309         break;
 310     case 'u':
 311         expansion = cManager.uplink->host;
 312         exp_length = strlen(expansion);
 313         break;
 314     default:
 315         log_module(PC_LOG, LOG_WARNING, "Request to expand unknown sockcheck variable $%c, using empty expansion.", var);
 316         expansion = "";
 317         exp_length = 0;
 318     }
 319     if (p_expansion) {
 320         *p_expansion = malloc(exp_length);
 321         memcpy(*p_expansion, expansion, exp_length);
 322     }
 323     if (p_exp_length) {
 324         *p_exp_length = exp_length;
 325     }
 326 }
 327
 328 static int
 329 sockcheck_check_template(const char *template, int is_input)
 330 {
 331     unsigned int nn;
 332     if (is_input && !strcmp(template, "other")) return 1;
 333     for (nn=0; template[nn]; nn += 2) {
 334         switch (template[nn]) {
 335         case '=':
 336             if (!template[nn+1]) {
 337                 log_module(MAIN_LOG, LOG_ERROR, "ProxyCheck template %s had = at end of template; needs a second character.", template);
 338                 return 0;
 339             }
 340             break;
 341         case '$':
 342             switch (template[nn+1]) {
 343             case 'c': case 'i': case 'p': case 'u': break;
 344             default:
 345                 log_module(MAIN_LOG, LOG_ERROR, "ProxyCheck template %s refers to unknown variable %c (pos %d).", template, template[nn+1], nn);
 346                 return 0;
 347             }
 348             break;
 349         case '.':
 350             if (!is_input) {
 351                 log_module(MAIN_LOG, LOG_ERROR, "ProxyCheck template %s: . is only valid in input templates.", template);
 352                 return 0;
 353             }
 354             if (template[nn+1] != '.') {
 355                 log_module(MAIN_LOG, LOG_ERROR, "ProxyCheck template %s expects .. to come in twos (pos %d).", template, nn);
 356                 return 0;
 357             }
 358             break;
 359         case '0': case '1': case '2': case '3': case '4':
 360         case '5': case '6': case '7': case '8': case '9':
 361         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 362         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 363             if (!hexvals[(unsigned char)template[nn+1]] && (template[nn+1] != '0')) {
 364                 log_module(MAIN_LOG, LOG_ERROR, "ProxyCheck template %s expects hex characters to come in twos (pos %d).", template, nn);
 365                 return 0;
 366             }
 367             break;
 368         default:
 369             log_module(MAIN_LOG, LOG_ERROR, "ProxyCheck template %s: unrecognized character '%c' (pos %d).", template, template[nn], nn);
 370             return 0;
 371         }
 372     }
 373     return 1;
 374 }
 375
 376 static void
 377 sockcheck_elaborate_state(struct sockcheck_client *client)
 378 {
 379     const char *template;
 380     unsigned int nn;
 381
 382     for (template = client->state->template, nn = 0; template[nn]; nn += 2) {
 383         switch (template[nn]) {
 384         case '=': ioset_write(client->fd, template+nn+1, 1); break;
 385         case '0': case '1': case '2': case '3': case '4':
 386         case '5': case '6': case '7': case '8': case '9':
 387         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 388         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': {
 389             char ch = hexvals[(unsigned char)template[nn]] << 4
 390                 | hexvals[(unsigned char)template[nn+1]];
 391             ioset_write(client->fd, &ch, 1);
 392             break;
 393         }
 394         case '$': {
 395             char *expansion;
 396             unsigned int exp_length;
 397             expand_var(client, template[nn+1], &expansion, &exp_length);
 398             ioset_write(client->fd, expansion, exp_length);
 399             free(expansion);
 400             break;
 401         }
 402         }
 403     }
 404     for (nn=0; nn<client->state->responses.used; nn++) {
 405         /* Set their resp_state to the start of the response. */
 406         client->resp_state[nn] = client->state->responses.list[nn]->template;
 407         /* If it doesn't require reading, take it now. */
 408         if (client->resp_state[nn] && !*client->resp_state[nn]) {
 409             if (SOCKCHECK_DEBUG) {
 410                 log_module(PC_LOG, LOG_INFO, "Skipping straight to easy option %d for %p.", nn, (void*)client);
 411             }
 412             sockcheck_advance(client, nn);
 413             return;
 414         }
 415     }
 416     timeq_add(now + client->state->timeout, sockcheck_timeout_client, client);
 417     if (SOCKCHECK_DEBUG) {
 418         log_module(PC_LOG, LOG_INFO, "Elaborated state for %s:", client->addr->hostname);
 419         sockcheck_print_client(client);
 420     }
 421 }
 422
 423 static void
 424 sockcheck_decide(struct sockcheck_client *client, enum sockcheck_decision decision)
 425 {
 426     unsigned int n;
 427
 428     checked_ip_count++;
 429     client->addr->decision = decision;
 430     client->addr->last_touched = now;
 431     switch (decision) {
 432     case ACCEPT:
 433         /* do nothing */
 434         if (SOCKCHECK_DEBUG) {
 435             log_module(PC_LOG, LOG_INFO, "Proxy check passed for client at %s.", client->addr->hostname);
 436         }
 437         break;
 438     case REJECT:
 439         client->addr->reason = client->state->template;
 440         proxies_detected++;
 441         sockcheck_issue_gline(client->addr);
 442         if (SOCKCHECK_DEBUG) {
 443             log_module(PC_LOG, LOG_INFO, "Proxy check rejects client at %s (%s)", client->addr->hostname, client->addr->reason);
 444         }
 445         /* Don't compare test_index != 0 directly, because somebody
 446          * else may have reordered the tests already. */
 447         if (client->tests->list[client->test_index] != tests->list[0]) {
 448             struct sockcheck_list *new_tests = sockcheck_list_clone(tests);
 449             struct sockcheck_state *new_first = client->tests->list[client->test_index];
 450             for (n=0; (n<tests->used) && (tests->list[n] != new_first); n++) ;
 451             for (; n>0; n--) new_tests->list[n] = new_tests->list[n-1];
 452             new_tests->list[0] = new_first;
 453             sockcheck_list_unref(tests);
 454             tests = new_tests;
 455         }
 456         break;
 457     default:
 458         log_module(PC_LOG, LOG_ERROR, "BUG: sockcheck_decide(\"%s\", %d): unrecognized decision.", client->addr->hostname, decision);
 459     }
 460     n = client->client_index;
 461     sockcheck_free_client(client);
 462     if ((--sockcheck_num_clients < sockcheck_conf.max_clients)
 463         && (pending_sci_list.used > 0)) {
 464         sockcheck_start_client(n);
 465     } else {
 466         client_list[n] = 0;
 467     }
 468 }
 469
 470 static void
 471 sockcheck_advance(struct sockcheck_client *client, unsigned int next_state)
 472 {
 473     struct sockcheck_state *ns;
 474
 475     verify(client);
 476     timeq_del(0, sockcheck_timeout_client, client, TIMEQ_IGNORE_WHEN);
 477     if (SOCKCHECK_DEBUG) {
 478         unsigned int n, m;
 479         char buffer[201];
 480         static const char *hexmap = "0123456789ABCDEF";
 481         log_module(PC_LOG, LOG_INFO, "sockcheck_advance(%s) following response %d (type %d) of %d.", client->addr->hostname, next_state, client->state->responses.list[next_state]->next->type, client->state->responses.used);
 482         for (n=0; n<client->read_used; n++) {
 483             for (m=0; (m<(sizeof(buffer)-1)>>1) && ((n+m) < client->read_used); m++) {
 484                 buffer[m << 1] = hexmap[client->read[n+m] >> 4];
 485                 buffer[m << 1 | 1] = hexmap[client->read[n+m] & 15];
 486             }
 487             buffer[m<<1] = 0;
 488             log_module(PC_LOG, LOG_INFO, " .. read data: %s", buffer);
 489             n += m;
 490         }
 491         sockcheck_print_client(client);
 492     }
 493
 494     ns = client->state = client->state->responses.list[next_state]->next;
 495     switch (ns->type) {
 496     case CHECKING:
 497         sockcheck_elaborate_state(client);
 498         break;
 499     case REJECT:
 500         sockcheck_decide(client, REJECT);
 501         break;
 502     case ACCEPT:
 503         if (++client->test_rep < client->tests->list[client->test_index]->reps) {
 504             sockcheck_begin_test(client);
 505         } else if (++client->test_index < client->tests->used) {
 506             client->test_rep = 0;
 507             sockcheck_begin_test(client);
 508         } else {
 509             sockcheck_decide(client, ACCEPT);
 510         }
 511         break;
 512     default:
 513         log_module(PC_LOG, LOG_ERROR, "BUG: unknown next-state type %d (after %p).", ns->type, (void*)client->state);
 514         break;
 515     }
 516 }
 517
 518 static void
 519 sockcheck_readable(struct io_fd *fd)
 520 {
 521     /* read what we can from the fd */
 522     struct sockcheck_client *client = fd->data;
 523     unsigned int nn;
 524     int res;
 525
 526     verify(client);
 527     res = read(fd->fd, client->read + client->read_used, client->read_size - client->read_used);
 528     if (res < 0) {
 529         switch (res = errno) {
 530         default:
 531             log_module(PC_LOG, LOG_ERROR, "BUG: sockcheck_readable(%d/%s): read() returned errno %d (%s)", fd->fd, client->addr->hostname, errno, strerror(errno));
 532         case EAGAIN:
 533             return;
 534         case ECONNRESET:
 535             sockcheck_advance(client, client->state->responses.used - 1);
 536             return;
 537         }
 538     } else if (res == 0) {
 539         sockcheck_advance(client, client->state->responses.used - 1);
 540         return;
 541     } else {
 542         client->read_used += res;
 543     }
 544     if (SOCKCHECK_DEBUG) {
 545         unsigned int n, m;
 546         char buffer[201];
 547         static const char *hexmap = "0123456789ABCDEF";
 548         for (n=0; n<client->read_used; n++) {
 549             for (m=0; (m<(sizeof(buffer)-1)>>1) && ((n+m) < client->read_used); m++) {
 550                 buffer[m << 1] = hexmap[client->read[n+m] >> 4];
 551                 buffer[m << 1 | 1] = hexmap[client->read[n+m] & 15];
 552             }
 553             buffer[m<<1] = 0;
 554             log_module(PC_LOG, LOG_INFO, "read %d bytes data: %s", client->read_used, buffer);
 555             n += m;
 556         }
 557     }
 558
 559     /* See if what's been read matches any of the expected responses */
 560     while (client->read_pos < client->read_used) {
 561         unsigned int last_pos = client->read_pos;
 562         char bleh;
 563         const char *resp_state;
 564
 565         for (nn=0; nn<(client->state->responses.used-1); nn++) {
 566             char *expected;
 567             unsigned int exp_length = 1, free_exp = 0;
 568             /* compare against possible target */
 569             resp_state = client->resp_state[nn];
 570             if (resp_state == NULL) continue;
 571             switch (*resp_state) {
 572             case '=':
 573                 bleh = resp_state[1];
 574                 expected = &bleh;
 575                 break;
 576             case '.':
 577                 /* any character passes */
 578                 client->read_pos++;
 579                 exp_length = 0;
 580                 break;
 581             case '0': case '1': case '2': case '3': case '4':
 582             case '5': case '6': case '7': case '8': case '9':
 583             case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 584             case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 585                 bleh = hexvals[(unsigned char)resp_state[0]] << 4
 586                     | hexvals[(unsigned char)resp_state[1]];
 587                 expected = &bleh;
 588                 break;
 589             case '$':
 590                 expand_var(client, resp_state[1], &expected, &exp_length);
 591                 free_exp = 1;
 592                 break;
 593             }
 594             if (client->read_pos+exp_length <= client->read_used) {
 595                 if (exp_length && memcmp(client->read+client->read_pos, expected, exp_length)) {
 596                     resp_state = NULL;
 597                 } else {
 598                     client->read_pos += exp_length;
 599                 }
 600             } else {
 601                 /* can't check the variable yet, so come back later */
 602                 resp_state -= 2;
 603             }
 604             if (free_exp) free(expected);
 605             if (resp_state) {
 606                 client->resp_state[nn] = resp_state = resp_state + 2;
 607                 if (!*resp_state) {
 608                     sockcheck_advance(client, nn);
 609                     return;
 610                 }
 611             } else {
 612                 client->resp_state[nn] = NULL;
 613             }
 614         }
 615         if (last_pos == client->read_pos) break;
 616     }
 617
 618     /* nothing seemed to match.  what now? */
 619     if (client->read_used >= client->read_size) {
 620         /* we got more data than we expected to get .. don't read any more */
 621         if (SOCKCHECK_DEBUG) {
 622             log_module(PC_LOG, LOG_INFO, "Buffer filled (unmatched) for client %s", client->addr->hostname);
 623         }
 624         sockcheck_advance(client, client->state->responses.used-1);
 625         return;
 626     }
 627 }
 628
 629 static void
 630 sockcheck_connected(struct io_fd *fd, int rc)
 631 {
 632     struct sockcheck_client *client = fd->data;
 633     verify(client);
 634     client->fd = fd;
 635     switch (rc) {
 636     default:
 637         log_module(PC_LOG, LOG_ERROR, "BUG: connect() got error %d (%s) for client at %s.", rc, strerror(rc), client->addr->hostname);
 638     case EHOSTUNREACH:
 639     case ECONNREFUSED:
 640     case ETIMEDOUT:
 641         if (SOCKCHECK_DEBUG) {
 642             log_module(PC_LOG, LOG_INFO, "Client %s gave us errno %d (%s)", client->addr->hostname, rc, strerror(rc));
 643         }
 644         sockcheck_advance(client, client->state->responses.used-1);
 645         return;
 646     case 0: break;
 647     }
 648     if (SOCKCHECK_DEBUG) {
 649         log_module(PC_LOG, LOG_INFO, "Connected: to %s port %d.", client->addr->hostname, client->state->port);
 650     }
 651     sockcheck_elaborate_state(client);
 652 }
 653
 654 static void
 655 sockcheck_begin_test(struct sockcheck_client *client)
 656 {
 657     struct io_fd *io_fd;
 658
 659     verify(client);
 660     ioset_close(client->fd, 1);
 661     client->fd = NULL;
 662     do {
 663         client->state = client->tests->list[client->test_index];
 664         client->read_pos = 0;
 665         client->read_used = 0;
 666         io_fd = ioset_connect(sockcheck_conf.local_addr, sockcheck_conf.local_addr_len, client->addr->hostname, client->state->port, 0, client, sockcheck_connected);
 667         client->fd = io_fd;
 668         if (!io_fd) {
 669             client->test_index++;
 670             continue;
 671         }
 672         io_fd->readable_cb = sockcheck_readable;
 673         timeq_add(now + client->state->timeout, sockcheck_timeout_client, client);
 674         if (SOCKCHECK_DEBUG) {
 675             log_module(PC_LOG, LOG_INFO, "Starting proxy check on %s:%d (test %d) with fd %d (%p).", client->addr->hostname, client->state->port, client->test_index, io_fd->fd, (void*)io_fd);
 676         }
 677         return;
 678     } while (client->test_index < client->tests->used);
 679     /* Ran out of tests to run; accept this client. */
 680     sockcheck_decide(client, ACCEPT);
 681 }
 682
 683 static void
 684 sockcheck_start_client(unsigned int idx)
 685 {
 686     sockcheck_cache_info sci;
 687     struct sockcheck_client *client;
 688
 689     if (pending_sci_list.used == 0) return;
 690     if (!(sci = pending_sci_list.list[0])) {
 691         log_module(PC_LOG, LOG_ERROR, "BUG: sockcheck_start_client(%d) found null pointer in pending_sci_list.", idx);
 692         return;
 693     }
 694     memmove(pending_sci_list.list, pending_sci_list.list+1,
 695             (--pending_sci_list.used)*sizeof(pending_sci_list.list[0]));
 696     sockcheck_num_clients++;
 697     if (!tests) return;
 698     client = client_list[idx] = sockcheck_alloc_client(sci);
 699     log_module(PC_LOG, LOG_INFO, "Proxy-checking client at %s as client %d (%p) of %d.", sci->hostname, idx, (void*)client, sockcheck_num_clients);
 700     client->test_rep = 0;
 701     client->client_index = idx;
 702     sockcheck_begin_test(client);
 703 }
 704
 705 void
 706 sockcheck_queue_address(irc_in_addr_t addr)
 707 {
 708     sockcheck_cache_info sci;
 709     const char *ipstr = irc_ntoa(&addr);
 710
 711     sci = dict_find(checked_ip_dict, ipstr, NULL);
 712     if (sci) {
 713         verify(sci);
 714         switch (sci->decision) {
 715         case CHECKING:
 716             /* We are already checking this host. */
 717             return;
 718         case ACCEPT:
 719             if (sci->last_touched + sockcheck_conf.max_cache_age >= now) {
 720                 return;
 721             }
 722             break;
 723         case REJECT:
 724             if (sci->last_touched + sockcheck_conf.gline_duration >= now) {
 725                 sockcheck_issue_gline(sci);
 726                 return;
 727             }
 728             break;
 729         }
 730         dict_remove(checked_ip_dict, sci->hostname);
 731     }
 732     sci = calloc(1, sizeof(*sci));
 733     sci->decision = CHECKING;
 734     sci->last_touched = now;
 735     sci->reason = NULL;
 736     sci->addr = addr;
 737     strncpy(sci->hostname, ipstr, sizeof(sci->hostname));
 738     dict_insert(checked_ip_dict, sci->hostname, sci);
 739     sci_list_append(&pending_sci_list, sci);
 740     if (sockcheck_num_clients < sockcheck_conf.max_clients)
 741         sockcheck_start_client(sockcheck_num_clients);
 742 }
 743
 744 int
 745 sockcheck_uncache_host(const char *name)
 746 {
 747     sockcheck_cache_info sci;
 748     if ((sci = dict_find(checked_ip_dict, name, NULL))
 749         && (sci->decision == CHECKING)) {
 750         return -1;
 751     }
 752     return dict_remove(checked_ip_dict, name);
 753 }
 754
 755 static int
 756 sockcheck_create_response(const char *key, void *data, void *extra)
 757 {
 758     const char *str, *end;
 759     struct record_data *rd = data;
 760     struct sockcheck_state *parent = extra;
 761     struct sockcheck_response *resp;
 762     dict_t resps;
 763     char *templ;
 764
 765     /* allocate memory and tack it onto parent->responses */
 766     resp = malloc(sizeof(*resp));
 767     for (end = key; *end != ':' && *end != 0; end += 2 && end) ;
 768     templ = malloc(end - key + 1);
 769     memcpy(templ, key, end - key);
 770     templ[end - key] = 0;
 771     resp->template = templ;
 772     if (!sockcheck_check_template(resp->template, 1)) _exit(1);
 773     resp->next = malloc(sizeof(*resp->next));
 774     resp->next->port = parent->port;
 775     response_list_append(&parent->responses, resp);
 776     /* now figure out how to create resp->next */
 777     if ((str = GET_RECORD_QSTRING(rd))) {
 778         if (!ircncasecmp(str, "reject", 6)) {
 779             resp->next->type = REJECT;
 780         } else if (!ircncasecmp(str, "accept", 6)) {
 781             resp->next->type = ACCEPT;
 782         } else {
 783             log_module(PC_LOG, LOG_ERROR, "Error: unknown sockcheck decision `%s', defaulting to accept.", str);
 784             resp->next->type = ACCEPT;
 785         }
 786         if (str[6]) {
 787             resp->next->template = strdup(str+7);
 788         } else {
 789             resp->next->template = strdup("No explanation given");
 790         }
 791     } else if ((resps = GET_RECORD_OBJECT(rd))) {
 792         resp->next->type = CHECKING;
 793         response_list_init(&resp->next->responses);
 794         if (*end == ':') {
 795             resp->next->template = strdup(end+1);
 796             if (!sockcheck_check_template(resp->next->template, 0)) _exit(1);
 797         } else {
 798             resp->next->template = strdup("");
 799         }
 800         dict_foreach(resps, sockcheck_create_response, resp->next);
 801     }
 802     return 0;
 803 }
 804
 805 /* key: PORT:send-pattern, as in keys of sockcheck.conf.example
 806  * data: recdb record_data containing response
 807  * extra: struct sockcheck_list* to append test to
 808  */
 809 static int
 810 sockcheck_create_test(const char *key, void *data, void *extra)
 811 {
 812     char *end;
 813     struct record_data *rd;
 814     dict_t object;
 815     struct sockcheck_state *new_test;
 816     unsigned int n;
 817
 818     rd = data;
 819     new_test = malloc(sizeof(*new_test));
 820     new_test->template = NULL;
 821     new_test->reps = 1;
 822     new_test->port = strtoul(key, &end, 0);
 823     new_test->timeout = 5;
 824     new_test->type = CHECKING;
 825     response_list_init(&new_test->responses);
 826     if (!(object = GET_RECORD_OBJECT(rd))) {
 827         log_module(PC_LOG, LOG_ERROR, "Error: misformed sockcheck test `%s', skipping it.", key);
 828         free(new_test);
 829         return 1;
 830     }
 831     while (*end) {
 832         switch (*end) {
 833         case '@': new_test->timeout = strtoul(end+1, &end, 0); break;
 834         case '*': new_test->reps = strtoul(end+1, &end, 0); break;
 835         case ':':
 836             new_test->template = strdup(end+1);
 837             end += strlen(end);
 838             if (!sockcheck_check_template(new_test->template, 0)) _exit(1);
 839             break;
 840         default:
 841             log_module(PC_LOG, LOG_ERROR, "Error: misformed sockcheck test `%s', skipping it.", key);
 842             free(new_test);
 843             return 1;
 844         }
 845     }
 846     if (!new_test->template) {
 847         log_module(PC_LOG, LOG_ERROR, "Error: misformed sockcheck test `%s', skipping it.", key);
 848         free(new_test);
 849         return 1;
 850     }
 851     dict_foreach(object, sockcheck_create_response, new_test);
 852     /* If none of the responses have template "other", create a
 853      * default response that goes to accept. */
 854     for (n=0; n<new_test->responses.used; n++) {
 855         if (!strcmp(new_test->responses.list[n]->template, "other")) break;
 856     }
 857     if (n == new_test->responses.used) {
 858         rd = alloc_record_data_qstring("accept");
 859         sockcheck_create_response("other", rd, new_test);
 860         free_record_data(rd);
 861     } else if (n != (new_test->responses.used - 1)) {
 862         struct sockcheck_response *tmp;
 863         /* switch the response for "other" to the end */
 864         tmp = new_test->responses.list[new_test->responses.used - 1];
 865         new_test->responses.list[new_test->responses.used - 1] = new_test->responses.list[n];
 866         new_test->responses.list[n] = tmp;
 867     }
 868     if (new_test->responses.used > max_responses) {
 869         max_responses = new_test->responses.used;
 870     }
 871     sockcheck_list_append(extra, new_test);
 872     return 0;
 873 }
 874
 875 static void
 876 sockcheck_read_tests(void)
 877 {
 878     dict_t test_db;
 879     struct sockcheck_list *new_tests;
 880     test_db = parse_database(SOCKCHECK_TEST_DB);
 881     if (!test_db)
 882         return;
 883     if (dict_size(test_db) > 0) {
 884         new_tests = sockcheck_list_alloc(dict_size(test_db));
 885         dict_foreach(test_db, sockcheck_create_test, new_tests);
 886         if (tests) sockcheck_list_unref(tests);
 887         tests = new_tests;
 888     } else {
 889         log_module(PC_LOG, LOG_ERROR, "%s was empty - disabling sockcheck.", SOCKCHECK_TEST_DB);
 890     }
 891     free_database(test_db);
 892 }
 893
 894 void
 895 sockcheck_free_state(struct sockcheck_state *state)
 896 {
 897     unsigned int n;
 898     if (state->type == CHECKING) {
 899         for (n=0; n<state->responses.used; n++) {
 900             free((char*)state->responses.list[n]->template);
 901             sockcheck_free_state(state->responses.list[n]->next);
 902             free(state->responses.list[n]);
 903         }
 904         response_list_clean(&state->responses);
 905     }
 906     free((char*)state->template);
 907     free(state);
 908 }
 909
 910 const char *
 911 sockcheck_add_test(const char *desc)
 912 {
 913     struct sockcheck_list *new_tests;
 914     const char *reason;
 915     char *name;
 916     struct record_data *rd;
 917
 918     if ((reason = parse_record(desc, &name, &rd)))
 919         return reason;
 920     new_tests = sockcheck_list_clone(tests);
 921     if (sockcheck_create_test(name, rd, new_tests)) {
 922         sockcheck_list_unref(new_tests);
 923         return "Sockcheck test parse error";
 924     }
 925     sockcheck_list_unref(tests);
 926     tests = new_tests;
 927     return 0;
 928 }
 929
 930 static void
 931 sockcheck_shutdown(void)
 932 {
 933     unsigned int n;
 934
 935     if (client_list) {
 936         for (n=0; n<sockcheck_conf.max_clients; n++) {
 937             if (client_list[n])
 938                 sockcheck_free_client(client_list[n]);
 939         }
 940         free(client_list);
 941     }
 942     sockcheck_num_clients = 0;
 943     dict_delete(checked_ip_dict);
 944     sci_list_clean(&pending_sci_list);
 945     if (tests)
 946         for (n=0; n<tests->used; n++)
 947             sockcheck_free_state(tests->list[n]);
 948     sockcheck_list_unref(tests);
 949     if (sockcheck_conf.local_addr) {
 950         free(sockcheck_conf.local_addr);
 951         sockcheck_conf.local_addr_len = 0;
 952     }
 953 }
 954
 955 static void
 956 sockcheck_clean_cache(UNUSED_ARG(void *data))
 957 {
 958     dict_t curr_clients;
 959     dict_iterator_t it, next;
 960     sockcheck_cache_info sci;
 961     unsigned int nn;
 962     int max_age;
 963
 964     if (SOCKCHECK_DEBUG) {
 965         struct string_buffer sb;
 966         string_buffer_init(&sb);
 967         /* Remember which clients we're still checking; we're not allowed to remove them. */
 968         for (curr_clients = dict_new(), nn=0; nn < sockcheck_conf.max_clients; nn++) {
 969             if (!client_list[nn])
 970                 continue;
 971             dict_insert(curr_clients, client_list[nn]->addr->hostname, client_list[nn]);
 972             string_buffer_append(&sb, ' ');
 973             string_buffer_append_string(&sb, client_list[nn]->addr->hostname);
 974         }
 975         string_buffer_append(&sb, '\0');
 976         log_module(PC_LOG, LOG_INFO, "Cleaning sockcheck cache at %lu; current clients: %s.", (unsigned long)now, sb.list);
 977         string_buffer_clean(&sb);
 978     } else {
 979         for (curr_clients = dict_new(), nn=0; nn < sockcheck_conf.max_clients; nn++) {
 980             if (!client_list[nn])
 981                 continue;
 982             dict_insert(curr_clients, client_list[nn]->addr->hostname, client_list[nn]);
 983         }
 984     }
 985
 986     for (it=dict_first(checked_ip_dict); it; it=next) {
 987         next = iter_next(it);
 988         sci = iter_data(it);
 989         max_age = (sci->decision == REJECT) ? sockcheck_conf.gline_duration : sockcheck_conf.max_cache_age;
 990         if (((sci->last_touched + max_age) < now)
 991             && !dict_find(curr_clients, sci->hostname, NULL)) {
 992             if (SOCKCHECK_DEBUG) {
 993                 log_module(PC_LOG, LOG_INFO, " .. nuking %s (last touched %lu).", sci->hostname, sci->last_touched);
 994             }
 995             dict_remove(checked_ip_dict, sci->hostname);
 996         }
 997     }
 998     dict_delete(curr_clients);
 999     timeq_add(now+sockcheck_conf.max_cache_age, sockcheck_clean_cache, 0);
1000 }
1001
1002 static MODCMD_FUNC(cmd_defproxy)
1003 {
1004     const char *reason;
1005
1006     if ((reason = sockcheck_add_test(unsplit_string(argv+1, argc-1, NULL)))) {
1007         reply("PCMSG_PROXY_DEFINITION_FAILED", reason);
1008         return 0;
1009     }
1010     reply("PCMSG_PROXY_DEFINITION_SUCCEEDED");
1011     return 1;
1012 }
1013
1014 static MODCMD_FUNC(cmd_hostscan)
1015 {
1016     unsigned int n;
1017     irc_in_addr_t ipaddr;
1018     char hnamebuf[IRC_NTOP_MAX_SIZE];
1019
1020     for (n=1; n<argc; n++) {
1021         struct userNode *un = GetUserH(argv[n]);
1022
1023         if (un) {
1024             if (!irc_in_addr_is_valid(un->ip)
1025                 || irc_in_addr_is_loopback(un->ip)) {
1026                 reply("PCMSG_UNSCANNABLE_IP", un->nick);
1027             } else {
1028                 irc_ntop(hnamebuf, sizeof(hnamebuf), &un->ip);
1029                 sockcheck_queue_address(un->ip);
1030                 reply("PCMSG_ADDRESS_QUEUED", hnamebuf);
1031             }
1032         } else {
1033             char *scanhost = argv[n];
1034             if (irc_pton(&ipaddr, NULL, scanhost)) {
1035                 sockcheck_queue_address(ipaddr);
1036                 reply("PCMSG_ADDRESS_QUEUED", scanhost);
1037             } else {
1038                 reply("PCMSG_ADDRESS_UNRESOLVED", scanhost);
1039             }
1040         }
1041     }
1042     return 1;
1043 }
1044
1045 static MODCMD_FUNC(cmd_clearhost)
1046 {
1047     unsigned int n;
1048     char hnamebuf[IRC_NTOP_MAX_SIZE];
1049
1050     for (n=1; n<argc; n++) {
1051         struct userNode *un = GetUserH(argv[n]);
1052         const char *scanhost;
1053
1054         if (un) {
1055             irc_ntop(hnamebuf, sizeof(hnamebuf), &un->ip);
1056             scanhost = hnamebuf;
1057         } else {
1058             scanhost = argv[n];
1059         }
1060         switch (sockcheck_uncache_host(scanhost)) {
1061         case -1:
1062             reply("PCMSG_CHECKING_ADDRESS", scanhost);
1063             break;
1064         case 0:
1065             reply("PCMSG_NOT_REMOVED_FROM_CACHE", scanhost);
1066             break;
1067         default:
1068             reply("PCMSG_REMOVED_FROM_CACHE", scanhost);
1069             break;
1070         }
1071     }
1072     return 1;
1073 }
1074
1075 static MODCMD_FUNC(cmd_stats_proxycheck)
1076 {
1077     if (argc > 1) {
1078         const char *hostname = argv[1];
1079         char elapse_buf[INTERVALLEN];
1080         const char *msg;
1081
1082         sockcheck_cache_info sci = dict_find(checked_ip_dict, hostname, NULL);
1083         if (!sci) {
1084             reply("PCMSG_NOT_CACHED", hostname);
1085             return 0;
1086         }
1087         intervalString(elapse_buf, now - sci->last_touched, user->handle_info);
1088         switch (sci->decision) {
1089         case CHECKING: msg = "PCMSG_STATUS_CHECKING"; break;
1090         case ACCEPT: msg = "PCMSG_STATUS_ACCEPTED"; break;
1091         case REJECT: msg = "PCMSG_STATUS_REJECTED"; break;
1092         default: msg = "PCMSG_STATUS_UNKNOWN"; break;
1093         }
1094         reply(msg, sci->hostname, elapse_buf, sci->reason);
1095         return 1;
1096     } else {
1097         reply("PCMSG_STATISTICS", checked_ip_count, proxies_detected, sockcheck_num_clients, sockcheck_conf.max_clients, pending_sci_list.used, dict_size(checked_ip_dict), (tests ? tests->used : 0));
1098         return 1;
1099     }
1100 }
1101
1102 static void
1103 sockcheck_new_user(struct userNode *user) {
1104     /* If they have a bum IP, or are bursting in, don't proxy-check or G-line them. */
1105     if (irc_in_addr_is_valid(user->ip)
1106         && !irc_in_addr_is_loopback(user->ip)
1107         && !user->uplink->burst)
1108         sockcheck_queue_address(user->ip);
1109 }
1110
1111 static void
1112 _sockcheck_init(void)
1113 {
1114     checked_ip_dict = dict_new();
1115     dict_set_free_data(checked_ip_dict, free);
1116     sci_list_init(&pending_sci_list);
1117     sockcheck_num_clients = 0;
1118     sockcheck_read_tests();
1119     timeq_del(0, sockcheck_clean_cache, 0, TIMEQ_IGNORE_WHEN|TIMEQ_IGNORE_DATA);
1120     client_list = calloc(sockcheck_conf.max_clients, sizeof(client_list[0]));
1121     timeq_add(now+sockcheck_conf.max_cache_age, sockcheck_clean_cache, 0);
1122 }
1123
1124 static void
1125 sockcheck_read_conf(void)
1126 {
1127     dict_t my_node;
1128     struct addrinfo *ai;
1129     const char *str;
1130
1131     /* set the defaults here in case the entire record is missing */
1132     sockcheck_conf.max_clients = 32;
1133     sockcheck_conf.max_read = 1024;
1134     sockcheck_conf.gline_duration = 3600;
1135     sockcheck_conf.max_cache_age = 60;
1136     if (sockcheck_conf.local_addr) {
1137         free(sockcheck_conf.local_addr);
1138         sockcheck_conf.local_addr = NULL;
1139     }
1140     /* now try to read from the conf database */
1141     if ((my_node = conf_get_data("modules/sockcheck", RECDB_OBJECT))) {
1142         str = database_get_data(my_node, "max_sockets", RECDB_QSTRING);
1143         if (str) sockcheck_conf.max_clients = strtoul(str, NULL, 0);
1144         str = database_get_data(my_node, "max_clients", RECDB_QSTRING);
1145         if (str) sockcheck_conf.max_clients = strtoul(str, NULL, 0);
1146         str = database_get_data(my_node, "max_read", RECDB_QSTRING);
1147         if (str) sockcheck_conf.max_read = strtoul(str, NULL, 0);
1148         str = database_get_data(my_node, "max_cache_age", RECDB_QSTRING);
1149         if (str) sockcheck_conf.max_cache_age = ParseInterval(str);
1150         str = database_get_data(my_node, "gline_duration", RECDB_QSTRING);
1151         if (str) sockcheck_conf.gline_duration = ParseInterval(str);
1152         str = database_get_data(my_node, "bind_address", RECDB_QSTRING);
1153         if (!str) str = database_get_data(my_node, "address", RECDB_QSTRING);
1154         if (!getaddrinfo(str, NULL, NULL, &ai)) {
1155             sockcheck_conf.local_addr_len = ai->ai_addrlen;
1156             sockcheck_conf.local_addr = calloc(1, ai->ai_addrlen);
1157             memcpy(sockcheck_conf.local_addr, ai->ai_addr, ai->ai_addrlen);
1158             freeaddrinfo(ai);
1159         } else {
1160             sockcheck_conf.local_addr_len = 0;
1161             sockcheck_conf.local_addr = NULL;
1162             if (str)
1163                 log_module(PC_LOG, LOG_ERROR, "Error: Unable to get host named `%s', not checking from a specific address.", str);
1164         }
1165     }
1166 }
1167
1168 int
1169 sockcheck_init(void)
1170 {
1171     PC_LOG = log_register_type("ProxyCheck", "file:proxycheck.log");
1172     conf_register_reload(sockcheck_read_conf);
1173     reg_exit_func(sockcheck_shutdown);
1174     _sockcheck_init();
1175     message_register_table(msgtab);
1176
1177     sockcheck_module = module_register("ProxyCheck", PC_LOG, "mod-sockcheck.help", NULL);
1178     modcmd_register(sockcheck_module, "defproxy", cmd_defproxy, 2, 0, "level", "999", NULL);
1179     modcmd_register(sockcheck_module, "hostscan", cmd_hostscan, 2, 0, "level", "650", NULL);
1180     modcmd_register(sockcheck_module, "clearhost", cmd_clearhost, 2, 0, "level", "650", NULL);
1181     modcmd_register(sockcheck_module, "stats proxycheck", cmd_stats_proxycheck, 0, 0, NULL);
1182     reg_new_user_func(sockcheck_new_user);
1183     return 1;
1184 }
1185
1186 int
1187 sockcheck_finalize(void)
1188 {
1189     return 1;
1190 }