mn.c

Go to the documentation of this file.

/* $Id: mn.c,v 1.239 2001/10/20 14:44:19 jm Exp $
 * Mobile Node - state machine and main loop
 *
 * 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.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <errno.h>
#include <unistd.h>

#include "agentapi.h"
#include "debug.h"
#include "util.h"
#include "dyn_ip.h"
#include "mn.h"
#ifndef DYN_TARGET_WINDOWS
#include "monitor.h"
#endif /* DYN_TARGET_WINDOWS */
#include "fixed_fd_zero.h"
#ifdef INCLUDE_IPAY
#include "mn_ipay.h"
#endif

extern int real_tunnel_up; /* from mn_tunnel */

struct mn_data mn;
struct mn_config config; /* configuration information */
/* Timers containing ending time for the timer */
struct timeval timers[TIMER_COUNT];
char *program_name;

/*
 * Determine the timeout value in seconds for a solicitation request.
 * Parameters:
 *  counter - pointer to variable holding information,
 *            how many requests have been sent.
 * Returns: timeout in seconds or zero when it's time to go passive mode.
 */
static int get_solicitation_interval(int *counter)
{
        static int intervals[] = SOLICITATION_INTERVALS;
        int t;

        ASSERT(counter != NULL);
        ASSERT(sizeof(intervals) > 0);

        if (*counter < 0) *counter = 0;

        if (*counter >= sizeof(intervals) / sizeof(int))
                t = 0;
        else t = intervals[*counter];

        (*counter)++;

        return t;

}

/*
 * Due to the unsuccessful registration to the FA, degrade its priority.
 */
int degrade_current_fa_priority(void)
{
        if (mn.current_adv == NULL)
                return 1;

        if (mn.current_adv->prio_degrade_percent == 0) {
                mn.current_adv->prio_degrade_percent = 
                        DEFAULT_PRIO_DEGRADE_INITIAL;
        } else {
                mn.current_adv->prio_degrade_percent *= 
                        DEFAULT_PRIO_DEGRADE_FACTOR;
        }

        if (mn.current_adv->prio_degrade_percent > 100) {
                mn.current_adv->prio_degrade_percent = 100;
        }

        DEBUG(DEBUG_INFO, "degrade_current_fa_priority: %d\n",
              mn.current_adv->prio_degrade_percent);
        
        return 0;
}


/*
 * Set reregistration time. Binary exponential backoff is used on
 * reregistrations. Maximum reregistration time is limited with
 * NORMAL_REREGISTRATION_TIME. At least half of the lifetime is
 * allowed to pass before registration is initiated.
 */
