mn_agentadv.h File Reference

#include "agentadv.h"
#include "list.h"
#include "sys/time.h"
#include "hashtable.h"

Include dependency graph for mn_agentadv.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	agentadv_key
struct	agentadv_data
Defines
#define	ADV_EXTRA_TIME   10
#define	ADV_CLEANUP_FREQ   10
#define	FA_GET_NO   0
#define	FA_GET_CHANGED   1
#define	FA_GET_SAME   2
#define	MAX_FA_NAI_LEN   (sizeof(struct fa_nai_ext) + 255)
Enumerations
enum	{ MN_ADV_TYPE_UNKNOWN = 0, MN_ADV_TYPE_FA, MN_ADV_TYPE_HA, MN_ADV_TYPE_OWN_HA }
Functions
int	handle_icmp (struct interface_data *iface)
agentadv_data *	get_ok_fa (void)
int	clean_agentadv (struct node *node, void *data)
int	get_fa (struct agentadv_data *adv)
agentadv_data *	adv_fetch (struct hashtable *adv_hash, struct in_addr *addr, int ifindex)
	adv_fetch: : hash of agent advertisements : address of agent : 0 to accept any interface, or index of a given interface

---

Define Documentation

#define ADV_CLEANUP_FREQ   10

Definition at line 24 of file mn_agentadv.h.

Referenced by check_expired_agent_advs().

#define ADV_EXTRA_TIME   10

Definition at line 22 of file mn_agentadv.h.

Referenced by check_expired_agent_advs().

#define FA_GET_CHANGED   1

Definition at line 29 of file mn_agentadv.h.

#define FA_GET_NO   0

Definition at line 28 of file mn_agentadv.h.

Referenced by find_agent().

#define FA_GET_SAME   2

Definition at line 30 of file mn_agentadv.h.

#define MAX_FA_NAI_LEN   (sizeof(struct fa_nai_ext) + 255)

Definition at line 32 of file mn_agentadv.h.

Referenced by mn_init().

---

Enumeration Type Documentation

anonymous enum

Enumerator:

MN_ADV_TYPE_UNKNOWN
MN_ADV_TYPE_FA
MN_ADV_TYPE_HA
MN_ADV_TYPE_OWN_HA

Definition at line 34 of file mn_agentadv.h.

     {
        MN_ADV_TYPE_UNKNOWN = 0,
        MN_ADV_TYPE_FA /* FA (and possibly unknown HA) */,
        MN_ADV_TYPE_HA /* unknown HA */,
        MN_ADV_TYPE_OWN_HA /* our own HA (and possibly FA) */
};

---

Function Documentation

struct agentadv_data* adv_fetch	(	struct hashtable *	adv_hash,
		struct in_addr *	addr,
		int	ifindex
	)

adv_fetch: : hash of agent advertisements : address of agent : 0 to accept any interface, or index of a given interface

fetch an agent advertisement from the . addr: the source IP address of the agent advertisment packet

Returns: the matching advertisement

Definition at line 124 of file mn_agentadv.c.

References agentadv_key::addr, agentadv_data::adv, and agentadv_key::ifindex.

Referenced by add_fa_host_route().

{
        struct agentadv_data *adv;
        struct agentadv_key key;
        key.addr.s_addr = addr->s_addr;
        key.ifindex = ifindex;

        adv = (struct agentadv_data *)
                hashtable_fetch(adv_hash, addr_hash, &key, addr_cmp);
        return (adv);
}

int clean_agentadv	(	struct node *	node,
		void *	data
	)

Definition at line 141 of file mn_agentadv.c.

References event_FA::adv, agentadv_data::adv, mn_data::agentadv, mn_data::current_adv, DEBUG(), DEBUG_AGENTADV, DEBUG_INFO, device_up(), FA_ADV_EXPIRE, handler_call_all(), event_FA::hash, LOG2, mn, and TRUE.

Referenced by check_expired_agent_advs(), and clean_up().

