monitor.c

Go to the documentation of this file.

/* $Id: monitor.c,v 1.83 2001/09/29 16:06:39 jm Exp $
 * Monitor module
 *
 * Dynamic hierarchial IP tunnel
 * Copyright (C) 1998-2001, Dynamics group
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation. See README and COPYING for
 * more details.
 */

/*
  ---------------
  Main call graph
  ---------------


            MONITOR_register_module 
                    handler_register 
            MONITOR_unregister_module 
                    dyn_wireless_iwspy_set 
 r                  rec_dump 
 r                  rec_clean_up 
            

  "event_FA" handlers       
  ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨

            monitor_add_fa 
                    gettimeofday 
                    monitor 
                            dyn_wireless_iwspy_get 
                            update_statistics 
 r                          rec_init 
 r                          rec_add_long 
                            get_qual_avg
 r                          rec_dump 
 r                          rec_clean_up 
                            get_free_slot 
                            dyn_wireless_iwspy_set 
            monitor_del_fa 
                    demonitor 
                            dyn_wireless_iwspy_get 
                            dyn_wireless_iwspy_set 
            monitor_get_fa 
                    mark_new_entries 
                    test_newest_fa_policy 
                    prioritize_all 
                    monitor_balance_prio 

            
  "event_INTERFACE" handlers
  ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨
            
            monitor_interface_down 
                    monitor_dev_down 
                            dyn_wireless_iwspy_set 
                    handler_unregister 
            monitor_interface_up 
                    monitor_dev_up 
                            dyn_wireless_create_socket 
                            dyn_wireless_iwspy_get 
                            dyn_wireless_iwspy_set 
                            dyn_wireless_get_channel 
                            dyn_wireless_set_channel 
                            dyn_wireless_get_range 
                    handler_register 
 r                  rec_init 
 r                  rec_dump 
 r                  rec_clean_up 
            
 r = Quality Recorder

*/

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <netinet/ip_icmp.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <asm/types.h>
#include <stdio.h>
#include <stddef.h>
#include <errno.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <syslog.h>
#include <assert.h>

#include <unistd.h>
#include <features.h>    /* for the glibc version number */
#if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
#include <netpacket/packet.h>
#include <net/ethernet.h>     /* the L2 protocols */
#include <netinet/if_ether.h>
#else
#include <linux/if_packet.h>
#include <linux/if_ether.h>   /* The L2 protocols */
#endif
#include "owntypes.h"
#include <linux/filter.h>

#include "mn.h"
#include "monitor.h"
#include "debug.h"
#include "util.h"
#include "mn_agentadv.h"
#include "mn_handler.h"
#include "list.h"
#include "dyn_wireless.h"
#include "dyn_iwspy_rec.h"

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#define DEBUG_FLAG 'm'
#define REC_DUMP_TYPE 4

/**************/
/**************/

/* event_INTERFACE handlers: */
static int monitor_interface_up(void *data);
static int monitor_interface_down(void *data);
/* event_FA handlers: */
static int monitor_get_fa(void *data);
static int monitor_add_fa(void *data);
static int monitor_del_fa(void *data);

struct monitor_global_data mon_conf;
struct monitor_interface mon_devs[MAX_INTERFACES];
int mon_rec_qual_initialized;

/****************/
/****************/

/* configuration variables. These are listed and modified with 
 * dynmn_tool (monitor)
 */
struct monitor_conf_vars monitor_conf[] = {
        {"Threshold (0-100)      ", 1, &mon_conf.threshold,      0, 100}, 
        {"Min-balance (0-100)    ", 1, &mon_conf.min_balance,    0, 100},
        {"Expirepercent (1-300)  ", 1, &mon_conf.expiretime,     1, 300},
        {"Old-FA-factor (0-100)  ", 1, &mon_conf.old_fa_factor,  0, 100},
        {"Worst-min-time (0- )   ", 8, &mon_conf.worst_min_time, 0,  -1},
        {"Worst-max-time (0- )   ", 8, &mon_conf.worst_max_time, 0,  -1},
        {"Average-length (1-10)  ", 1, &mon_conf.average_length, 1,  10},
        {"Default-channel (1-14) ", 1, &mon_conf.default_ch,     1,  14},
        {"Record-quality (0, 1)  ", 1, &mon_conf.rec_qual,       0,   1},
        {"SQ-cache (0, 1)        ", 1, &mon_conf.SQ_cache,       0,   1},
        {"", 0, NULL, 0, 0}
};


/***************/
/***************/

/*
 * Update signal quality vectors (FIFO), averages and
 * timestamps. Signal quality averages are stored in percent values
 * (avg: 0 - 100%)
 *
 * returns nothing 
 */
static void update_statistics(struct sockaddr *hwa, struct iw_quality *qual,
                              struct timeval tstamp,
                              struct monitor_interface *dev, int monitored)
{
        unsigned int j, k, i = 0, sum, p;

