mn_util.c

Go to the documentation of this file.

/* $Id: mn_util.c,v 1.89 2001/10/20 14:20:38 jm Exp $
 * Mobile Node - help functions
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <getopt.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <assert.h>
#ifdef DYN_TARGET_WINDOWS
#include <fcntl.h>
#endif

#include "debug.h"
#include "dyn_ip.h"
#include "proxyarp.h"
#include "agentapi.h"
#include "util.h"
#ifdef WITH_WIRELESS
#include "monitor.h"
#endif
#include "mn_handler.h"
#include "mn.h"
#include "mn_tunnel.h"
#ifdef INCLUDE_IPAY
#include "mn_ipay.h"
#endif
#include "device_info.h"



extern struct mn_data mn;
extern struct mn_config config;
extern struct timeval timers[TIMER_COUNT];
extern char* program_name;
extern char *opt_config;
extern int opt_foreground;
extern int real_tunnel_up; /* from mn_tunnel */

static int wireless_extensions;

static int check_ignore_iface(const char *ifname)
{
        struct ignore_iflist_entry *i;
        struct node *node;

        if (strcmp(ifname, TUNNEL_DEVICE) == 0) 
                return 1;
        if (strcmp(ifname, TUNNEL_DEVICE_B) == 0) 
                return 1;

        for (node = list_get_first(&config.ignore_iflist); node != NULL;
             node = list_get_next(node)) {
                i = (struct ignore_iflist_entry *)node;
                if (strncmp(ifname, i->ifname, IFNAMSIZ) == 0) 
                        return 1;
        }

        return 0;
}


struct fa_spi_entry* get_fa_spi(int spi, struct in_addr addr)
{
        struct fa_spi_entry *s;
        struct node *node;
        time_t now;

        time(&now);

        node = list_get_first(&config.fa_spi_list);
        while (node != NULL) {
                s = (struct fa_spi_entry *) node;
                node = list_get_next(node);

                /* Expire dynamic entries that are not infinite (lifetime=0) */
                if (s->created != 0 && s->lifetime != 0 &&
                    now > s->created + s->lifetime) {
                        DEBUG(DEBUG_INFO, "get_fa_spi: dynamic "
                              "security association (SPI=%i, addr=%s) "
                              "expired\n", s->spi, inet_ntoa(s->addr));
                        list_remove((struct node *) s);
                        free(s);
                        continue;
                }

                if ((spi != 0 && s->spi != spi) ||
                    s->addr.s_addr != addr.s_addr)
                        continue;

                return s;
        }
        return NULL;
}


int add_fa_spi(struct fa_spi_entry *spi, int replace_any_spi)
{
        struct fa_spi_entry *old;

        old = get_fa_spi(replace_any_spi ? 0 : spi->spi, spi->addr);
        if (old != NULL) {
                if (old->created == 0) {
                        DEBUG(DEBUG_INFO, "add_fa_spi: trying to replace "
                              "static security association - aborting "
                              "operation\n");
                        return -1;
                }

                DEBUG(DEBUG_INFO, "add_fa_spi: overwriting previous dynamic "
                      "security association\n");
                remove_fa_spi(old);
                free(old);
                old = NULL;
        }

        DEBUG(DEBUG_INFO, "add_fa_spi: adding dynamic security association "
              "(SPI=%i, addr=%s)\n", spi->spi, inet_ntoa(spi->addr));
        list_init_node(&spi->node);
        list_add_tail(&config.fa_spi_list, &spi->node);
        return 0;
}


void remove_fa_spi(struct fa_spi_entry *spi)
{
        DEBUG(DEBUG_INFO, "remove_fa_spi: removing security association "
              "(SPI=%i, addr=%s)\n", spi->spi, inet_ntoa(spi->addr));
        list_remove(&spi->node);
}


void send_gratuitous_arp(struct in_addr route_addr, 
                         struct in_addr gratuitous_addr)
{
        char arp_if[IFNAMSIZ];

        if (dyn_ip_route_get(route_addr, arp_if, IFNAMSIZ) != 0) {
                DEBUG(DEBUG_INFO, "Could not get ARP interface\n");
                return;
        }
        proxyarp_gratuitous(gratuitous_addr, arp_if);
}


#ifdef MN_LOCUPD_PROFILER
void write_profiler(const char *msg)
{
        struct timeval tv;
        gettimeofday(&tv, NULL);
        fprintf(mn.profile, "%s %u.%06u (%li usec)\n", msg,
                (unsigned int) tv.tv_sec, (unsigned int) tv.tv_usec,
                (tv.tv_sec - mn.last_api.tv_sec) * 1000000 +
                tv.tv_usec - mn.last_api.tv_usec);
}
#endif