{
        struct agentadv_data *adv;
        struct timeval *tval;
        struct event_FA dat;

        adv = (struct agentadv_data *) node;
        tval = (struct timeval *) data;

        if (tval != NULL && cmp_timeval(tval, &adv->expire) < 0)
                return TRUE; /* not expired */

        if (tval != NULL && adv->in_use) {
                /* in use and removal not forced */
                current_agent_expired = TRUE;
                return TRUE;
        }

        DEBUG(DEBUG_AGENTADV, "clean_agentadv: removing %s\n",
              inet_ntoa(adv->addr));

        /* call handlers registered for FA_ADV_EXPIRE event */
        dat.adv = adv;
        dat.hash = mn.agentadv;
        handler_call_all(FA_ADV_EXPIRE, &dat);

        /* remove the possible ARP entries etc. */
        if (adv->arpentry == 1 &&
            arp_del_permanent_item(adv->addr, adv->ifname) < 0) {
                if (device_up(adv->ifindex)) {
                        LOG2(LOG_WARNING,
                             "arp_del_permanent_item(%s, %s) failed\n",
                             inet_ntoa(adv->addr), adv->ifname);
                } else {
                        DEBUG(DEBUG_INFO, "arp_del_permanent_item(%s, %s) "
                              "failed (device down)\n",
                              inet_ntoa(adv->addr), adv->ifname);
                }
        }

        /* remove the possible host route to FA */
        if (adv->routeentry == 1) {
                DEBUG(DEBUG_INFO, "Removing FA route (%s,%s)\n",
                      inet_ntoa(adv->addr), adv->ifname);
                if (dyn_ip_route_del(adv->addr, adv->ifname) != 0)
                        DEBUG(DEBUG_INFO, "FA route removing failed\n");
        }

        if (mn.current_adv == adv) {
                DEBUG(DEBUG_AGENTADV, "clean_agentadv: removed current_adv\n");
                mn.current_adv = NULL;
        }

        hashtable_remove(node);
        free(adv);

        return TRUE;
}

Here is the call graph for this function:

int get_fa

(

struct agentadv_data *

adv

)

Definition at line 415 of file mn_agentadv.c.

References event_FA::adv, mn_data::agentadv, FA_GET, handler_call_all(), event_FA::hash, and mn.

Referenced by find_agent().

{
        struct event_FA data;

        data.adv = adv;
        data.hash = mn.agentadv;
        handler_call_all(FA_GET, &data);
        return update_fa_decision(adv);
}

Here is the call graph for this function:

struct agentadv_data* get_ok_fa

(

void

)

int handle_icmp

(

struct interface_data *

iface

)

Definition at line 543 of file mn_agentadv.c.

References agentadv_key::addr, agentadv_data::adv, mn_data::agentadv, check_interfaces(), DEBUG(), DEFAULT_PRIO_DEGRADE_DEGRADE, interface_data::device, mn_data::force_fa_addr, mn_data::iface, agentadv_key::ifindex, interface_data::index, MAX_INTERFACES, MIN_ALLOWED_LIFETIME, mn, MN_ADV_TYPE_FA, MN_ADV_TYPE_HA, MN_ADV_TYPE_OWN_HA, interface_data::s_adv, and UPDATE_OFFSET.

Referenced by main_vanha().