        /* every entry in the kernel structure */
        for (i = 0; i < monitored; i++) {
                /* If quality updated */
                if (!(qual[i].updated & 0x7))
                        continue;
                /* find the correct entry from monitor structure */
                for (j = 0; j < MAX_MONITOR; j++) {
                        if (dev->mon[j].active != 1 ||
                             (memcmp(hwa[i].sa_data, 
                                     dev->mon[j].adv->adv.from.sll_addr,
                                     ETH_ALEN)))
                                continue;

                        /* update the FIFO pointer */
                        p = next(dev->mon[j].q10_index);
                        dev->mon[j].q10_index = p;

                        dev->mon[j].qual.level   = qual[i].level;
                        dev->mon[j].qual.qual    = qual[i].qual;
                        dev->mon[j].qual.noise   = qual[i].noise;
                        dev->mon[j].qual.updated = qual[i].updated;

                        /* history size is 10 */
                        /* (Bug in driver (>92)) */
                        if (dev->mon[j].qual.qual > dev->range.max_qual.qual)
                                dev->mon[j].q10[p] = 
                                        dev->mon[j].q10[prev(p)];
                        else
                                dev->mon[j].q10[p] = 
                                        dev->mon[j].qual.qual;

                        /* timestamps */
                        dev->mon[j].updated.tv_sec  = tstamp.tv_sec;
                        dev->mon[j].updated.tv_usec = tstamp.tv_usec;

                        if (monitor_check_policy(EAGER_SWITCH_BIT)) {
                                dev->mon[j].avg  = ((100*dev->mon[j].q10[p])/
                                                    dev->range.max_qual.qual);
                                return;
                        } 
                        
                        /* calculate the average. The number of
                           quality values used in the average
                           calculation is a configurable variable */
                        /* New entry doesn't have history */

                        if (mon_conf.average_length <= 0 || 
                            mon_conf.average_length > 10) {
                                DEBUG(DEBUG_FLAG, "update_statistics: "
                                      "configuration variable: "
                                      "average_length was out of range! "
                                      " (%d)\n", mon_conf.average_length);
                                mon_conf.average_length = DEFAULT_AVG_LEN;
                        }

                        sum = dev->mon[j].q10[p];
                        for (k = 1; k < mon_conf.average_length; k++) {
                                /* new entries don't have history */
                                if (dev->mon[j].q10[prev(p)] >= 255) {
                                        dev->mon[j].q10[prev(p)] =
                                                dev->mon[j].q10[p];
                                }
                                sum += dev->mon[j].q10[prev(p)];
                                p = prev(p);
                        }

                        /* calculate the average and normalize the result */
                        dev->mon[j].avg  = (unsigned short)
                                ((sum*100/mon_conf.average_length)/
                                 dev->range.max_qual.qual);
                }
        }
}

static int get_qual_avg(struct monitor_interface *dev, unsigned char *hw)
{
        int j;

        for (j = 0; j < MAX_MONITOR; j++) {
                if (dev->mon[j].active != 1 ||
                    (memcmp(hw, dev->mon[j].adv->adv.from.sll_addr, ETH_ALEN)))
                        continue;
                /* entry found */
                return dev->mon[j].avg;
        }

        DEBUG(DEBUG_FLAG, "get_qual_avg: mac not found!\n");
        return -1;
}

/*
 * Start monitoring NODE
 * 
 * Parameters: 
 *   dev       Interface structure
 *   adv       agentadv data
 *   tstamp    Timestamp
 *
 * returns:
 *     0       success
 *    -1       get iwspy or set iwspy failed
 *    -2       slots are full and the worst entry is current FA
 *    -3       already monitoring (usual case, not failure)
 */
static int monitor(struct monitor_interface *dev, struct agentadv_data *adv, 
                   struct timeval tstamp)
{
        int i, ph = -1, monitored, ret;
        struct sockaddr *hw;
        struct iw_quality *qual;
        char buffer[(sizeof(struct iw_quality) +
                     sizeof(struct sockaddr)) * (IW_MAX_SPY)];

        /* Get monitored addresses from the kernel */
        monitored = dyn_wireless_iwspy_get(dev->sock, dev->ifname, buffer);
        if (monitored == -1) {
                DEBUG(DEBUG_FLAG,"monitor: get monitored addresses failed\n");
                return -1;
        }
        hw = (struct sockaddr *)buffer;
        qual = (struct iw_quality *)
                (buffer + (sizeof(struct sockaddr) * monitored));

        /* Check if it's already monitored. */
        /* FIX: add support for multiple IP addresses for each hw address */
        for (i = 0; i < MAX_MONITOR; i++) {
                if (dev->mon[i].active == 0) /* not initialized */
                        continue;
                if (adv->addr.s_addr == dev->mon[i].adv->addr.s_addr ||
                    !memcmp(adv->adv.from.sll_addr,
                            dev->mon[i].adv->adv.from.sll_addr, ETH_ALEN)) {
                        DEBUG(DEBUG_FLAG, "monitor: already monitoring %s\n",
                              inet_ntoa(dev->mon[i].adv->addr));
                        update_statistics(hw, qual, tstamp, dev, monitored); 
                        return -3;
                }
        }

        /* NEW ENTRY: */

        /* Room for the entry? */
        ph = get_free_slot(&tstamp, dev);
        if (ph < 0)  { 
                DEBUG(DEBUG_FLAG, "monitor: worst entry was current fa\n");
                return -2; /* No, the worst entry was current FA */
        }

        /* Initialize and store values to local data structure */
        memset(&dev->mon[ph], 0, sizeof(struct monitor_address));
        memset(dev->mon[ph].q10, MAXINT, sizeof(dev->mon[ph].q10));
        assert(adv != NULL);
        if (dev->mon[ph].adv != NULL) /* if we replace the worst entry */
                dev->mon[ph].adv->mon = NULL; /* then reset the old pointer */
        dev->mon[ph].adv = adv;  /* pointer to data in MN */
        dev->mon[ph].adv->mon = &dev->mon[ph];
        dev->mon[ph].added.tv_sec = tstamp.tv_sec;
        dev->mon[ph].added.tv_usec = tstamp.tv_usec;
        dev->mon[ph].active = 1;
        update_statistics(hw, qual, tstamp, dev, monitored); 

        if (mon_conf.SQ_cache) {
                if (dev->spy_number < MAX_MONITOR)
                        dev->spy_number++;
                return ph;
        }

        /* SET THE NEW ENTRY TO THE KERNEL WITH SIOCSIWSPY: */

        if (monitored < MAX_KERNEL) {
                memcpy((char *)hw[monitored].sa_data, 
                       (char *)adv->adv.from.sll_addr, ETH_ALEN);
                monitored++;
        } else {
                /* working set is full, replace worst entry */
                for (i = 0; i < monitored; i++) {
                        if (dev != NULL && dev->mon[ph].adv != NULL &&
                            memcmp((char *)hw[i].sa_data,
                                   (char *)dev->mon[ph].adv->adv.from.sll_addr,
                                   ETH_ALEN) == 0) {
                                /* replace hw address */
                                DEBUG(DEBUG_FLAG, "monitor: Replace "
                                      "worst entry buffer\n");
                                memcpy((char *)hw[i].sa_data,
                                       (char *)adv->adv.from.sll_addr,
                                       ETH_ALEN);
                                break;
                        }
                }
        }
        /* Send addresses to the driver */
        ret = dyn_wireless_iwspy_set(dev->sock, dev->ifname, 
                                     buffer, monitored);
        if (ret == -1) {
                DEBUG(DEBUG_FLAG, "Call to dyn_wireless_iwspy_set failed\n");
                return -1;
        }
        if (dev->spy_number < MAX_MONITOR)
                dev->spy_number++;