static void set_reregistration_time(int total_lifetime)
{
        int rt;   /* remaining lifetime */
        struct timeval expire_time, now;
        struct fa_spi_entry *fa_spi;

        expire_time = timers[TIMER_LIFETIME];

        gettimeofday(&now, NULL);
        DEBUG(DEBUG_TIMERS, "set_reregistration_time(%i) - now=%li.%06li\n",
              total_lifetime, now.tv_sec, now.tv_usec);
        DEBUG(DEBUG_TIMERS, "\tTIMER_LIFETIME: %li.%06li\n",
              timers[TIMER_LIFETIME].tv_sec, timers[TIMER_LIFETIME].tv_usec);

        if (config.mn_ha_key_timestamp != 0 &&
            config.mn_ha_key_lifetime != 0 &&
            expire_time.tv_sec > config.mn_ha_key_timestamp +
            config.mn_ha_key_lifetime) {
                expire_time.tv_sec = config.mn_ha_key_timestamp +
                        config.mn_ha_key_lifetime;
                expire_time.tv_usec = 0;
                mn.aaa_rekey = 1;

                DEBUG(DEBUG_TIMERS, "\tMN-HA key lifetime overriding at "
                      "%li\n", expire_time.tv_sec);
        }

        fa_spi = get_fa_spi(0, mn.fa_addr);
        if (fa_spi != NULL && fa_spi->created > 0 &&
            expire_time.tv_sec > fa_spi->created + fa_spi->lifetime) {
                expire_time.tv_sec = fa_spi->created + fa_spi->lifetime;
                expire_time.tv_usec = 0;
                mn.aaa_rekey = 1;

                DEBUG(DEBUG_TIMERS, "\tMN-FA key lifetime overriding at "
                      "%li\n", expire_time.tv_sec);
        }

        rt = sec_passed(&expire_time);

        /* if total lifetime is set ( > 0), set initial reregistration
         *  time, else use exponential backoff
         */
        if (total_lifetime > 0) {
                /* bound to end of the lifetime */
                if (rt > 2*NORMAL_REREGISTRATION_TIME) {
                        timers[TIMER_REREG] = expire_time;
                        timers[TIMER_REREG].tv_sec -=
                                mn.aaa_rekey ? MN_AAA_REG_TIME :
                                NORMAL_REREGISTRATION_TIME;
                } else {
                        struct timeval rereg;

                        now.tv_sec++;

                        rereg = expire_time;
                        rereg.tv_sec -= mn.aaa_rekey ? MN_AAA_REG_TIME :
                                total_lifetime / 2;

                        if (cmp_timeval(&rereg, &now) > 0)
                                timers[TIMER_REREG] = rereg;
                        else
                                timers[TIMER_REREG] = now;
                }
                if (mn.current_adv == NULL) {
                        LOG2(LOG_ALERT, "set_registration_time - current_adv "
                             "== NULL\n");
                        mn.HA_reg_retry_time = MIN_REGISTRATION_TIME;
                } else {
                        DEBUG(DEBUG_TIMERS, "FA[%s] reg_retry_time = %i\n",
                              inet_ntoa(mn.current_adv->addr),
                              MIN_REGISTRATION_TIME);
                        mn.current_adv->reg_retry_time = MIN_REGISTRATION_TIME;
                }
        } else {
                if (mn.current_adv == NULL) {
                        LOG2(LOG_ALERT, "set_registration_time - current_adv "
                             "== NULL\n");
                        if (mn.HA_reg_retry_time == 0)
                                mn.HA_reg_retry_time = MIN_REGISTRATION_TIME;
                        else
                                mn.HA_reg_retry_time *= 2;
                        timers[TIMER_REREG].tv_sec += mn.HA_reg_retry_time;
                } else {
#ifndef NO_PRIO_DEGRADE
                        /* degrade FA priority */
                        degrade_current_fa_priority();
#endif /* NO_PRIO_DEGRADE */

                        DEBUG(DEBUG_TIMERS, "FA[%s] reg_retry_time: %i => ",
                              inet_ntoa(mn.current_adv->addr),
                              mn.current_adv->reg_retry_time);
                        if (mn.current_adv->reg_retry_time == 0)
                                mn.current_adv->reg_retry_time =
                                        MIN_REGISTRATION_TIME;
                        else
                                mn.current_adv->reg_retry_time *= 2;
                        DEBUG(DEBUG_TIMERS, "%i\n",
                              mn.current_adv->reg_retry_time);
                        timers[TIMER_REREG].tv_sec +=
                                mn.current_adv->reg_retry_time;
                }
        }
}


/* Select next timer to timeout and place timeout to *tv.
 * Returns non-zero if timeout is valid otherwise 0. */
static int get_next_timeout(struct timeval *tv)
{
        struct timeval *t, now;

        t = &timers[TIMER_GEN];

        if (config.wlan_ap_poll_interval > -1 &&
            timerisset(&timers[TIMER_WLAN_AP_POLL]) &&
            (!timerisset(t) ||
             cmp_timeval(&timers[TIMER_WLAN_AP_POLL], t) < 0))
                t = &timers[TIMER_WLAN_AP_POLL];
        if (config.solicitation_interval > -1 &&
            timerisset(&timers[TIMER_SOLICITATION]) &&
            (!timerisset(t) ||
             cmp_timeval(&timers[TIMER_SOLICITATION], t) < 0))
                t = &timers[TIMER_SOLICITATION];

        if (!timerisset(t)) return 0;

        /* check if the current agentadv expires before the TIMER_GEN */
        if (mn.current_adv && mn.expire_check &&
            cmp_timeval(&mn.current_adv->expire, t) < 0) {
                mn.expire_check = 0;
                t = &mn.current_adv->expire;
        }

        gettimeofday(&now, NULL);

        if (now.tv_usec > t->tv_usec) {
                tv->tv_sec = t->tv_sec - now.tv_sec - 1;
                tv->tv_usec = 1000000 + t->tv_usec - now.tv_usec;
        } else {
                tv->tv_sec = t->tv_sec - now.tv_sec;
                tv->tv_usec = t->tv_usec - now.tv_usec;
        }

        if (tv->tv_sec < 0) timerclear(tv);

        return 1;
}


/* State change functions
 * Same functions are used for entering the for the state first time and
 * retrying after timeout. If state is already set, timeout processing is done.
 */


/* Just listen to agent advertisements and switch to request_tunnel after one
 * is heard. */
void passive_find(void)
{
        mn.state = MN_PASSIVE_FIND;
        DEBUG(DEBUG_STATES, "State: Passive find\n");
}


