*
* $Id$
*
+ *
+ * This file should be edited in a window with a width of 141 characters
+ * ick
*/
+#include "config.h"
+
#include "IPcheck.h"
#include "client.h"
#include "ircd.h"
+#include "msg.h"
#include "numnicks.h" /* NumNick, NumServ (GODMODE) */
#include "ircd_alloc.h"
-#include "msg.h"
-#include "s_bsd.h" /* SetIPChecked */
+#include "ircd_events.h"
#include "s_debug.h" /* Debug */
#include "s_user.h" /* TARGET_DELAY */
#include "send.h"
#include <assert.h>
-#include <stdio.h> /* NULL ... bleah */
-#include <string.h> /* memset */
-
+#include <string.h>
struct IPTargetEntry {
int count;
struct IPRegistryEntry* next;
struct IPTargetEntry* target;
unsigned int addr;
- unsigned short last_connect;
- unsigned char connected;
+ int last_connect;
+ unsigned short connected;
unsigned char attempts;
};
#define NOW ((unsigned short)(CurrentTime & MASK_16))
#define CONNECTED_SINCE(x) (NOW - (x))
-#define IPCHECK_CLONE_LIMIT 2
-#define IPCHECK_CLONE_PERIOD 20
+#define IPCHECK_CLONE_LIMIT 4
+#define IPCHECK_CLONE_PERIOD 40
#define IPCHECK_CLONE_DELAY 600
static struct IPRegistryEntry* hashTable[IP_REGISTRY_TABLE_SIZE];
static struct IPRegistryEntry* freeList = 0;
+static struct Timer expireTimer;
+
static unsigned int ip_registry_hash(unsigned int ip)
{
return ((ip >> 16) ^ ip) & (IP_REGISTRY_TABLE_SIZE - 1);
}
}
-/*
- * ip_registry_expire
- */
-static void ip_registry_expire()
+/* Callback to run an expiry of the IPcheck registry */
+static void ip_registry_expire(struct Event* ev)
{
int i;
struct IPRegistryEntry* entry;
struct IPRegistryEntry* entry_next;
+ assert(ET_EXPIRE == ev_type(ev));
+ assert(0 != ev_timer(ev));
+
for (i = 0; i < IP_REGISTRY_TABLE_SIZE; ++i) {
for (entry = hashTable[i]; entry; entry = entry_next) {
entry_next = entry->next;
}
}
+/*
+ * IPcheck_init()
+ *
+ * Initializes the registry timer
+ */
+void IPcheck_init(void)
+{
+ timer_add(&expireTimer, ip_registry_expire, 0, TT_PERIODIC, 60);
+}
+
/*
* IPcheck_local_connect
*
if (next_target_out)
*next_target_out = CurrentTime - (TARGET_DELAY * free_targets - 1);
}
- else if ((CurrentTime - me.since) > IPCHECK_CLONE_DELAY) {
+ else if ((CurrentTime - cli_since(&me)) > IPCHECK_CLONE_DELAY) {
/*
* Don't refuse connection when we just rebooted the server
*/
#ifdef NOTHROTTLE
return 1;
#else
- /* Thanks BLMet :) */
--entry->connected;
return 0;
#endif
*/
int ip_registry_check_remote(struct Client* cptr, int is_burst)
{
- struct IPRegistryEntry* entry = ip_registry_find(cptr->ip.s_addr);
+ struct IPRegistryEntry* entry = ip_registry_find((cli_ip(cptr)).s_addr);
/*
* Mark that we did add/update an IPregistry entry
SetIPChecked(cptr);
if (0 == entry) {
entry = ip_registry_new_entry();
- entry->addr = cptr->ip.s_addr;
+ entry->addr = (cli_ip(cptr)).s_addr;
if (is_burst)
entry->attempts = 0;
ip_registry_add(entry);
{
const char* tr = "";
unsigned int free_targets = STARTTARGETS;
- struct IPRegistryEntry* entry = ip_registry_find(cptr->ip.s_addr);
+ struct IPRegistryEntry* entry = ip_registry_find((cli_ip(cptr)).s_addr);
if (!entry) {
- Debug((DEBUG_ERROR, "Missing registry entry for: %s", cptr->sock_ip));
+ Debug((DEBUG_ERROR, "Missing registry entry for: %s", cli_sock_ip(cptr)));
return;
}
if (entry->target) {
- memcpy(cptr->targets, entry->target->targets, MAXTARGETS);
+ memcpy(cli_targets(cptr), entry->target->targets, MAXTARGETS);
free_targets = entry->target->count;
tr = " tr";
}
*/
void ip_registry_disconnect(struct Client *cptr)
{
- struct IPRegistryEntry* entry = ip_registry_find(cptr->ip.s_addr);
+ struct IPRegistryEntry* entry = ip_registry_find((cli_ip(cptr)).s_addr);
if (0 == entry) {
/*
* trying to find an entry for a server causes this to happen,
}
assert(0 != entry->target);
- memcpy(entry->target->targets, cptr->targets, MAXTARGETS);
+ memcpy(entry->target->targets, cli_targets(cptr), MAXTARGETS);
/*
* This calculation can be pretty unfair towards large multi-user hosts, but
* there is "nothing" we can do without also allowing spam bots to send more
* ALL should get no free targets when reconnecting. We'd need to store an entry
* per client (instead of per IP number) to avoid this.
*/
- if (cptr->nexttarget < CurrentTime) {
+ if (cli_nexttarget(cptr) < CurrentTime) {
/*
* Number of free targets
*/
- free_targets = (CurrentTime - cptr->nexttarget) / TARGET_DELAY + 1;
+ free_targets = (CurrentTime - cli_nexttarget(cptr)) / TARGET_DELAY + 1;
}
else
free_targets = 0;
/*
* Add bonus, this is pretty fuzzy, but it will help in some cases.
*/
- if ((CurrentTime - cptr->firsttime) > 600)
+ if ((CurrentTime - cli_firsttime(cptr)) > 600)
/*
* Was longer then 10 minutes online?
*/
- free_targets += (CurrentTime - cptr->firsttime - 600) / TARGET_DELAY;
+ free_targets += (CurrentTime - cli_firsttime(cptr) - 600) / TARGET_DELAY;
/*
* Finally, store smallest value for Judgement Day
*/
unsigned short IPcheck_nr(struct Client *cptr)
{
assert(0 != cptr);
- return ip_registry_count(cptr->ip.s_addr);
-}
-
-void IPcheck_expire()
-{
- static time_t next_expire = 0;
- if (next_expire < CurrentTime) {
- ip_registry_expire();
- next_expire = CurrentTime + 60;
- }
+ return ip_registry_count(cli_ip(cptr).s_addr);
}
-
-