        return ph;
}


/* 
 * Stop monitoring NODE
 * 
 * Parameters:
 *   dev       Interface structure
 *   addr      Node's IP address
 *
 * returns:
 *    0        success
 *   -1        set iwspy failed
 *   -2        device entry not found
 */
static int demonitor(struct monitor_interface *dev, struct in_addr addr)
{ 
        int monitored, i, j, found = -1, ret;
        struct sockaddr *hw_set, *hw_get;
        char buffer_get[(sizeof(struct iw_quality) +
                     sizeof(struct sockaddr)) * (IW_MAX_SPY)];
        char buffer_set[(sizeof(struct iw_quality) +
                     sizeof(struct sockaddr)) * (IW_MAX_SPY)];

        /* Find the entry from the local structure and mark unused */
        for (i = 0; i < MAX_MONITOR; i++) {
                if (dev->mon[i].active == 0) /* not initialized */
                        continue;
                assert(dev->mon[i].adv != NULL);
                if (dev->mon[i].adv->addr.s_addr == addr.s_addr) {
                        dev->mon[i].active =  0;
                        dev->mon[i].adv->mon = NULL;
                        found = i;
                        break;
                }
        }

        if (found == -1) {
                DEBUG(DEBUG_FLAG,
                      "monitor_del_fa: Entry not found! (%s)\n",
                      dev->ifname);
                return -2;
        }

#ifndef IWSPY_SIM
        /* Get entries from the kernel */
        monitored = dyn_wireless_iwspy_get(dev->sock, dev->ifname, buffer_get);
        hw_get = (struct sockaddr *)buffer_get;
        hw_set = (struct sockaddr *)buffer_set;

        /* Take the unused entry away */
        DEBUG(DEBUG_FLAG, "monitor_del_fa: Remove entry from the "
              "buffer (%d/%d)\n", found, monitored);
        assert(dev->mon[found].adv != NULL);
        for (i = 0, j = 0; i < monitored; i++) {
                if ((memcmp((unsigned char *)(hw_get[i].sa_data),
                            (unsigned char *)
                            (dev->mon[found].adv->adv.from.sll_addr),
                            ETH_ALEN)) != 0) {
                        memcpy((char *)(hw_set[j].sa_data), 
                               (char *)(hw_get[i].sa_data),
                               ETH_ALEN);
                        j++;
                }
        }

        /* Reset kernel iwspy entries */
        ret = dyn_wireless_iwspy_set(dev->sock, dev->ifname, buffer_set, j);
        if (ret) {
                DEBUG(DEBUG_FLAG, "dyn_wireless_iwspy_set failed (%s)\n",
                      dev->ifname);
                return -1;
        }
#endif /* IWSPY_SIM */

        return 0;
}


/*
 * This function removes the kernel entry and also the entry from the
 * local structure. Called from the MN when agent advertisement expires.
 *
 * return:
 *    0 success
 *   -1 not a wireless interface
 *   -2 not found
 */
static int monitor_del_fa(void *data)
{
        struct agentadv_data *adv = NULL;
        struct monitor_interface *dev;

        if (data) {
                adv = ((struct event_FA *)data)->adv;
        }

        if (adv == NULL)
                return -1;

        DEBUG(DEBUG_FLAG, "monitor_del_fa: %s\n",
              inet_ntoa(adv->addr));

        /* Check if interface has wireless extensions */
        dev = monitor_get_dev(adv->ifname);
        if (!dev || !dev->iwspy_support) {
                DEBUG(DEBUG_FLAG, "monitor_del_fa: Not a wireless "
                      "interface (%s)\n", adv->ifname);
                return 1;
        }

        return demonitor(dev, adv->addr);
}


/*
 * Updates current device and FA index. If INTERVA_2_ADV policy is on then
 * use own agent advertisement expiration. Otherwise let MN handle expiration.
 * 
 * returns nothing
 */
static void mark_new_entries(void)
{
        int i, j;
        struct timeval timest;
        int lifetime = 0;

        gettimeofday(&timest,NULL);

        /* check all interfaces */
        for (j = 0; j < MAX_INTERFACES; j++) {
                if (!mon_devs[j].in_use || !mon_devs[j].iwspy_support)
                        continue;

                /* check all entries in this interface */
                for (i = 0; i < MAX_MONITOR; i++) {
                        if (mon_devs[j].mon[i].active != 1) {
                                mon_devs[j].vector_update[i] = 0;
                                continue;
                        }
                        
                        /* At the moment MN expires FA advertisements after
                           3*interval+1s. */
                        if (!monitor_check_policy(EARLY_EXPIRE_BIT)) {
                                /* MN's agent adv. expiration is ok */
                                mon_devs[j].vector_update[i] = 1;
                        } else {
                                /* if the entry is older than
                                   lifetime*(expiretime/100) seconds
                                   then it's considered old and marked
                                   "not updated" */
                                /* NOTE: should we limit expiretime 
                                   differently */
                                lifetime = (int)
                                  (mon_devs[j].mon[i].adv->expire.tv_sec -
                                   mon_devs[j].mon[i].adv->last.tv_sec);
                                if ((mon_devs[j].mon[i].updated.tv_sec +
                                     ((lifetime*mon_conf.expiretime)/100)) 
                                    > timest.tv_sec) {
                                        mon_devs[j].vector_update[i] = 1;
                                        mon_devs[j].mon[i].active = 1;
                                } else {
                                        DEBUG(DEBUG_FLAG, "mark_new_entries: "
                                              "inactive (old) entry\n");
                                        mon_devs[j].vector_update[i] = 0;
                                        /* set priority to 1 */
                                        mon_devs[j].mon[i].adv->priority = 1;
                                }
                        }
                        /* Get current FA index */
                        /* Check interface name and FA ip address */
                        if (*mon_conf.current_adv != NULL && 
                            !strncmp((*mon_conf.current_adv)->ifname,
                                     mon_devs[j].ifname, IFNAMSIZ) &&
                            (*mon_conf.current_adv)->addr.s_addr ==
                            mon_devs[j].mon[i].adv->addr.s_addr) {
                                mon_conf.current_fa = i;
                                memcpy(mon_conf.current_dev, 
                                       mon_devs[j].ifname, IFNAMSIZ);
                                DEBUG(DEBUG_FLAG, "mark_new_entries: "
                                      "curr.dev %s, curr.fa %d\n",
                                      mon_conf.current_dev, 
                                      mon_conf.current_fa);
                        }
                                
                        
                        /* NOTE: if current FA is in the wired side OR,
                           MN not connected yet, current_fa will be -1 */
                }
        }

        return;
}