static void send_solicitations(struct mn_data *mn)
{
        int i;
        struct timeval now;

        gettimeofday(&now, NULL);
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (mn->iface[i].s > -1) {
                        if ((now.tv_sec < mn->iface[i].last_solicitation.tv_sec
                             || !timerisset(&mn->iface[i].last_solicitation) ||
                             usec_passed(&mn->iface[i].last_solicitation, &now)
                             > MIN_SOLICITATION_DELAY)) {
                                send_agent_solicitation(mn->iface[i].s);
                                mn->iface[i].last_solicitation = now;
                        } else {
                                DEBUG(DEBUG_TIMERS, "Too frequent agent "
                                      "solicitations (dev=%s) - skipping\n",
                                      mn->iface[i].device);
                        }
                }
        }
}

void find_agent(int entry)
{
        int t, chg;
        static int retry_time = 0; /* time in seconds between retries of agent
                                    * solicitations */

        DEBUG(DEBUG_INFO, "find_agent(%i)\n", entry);

        mn.tunnel_up = 0;

        if (mn.device_count == 0) {
                passive_find();
                return;
        }

        if (mn.tunnel_mode == API_TUNNEL_FULL_HA) {
                DEBUG(DEBUG_INFO,
                      "find_agent: trying to register directly to HA\n");
                if (config.ha_ip_addr.s_addr == 0 &&
                    config.home_net_addr_plen > -1) {
                        /* dynamic HA address resolution */
                        mn.fa_addr.s_addr = config.home_net_subnet_bc.s_addr;
                } else
                        mn.fa_addr.s_addr = config.ha_ip_addr.s_addr;
                mn.co_addr.s_addr = mn.local_addr.s_addr;
                if (mn.current_adv != NULL) {
                        mn.current_adv->in_use = 0;
                        mn.current_adv = NULL;
                }
                request_tunnel(STATE_INIT, 0, 0);
                return;
        }

        /* try to find the best FA from the previously received agentadvs;
         * if a valid entry is found, use it; otherwise send agent
         * solicitation */
        chg = get_fa(NULL);
        if (chg != FA_GET_NO) {
                DEBUG(DEBUG_INFO, "find_agent: found FA from stored agentadv "
                      "data - FA=%s, HFA=", inet_ntoa(mn.fa_addr));
                DEBUG(DEBUG_INFO, "%s\n", inet_ntoa(mn.co_addr));
                request_tunnel(STATE_INIT, 0, 0);
                return;
        }

        if (entry == STATE_INIT) {
                mn.state = MN_FIND_AGENT;
                retry_time = 0;
                mn.req_lifetime = config.mn_default_tunnel_lifetime;
        }

        t = get_solicitation_interval(&retry_time);
        if (t == 0) {
                passive_find();
                return;
        }

        /* send agent solicitation to all the active interfaces */
        send_solicitations(&mn);

        DEBUG(DEBUG_TIMERS, "find_agent - TIMER_GEN: set now+%i sec\n", t);
        gettimeofday(&timers[TIMER_GEN], NULL);
        timers[TIMER_GEN].tv_sec += t;
        add_usecs(&timers[TIMER_GEN],
                  get_rand32() % MAX_RANDOM_SOLICITATION_DELAY);

        DEBUG(DEBUG_STATES, "State: Find agent\n");
}