int update_fa_decaps_routes(const char *ifname, int ifindex, 
                            struct in_addr fa_addr, 
                            struct in_addr home_net_addr, 
                            int home_net_addr_plen)
{
        DEBUG(DEBUG_INFO, "FA decapsulation - setting default route to "
              "%s via %s\n", ifname, inet_ntoa(fa_addr));

        mn.cur_route_info.known = 1;
        mn.cur_route_info.via.s_addr = fa_addr.s_addr;
        mn.cur_route_info.ifindex = ifindex;
        memcpy(mn.cur_route_info.ifname, ifname, IFNAMSIZ);
        mn.cur_route_info.ifindex_net = -1;

        if (dyn_ip_route_replace_default(ifname, &fa_addr,
                                         &config.mn_home_ip_addr) != 0) {
                LOG2(LOG_ERR, "Set default route (to %s via %s) failed\n",
                     ifname, inet_ntoa(fa_addr));
                return -1;
        }
        if (home_net_addr_plen > -1) {
                int count;
                DEBUG(DEBUG_INFO, "Deleting home net route (%s/%i)\n",
                      inet_ntoa(home_net_addr), home_net_addr_plen);
                count = dyn_ip_route_delete_net_routes(&home_net_addr,
                                                       home_net_addr_plen);
                if (count < 0) {
                        LOG2(LOG_ERR, "Home net route (%s/%i) delete failed\n",
                             inet_ntoa(home_net_addr), home_net_addr_plen);
#ifdef DYN_TARGET_WINDOWS
                        /* at least Win98 does not seem to like to remove
                         * home net route.. */
                        DEBUG(DEBUG_INFO, "Trying to set net route via the FA "
                              "to circumvent failed net route removal\n");

                        if (dyn_ip_route_set_net(ifname, &home_net_addr,
                                                 home_net_addr_plen,
                                                 NULL, 2) < 0) {
                                DEBUG(DEBUG_INFO, "Could not increase home "
                                      "net route metric\n");
                        }

                        if (dyn_ip_route_set_net(ifname, &home_net_addr,
                                                 home_net_addr_plen,
                                                 &fa_addr, 1) < 0) {
                                DEBUG(DEBUG_INFO, "Could not set net route via"
                                      " FA\n");
                        } else
                                mn.home_net_route_set_via_fa = 1;
#endif /* DYN_TARGET_WINDOWS */
                } else {
                        DEBUG(DEBUG_INFO,
                              "   %i net route%s deleted\n", count,
                              count != 1 ? "s" : "");
                }
        }

        return 0;
}

static void modify_new_interface(struct interface_data *iface, 
                                 struct idxmap *idx)
{
        struct event_INTERFACE data;
        int ret;

        DEBUG(DEBUG_INFO, "modify_new_interface (start): device_count %d\n",
              mn.device_count);
        if (config.enable_fa_decapsulation) {
                ret = dyn_ip_iface_address(idx->index, 
                                           &config.mn_home_ip_addr);
                if ((ret == 2 || ret == 0) &&
                    config.use_aaa &&
                    config.mn_home_ip_addr.s_addr == 0 &&
                    config.enable_fa_decapsulation) {
                        DEBUG(DEBUG_INFO, "modify_interface: interface with no"
                              " addresses - using AAA to obtain a home "
                              "address\n");
                } else {

                        if (ret == 0) {
                                DEBUG(DEBUG_INFO, "FA decapsulation and an "
                                      "interface does not have the home "
                                      "address\n");
                                mn.warn_str = "FA decapsulation and an "
                                        "interface does not have the home "
                                        "address";
                                return;
                        }

                        /* continue only if the interface has a correct
                         * address */
                        if (ret != 1) {
                                DEBUG(DEBUG_INFO, "modify_interface: no "
                                      "addresses found (ret=%i)\n", ret);
                                return;
                        }
                }
        }