/*
 * If NEWEST_FA/NEWEST_ADV policy is on, then check if this FA has just
 * appeared. If so choose the FA immediately.
 *
 * returns:
 *   0 don't change FA
 *   1 change FA
 */
static int test_newest_fa(struct agentadv_data *adv)
{
        int i, j;

        if (adv == NULL) {
                DEBUG(DEBUG_FLAG, "NEWEST_FA: test_newest_fa() called with "
                      "NULL adv\n");
                return 0;
        }

        if (monitor_check_policy(NEWEST_FA_BIT) && adv->counter > 1)
                return 0;

        /* Use FA with newest agent advertisement */
        /* Mark the FA with highest priority */
        adv->priority = MAXPRIORITY;
        DEBUG(DEBUG_FLAG, "mark_best_fa: newly arrived FA agent"
              " advertisement (%s) - policy NEWEST_FA\n", 
              inet_ntoa(adv->addr));
        
        /* FIX? Make the other FAs "unavailable" for a moment
           so that monitor will not change to the other OLD
           entries with better signal quality immediately */
        
        /* This is not a problem, since monitor will not change
           the FA if no other advertisements are heard. Hmm
           what if the same FA's advertismeent is heard again
           very fast? I mean if the interval of this new FA is
           much more smaller than for the older ones. */
        
        /* SOLUTION: degrade the other priorities to 1. But,
           hey what if this new FA will not accept my
           registration? What the heck are you using this
           policy anyway then? The priority will degrade
           exponentially to zero and after that the other FAs
           are better than this FA. Yes, because the signal
           quality values are not updated if the updated flag
           isn't set --> get_iwspy wount mix the entries when
           once degraded. Hmm. what about the default
           interface priority? Isn't that made the base
           priority for interfaces? Yes, damn. Hey, wait a
           minute. Isn't the wireless interface priority set
           to 1? If so it will not harm us. Heck, we don't even
           use the interface priority for wireless
           interfaces. So after all the solution seems to be
           good in these circumstances. ;) */
        
        /* Set priority to 1 for other FAs */
        DEBUG(DEBUG_FLAG, "NEWEST_FA: priorities\n");
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (!mon_devs[i].in_use || !mon_devs[i].iwspy_support || 
                    mon_devs[i].spy_number <= 0)
                        continue;

                for (j = 0; j < MAX_MONITOR; j++) {
                        if (mon_devs[i].mon[j].active != 1)
                                continue;

                        DEBUG(DEBUG_FLAG, "NEWEST_FA:    FA=%s prio=%i\n",
                              inet_ntoa(mon_devs[i].mon[j].adv->addr),
                              mon_devs[i].mon[j].adv->priority);

                        if (mon_devs[i].mon[j].adv == adv ||
                            mon_devs[i].mon[j].adv->priority <= 1)
                                continue;

                        DEBUG(DEBUG_FLAG, "NEWEST_FA:    setting other FA "
                              "priority %i -> 1\n",
                              mon_devs[i].mon[j].adv->priority);
                        mon_devs[i].mon[j].adv->priority = 1;
                }
        }

        return 1; /* change FA - NEWEST_FA */
}


/* 
 * Sets priority according to the quality level. The quality level is 0 - 100%.
 *
 * returns nothing:
 */
static void prioritize_all(void)
{
        int i, j;
        int p = mon_conf.dev_priority_percentage;
        struct agentadv_data *adv;
        struct monitor_address *mon;

        for (i = 0; i < MAX_INTERFACES; i++) {
                if (!mon_devs[i].in_use || !mon_devs[i].iwspy_support || 
                    mon_devs[i].spy_number <= 0)
                        continue;
                
                for (j = 0; j < MAX_MONITOR; j++) {
                        if (mon_devs[i].mon[j].active != 1 ||
                            mon_devs[i].mon[j].adv->priority <= 0)
                                continue;

                        adv = mon_devs[i].mon[j].adv;
                        assert(adv!=NULL);
                        assert(adv->mon != NULL);
                        mon = &mon_devs[i].mon[j];
                        assert(mon!=NULL);

                        /* prioritize FA */
                        adv->priority = (int)(((mon_devs[i].priority*p + 
                                   mon->avg*(100-p)))/100.0);

                        /* This downgrade might be moved to general agent
                         * advertisement handling (i.e. used also if IWSPY is
                         * not in use) */

                        /* downgrade priority if old entry */
                        if (monitor_check_policy(EARLY_EXPIRE_BIT) &&
                            mon_devs[i].vector_update[j] != 1) {
                                adv->priority = (int)((adv->priority * 
                                          (100-mon_conf.old_fa_factor))/100);
                                DEBUG(DEBUG_FLAG, "(%d/%d) Not fresh! %-15s"
                                      " prio %d (factor: %d%%)\n", 
                                      j+1, MAX_MONITOR, inet_ntoa(adv->addr),
                                      adv->priority, mon_conf.old_fa_factor);
                        }
                        /* When the wireless card is inserted, the
                           iwspy entry in the kernel doesn't
                           exists. We put priority nonzero to enable
                           registration. */
                        if (adv->priority == 0) 
                                adv->priority = 1;
                }
        }
}


/* 
 * According to configuration settings (threshold) priorities are balanced
 * so that no unnecessary FA changing happens.
 *
 * returns nothing:
 */
