#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_if.h"
#include "ntp_stdlib.h"
#include <ntp_random.h>
#include <stdio.h>
#include <signal.h>
#ifdef HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#ifndef MAXMONMEM
#define MAXMONMEM 600
#endif
#ifndef MONMEMINC
#define MONMEMINC 40
#endif
#define MON_HASH_SIZE NTP_HASH_SIZE
#define MON_HASH_MASK NTP_HASH_MASK
#define MON_HASH(addr) NTP_HASH_ADDR(addr)
static struct mon_data *mon_hash[MON_HASH_SIZE];
struct mon_data mon_mru_list;
static struct mon_data *mon_free;
static int mon_total_mem;
static int mon_mem_increments;
int ntp_minpkt = NTP_MINPKT;
int ntp_minpoll = NTP_MINPOLL;
int mon_enabled;
int mon_age = 3000;
static int mon_have_memory;
static void mon_getmoremem (void);
static void remove_from_hash (struct mon_data *);
void
init_mon(void)
{
mon_enabled = MON_OFF;
mon_have_memory = 0;
mon_total_mem = 0;
mon_mem_increments = 0;
mon_free = NULL;
memset(&mon_hash[0], 0, sizeof mon_hash);
memset(&mon_mru_list, 0, sizeof mon_mru_list);
}
void
mon_start(
int mode
)
{
if (mon_enabled != MON_OFF) {
mon_enabled |= mode;
return;
}
if (mode == MON_OFF)
return;
if (!mon_have_memory) {
mon_total_mem = 0;
mon_mem_increments = 0;
mon_free = NULL;
mon_getmoremem();
mon_have_memory = 1;
}
mon_mru_list.mru_next = &mon_mru_list;
mon_mru_list.mru_prev = &mon_mru_list;
mon_enabled = mode;
}
void
mon_stop(
int mode
)
{
register struct mon_data *md, *md_next;
register int i;
if (mon_enabled == MON_OFF)
return;
if ((mon_enabled & mode) == 0 || mode == MON_OFF)
return;
mon_enabled &= ~mode;
if (mon_enabled != MON_OFF)
return;
for (i = 0; i < MON_HASH_SIZE; i++) {
md = mon_hash[i];
mon_hash[i] = NULL;
while (md != NULL) {
md_next = md->hash_next;
md->hash_next = mon_free;
mon_free = md;
md = md_next;
}
}
mon_mru_list.mru_next = &mon_mru_list;
mon_mru_list.mru_prev = &mon_mru_list;
}
void
ntp_monclearinterface(struct interface *interface)
{
struct mon_data *md;
for (md = mon_mru_list.mru_next; md != &mon_mru_list;
md = md->mru_next) {
if (md->interface == interface) {
md->mru_prev->mru_next = md->mru_next;
md->mru_next->mru_prev = md->mru_prev;
remove_from_hash(md);
md->hash_next = mon_free;
mon_free = md;
}
}
}
int
ntp_monitor(
struct recvbuf *rbufp,
int flags
)
{
register struct pkt *pkt;
register struct mon_data *md;
sockaddr_u addr;
register u_int hash;
register int mode;
int interval;
if (mon_enabled == MON_OFF)
return (flags);
pkt = &rbufp->recv_pkt;
memset(&addr, 0, sizeof(addr));
memcpy(&addr, &(rbufp->recv_srcadr), sizeof(addr));
hash = MON_HASH(&addr);
mode = PKT_MODE(pkt->li_vn_mode);
md = mon_hash[hash];
while (md != NULL) {
int head;
int leak;
int limit;
if (SOCK_EQ(&md->rmtadr, &addr)) {
interval = current_time - md->lasttime;
md->lasttime = current_time;
md->count++;
md->flags = flags;
md->rmtport = NSRCPORT(&rbufp->recv_srcadr);
md->mode = (u_char) mode;
md->version = PKT_VERSION(pkt->li_vn_mode);
md->mru_next->mru_prev = md->mru_prev;
md->mru_prev->mru_next = md->mru_next;
md->mru_next = mon_mru_list.mru_next;
md->mru_prev = &mon_mru_list;
mon_mru_list.mru_next->mru_prev = md;
mon_mru_list.mru_next = md;
md->leak -= interval;
if (md->leak < 0)
md->leak = 0;
head = 1 << ntp_minpoll;
leak = md->leak + head;
limit = NTP_SHIFT * head;
#ifdef DEBUG
if (debug > 1)
printf("restrict: interval %d headway %d limit %d\n",
interval, leak, limit);
#endif
if (interval + 1 >= (1 << ntp_minpkt) &&
leak < limit) {
md->leak = leak - 2;
md->flags &= ~(RES_LIMITED | RES_KOD);
} else if (md->leak < limit) {
md->leak = limit + head;
} else {
md->flags &= ~RES_KOD;
}
return (md->flags);
}
md = md->hash_next;
}
if (mon_free == NULL && mon_total_mem >= MAXMONMEM) {
md = mon_mru_list.mru_prev;
if (md->count == 1 || ntp_random() / (2. * FRAC) >
(double)(current_time - md->lasttime) / mon_age)
return (flags & ~RES_LIMITED);
md->mru_prev->mru_next = &mon_mru_list;
mon_mru_list.mru_prev = md->mru_prev;
remove_from_hash(md);
} else {
if (mon_free == NULL)
mon_getmoremem();
md = mon_free;
mon_free = md->hash_next;
}
md->lasttime = md->firsttime = current_time;
md->count = 1;
md->flags = flags & ~RES_LIMITED;
md->leak = 0;
memset(&md->rmtadr, 0, sizeof(md->rmtadr));
memcpy(&md->rmtadr, &addr, sizeof(addr));
md->rmtport = NSRCPORT(&rbufp->recv_srcadr);
md->mode = (u_char) mode;
md->version = PKT_VERSION(pkt->li_vn_mode);
md->interface = rbufp->dstadr;
md->cast_flags = (u_char)(((rbufp->dstadr->flags &
INT_MCASTOPEN) && rbufp->fd == md->interface->fd) ?
MDF_MCAST: rbufp->fd == md->interface->bfd ? MDF_BCAST :
MDF_UCAST);
md->hash_next = mon_hash[hash];
mon_hash[hash] = md;
md->mru_next = mon_mru_list.mru_next;
md->mru_prev = &mon_mru_list;
mon_mru_list.mru_next->mru_prev = md;
mon_mru_list.mru_next = md;
return (md->flags);
}
static void
mon_getmoremem(void)
{
register struct mon_data *md;
register int i;
struct mon_data *freedata;
md = (struct mon_data *)emalloc(MONMEMINC *
sizeof(struct mon_data));
freedata = mon_free;
mon_free = md;
for (i = 0; i < (MONMEMINC-1); i++) {
md->hash_next = (md + 1);
md++;
}
md->hash_next = freedata;
mon_total_mem += MONMEMINC;
mon_mem_increments++;
}
static void
remove_from_hash(
struct mon_data *md
)
{
register u_int hash;
register struct mon_data *md_prev;
hash = MON_HASH(&md->rmtadr);
if (mon_hash[hash] == md) {
mon_hash[hash] = md->hash_next;
} else {
md_prev = mon_hash[hash];
while (md_prev->hash_next != md) {
md_prev = md_prev->hash_next;
if (md_prev == NULL) {
return;
}
}
md_prev->hash_next = md->hash_next;
}
}