        if (iface->handlers_off == 1) {
                DEBUG(DEBUG_INFO, "modify_interface: interface up\n");
                memset(&data, 0, sizeof(data));
                data.iface = iface;
                data.ifname = iface->device;
                data.index = &iface->index;
                data.icmp_sock = &iface->s;
                data.icmp_sock_adv = &iface->s_adv;
                assert(idx != NULL);
                data.idx = idx;
                data.last_reg_send_time = &mn.last_reg_send_time;
                data.current_adv = &mn.current_adv;
                data.priority = &iface->priority;
                ret = handler_call_all(INTERFACE_INIT, &data);
                if (ret == -1) {
                        DEBUG(DEBUG_INFO, "modify_interface: interface "
                              "initialization failed\n");
                        return;
                }
                iface->handlers_off = 0;
                if (config.enable_fa_decapsulation &&
                    mn.current_adv != NULL &&
                    real_tunnel_up) {
                        DEBUG(DEBUG_INFO, "modify_new_interface: fix possibly "
                              "changed routing entries\n");
                        update_fa_decaps_routes(mn.current_adv->ifname,
                                                mn.current_adv->ifindex,
                                                mn.fa_addr,
                                                config.home_net_addr,
                                                config.home_net_addr_plen);
                }
        } 
        mn.device_count++;

        DEBUG(DEBUG_INFO, "modify_new_interface (end): device_count %d\n",
              mn.device_count);

        /* go from passive find to find agent state if a new interface is up
         * and there was previously no interfaces available OR if the current 
         * adv. was removed */
        if ((mn.device_count == 1 && mn.state == MN_PASSIVE_FIND) ||
            (mn.current_adv == NULL && mn.state != MN_DISCONNECTED)) {
                find_agent(STATE_INIT);
        }
}

static void modify_removed_interface(struct interface_data *iface)
{
        struct event_INTERFACE data;
        int ret;

        DEBUG(DEBUG_INFO, "modify_remved_interface (start): device_count %d\n",
              mn.device_count);

        if (iface->handlers_off != 1) {
                DEBUG(DEBUG_INFO, "modify_removed_interface: interface down\n");
                memset(&data, 0, sizeof(data));
                data.ifname = iface->device;
                data.index = &iface->index;
                data.icmp_sock = &iface->s;
                data.icmp_sock_adv = &iface->s_adv;
                ret = handler_call_all(INTERFACE_DOWN, &data);
                if (ret == -1) {
                        DEBUG(DEBUG_INFO, "modify_interface: interface "
                              "down failed\n");
                        return;
                }
                iface->handlers_off = 1;
        } 
        mn.device_count--;
        if (mn.device_count < 0) {
                DEBUG(DEBUG_INFO, "modify_interface: device "
                      "count < 0!\n");
                mn.device_count = 0;
        }

        DEBUG(DEBUG_INFO, "modify_remived_interface (end): device_count %d\n",
              mn.device_count);

        /* go from passive find to find agent state if the current 
         * adv. was removed */
        if (mn.current_adv == NULL && mn.state != MN_DISCONNECTED) {
                find_agent(STATE_INIT);
        }
}

int check_interfaces(struct interface_data *iface, int iface_num)
{
        int i;
        struct idxmap *idxmap, *idx;

        idxmap = dyn_ip_get_interface_map();
        if (idxmap == NULL) {
                DEBUG(DEBUG_INFO, "check_interfaces: interface map could "
                      "not be created\n");
                return 1;
        }

        /* remove the ignored interfaces */
        /* FIX: add list of interfaces to be ignored to dynmnd.conf and try to
         * eliminate 'virtual' interfaces like tunnels etc. */
        idx = idxmap;
        while (idx != NULL) {
                if (check_ignore_iface(idx->name) ||
                    (dyn_ip_get_ifflags(idx->name) & IFF_UP) == 0)
                        idx->index = -1;
                idx = idx->next;
        }

        /* check removed interfaces */
        for (i = 0; i < iface_num; i++) {
                idx = idxmap;
                while (idx != NULL) {
                        if (iface[i].index == idx->index)
                                break;
                        idx = idx->next;
                }
                
                if (iface[i].s > -1) {
                        if (idx != NULL) {
                                /* mark the interface used */
                                idx->index = -1;
                        } else {                        
                                DEBUG(DEBUG_INFO, "check_interfaces: "
                                      "removed interface\n");
                                /* this interface has been removed */
                                modify_removed_interface(&iface[i]);
                        }
                }
        }
        
        /* check new interfaces */
        idx = idxmap;
        while (idx != NULL) {
                if (idx->index == -1) {
                        idx = idx->next;
                        continue;
                }

                /* find a free slot */
                i = 0;
                while (i < iface_num && iface[i].s > -1) i++;
                if (i >= iface_num) {
                        DEBUG(DEBUG_INFO, "Not enough space for all "
                              "the interfaces\n");
                        break;
                }

                /* call handlers for INTERFACE_INIT event */
                DEBUG(DEBUG_INFO, "check_interfaces: new interface\n");
                modify_new_interface(&iface[i], idx);
                idx = idx->next;
        }

        dyn_ip_free_interface_map(idxmap);

        return 0;
}