static void monitor_balance_prio(void) 
{
        int curr_qual, i, j, max_index = -1;
        struct monitor_interface *curr_dev = NULL;
        struct monitor_interface *max_dev = NULL;
        int max_qual = 0;
        double d;
        
        if (mon_conf.current_fa < 0 ||
            (*mon_conf.current_adv) == NULL) {
                DEBUG(DEBUG_FLAG, "monitor_balance_prio: current fa "
                      "not known\n");
                return;
        }

        /* current FA */
        curr_dev = monitor_get_dev(mon_conf.current_dev);
        if (!curr_dev || !curr_dev->iwspy_support) {
                DEBUG(DEBUG_FLAG, "monitor_balance_prio: currently not "
                      "using wireless device\n");
                return;
        }
        curr_qual = curr_dev->mon[mon_conf.current_fa].avg;
        
        /* find max link quality */
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (mon_devs[i].in_use == 0 ||
                    mon_devs[i].iwspy_support == 0 ||
                    mon_devs[i].spy_number <= 0)
                        continue;
                
                for (j = 0; j < MAX_MONITOR; j++) {
                        if (mon_devs[i].mon[j].active != 1)
                                continue;
                        if (mon_devs[i].mon[j].avg > max_qual) {
                                max_dev = &mon_devs[i];
                                max_qual = mon_devs[i].mon[j].avg;
                                max_index = j;
                        }
                }
        }
        if (max_index == -1) {
                DEBUG(DEBUG_FLAG, "monitor_balance_prio: no maximum!\n");
                return;
        }
        assert(max_dev != NULL);

        /* if current quality below min_balance don't balance */
        if (curr_dev->mon[mon_conf.current_fa].avg < mon_conf.min_balance) {
                DEBUG(DEBUG_FLAG, "monitor_balance_prio: quality too small."
                      " No balancing (quality %d, min_balance %d)\n",
                      curr_dev->mon[mon_conf.current_fa].avg,
                      mon_conf.min_balance);
                return;
        }
        /* balance priorities if quality values are near */
        if (max_dev->mon[max_index].avg>0)
                d = (double)(((double)curr_dev->mon[mon_conf.current_fa].avg)/
                             ((double)max_dev->mon[max_index].avg));
        else
                d = 1.0;

        DEBUG(DEBUG_FLAG, "monitor_balance_prio: current=%d, max=%d,"
              " divide=%f, (%d)threshold=%f\n",
              curr_dev->mon[mon_conf.current_fa].avg, 
              max_dev->mon[max_index].avg, d,
              mon_conf.threshold, 
              (double)(mon_conf.threshold/100.0));
        if(d < 1.0 && d > (mon_conf.threshold/100.0) &&
           max_dev->mon[max_index].adv->priority > 0) {
                curr_dev->mon[mon_conf.current_fa].adv->priority =
                        max_dev->mon[max_index].adv->priority;
                DEBUG(DEBUG_FLAG, "monitor_balance_prio: "
                      "Qualities near enough, balancing\n");
        }
#ifdef PRINT_ENTRIES /* by default not defined */
        print_entries();
#endif /* PRINT_ENTRIES */
        return; 
}


/*
 * Get the best Foreign Agent. First marks fresh FA's and gets the current FA.
 * With NEWEST_FA policy is on monitor_get_fa checks if the FA has just 
 * appeared and uses that FA. Otherwise all FAs are prioritized and according 
 * configuration settings priorities are balanced. This means that there is 
 * certain threshold for changing the FAs.
 * 
 * returns:
 *    1    Foreign Agent changed
 *    0    No need to change FA
 *   -1    on error
 */
static int monitor_get_fa(void *data)
{
        int i;
        struct agentadv_data *adv = NULL;
        struct monitor_interface *dev = NULL;

        if (data) {
                adv = ((struct event_FA *)data)->adv;
        }

        for (i = 0; i < MAX_INTERFACES; i++) {
                if (!mon_devs[i].in_use || 
                    !mon_devs[i].iwspy_support ||
                    mon_devs[i].spy_number <= 0)
                        continue;
        }

        /* Get current FA */
        if (*mon_conf.current_adv == NULL)
                DEBUG(DEBUG_FLAG, "monitor_get_fa: Current adv "
                      "pointer is NULL\n");
        else {
                DEBUG(DEBUG_FLAG, "monitor_get_fa: current_dev %s\n",
                      mon_conf.current_dev);
                dev = monitor_get_dev(mon_conf.current_dev);
        }

        /* Mark new entries and get current FA index */
        mon_conf.current_fa = -1;
        mark_new_entries();

        if (dev != NULL && dev->iwspy_support && mon_conf.current_fa != -1 &&
            !strncmp(dev->ifname, mon_conf.current_dev, IFNAMSIZ)) {
                DEBUG(DEBUG_FLAG, "current FA: %-15s",
                      inet_ntoa(dev->mon[mon_conf.current_fa].adv->addr));
                DEBUG(DEBUG_FLAG, " active %d, prio %d, avg %d\n",
                      dev->mon[mon_conf.current_fa].active,
                      dev->mon[mon_conf.current_fa].adv->priority,
                      dev->mon[mon_conf.current_fa].avg);
        } else
                DEBUG(DEBUG_FLAG, "current FA: Not connected or "
                      "FA in the non-wireless-extensions interface\n");

        /* update prioritie(s) for FA(s) behind the wireless interface(s) */
        if (adv != NULL &&
            (monitor_check_policy(NEWEST_FA_BIT) ||
             monitor_check_policy(NEWEST_ADV_BIT))) {
                DEBUG(DEBUG_FLAG, "NEWEST_FA/ADV policy\n");
                if (test_newest_fa(adv) && !adv->in_use)
                        return 1; 

                /* with NEWEST_ADV policy, just simply select the newest FA,
                   so no need for other policy-based prioritize functions */
                if (monitor_check_policy(NEWEST_ADV_BIT))
                        return 0;
        }
        
        prioritize_all();

        if (!monitor_check_policy(EAGER_SWITCH_BIT))
                monitor_balance_prio(); 
        else {
                /* allow quick location updates */
                timerclear(mon_conf.reg_send_timer);
        }

        return 0;
}


/*
 * Add the Foreign Agent's address into monitor.
 *
 * returns:
 *    0  on success
 *    1  not a wireless interface
 *   -1  on error (iwspy)
 *   -2  working set is full
 */