void request_tunnel(int entry, int forced, int check_timer)
{
        int retry_time;

        DEBUG(DEBUG_INFO, "request_tunnel(%i, %i, %i)\n", entry, forced,
              check_timer);

        if (mn.current_adv == NULL) {
                retry_time = mn.HA_reg_retry_time;
                DEBUG(DEBUG_INFO, "No current agent advertisement " 
                      "when requesting tunnel (direct tunnel to HA?)\n");
        } else
                retry_time = mn.current_adv->reg_retry_time;

        if (check_timer && retry_time > 1) {
                struct timeval now;
                gettimeofday(&now, NULL);
                if (timerisset(&timers[TIMER_GEN]) &&
                    cmp_timeval(&now, &timers[TIMER_GEN]) < 0) {
                        DEBUG(DEBUG_TIMERS, "request_tunnel: TIMER_GEN not "
                              "yet reached\n");
                        return;
                }
        }

        if (config.enable_fa_decapsulation && mn.current_adv != NULL)
                add_fa_host_route(mn.current_adv->ifname, mn.agentadv,
                                  mn.current_adv->ifindex, mn.fa_addr);

        if (entry == STATE_INIT) {
                mn.state = MN_REQUEST_TUNNEL;
                if (!forced)
                        mn.tunnel_up = 0;

                /* if last registration was sent less than a second ago,
                   wait a second before sending the request */
                if (usec_passed(&mn.last_reg_send_time, NULL) <
                    MIN_REGISTRATION_DELAY) {
                        DEBUG(DEBUG_INFO, "Too frequent registration request "
                              "- delaying\n");
                        DEBUG(DEBUG_TIMERS, "request_tunnel: TIMER_GEN: set "
                              "now+1 sec (too freq.)\n");
                        gettimeofday(&timers[TIMER_GEN], NULL);
                        timers[TIMER_GEN].tv_sec++;
                        return;
                }
        } else if (retry_time > MAX_REGISTRATION_TIME) {
                /* STATE_TIMEOUT */
                if (config.use_hadisc) {
                        DEBUG(DEBUG_INFO, "HA does not reply - try to discover"
                              " another HA\n");
                        mn.info_str = "restarting HA discovery";
                        config.ha_ip_addr.s_addr = 0;
                        if (mn.current_adv != NULL)
                                mn.current_adv->reg_retry_time =
                                        MIN_REGISTRATION_TIME;
                        else
                                mn.HA_reg_retry_time =
                                        MIN_REGISTRATION_TIME;
                } else {
                        /* give up, switch to find agent */
                        if (forced) {
                                DEBUG(DEBUG_INFO,
                                      "Could not confirm tunnel.\n");
                                reply_waiting_api(API_FAILED, NULL, 0);
                        } else {
                                DEBUG(DEBUG_INFO, "Could not register.\n");
                        }
                        find_agent(STATE_INIT);
                        return;
                }
        } else if (mn.current_adv != NULL) {
                /* STATE_TIMEOUT */
#ifndef NO_PRIO_DEGRADE
                /* degrade the FA priority */
                degrade_current_fa_priority();
#endif /* NO_PRIO_DEGRADE */
                DEBUG(DEBUG_TIMERS, "FA[%s] reg_retry_time: %i => ",
                      inet_ntoa(mn.current_adv->addr),
                      mn.current_adv->reg_retry_time);
                if (mn.current_adv->reg_retry_time == 0)
                        mn.current_adv->reg_retry_time = MIN_REGISTRATION_TIME;
                else
                        mn.current_adv->reg_retry_time *= 2;
                DEBUG(DEBUG_TIMERS, "%i\n", mn.current_adv->reg_retry_time);
        } else {
                if (mn.HA_reg_retry_time == 0)
                        mn.HA_reg_retry_time = MIN_REGISTRATION_TIME;
                else
                        mn.HA_reg_retry_time *= 2;
        }

        if (send_registration(forced ? REG_REREG : REG_CONNECT) < 0) {
                DEBUG(DEBUG_INFO, "Registration failed for this FA - trying to"
                      " find a new one\n");
                mn.warn_str = "Registration failed for this FA, trying to find"
                        " a new one";
                find_agent(STATE_INIT);
                return;
        }

        gettimeofday(&timers[TIMER_GEN], NULL);
        if (mn.current_adv != NULL) {
                if (mn.current_adv->reg_retry_time < MIN_REGISTRATION_TIME)
                        mn.current_adv->reg_retry_time = MIN_REGISTRATION_TIME;
                retry_time = mn.current_adv->reg_retry_time;
        } else {
                if (mn.HA_reg_retry_time < MIN_REGISTRATION_TIME)
                        mn.HA_reg_retry_time = MIN_REGISTRATION_TIME;
                retry_time = mn.HA_reg_retry_time;
        }
        DEBUG(DEBUG_TIMERS, "request_tunnel - TIMER_GEN: set now+%i sec\n",
              retry_time);
        timers[TIMER_GEN].tv_sec += retry_time;

        DEBUG(DEBUG_STATES, "State: Request tunnel%s\n",
              forced ? " (forced)" : "");
}


/* Enter connected state.
 * Paramters:
 *   type:
 *     CON_HA   : connection was approved by HA
 *     CON_FA   : connection was approved by FA
 *   lifetime: lifetime received in reply
 */