int create_registration_socket(void)
{
        int s;
        unsigned char ttl;
#ifdef BIND_UDP_SOCKET
        struct sockaddr_in addr;
#endif

        if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
                LOG2(LOG_ERR, "create_reg_socket - socket: %s\n",
                     strerror(errno));
                return -1;
        }
#ifdef BIND_UDP_SOCKET
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = config.bind_addr.s_addr;
        addr.sin_port = config.bind_port;
        DEBUG(DEBUG_INFO, "binding UDP socket to %s:%i\n",
              inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
        if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
                LOG2(LOG_ERR, "create_reg_socket - bind: %s\n",
                     strerror(errno));
                return -1;
        }
#endif

        if (config.socket_priority > -1 &&
            setsockopt(s, SOL_SOCKET, SO_PRIORITY,
                       (char *)&config.socket_priority,
                       sizeof(config.socket_priority)) < 0) {
                LOG2(LOG_ERR,
                     "create_reg_socket - setsockopt SO_PRIORITY: %s\n",
                     strerror(errno));
                /* continue without SO_PRIORITY set */
        }

        /* send registration request with TTL 255 [RFC 2344, Chap. 3.2] */
        ttl = 255;
        if (setsockopt(s, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)) < 0) {
                LOG2(LOG_ERR, "setsockopt: IP_TTL failed: %s\n",
                     strerror(errno));
                /* continue with the default setting anyway */
#ifdef DYN_TARGET_WINDOWS
                if (dyn_ip_set_ttl(255) < 0) {
                        DEBUG(DEBUG_INFO, "Also dyn_ip_set_ttl() failed\n");
                }
#endif /* DYN_TARGET_WINDOWS */
        }

        return s;
}


static void show_usage(void)
{
        printf("      --wireless_policy <integer>\n"
               "\t\tset wireless handoff policy (1=on, 0=off):\n"
               "\t\t  bit 0: rely on MN's agent adv. expiration\n"
               "\t\t  bit 1: use shorter agent adv. expiration interval\n"
               "\t\t  bit 2: use FA with newest agent advertisement\n"
               "\t\t  bit 3: eager switching\n"
               "\t\t  bit 4: use newest agent advertisement\n"
               "      --no-wireless\tdisable wireless extensions\n"
               "      --disconnect\tstart in disconnected state\n");
}


int mn_parse_command_line(int argc, char *argv[])
{
        int c, oindex = 0;

        static struct option long_options[] = {
                {"help", no_argument, NULL, 'h'},
                {"version", no_argument, NULL, 'v'},
                {"debug", no_argument, NULL, 0},
                {"fg", no_argument, NULL, 0},
                {"config", required_argument, NULL, 'c'},
                /* MN specific arguments */
                {"no-wireless", no_argument, NULL, 'n'},
                {"wireless_policy", required_argument, NULL, 'p'},
                {"disconnect", no_argument, NULL, 'd'},
                /* end of arguments */
                {0, 0, 0, 0}
        };

        mn.opt_connect = 1;
        mn.policy_bits = 0;

        /* parse mn specific options */
        wireless_extensions = 1;
        while ((c = getopt_long(argc, argv, "+hv", long_options, &oindex)) !=
               EOF) {
                switch (c) {
                case 'n':
                        wireless_extensions = 0;
                        break;
                case 'p':
                        mn.policy_bits = atoi(optarg);
                        /* 0: no timestamps */
                        /* 1: with timestamps */
                        DEBUG(DEBUG_INFO, "Option: %s"
                              " 0x%02x (wireless policy)\n",
                              long_options[oindex].name,
                              mn.policy_bits);
                        break;
                case 'h':
                        /* show MN specific parameters */
                        show_usage();
                        exit(1);
                        break;

                case 'd':
                        mn.opt_connect = 0;
                        break;

                case '?':
                        printf("Command line parsing failed - aborting\n");
                        exit(1);

                case 'v':
                case 'c':
                case 0:
                        break;

                default:
                        printf("getopt returned character code 0%o\n", c);
                        exit(1);
                }
        }

        return 0;
}


#ifdef DYN_TARGET_WINDOWS
/* FIX: currently using local UDP socket on Windows because there is no support
 * for UNIX domain socket.. maybe something else would be better for IPC on
 * Windows platform(?) */