static int monitor_add_fa(void *data)
{
        int ph;
        struct agentadv_data *adv = NULL;
        struct monitor_interface *dev;
        struct timeval tstamp;
        struct iw_quality avg_qual;

        if (data) {
                adv = ((struct event_FA *)data)->adv;
        }

        /* Check if interface has wireless extensions */
        dev = monitor_get_dev(adv->ifname);
        if (!dev || !dev->iwspy_support) {
                DEBUG(DEBUG_FLAG, "monitor_add_fa: Not a wireless "
                      "interface (%s)\n", adv->ifname);
                return 1;
        }

        gettimeofday(&tstamp,NULL);
        
        /* start monitoring node if it's not monitored yet */
        ph = monitor(dev, adv, tstamp);
        if (ph < 0 && ph != -3) {
                DEBUG(DEBUG_FLAG, "monitor_add_fa: failed to monitor\n");
        } 
        if (ph >= 0)
                DEBUG(DEBUG_FLAG, "monitor_add_fa (index=%d): ip: %s -  "
                      "hw: %s\n", ph, inet_ntoa(dev->mon[ph].adv->addr),
                      ether_hwtoa((unsigned char *)
                                  dev->mon[ph].adv->adv.from.sll_addr));

        /* QUALITY RECORDER:  */
        if (mon_conf.rec_qual) {
                if (mon_rec_qual_initialized == 0) {
                        rec_init();
                        mon_rec_qual_initialized = 1;
                }
                avg_qual.qual = get_qual_avg(dev, adv->adv.from.sll_addr);
                avg_qual.level = 0;
                avg_qual.noise = 0;
                if (memcmp(adv->adv.from.sll_addr, 
                           ((*mon_conf.current_adv)->adv.from.sll_addr), 
                           ETH_ALEN) == 0) {
                        DEBUG(DEBUG_FLAG, "monitor_add_fa: add quality "
                              "record\n");
                        rec_add((char *) adv->adv.from.sll_addr, &avg_qual,
                                &tstamp, adv->addr);
                }
        } else if (mon_rec_qual_initialized) {
                DEBUG(DEBUG_FLAG, "monitor_add_fa: dump quality record\n");
                rec_dump(REC_DUMP_TYPE, -1);
                rec_clean_up();
                mon_rec_qual_initialized = 0;
        }

        return ph;
}


/*
 * Opens socket, tests iwspy and channel support. Wireless extensions 
 * are supported only in interfaces that support iwspy ioctls. Queries 
 * range for wireless parameters.
 *
 * returns:
 *   dev    success
 *  NULL    failed
 */
static struct monitor_interface *monitor_dev_up(char *ifname)
{
        int i, r;
        struct monitor_interface *dev = NULL;
        char buffer[(sizeof(struct iw_quality) +
                     sizeof(struct sockaddr)) *
                   (IW_MAX_SPY+1)];

        /* find free slot */
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (!mon_devs[i].in_use) {
                        memset(&mon_devs[i], 0, 
                               sizeof(struct monitor_interface));
                        dev = &mon_devs[i];
                        break;
                }
        }

        if (!dev) {
                DEBUG(DEBUG_FLAG, "monitor_dev_up: Free slots unavailable!\n");
                return NULL;
        }

        /* open socket */
        dev->sock = dyn_wireless_create_socket();
        if (dev->sock < 0) {
                DEBUG(DEBUG_FLAG, "monitor_dev_up - open wireless socket: "
                      "%s\n", strerror(errno));
                return NULL;
        }

        /* Copy the wireless interface name */
        memcpy(dev->ifname, ifname, IFNAMSIZ);
        if (dev->ifname == NULL) {
                DEBUG(DEBUG_FLAG, "monitor_dev_up: dev->ifname NULL!\n");
                return NULL;
        }

        /* This is only for testing wireless extension support and
         * iwspy ioctls support from the kernel */
        r = dyn_wireless_iwspy_get(dev->sock, dev->ifname, buffer);
        dev->iwspy_support = r == -1 ? 0 : 1;
        if (!dev->iwspy_support)
                DEBUG(DEBUG_FLAG, "monitor_dev_up: IWSPY not supported (%s)\n",
                      dev->ifname);


        /* Clean all the iwspy entries from the kernel */
        r = dyn_wireless_iwspy_set(dev->sock, dev->ifname, NULL, 0);
        dev->iwspy_support = r == -1 ? 0 : 1;
        if (!dev->iwspy_support)
                DEBUG(DEBUG_FLAG, "monitor_dev_up: IWSPY not supported (%s)\n",
                      dev->ifname);
        
        /* Get channel and set the default */
        dev->channel = dyn_wireless_get_channel(dev->sock, dev->ifname);
        dev->channel_support = dev->channel_get_support =
                dev->channel == -1 ? 0 : 1;
        if (!dev->channel_support)
                DEBUG(DEBUG_FLAG, "monitor_dev_up: channel query not "
                      "supported (%s)\n", dev->ifname);
        else
                DEBUG(DEBUG_FLAG, "monitor_dev_up: %s: channel %d\n",
                      dev->ifname, dev->channel);


        if (mon_conf.default_ch >= 1)
                r = dyn_wireless_set_channel(dev->sock, dev->ifname, 
                                             mon_conf.default_ch);
        else
                r = dyn_wireless_set_channel(dev->sock, dev->ifname, 
                                             dev->channel);
                
        dev->channel_support = r == -1 ? 0 : 1;
        if (!dev->channel_support)
                DEBUG(DEBUG_FLAG, "monitor_dev_up: set channel not "
                      "supported (%s)\n", dev->ifname);
        else 
                DEBUG(DEBUG_FLAG, "monitor_dev_up: set channel "
                      "successful (%s, %d)\n", dev->ifname,
                      dev->channel);

        /* Get range of parameters */
        if (dyn_wireless_get_range(dev->sock, dev->ifname, &dev->range)) {
                DEBUG(DEBUG_FLAG, "monitor_dev_up: get range of parameters "
                      "not supported (%s)\n", dev->ifname);
                /* set default values (?) */
#define MAX_QUAL 92             
                dev->range.max_qual.qual = MAX_QUAL;
        } else {
                /* wvlan_cs 1.0.1 driver doesn't report max quality if 
                   no entries to monitor in the driver (e.g. spy_number = 0) */
                if (dev->range.max_qual.qual <= 0) {
                        DEBUG(DEBUG_FLAG, "monitor_dev_up: max qual value is "
                              "ZERO, assuming wvlan_cs driver and using 92 "
                              "as the maximum\n");
                        dev->range.max_qual.qual = MAX_QUAL;
                }

                DEBUG(DEBUG_FLAG, "RANGE (%s):\n", dev->ifname);
                DEBUG(DEBUG_FLAG, "\tthroughput          %d\n", 
                      dev->range.throughput);
                DEBUG(DEBUG_FLAG, "\tmin_nwid            %d\n", 
                      dev->range.min_nwid);
                DEBUG(DEBUG_FLAG, "\tmax_nwid            %d\n", 
                      dev->range.max_nwid);
                DEBUG(DEBUG_FLAG, "\tchannels            %d\n", 
                      dev->range.num_channels);
                DEBUG(DEBUG_FLAG, "\tsensitivity         %d\n", 
                      dev->range.sensitivity);
                DEBUG(DEBUG_FLAG, "\tmax_qual.qual       %d\n", 
                      dev->range.max_qual.qual);
                DEBUG(DEBUG_FLAG, "\tmax_qual.level      %d\n", 
                      dev->range.max_qual.level);
                DEBUG(DEBUG_FLAG, "\tmax_qual.noise      %d\n", 
                      dev->range.max_qual.noise);

#if WIRELESS_EXT >= 9
                /* FIX: encoding structure changed in wireless ext ver. 9 */
#else
                DEBUG(DEBUG_FLAG, "\tmax_encoding.method %d\n", 
                      dev->range.max_encoding.method);
#endif

#if WIRELESS_EXT >= 8
                DEBUG(DEBUG_FLAG, "\tnum_bitrates        %d\n", 
                      dev->range.num_bitrates);
                DEBUG(DEBUG_FLAG, "\tmin_rts             %d\n", 
                      dev->range.min_rts);
                DEBUG(DEBUG_FLAG, "\tmax_rts             %d\n", 
                      dev->range.max_rts);
                DEBUG(DEBUG_FLAG, "\tmin_frag            %d\n", 
                      dev->range.min_frag);
                DEBUG(DEBUG_FLAG, "\tmax_frag            %d\n", 
                      dev->range.max_frag);
#endif
        }

        dev->in_use = 1;
        mon_conf.interfaces++;

        if (!dev->channel_get_support && !dev->channel_support &&
            !dev->iwspy_support) {
                close(dev->sock);
                dev->sock = -1;
        }

        return dev;
}