{
        char buf[MAX_ADV_MSG];
        struct adv_extensions ext;
        struct agentadv_key key;
        struct agentadv_data *adv;
        int res;

        /* return, if message was not for us */
        res = handle_icmp_adv(iface->s_adv, buf, MAX_ADV_MSG, &ext);
        if (res == -1) {
                /* network is down - rescan interfaces */
                check_interfaces(mn.iface, MAX_INTERFACES);
        }

        if (res != 1)
                return 0;

        UNALIGNED_(&key.addr.s_addr, &ext.ip->saddr);

#ifndef MN_FA_FORCE_AFTER_AGENTADV_UPDATE
        if (mn.force_fa_addr.s_addr != 0 &&
            mn.force_fa_addr.s_addr != key.addr.s_addr) {
                DEBUG(DEBUG_AGENTADV,
                      "handle_icmp: force_fa set to %s - ignoring this FA(1)",
                      inet_ntoa(mn.force_fa_addr));
                DEBUG(DEBUG_AGENTADV, " (%s)\n", inet_ntoa(key.addr));
                return 0;
        }
#endif /* MN_FA_FORCE_AFTER_AGENTADV_UPDATE */

        key.ifindex = iface->index;

        if (ntohs(ext.ext->reg_lifetime) < MIN_ALLOWED_LIFETIME) {
                DEBUG(DEBUG_AGENTADV,
                      "handle_icmp: too small lifetime advertised (%d) "
                      "- ignoring this FA (%s)\n",
                      ntohs(ext.ext->reg_lifetime), inet_ntoa(key.addr));
                return 0;
        }

        /* save the last agentadv */
        adv = (struct agentadv_data *)
                hashtable_fetch(mn.agentadv, addr_hash, &key, addr_cmp);
        if (adv == NULL) {
                /* we have no previous information on this mobility agent */
                adv = (struct agentadv_data *)
                        malloc(sizeof(struct agentadv_data));
                if (adv == NULL) {
                        DEBUG(DEBUG_AGENTADV,
                              "handle_icmp: no memory for agentadv data\n");
                        return 0;
                }
                DEBUG(DEBUG_AGENTADV, "Added new agentadv entry for %s\n",
                      inet_ntoa(key.addr));
                memset(adv, 0, sizeof(struct agentadv_data));
                list_init_node(&adv->node);
                UNALIGNED_(&adv->addr.s_addr, &ext.ip->saddr);
                adv->counter = 1;
                adv->prio_degrade_percent = 0; /* don't degrade new FAs! */ 
                if (!hashtable_add(mn.agentadv, addr_hash, &key.addr,
                                   &adv->node)) {
                        DEBUG(DEBUG_AGENTADV,
                              "handle_icmp: hashtable_add failed\n");
                        free(adv);
                        return 0;
                }
        } else {
                /* updating information for previously heard mobility agent */
                DEBUG(DEBUG_AGENTADV, "Used old agentadv entry for %s\n",
                      inet_ntoa(key.addr));
                adv->counter++;
                /* Let FA become slowly "available" again */
                if (adv->prio_degrade_percent > 0)
                        adv->prio_degrade_percent = (int)
                                (adv->prio_degrade_percent*
                                 DEFAULT_PRIO_DEGRADE_DEGRADE);
                /* remove the reg_failed flag if the adv. opts has changed */
                if (adv->reg_failed && ext.ext->opts != adv->adv.ext->opts) {
                        DEBUG(DEBUG_AGENTADV,
                              "Reseting reg_failed for this FA\n");
                        adv->reg_failed = 0;
                }
        }

        adv->ifindex = iface->index;
        dynamics_strlcpy(adv->ifname, iface->device, sizeof(adv->ifname));
        gettimeofday(&adv->last, NULL);
        adv->expire.tv_sec = adv->last.tv_sec + ntohs(ext.radv->lifetime) + 1;
        adv->expire.tv_usec = adv->last.tv_usec;
        DEBUG(DEBUG_AGENTADV, "\tnow=%li.%li, expire=%li.%li\n",
              adv->last.tv_sec, adv->last.tv_usec,
              adv->expire.tv_sec, adv->expire.tv_usec);

        memcpy(adv->buf, buf, MAX_ADV_MSG);
        memcpy(&adv->adv, &ext, sizeof(struct adv_extensions));
        adv->adv.start = adv->buf;
        adv->adv.len = ext.len;
        adv->adv.coaddrs = ext.coaddrs;
        memcpy(&adv->adv.from, &ext.from, sizeof(ext.from));
#define UPDATE_OFFSET(n) adv->adv.n = ext.n ? \
(typeof(ext.n)) (((char *) ext.n) - ext.start + adv->adv.start) : NULL
#ifndef DYN_TARGET_LINUX
        UPDATE_OFFSET(eth);
#endif
        UPDATE_OFFSET(ip);
        UPDATE_OFFSET(radv);
        UPDATE_OFFSET(ext);
        UPDATE_OFFSET(prefix);
        UPDATE_OFFSET(own_ext);
        UPDATE_OFFSET(pubkey_hash);
        UPDATE_OFFSET(fa_nai);
        UPDATE_OFFSET(challenge);

#ifdef MN_FA_FORCE_AFTER_AGENTADV_UPDATE
        if (mn.force_fa_addr.s_addr != 0 &&
            mn.force_fa_addr.s_addr != key.addr.s_addr) {
                DEBUG(DEBUG_AGENTADV,
                      "handle_icmp: force_fa set to %s - ignoring this FA(2)",
                      inet_ntoa(mn.force_fa_addr));
                DEBUG(DEBUG_AGENTADV, " (%s)\n", inet_ntoa(key.addr));
                return 0;
        }
#endif /* MN_FA_FORCE_AFTER_AGENTADV_UPDATE */

        if (ntohs(ext.ext->opts) & AGENT_ADV_HOME_AGENT) {
                adv->adv_type = MN_ADV_TYPE_HA;
                handle_home_adv(adv);
        }
        if (ntohs(ext.ext->opts) & AGENT_ADV_FOREIGN_AGENT) {
                if (adv->adv_type != MN_ADV_TYPE_OWN_HA)
                        adv->adv_type = MN_ADV_TYPE_FA;
                if (ext.coaddrs <= 0)
                        DEBUG(DEBUG_AGENTADV,
                              "handle_icmp: FA adv with no COAs - ignoring\n");
                else
                        handle_fa_adv(adv);
        }

        return 0;
}

Here is the call graph for this function:

---