void connected(int type, __u16 lifetime)
{
        DEBUG(DEBUG_INFO, "connected(%i, %i)\n", type, lifetime);
        ASSERT(lifetime > 0);

        if (mn.current_adv != NULL) {
                if (mn.current_adv->addr.s_addr != mn.fa_addr.s_addr) {
                        DEBUG(DEBUG_INFO, "fa_addr=%s != ",
                              inet_ntoa(mn.fa_addr));
                        DEBUG(DEBUG_INFO, "current_adv->addr=%s\n",
                              inet_ntoa(mn.current_adv->addr));
                }
                mn.current_adv->in_use = 1;
                /* This FA works, so don't degrade priority: */
                mn.current_adv->prio_degrade_percent = 0; 
        } else {
                LOG2(LOG_WARNING, "connected - current_adv == NULL\n");
                mn.warn_str = "connected - current_adv == NULL";
        }

        /* HA MUST NOT use larger lifetime and the FAs cannot change the
         * requested lifetime - force the lifetime to be at maximum the
         * configured time */
        if (lifetime > config.mn_default_tunnel_lifetime) {
                LOG2(LOG_WARNING, "Lifetime in the reply (%i sec) larger than "
                     "expected (%i sec) - lowering it\n", lifetime,
                     config.mn_default_tunnel_lifetime);
                mn.warn_str = "lifetime in the reply larger than expected";
                lifetime = config.mn_default_tunnel_lifetime;
        }

        if (config.enable_fa_decapsulation &&
            mn.fa_addr.s_addr != mn.tunnel_addr.s_addr &&
            mn.tunnel_addr.s_addr != 0 &&
            mn.current_adv != NULL)
                remove_fa_host_routes(0);

        /* if tunnel endpoint has changed, or tunnel is down, create tunnel to
         * FA */
        if (mn.fa_addr.s_addr != mn.tunnel_addr.s_addr || !real_tunnel_up) {
                if (real_tunnel_up) {
                        DEBUG(DEBUG_STATES, "Restart tunneling\n");
                        restart_tunneling();
                } else {
                        DEBUG(DEBUG_STATES, "Start tunneling\n");
                        start_tunneling();
                }
        }

        /* set lifetime timer */
        timers[TIMER_LIFETIME].tv_sec = timers[TIMER_REQUEST].tv_sec +
                lifetime;
        timers[TIMER_LIFETIME].tv_usec = timers[TIMER_REQUEST].tv_usec;

          /* If connection was approved by HA,
           * reset timer for reregistering the tunnel */
        if (type == CON_HA) {
                set_reregistration_time(lifetime);
        }
        if (mn.state != MN_CONNECTED && type == CON_HA) {
                LOG2(LOG_INFO, "Connection established.\n");
                mn.info_str = "connection established";
        }

        DEBUG(DEBUG_TIMERS, "setting TIMER_GEN = TIMER_REREG %li.%06li (in %li"
              " sec)\n",
              timers[TIMER_REREG].tv_sec, timers[TIMER_REREG].tv_usec,
              timers[TIMER_REREG].tv_sec - time(NULL));
        timers[TIMER_GEN] = timers[TIMER_REREG];
        mn.state = MN_CONNECTED;
        mn.tunnel_up = 1;
        DEBUG(DEBUG_STATES, "State: Connected\n");
}


/* Send registration request and set timer */
static void reregister(void)
{
        struct timeval now;

        DEBUG(DEBUG_INFO, "Reregistering..\n");

        /* if tunnel has expired, switch to find agent */
        gettimeofday(&now, NULL);
        if (cmp_timeval(&timers[TIMER_LIFETIME], &now) <= 0) {
                DEBUG(DEBUG_INFO, "Binding expired - trying to find another "
                      "FA and re-establish binding\n");
                mn_remove_dynamic_home_addr();
                
                /* make sure that closest FA won't take next reg_req
                 * as locupd. */
                if (mn.session_key != NULL) free(mn.session_key);
                mn.session_key = NULL;
                mn.session_key_len = 0;
                find_agent(STATE_INIT);
                return;
        }

        if (send_registration(REG_REREG) < 0) {
                mn.warn_str = "Registration failed, trying to find another FA";
                DEBUG(DEBUG_INFO,
                      "Registration failed - trying to find another FA\n");
                if (mn.session_key != NULL) free(mn.session_key);
                mn.session_key = NULL;
                mn.session_key_len = 0;
                find_agent(STATE_INIT);
                return;
        }

        set_reregistration_time(0);

        if (cmp_timeval(&timers[TIMER_REREG], &timers[TIMER_LIFETIME]) < 0) {
                DEBUG(DEBUG_TIMERS, "setting TIMER_GEN = TIMER_REREG %li.%06li"
                      " (in %li sec)\n", timers[TIMER_REREG].tv_sec,
                      timers[TIMER_REREG].tv_usec,
                      timers[TIMER_REREG].tv_sec - time(NULL));
                timers[TIMER_GEN] = timers[TIMER_REREG];
        } else {
                DEBUG(DEBUG_TIMERS, "setting TIMER_GEN = TIMER_LIFETIME "
                      "%li.%06li (in %li sec)\n",
                      timers[TIMER_LIFETIME].tv_sec,
                      timers[TIMER_LIFETIME].tv_usec,
                      timers[TIMER_REREG].tv_sec - time(NULL));
                timers[TIMER_GEN] = timers[TIMER_LIFETIME];
        }

}


/* Stop tunneling and send deregistering message to the home agent.
 * We'll advance to next state when reply arrives. If the message is lost, it
 * will be resent after an interval.
 * Parameters:
 *  entry - STATE_INIT to move to this state
 *          STATE_TIMEOUT to indicate timeout in this state
 */