static int windows_api_socket(int admin)
{
        int s;
        struct sockaddr_in addr;
        int flags;

        s = socket(AF_INET, SOCK_DGRAM, 0);
        if (s < 0) {
                DEBUG(DEBUG_INFO, "API socket opening failed: %s\n",
                      strerror(errno));
                return -1;
        }

        flags = fcntl(s, F_GETFL, 0);
        if (flags == -1 || fcntl(s, F_SETFL, flags | O_NDELAY) == -1) {
                DEBUG(DEBUG_INFO, "API rw fcntl F_SETFL failed: %s\n",
                      strerror(errno));
                close(s);
                return -1;
        }

        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = htonl((127 << 24) | 1);
        addr.sin_port = htons(admin ? API_UDP_PORT_RW : API_UDP_PORT_RO);
        if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
                LOG2(LOG_ERR, "API socket - bind: %s\n", strerror(errno));
                close(s);
                return -1;
        }

        return s;
}
#endif


/* Initialization routines. Setup sockets and variables.
 * Returns 1 on success else 0. */
int mn_init(void)
{
        int i;

        /* Load configuration */
        DEBUG(DEBUG_INFO, "Load config\n");
        if (!load_mn(&config, program_name,
                     opt_config == NULL ? MN_GLOBAL_CONF_FILE : opt_config)) {
                LOG2(LOG_ERR, "init: unable to load configuration\n");
                
                return 0;
        }
        mn.use_auth_alg = config.auth_alg;
        mn.agentadv = hashtable_init(256);
        if (mn.agentadv == NULL) {
                LOG2(LOG_ERR, "init: unable to init agentadv hashtable\n");
                return 0;
        }
        mn.last_req_FA_NAI = (struct fa_nai_ext *) malloc(MAX_FA_NAI_LEN);
        if (mn.last_req_FA_NAI == NULL) {
                LOG2(LOG_ERR, "init: not enough memory\n");
                return 0;
        }
        memset(mn.last_req_FA_NAI, 0, MAX_FA_NAI_LEN);

        if (!config.enable_fa_decapsulation)
                check_kernel_support(CHECK_KERNEL_IPIP);
        check_kernel_support(CHECK_KERNEL_NETLINK);

#ifdef DYN_TARGET_LINUX
        if (getuid() || geteuid()) {
                fprintf(stderr, "This program must be run by root.\n");
                return 0;
        }
#endif
#ifdef DYN_TARGET_WINDOWS
        /* FIX: on Windows NT and Windows 2000 check for Administrator
         * privileges */
#endif

        if ((mn.registration_socket = create_registration_socket()) < 0)
                return 0;

        mn_handlers_init();
        mn.dev_info_addr.sun_family = AF_LOCAL;
        /* initialize default socket info path */
        dynamics_strlcpy(mn.dev_info_addr.sun_path, DEFAULT_DEVICE_INFO_PATH,
                         sizeof(mn.dev_info_addr.sun_path));

#ifdef WITH_WIRELESS
        /* If wireless extensions enabled, monitor will register it's own
           handlers also */
        DEBUG(DEBUG_INFO, "REGISTER MODULE(S)\n");
        if (wireless_extensions)
                MONITOR_register_module();
#endif

        /* Check interfaces */
        for (i = 0; i < MAX_INTERFACES; i++) {
                mn.iface[i].s = -1;
                mn.iface[i].s_adv = -1;
                mn.iface[i].handlers_off = 1;
        }

#ifdef INCLUDE_IPAY
        /* register Ipay handlers after monitor */
        ipay_init();
#endif

        if (config.home_net_addr_plen < 0 ||
            dyn_ip_route_get(config.home_net_addr, mn.start_default_device,
                             IFNAMSIZ) != 0)
                mn.start_default_device[0] = '\0';
        else
                DEBUG(DEBUG_INFO, "Initial default device: %s\n",
                      mn.start_default_device);

#ifdef DYN_TARGET_LINUX
        if ((mn.api_ro_socket =
             api_open_socket(config.mn_api_read_socket_path,
                             config.mn_api_read_socket_group,
                             config.mn_api_read_socket_owner,
                             config.mn_api_read_socket_permissions)) < 0) {
                LOG2(LOG_ERR, "init - open_api_ro_socket: %s\n",
                     strerror(errno));
                return 0;
        }

        if ((mn.api_rw_socket =
             api_open_socket(config.mn_api_admin_socket_path,
                             config.mn_api_admin_socket_group,
                             config.mn_api_admin_socket_owner,
                             config.mn_api_admin_socket_permissions)) < 0) {
                LOG2(LOG_ERR, "init - open api_rw_socket: %s\n",
                     strerror(errno));
                return 0;
        }
#endif
#ifdef DYN_TARGET_WINDOWS
        mn.api_ro_socket = windows_api_socket(0);
        mn.api_rw_socket = windows_api_socket(1);
#endif

#ifdef INCLUDE_IPAY
        mn.ipay_sock = socket(AF_INET, SOCK_DGRAM, 0);
        if (mn.ipay_sock < 0) {
                LOG2(LOG_ERR, "init - open ipay_sock: %s\n", strerror(errno));
                return 0;
        }
        if (config.ipay_mn_port > 0) {
                struct sockaddr_in addr;
                memset(&addr, 0, sizeof(addr));
                addr.sin_family = AF_INET;
                addr.sin_addr = config.ipay_mn_addr;
                addr.sin_port = htons(config.ipay_mn_port);
                if (bind(mn.ipay_sock, (struct sockaddr *) &addr,
                    sizeof(addr)) < 0) {
                        LOG2(LOG_ERR, "init - bind ipay_sock: %s\n",
                             strerror(errno));
                        return 0;
                }
        }
        mn.ipay_sock_fa = socket(AF_INET, SOCK_DGRAM, 0);
        if (mn.ipay_sock_fa < 0) {
                LOG2(LOG_ERR, "init - open ipay_sock_fa: %s\n",
                     strerror(errno));
                return 0;
        }
        if (config.ipay_fa_port > 0) {
                struct sockaddr_in addr;
                memset(&addr, 0, sizeof(addr));
                addr.sin_family = AF_INET;
                addr.sin_addr.s_addr = INADDR_ANY;
                addr.sin_port = htons(config.ipay_fa_port);
                if (bind(mn.ipay_sock_fa, (struct sockaddr *) &addr,
                    sizeof(addr)) < 0) {
                        LOG2(LOG_ERR, "init - bind ipay_sock_fa: %s\n",
                             strerror(errno));
                        return 0;
                }
        }
#endif

        mn.rtnetlink_socket = dyn_ip_monitor_open();
        if (mn.rtnetlink_socket < 0)
                DEBUG(DEBUG_INFO, "init - rtnetlink socket opening failed\n");

        /* set own ip-addr */
        mn.local_addr = config.mn_home_ip_addr;

        init_tunneling();

        /* init variables */
        mn.registration_id[0] = 0;
        mn.registration_id[1] = 0;
        mn.last_nonce = 0;
        mn.clock_correction = 0;
        mn.state = MN_DISCONNECTED;
        mn.fa_addr.s_addr = 0;
        mn.current_adv = NULL;
        mn.force_fa_addr.s_addr = 0;
        mn.session_key = NULL;
        mn.session_key_len = 0;
        mn.tunnel_up = 0;
        mn.tunnel_mode = API_TUNNEL_NONE;
        mn.ha_error_count = 0;
        memset(&mn.cur_route_info, 0, sizeof(mn.cur_route_info));
        mn.cur_route_info.net.s_addr = config.home_net_addr.s_addr;
        mn.cur_route_info.prefix_len = config.home_net_addr_plen;

        timerclear(&mn.last_reg_send_time);

        for (i = 0; i < TIMER_COUNT; i++) timerclear(&timers[i]);
        if (config.wlan_ap_poll_interval > -1)
                gettimeofday(&timers[TIMER_WLAN_AP_POLL], NULL);
        if (config.solicitation_interval > -1)
                gettimeofday(&timers[TIMER_SOLICITATION], NULL);

        openlog(SYSLOG_IDENT, SYSLOG_OPTIONS, config.syslog_facility);

        dyn_ip_route_save_default(config.home_net_gateway.s_addr != 0 ?
                &config.home_net_gateway : NULL);

#ifdef MN_LOCUPD_PROFILER
        mn.profile = fopen("mn.prof.log", "a");
        if (mn.profile == NULL) {
                fprintf(stderr, "Cannot open mn.prof.log\n");
                return 0;
        }
        gettimeofday(&mn.last_api, NULL);
        fprintf(mn.profile, "START %u.%06u\n",
                (unsigned int) mn.last_api.tv_sec,
                (unsigned int) mn.last_api.tv_usec);
#endif

        /* Setup signals */
        signal(SIGTERM, clean_up);
        signal(SIGINT, clean_up);
        signal(SIGHUP, SIG_IGN);
        signal(SIGPIPE, SIG_IGN);

/*      if (!opt_foreground && dynamics_fork_daemon() == -1)
                clean_up(0);
        dynamics_write_pid_file(MN_PID_FILE);
*/
        DEBUG(DEBUG_INFO, " MN initialized to %sconnected state,\n"
              "  SPI: %d, HA: %s,\n", (mn.opt_connect ? "" : "dis"),
              config.spi, inet_ntoa(config.ha_ip_addr));
        DEBUG(DEBUG_INFO, "  HomeAddr: %s",
              inet_ntoa(config.mn_home_ip_addr));
        DEBUG(DEBUG_INFO, ", CurrentAddr: %s\n", inet_ntoa(mn.local_addr));


        syslog(LOG_INFO, "Started.");

        check_interfaces(mn.iface, MAX_INTERFACES);

#ifdef DYN_TARGET_WINDOWS
        mn.pcap_capturer = init_pcap_for_advs();
#else
        mn.pcap_capturer = -1;
#endif /* DYN_TARGET_WINDOWS */

        return 1;
}