/*
 * Cleans monitored entries from the driver. Decreases counters and closes 
 * sockets.
 *
 * returns:
 *   0  success
 *  -1  device structure not in use 
 */
static int monitor_dev_down(struct monitor_interface *dev)
{
        if (dev->in_use) {
                mon_conf.interfaces--;
                dev->in_use = 0;
                if (mon_conf.interfaces < 0) {
                        mon_conf.interfaces = 0;
                        DEBUG(DEBUG_FLAG, "monitor_dev_down: Negative "
                              "interface count!\n");
                }
                if (!dev->iwspy_support) 
                        return 0;

                /* remove iwspy entries from the interface */
                dyn_wireless_iwspy_set(dev->sock, dev->ifname, NULL, 0);
                /* close socket */
                if (dev->sock >= 0) {
                        close(dev->sock);
                        dev->sock = -1;
                }
                mon_conf.iwspy_supported--;
                if (mon_conf.iwspy_supported < 0) {
                        mon_conf.iwspy_supported = 0;
                        DEBUG(DEBUG_FLAG, "monitor_dev_down: Negative "
                              "iwspy_support count!\n");
                }
        } else
                return -1;
        
        return 0;
}


/*
 * "event_INTERFACE_UP" event handler
 *
 * Makes and fill in new interface structure. Register handlers for 
 * for this interface.
 *
 * returns:
 *   -1  open socket failed 
 *    0  iwspy: YES, channel switch: YES
 *    1  iwspy: YES, channel switch: NO
 *    2  iwspy: NO,  channel switch: YES
 *    3  iwspy: NO,  channel switch: NO
 */
static int monitor_interface_up(void *data)
{
        struct monitor_interface *dev;
        char *ifname = NULL;
        struct timeval *last_reg_send_time = NULL;
        int *priority = NULL;

        if (data) {
                ifname = ((struct event_INTERFACE *)data)->ifname;
                last_reg_send_time = ((struct event_INTERFACE *)
                                      data)->last_reg_send_time;
                mon_conf.current_adv = ((struct event_INTERFACE *)
                                         data)->current_adv;
                priority = ((struct event_INTERFACE *)data)->priority;
        }
        
        /* find free slot, if not already initialized */
        dev = monitor_dev_up(ifname);
        if (dev == NULL) {
                DEBUG(DEBUG_FLAG, "monitor_interface_up: no free slots\n");
                syslog(LOG_ERR, "monitor_interface_up: no free slots, %m");
                return -1;
        }
        
        /* Get pointer to the send timer (we need to set this zero, if 
         * location updates are more frequent than 1 second) */
        if (mon_conf.reg_send_timer == NULL)
                mon_conf.reg_send_timer = last_reg_send_time;

        /* Register handlers if not already registered */
        if (dev->iwspy_support && mon_conf.iwspy_supported == 0) {
                handler_register(FA_ADV_EXPIRE, monitor_del_fa);
                handler_register(FA_ADV_RECEIVE, monitor_add_fa);
#ifndef PLAIN_MIP
                handler_register(FA_GET, monitor_get_fa);
#endif /* PLAIN_MIP */
                mon_conf.iwspy_supported++;
                DEBUG(DEBUG_FLAG, "monitor_interface_up: Handlers "
                      "initialized (%s)\n", dev->ifname);
                if (mon_conf.rec_qual) {
                        if (mon_rec_qual_initialized == 0) {
                                /* quality recorder only valuable if 
                                   iwspy supported */
                                rec_init();
                                mon_rec_qual_initialized = 1;
                        }
                } else if (mon_rec_qual_initialized) {
                        rec_dump(REC_DUMP_TYPE, -1);
                        rec_clean_up();
                        mon_rec_qual_initialized = 0;
                }
        }
        
        /* set priority */
        if (priority != NULL && *priority >= 0)
                dev->priority = *priority;
        else
                if (dev->iwspy_support)
                        dev->priority = DEFAULT_WIRELESS_PRIO;
                else
                        dev->priority = DEFAULT_INTERFACE_PRIORITY;


        DEBUG(DEBUG_FLAG, "monitor_interface_up: iwspy: %s channel"
              " switch: %s\n", 
              dev->iwspy_support   ? "YES" : "NO",
              dev->channel_support ? "YES" : "NO");

        if (dev->channel_support && dev->iwspy_support)
                return 0;
        else if (!dev->channel_support && dev->iwspy_support)
                return 1;
        else if (dev->channel_support && !dev->iwspy_support)
                return 2;
        else
                return 3;
}