void close_for_home(int entry)
{
        int retry_time;

        DEBUG(DEBUG_INFO, "close_for_home(%i)\n", entry);

        if (mn.current_adv == NULL) {
                LOG2(LOG_ALERT, "close_for_home - current_adv == NULL\n");
        }
        if (entry == STATE_INIT) {
                mn.state = MN_CLOSE_FOR_HOME;
                if (real_tunnel_up)
                        stop_tunneling();
                else if (config.shared_secret_len < 0 ||
                         config.mn_home_ip_addr.s_addr == 0) {
                        DEBUG(DEBUG_INFO,
                              "close_for_home - not registered; going directly"
                              " to home\n");
                        at_home();
                        return;
                } else {
                        DEBUG(DEBUG_INFO,
                              "close_for_home - not registered, but trying to "
                              "deregister possible old bindings at HA\n");
                        if (mn.co_addr.s_addr == 0)
                                mn.co_addr.s_addr = mn.local_addr.s_addr;
                }
                if (mn.current_adv != NULL) {
                        DEBUG(DEBUG_TIMERS, "FA[%s] reg_retry_time: "
                              "%i => %i (close_for_home)\n",
                              inet_ntoa(mn.current_adv->addr),
                              mn.current_adv->reg_retry_time,
                              MIN_REGISTRATION_TIME);
                        mn.current_adv->reg_retry_time = MIN_REGISTRATION_TIME;
                } else
                        mn.HA_reg_retry_time = MIN_REGISTRATION_TIME;

                /* drop the previous session key so that locupd to FA with the
                 * old binding goes to the HA */
                if (mn.session_key != NULL)
                        free(mn.session_key);
                mn.session_key = NULL;
                mn.session_key_len = 0;
        } else if (mn.current_adv == NULL ||
                   mn.current_adv->reg_retry_time >= MAX_REGISTRATION_TIME) {
                DEBUG(DEBUG_MESSAGES,
                      "Could not get reply from HA - assuming deregistration "
                      "worked\n");
                at_home();
                return;
        } else if (mn.current_adv != NULL) {
                DEBUG(DEBUG_TIMERS, "FA[%s] reg_retry_time: %i => ",
                      inet_ntoa(mn.current_adv->addr),
                      mn.current_adv->reg_retry_time);
                if (mn.current_adv->reg_retry_time == 0)
                        mn.current_adv->reg_retry_time = 1;
                else
                        mn.current_adv->reg_retry_time *= 2;
                DEBUG(DEBUG_TIMERS, "%i\n", mn.current_adv->reg_retry_time);
        }

        send_gratuitous_arp(config.ha_ip_addr, config.mn_home_ip_addr);

        /* send deregistration message to HA */
        mn.fa_addr = config.ha_ip_addr;
        send_registration(REG_DISC);

        /* at least full retry time should be waited */
        gettimeofday(&timers[TIMER_GEN], NULL);
        retry_time = mn.current_adv ? mn.current_adv->reg_retry_time :
                mn.HA_reg_retry_time;
        DEBUG(DEBUG_TIMERS, "close_for_home - TIMER_GEN: set now+%i sec\n",
              retry_time);
        timers[TIMER_GEN].tv_sec += retry_time;

        DEBUG(DEBUG_STATES, "State: Close for home\n");
}


/* We have successfully deregistered from HA and wait for IP address change
 * signal to start tunneling again. */
void at_home(void)
{
        DEBUG(DEBUG_INFO, "at_home()\n");
        send_gratuitous_arp(config.ha_ip_addr, config.mn_home_ip_addr);
        mn.state = MN_AT_HOME;
        DEBUG(DEBUG_STATES, "State: At home\n");
        DEBUG(DEBUG_TIMERS, "Clearing TIMER_GEN\n");
        timerclear(&timers[TIMER_GEN]);
        mn_remove_dynamic_home_addr();
}


/* We are disconnected from tunneling system and nothing is done until
 * connection is asked. */
void disconnect(void)
{
        DEBUG(DEBUG_INFO, "disconnect()\n");

        mn.cur_route_info.known = 0;

        /* if we are connected, we'd better throw out a
         * deregistration message */
        if (mn.state == MN_CONNECTED) {
                send_registration(REG_DISC);
                DEBUG(DEBUG_MESSAGES, "Deregistration message sent\n");
        }
        if (real_tunnel_up) stop_tunneling();

        /* free session key */
        if (mn.session_key) {
                free(mn.session_key);
                mn.session_key = NULL;
                mn.session_key_len = 0;
        }

        DEBUG(DEBUG_TIMERS, "Clearing TIMER_GEN\n");
        timerclear(&timers[TIMER_GEN]);
        mn.state = MN_DISCONNECTED;
        DEBUG(DEBUG_STATES, "State: Disconnected\n");
        syslog(LOG_INFO, "Disconnected.");
        mn_remove_dynamic_home_addr();
}