/* Perform clean up: close sockets and log. */
void clean_up(int sig)
{
        int i;

        DEBUG(DEBUG_INFO, "cleaning up..\n");

        /* try to disconnect if connected */
        if (mn.state == MN_CONNECTED) {
                send_registration(REG_DISC);
                DEBUG(DEBUG_MESSAGES, "Deregistration message sent\n");
        }

        if (mn.pcap_capturer > -1) {
                DEBUG(DEBUG_INFO, "Terminating pcap capturer\n");
                kill(mn.pcap_capturer, SIGTERM);
                usleep(100000);
                kill(mn.pcap_capturer, SIGKILL);
        }

        if (mn.agentadv != NULL) {
                hashtable_iterator(mn.agentadv, clean_agentadv, NULL);
                hashtable_destroy(mn.agentadv);
        }

        /* close sockets */
        close(mn.registration_socket);
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (mn.iface[i].s > -1)
                        close(mn.iface[i].s);
                if (mn.iface[i].s_adv > -1)
                        close(mn.iface[i].s_adv);
        }
        if (mn.api_ro_socket > -1)
                close(mn.api_ro_socket);
        if (mn.api_rw_socket > -1)
                close(mn.api_rw_socket);
#ifdef INCLUDE_IPAY
        close(mn.ipay_sock);
        ipay_cleanup();