/*
 * "event_INTERFACE_DOWN" event handler
 * 
 * Clears device structures in monitor and unregisters handlers that
 * were bound to this interface
 * 
 * return:
 *   0   success
 *  -1   failed
 */
static int monitor_interface_down(void *data)
{
        struct event_INTERFACE *vars = (struct event_INTERFACE *)data;
        struct monitor_interface *dev = NULL;

        if (vars == NULL) {
                DEBUG(DEBUG_FLAG, "monitor_interface_down: NULL argument!\n");
                return -1;
        }

        dev = monitor_get_dev(vars->ifname);
        if (!dev) {
                DEBUG(DEBUG_FLAG, "monitor_interface_down: Device not "
                      "found! (%s)\n", vars->ifname);
                return -1;
        }

        monitor_dev_down(dev);

        /* unregister event_FA handlers if the only interface */
        if (mon_conf.iwspy_supported == 0 && dev->iwspy_support) {
                handler_unregister(FA_ADV_EXPIRE, monitor_del_fa);
                handler_unregister(FA_ADV_RECEIVE, monitor_add_fa);
#ifndef PLAIN_MIP
                handler_unregister(FA_GET, monitor_get_fa);
#endif /* PLAIN_MIP */
        }

        return 0;
}


/***********************/
/* MODULE registration */
/***********************/

int MONITOR_unregister_module(void)
{
        int i;

        for (i = 0; i < MAX_INTERFACES; i++) {
                if (!mon_devs[i].in_use)
                        continue;
                if (mon_devs[i].iwspy_support && !mon_conf.SQ_cache)
                        dyn_wireless_iwspy_set(mon_devs[i].sock, 
                                               mon_devs[i].ifname, NULL, 0);

                if (mon_devs[i].sock >= 0) {
                        close(mon_devs[i].sock);
                        mon_devs[i].sock = -1;
                }
        }

        if (mon_rec_qual_initialized) {
                if (mon_conf.rec_qual)
                        rec_dump(REC_DUMP_TYPE, -1);
                rec_clean_up();
                mon_rec_qual_initialized = 0;
        }

        return 0;
}


void MONITOR_register_module(void)
{
        /* initialize state and variables */
        memset(&mon_conf, 0, sizeof(struct monitor_global_data));
        mon_conf.current_fa = -1;    /* not connected yet */
        mon_conf.current_adv = NULL;
        mon_conf.reg_send_timer = NULL;
        mon_conf.interfaces = 0;
        mon_conf.iwspy_supported = 0;
        mon_conf.threshold = DEFAULT_THRESHOLD;
        mon_conf.default_ch = -1;
        mon_conf.old_fa_factor = OLD_FA_FACTOR;
        mon_conf.expiretime = DEFAULT_EARLY_EXPIRE_TIME;
        mon_conf.min_balance = DEFAULT_MIN_BALANCE;
        mon_conf.worst_min_time = DEFAULT_WORST_MIN_TIME;
        mon_conf.worst_max_time = DEFAULT_WORST_MAX_TIME;
        mon_conf.dev_priority_percentage = DEFAULT_DEV_PRIO_PERCENT;
        mon_conf.average_length = DEFAULT_AVG_LEN;
        mon_conf.rec_qual = 0;
        mon_conf.SQ_cache = 0;
        mon_rec_qual_initialized = 0;
        memset(mon_devs, 0, sizeof(mon_devs));

        /* register event_INTERFACE handlers */
        handler_register(INTERFACE_INIT, monitor_interface_up);
        handler_register(INTERFACE_DOWN, monitor_interface_down);
}


void monitor_poll_ap_addresses(struct mn_data *mn)
{
        int i, j;
        char new_addr[ETH_ALEN];

        DEBUG(DEBUG_FLAG, "monitor_poll_ap_addresses()\n");
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (!mon_devs[i].in_use || mon_devs[i].sock < 0)
                        continue;

                if (dyn_wireless_get_ap_address(mon_devs[i].sock,
                                                mon_devs[i].ifname,
                                                new_addr) < 0) {
                        DEBUG(DEBUG_FLAG, "monitor_poll_ap_addresses: get AP "
                              "hw addr failed\n");
                        continue;
                }

                if (memcmp(new_addr, mon_devs[i].ap_hwaddr, ETH_ALEN) != 0) {
                        DEBUG(DEBUG_FLAG, "Monitor: AP hw addr changed "
                              "(iface=%s): %s => ",
                              mon_devs[i].ifname,
                              ether_hwtoa((unsigned char *)
                                          mon_devs[i].ap_hwaddr));
                        DEBUG(DEBUG_FLAG, "%s\n",
                              ether_hwtoa((unsigned char *) new_addr));
                        /* send agentsol to this interface */
                        for (j = 0; j < MAX_INTERFACES; j++) {
                                if (strcmp(mon_devs[i].ifname,
                                           mn->iface[j].device) != 0 ||
                                    mn->iface[j].s < 0)
                                        continue;

                                send_agent_solicitation(mn->iface[j].s);
                        }
                        memcpy(mon_devs[i].ap_hwaddr, new_addr, ETH_ALEN);
                }
        }
}

---