/* handle reregistration when the not supported request option can be fixed */
static void reinitiate_state(void)
{
        DEBUG(DEBUG_INFO, "reinitiate_state()\n");

        if (mn.current_adv == NULL) {
                DEBUG(DEBUG_INFO, "reinitiate_state - current_adv == NULL\n");
                mn.HA_reg_retry_time = MIN_REGISTRATION_TIME;
        } else {
                DEBUG(DEBUG_TIMERS, "FA[%s] reg_retry_time: "
                      "%i => %i (reinitiate_state)\n",
                      inet_ntoa(mn.current_adv->addr),
                      mn.current_adv->reg_retry_time,
                      MIN_REGISTRATION_TIME);
                mn.current_adv->reg_retry_time = MIN_REGISTRATION_TIME;
        }
        switch (mn.state) {
        case MN_REQUEST_TUNNEL:
                request_tunnel(STATE_INIT, 0, 0);
                break;
        case MN_CONNECTED:
                reregister();
                break;
        default:
                break;
        }
}


static int check_sol_reply(struct node *node, void *data)
{
        struct agentadv_data *adv;
        struct timeval *tv;
        
        adv = (struct agentadv_data *) node;
        tv = (struct timeval *) data;

        if (timerisset(tv) && cmp_timeval(&adv->last, tv) < 0 &&
            usec_passed(&adv->last, tv) > MAX_AGENTSOL_REPLY_WAIT) {
                DEBUG(DEBUG_INFO, "  timediff=%u\n",
                      usec_passed(&adv->last, tv));
                DEBUG(DEBUG_INFO, "No reply from MA (addr=%s) to "
                      "agent solicitation within %i usec",
                      inet_ntoa(adv->addr), MAX_AGENTSOL_REPLY_WAIT);
                adv->prio_degrade_percent += SOLICITATION_PRIO_DEGRADE;
                if (adv->prio_degrade_percent > 100)
                        adv->prio_degrade_percent = 100;
                DEBUG(DEBUG_INFO, " - prio to %i\n",
                      adv->prio_degrade_percent);
        }

        return TRUE;
}


static void handle_timeout(void)
{
        struct timeval tv;

        DEBUG(DEBUG_TIMERS, "Timeout\n");
        gettimeofday(&tv, NULL);

#ifdef WITH_WIRELESS
        if (config.wlan_ap_poll_interval > -1 &&
            timerisset(&timers[TIMER_WLAN_AP_POLL]) &&
            cmp_timeval(&tv, &timers[TIMER_WLAN_AP_POLL]) >= 0) {
                DEBUG(DEBUG_TIMERS, "\tTIMER_WLAN_AP_POLL\n");
                /* poll AP addresses and send agentsol if handoff has
                 * occured (do this for each interface supporting wireless
                 * extensions) */
                monitor_poll_ap_addresses(&mn);
                timers[TIMER_WLAN_AP_POLL].tv_sec = tv.tv_sec;
                timers[TIMER_WLAN_AP_POLL].tv_usec = tv.tv_usec;
                add_usecs(&timers[TIMER_WLAN_AP_POLL],
                          config.wlan_ap_poll_interval);
        }
#endif /* WITH_WIRELESS */

        if (config.solicitation_interval > -1 &&
            timerisset(&timers[TIMER_SOLICITATION]) &&
            cmp_timeval(&tv, &timers[TIMER_SOLICITATION]) >= 0) {
                DEBUG(DEBUG_TIMERS, "\tTIMER_SOLICITATION\n");
                /* check whether some FAs did not reply previous solicitation
                 */
                hashtable_iterator(mn.agentadv, check_sol_reply,
                                   &mn.last_scheduled_solicitation);
                /* send agentsol to all interfaces */
                send_solicitations(&mn);
                timers[TIMER_SOLICITATION].tv_sec = tv.tv_sec;
                timers[TIMER_SOLICITATION].tv_usec = tv.tv_usec;
                add_usecs(&timers[TIMER_SOLICITATION],
                          config.solicitation_interval +
                          get_rand32() % MAX_RANDOM_SOLICITATION_DELAY);
                mn.last_scheduled_solicitation = tv;
        }


        if (!timerisset(&timers[TIMER_GEN])) {
                DEBUG(DEBUG_TIMERS, "\tTIMER_GEN is not set\n");
                return;
        }

        if (cmp_timeval(&tv, &timers[TIMER_GEN]) < 0) {
                DEBUG(DEBUG_TIMERS, "\tTIMER_GEN not yet reached - ignoring "
                      "timeout\n");
                return;
        }

        /* disable timer */
        DEBUG(DEBUG_TIMERS, "\tdisabling TIMER_GEN\n");
        timerclear(&timers[TIMER_GEN]);

        switch (mn.state) {
        case MN_DISCONNECTED:
        case MN_AT_HOME:
                break;
        case MN_CLOSE_FOR_HOME:
                close_for_home(STATE_TIMEOUT);
                break;
        case MN_FIND_AGENT:
                find_agent(STATE_TIMEOUT);
                break;
        case MN_PASSIVE_FIND:
                break;
        case MN_REQUEST_TUNNEL:
                request_tunnel(STATE_TIMEOUT, 0, 0);
                break;
        case MN_CONNECTED:
                reregister();
                break;
        default:
                break;
        }
}