#endif
        if (mn.rtnetlink_socket > -1)
                close(mn.rtnetlink_socket);

#ifdef WITH_WIRELESS
        /* Remove iwspy entries */
        MONITOR_unregister_module();
#endif

        /* stop to any waiting api call */
        reply_waiting_api(API_FAILED, NULL, 0);
        /* close tunneling device */
        close_tunneling();
        mn_remove_dynamic_home_addr();

        /* free session key */
        if (mn.session_key != NULL)
                free(mn.session_key);

        if (mn.last_req_FA_NAI != NULL)
                free(mn.last_req_FA_NAI);

        /* unlink api domain sockets */
        unlink(config.mn_api_read_socket_path);
        unlink(config.mn_api_admin_socket_path);

        unlink(MN_PID_FILE);

        /* unregister all handlers */
        /* FA_ADV_RECEIVE */
        i = handler_unregister_all(FA_ADV_RECEIVE);
        DEBUG(DEBUG_HANDLERS, "clean_up: %d \"%s\" handler(s) "
              "removed\n", i, event_type_str(FA_ADV_RECEIVE));
        /* FA_ADV_EXPIRE  */
        i = handler_unregister_all(FA_ADV_EXPIRE);
        DEBUG(DEBUG_HANDLERS, "clean_up: %d \"%s\" handler(s) "
              "removed\n", i, event_type_str(FA_ADV_EXPIRE));
        /* FA_GET */
        i = handler_unregister_all(FA_GET);
        DEBUG(DEBUG_HANDLERS, "clean_up: %d \"%s\" handler(s) "
              "removed\n", i, event_type_str(FA_GET));
        /* INTERFACE_INIT */
        i = handler_unregister_all(INTERFACE_INIT);
        DEBUG(DEBUG_HANDLERS, "clean_up: %d \"%s\" handler(s) "
              "removed\n", i, event_type_str(INTERFACE_INIT));
        /* INTERFACE_DOWN */
        i = handler_unregister_all(INTERFACE_DOWN);
        DEBUG(DEBUG_HANDLERS, "clean_up: %d \"%s\" handler(s) "
              "removed\n", i, event_type_str(INTERFACE_DOWN));

        syslog(LOG_INFO, "stopped");
        closelog();

#ifdef MN_LOCUPD_PROFILER
        fclose(mn.profile);
#endif

        DEBUG(DEBUG_INFO, "cleaned up\n");

        exit(0);
}