int main_vanha(int argc, char *argv[])
{
        int n, i;
        fd_set set;
        struct timeval tv;

        memset(&mn, 0, sizeof(mn));
        mn.info_str = "initialization in progress";

        program_name = parse_long_options(argc, argv, "mobile node",
                                             PACKAGE, VERSION, dynamics_usage);

        mn_parse_command_line(argc, argv);

        if (!mn_init()) {
                fprintf(stderr, "Initialization failed.\n");
                exit(0);
        }

        if (mn.opt_connect) {
                /* try to connect to a FA if MN is using FA decapsulation (i.e.
                 * its own home IP addr also in the foreign network) or if the
                 * home address is not assigned to a local interface with MN
                 * decapsulation */
                mn.info_str = "trying to connect";
                if (config.enable_fa_decapsulation || is_coloc_addr_foreign())
                {
                        mn.tunnel_mode = API_TUNNEL_FULL;
                        find_agent(STATE_INIT);
                } else at_home();
        }

        /* MN main loop */
        while (mn.state != MN_STOP) {
                check_old_tunnel_expiration();

                FD_ZERO(&set);
                FD_SET(mn.registration_socket, &set);
                for (i = 0; i < MAX_INTERFACES; i++) {
                        if (mn.iface[i].s_adv > -1)
                                FD_SET(mn.iface[i].s_adv, &set);
                }
                if (mn.api_rw_socket > -1)
                        FD_SET(mn.api_rw_socket, &set);
                if (mn.api_ro_socket > -1)
                        FD_SET(mn.api_ro_socket, &set);
#ifdef INCLUDE_IPAY
                FD_SET(mn.ipay_sock, &set);
                FD_SET(mn.ipay_sock_fa, &set);
#endif
                if (mn.rtnetlink_socket > -1)
                        FD_SET(mn.rtnetlink_socket, &set);

                if (get_next_timeout(&tv))
                        n = select(FD_SETSIZE, &set, NULL, NULL, &tv);
                else n = select(FD_SETSIZE, &set, NULL, NULL, NULL);
                if (n == 0) {
                        handle_timeout();
                        continue;
                } else if (n == -1) {
                        switch (errno) {
                        case EINTR:
                                break;
                        default:
                                LOG2(LOG_ERR, "main - select: %s\n",
                                     strerror(errno));
                                /* this used to exit dynmnd with
                                 * mn.state = MN_STOP;
                                 * but this might be a temporary problem, so
                                 * try agains; use a small delay to prevent
                                 * hogging all the CPU in case of select()
                                 * returning error all the time */
                                sleep(1);
                        }
                        continue;
                }

                if (FD_ISSET(mn.registration_socket, &set) &&
                    handle_registration(mn.registration_socket)) {
                        /* try to reregister */
                        reinitiate_state();
                }

                for (i = 0; i < MAX_INTERFACES; i++) {
                        if (mn.iface[i].s_adv > -1 &&
                            FD_ISSET(mn.iface[i].s_adv, &set))
                                handle_icmp(&mn.iface[i]);
                }

                if (mn.rtnetlink_socket > -1 &&
                    FD_ISSET(mn.rtnetlink_socket, &set)) {
                        int res = dyn_ip_monitor_get(
                                mn.rtnetlink_socket,
                                (config.enforce_routes &&
                                 mn.state != MN_DISCONNECTED) ?
                                &mn.cur_route_info : NULL);
                        if (res == 1 || res == 2)
                                check_interfaces(mn.iface, MAX_INTERFACES);
                }

                if (mn.api_rw_socket > -1 && FD_ISSET(mn.api_rw_socket, &set))
                        handle_api(mn.api_rw_socket, 1);

                if (mn.api_ro_socket > -1 && FD_ISSET(mn.api_ro_socket, &set))
                        handle_api(mn.api_ro_socket, 0);

#ifdef INCLUDE_IPAY
                if (FD_ISSET(mn.ipay_sock, &set))
                        handle_ipay(mn.ipay_sock);
                if (FD_ISSET(mn.ipay_sock_fa, &set))
                        handle_ipay(mn.ipay_sock_fa);
#endif

                /* check expired agent advs. If current FA's agent
                   adv. has expired move to FIND_AGENT state */
                if (check_expired_agent_advs())
                        find_agent(STATE_INIT);
        }

        clean_up(0);
        return 0;
}

---