void add_fa_host_route(char *dev, struct hashtable *adv_hash, 
                       int ifindex, struct in_addr addr)
{
        struct agentadv_data *adv;
        adv = adv_fetch(adv_hash, &addr, ifindex);

        if (dyn_ip_route_replace(addr, dev) != 0) {
                if (adv != NULL && adv->routeentry)
                        DEBUG(DEBUG_INFO, "Route entry already added for the "
                              "FA (%s=>%s)\n", inet_ntoa(addr), dev);
                else
                        DEBUG(DEBUG_INFO, "Could not add a route to the FA "
                              "(%s=>%s), but trying to register anyway\n",
                              inet_ntoa(addr), dev);
        } else {
                if (adv != NULL)
                        adv->routeentry = 1;
                else
                        DEBUG(DEBUG_INFO, "No agentadv for FA %s\n",
                              inet_ntoa(addr));
        }
}


static int clean_routes(struct node *node, void *data)
{
        struct agentadv_data *adv, *current;
        adv = (struct agentadv_data *) node;
        current = (struct agentadv_data *) data;

        if (current == adv) return TRUE; /* do not remove current FA's entry */
        if (!adv->routeentry) return TRUE;

        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)
                LOG2(LOG_ERR, "FA route removing failed (addr=%s, dev=%s)\n",
                     inet_ntoa(adv->addr), adv->ifname);

        adv->routeentry = 0;
        return TRUE;
}


void remove_fa_host_routes(int all)
{
        DEBUG(DEBUG_INFO, "remove_fa_host_routes(%i)\n", all);
        hashtable_iterator(mn.agentadv, clean_routes,
                           all ? NULL: mn.current_adv);
}



int is_coloc_addr_foreign(void)
{
        char dev[IFNAMSIZ];
        if (dyn_ip_route_get(config.mn_home_ip_addr, dev, IFNAMSIZ) != 0 ||
            strcmp(dev, "lo") != 0)
                return 1;
        return 0;
}


int device_up(int ifindex)
{
        int i;
        for (i = 0; i < MAX_INTERFACES; i++) {
                if (mn.iface[i].s > -1 &&
                    mn.iface[i].index == ifindex)
                        return 1;
        }
        return 0;
}


char *event_type_str(int event_type)
{
        switch (event_type) {
        case FA_ADV_RECEIVE:
                return "FA Advertisement receive";
        case FA_ADV_EXPIRE:
                return "FA Advertisement expire";
        case FA_GET:
                return "Get best FA";
        case INTERFACE_INIT:
                return "Initialize interface";
        case INTERFACE_DOWN:
                return "Interface down";
        default:
                return "Unknown event type!";
        }
}



int mn_remove_dynamic_home_addr(void)
{
        if (mn.dynamic_home_addr.s_addr == 0)
                return 0;

        if (dyn_ip_addr_del(mn.dynamic_home_addr_dev, mn.dynamic_home_addr) ==
            0) {
                DEBUG(DEBUG_INFO, "Dynamic home address '%s' removed from "
                      "interface '%s'\n", inet_ntoa(mn.dynamic_home_addr),
                      mn.dynamic_home_addr_dev);
                if (config.mn_home_ip_addr.s_addr ==
                    mn.dynamic_home_addr.s_addr) {
                        DEBUG(DEBUG_INFO, "\treset home address to 0 (use "
                              "discovery)\n");
                        config.mn_home_ip_addr.s_addr =
                                mn.local_addr.s_addr = 0;
                        if (config.ha_ip_addr_orig.s_addr == 0) {
                                DEBUG(DEBUG_INFO, "\treset home agent address "
                                      "to 0 (use discovery)\n");
                                config.ha_ip_addr.s_addr = 0;
                        }
                } else {
                        DEBUG(DEBUG_INFO, "\tDEBUG: config: %s, ",
                              inet_ntoa(config.mn_home_ip_addr));
                        DEBUG(DEBUG_INFO, "obtained: %s\n",
                              inet_ntoa(mn.dynamic_home_addr));
                }

                mn.dynamic_home_addr.s_addr = 0;
                return 1;
        }

        DEBUG(DEBUG_INFO, "Could not remove dynamic home address '%s' "
              "from interface '%s'\n", inet_ntoa(mn.dynamic_home_addr),
              mn.dynamic_home_addr_dev);
        return -1;
}


int monitor_check_policy(int bit)
{
        return POLICY(bit);
}


int copy_str(char *buffer, int len, int *curr, char *str, char *attr)
{
        int l;

        l = strlen(str) + strlen(attr) + 1;
        if (*curr+l > len) {
                DEBUG(DEBUG_INFO, "copy_str: Not enough room (%d/%d)\n", 
                      l, len);
                return 1;
        }
        sprintf(buffer+*curr, "%s%s\n", str, attr);
        *curr += l;

        return 0;
}

---