mn_util.c File Reference

#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>
#include "debug.h"
#include "dyn_ip.h"
#include "proxyarp.h"
#include "agentapi.h"
#include "util.h"
#include "mn_handler.h"
#include "mn.h"
#include "mn_tunnel.h"
#include "device_info.h"

Include dependency graph for mn_util.c:

Go to the source code of this file.

Functions
fa_spi_entry *	get_fa_spi (int spi, struct in_addr addr)
int	add_fa_spi (struct fa_spi_entry *spi, int replace_any_spi)
void	remove_fa_spi (struct fa_spi_entry *spi)
void	send_gratuitous_arp (struct in_addr route_addr, struct in_addr gratuitous_addr)
	send_gratuitous_arp: : :
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)
	update_fa_decsps_routes: : interface name : interface index : foreign agent addres : home network addres : home network prefix length, -1 if no home network
int	check_interfaces (struct interface_data *iface, int iface_num)
	check_interfaces: : array of interfaces : number of interfaces in
int	create_registration_socket (void)
	create_registration_socket:
int	mn_parse_command_line (int argc, char *argv[])
int	mn_init (void)
void	clean_up (int sig)
void	add_fa_host_route (char *dev, struct hashtable *adv_hash, int ifindex, struct in_addr addr)
void	remove_fa_host_routes (int all)
int	is_coloc_addr_foreign (void)
int	device_up (int ifindex)
char *	event_type_str (int event_type)
int	mn_remove_dynamic_home_addr (void)
	mn_remove_dynamic_home_addr:
int	monitor_check_policy (int bit)
int	copy_str (char *buffer, int len, int *curr, char *str, char *attr)
Variables
mn_data	mn
mn_config	config
timeval	timers [TIMER_COUNT]
char *	program_name
char *	opt_config
int	opt_foreground
int	real_tunnel_up

---

Function Documentation

void add_fa_host_route	(	char *	dev,
		struct hashtable *	adv_hash,
		int	ifindex,
		struct in_addr	addr
	)

Definition at line 998 of file mn_util.c.

References agentadv_data::adv, adv_fetch(), DEBUG(), and DEBUG_INFO.

Referenced by request_tunnel(), and send_registration().

{
        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));
        }
}

Here is the call graph for this function:

int add_fa_spi	(	struct fa_spi_entry *	spi,
		int	replace_any_spi
	)

Definition at line 122 of file mn_util.c.

References fa_spi_entry::created, DEBUG(), DEBUG_INFO, mn_config::fa_spi_list, get_fa_spi(), remove_fa_spi(), and fa_spi_entry::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;
}

Here is the call graph for this function:

int check_interfaces	(	struct interface_data *	iface,
		int	iface_num
	)

check_interfaces: : array of interfaces : number of interfaces in

Check whether new interfaces can be detected or if an interface has been removed

Returns: 0 if successfully executed, 1 on error

Definition at line 411 of file mn_util.c.

References DEBUG(), DEBUG_INFO, and interface_data::index.

Referenced by handle_api(), handle_icmp(), main_vanha(), and mn_init().

{
        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;
}

Here is the call graph for this function:

void clean_up

(

int

sig

)

Definition at line 896 of file mn_util.c.

References mn_data::agentadv, mn_data::api_ro_socket, mn_data::api_rw_socket, clean_agentadv(), clean_up(), close_tunneling(), DEBUG(), DEBUG_HANDLERS, DEBUG_INFO, DEBUG_MESSAGES, event_type_str(), FA_ADV_EXPIRE, FA_ADV_RECEIVE, FA_GET, handler_unregister_all(), mn_data::iface, INTERFACE_DOWN, INTERFACE_INIT, mn_data::last_req_FA_NAI, MAX_INTERFACES, mn, mn_config::mn_api_admin_socket_path, mn_config::mn_api_read_socket_path, MN_CONNECTED, MN_PID_FILE, mn_remove_dynamic_home_addr(), MONITOR_unregister_module(), mn_data::pcap_capturer, REG_DISC, mn_data::registration_socket, reply_waiting_api(), mn_data::rtnetlink_socket, interface_data::s, interface_data::s_adv, send_registration(), mn_data::session_key, sock, and mn_data::state.

{
        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);
}

Here is the call graph for this function:

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

Definition at line 1147 of file mn_util.c.

References DEBUG(), and DEBUG_INFO.

{
        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;
}

Here is the call graph for this function:

int create_registration_socket

(

void

)

create_registration_socket:

Create registration socket and bind it to specified port.

Returns: created socket or -1 on error.

Definition at line 492 of file mn_util.c.

References DEBUG(), DEBUG_INFO, LOG2, and mn_config::socket_priority.

Referenced by mn_init().

{
        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;
}

Here is the call graph for this function:

int device_up

(

int

ifindex

)

Definition at line 1061 of file mn_util.c.

References mn_data::iface, interface_data::index, MAX_INTERFACES, mn, and interface_data::s.

Referenced by clean_agentadv(), and stop_tunneling().

{
        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

)

Definition at line 1073 of file mn_util.c.

References FA_ADV_EXPIRE, FA_ADV_RECEIVE, FA_GET, INTERFACE_DOWN, and INTERFACE_INIT.

Referenced by clean_up(), handler_call_all(), handler_register(), and handler_unregister().

{
        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!";
        }
}

struct fa_spi_entry* get_fa_spi	(	int	spi,
		struct in_addr	addr
	)

Definition at line 88 of file mn_util.c.

References fa_spi_entry::addr, fa_spi_entry::created, DEBUG(), DEBUG_INFO, mn_config::fa_spi_list, fa_spi_entry::lifetime, and fa_spi_entry::spi.

Referenced by add_fa_spi().

{
        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;
}

Here is the call graph for this function:

int is_coloc_addr_foreign

(

void

)

Definition at line 1051 of file mn_util.c.

References IFNAMSIZ.

Referenced by main_vanha().

{
        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 mn_init

(

void

)

Definition at line 669 of file mn_util.c.

References mn_data::agentadv, mn_data::api_ro_socket, mn_data::api_rw_socket, mn_config::auth_alg, check_interfaces(), clean_up(), mn_data::clock_correction, create_registration_socket(), mn_data::cur_route_info, mn_data::current_adv, DEBUG(), DEBUG_INFO, DEFAULT_DEVICE_INFO_PATH, mn_data::dev_info_addr, mn_config::enable_fa_decapsulation, mn_data::fa_addr, mn_data::force_fa_addr, mn_data::ha_error_count, interface_data::handlers_off, mn_config::home_net_addr, mn_config::home_net_addr_plen, mn_config::home_net_gateway, mn_data::iface, IFNAMSIZ, init_pcap_for_advs(), init_tunneling(), mn_data::last_nonce, mn_data::last_reg_send_time, mn_data::last_req_FA_NAI, load_mn(), mn_data::local_addr, LOG2, MAX_FA_NAI_LEN, MAX_INTERFACES, mn, mn_config::mn_api_admin_socket_group, mn_config::mn_api_admin_socket_owner, mn_config::mn_api_admin_socket_path, mn_config::mn_api_admin_socket_permissions, mn_config::mn_api_read_socket_group, mn_config::mn_api_read_socket_owner, mn_config::mn_api_read_socket_path, mn_config::mn_api_read_socket_permissions, MN_DISCONNECTED, MN_GLOBAL_CONF_FILE, mn_handlers_init(), MONITOR_register_module(), opt_config, mn_data::opt_connect, mn_data::pcap_capturer, program_name, mn_data::registration_id, mn_data::registration_socket, mn_data::rtnetlink_socket, interface_data::s, interface_data::s_adv, mn_data::session_key, mn_data::session_key_len, mn_config::solicitation_interval, mn_config::spi, mn_data::start_default_device, mn_data::state, mn_config::syslog_facility, SYSLOG_IDENT, SYSLOG_OPTIONS, TIMER_COUNT, TIMER_SOLICITATION, TIMER_WLAN_AP_POLL, timers, mn_data::tunnel_mode, mn_data::tunnel_up, mn_data::use_auth_alg, and mn_config::wlan_ap_poll_interval.

Referenced by main(), and main_vanha().

{
        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;
}

Here is the call graph for this function:

int mn_parse_command_line	(	int	argc,
		char *	argv[]
	)

Definition at line 560 of file mn_util.c.

References DEBUG(), DEBUG_INFO, mn, mn_data::opt_connect, optarg, and mn_data::policy_bits.

Referenced by main_vanha().

{
        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;
}

Here is the call graph for this function:

int mn_remove_dynamic_home_addr

(

void

)

mn_remove_dynamic_home_addr:

Remove dynamic home address from interface if it is maintained by Dynamics MN.

Returns: 1 on success (address removed), 0 if no dynamic home address, or -1 on failure

Definition at line 1102 of file mn_util.c.

References DEBUG(), DEBUG_INFO, mn_data::dynamic_home_addr, mn_data::dynamic_home_addr_dev, mn_config::ha_ip_addr_orig, mn_data::local_addr, and mn.

Referenced by at_home(), clean_up(), and disconnect().

{
        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;
}

Here is the call graph for this function:

int monitor_check_policy

(

int

bit

)

Definition at line 1141 of file mn_util.c.

References POLICY.

{
        return POLICY(bit);
}

void remove_fa_host_routes

(

int

all

)

Definition at line 1042 of file mn_util.c.

References mn_data::agentadv, mn_data::current_adv, DEBUG(), DEBUG_INFO, and mn.

Referenced by connected(), and stop_tunneling().

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

Here is the call graph for this function:

void remove_fa_spi

(

struct fa_spi_entry *

spi

)

Definition at line 150 of file mn_util.c.

References DEBUG(), DEBUG_INFO, and fa_spi_entry::spi.

Referenced by add_fa_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);
}

Here is the call graph for this function:

void send_gratuitous_arp	(	struct in_addr	route_addr,
		struct in_addr	gratuitous_addr
	)

send_gratuitous_arp: : :

A gratuituous arp message for address will be sent on the interface where there is a route to .

Definition at line 166 of file mn_util.c.

References DEBUG(), DEBUG_INFO, and IFNAMSIZ.

Referenced by at_home(), and close_for_home().

{
        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);
}

Here is the call graph for this function:

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
	)

update_fa_decsps_routes: : interface name : interface index : foreign agent addres : home network addres : home network prefix length, -1 if no home network

Set the default route to via and delete all routes to /.

Returns: 0 if successful

Definition at line 206 of file mn_util.c.

References mn_data::cur_route_info, DEBUG(), DEBUG_INFO, mn_data::home_net_route_set_via_fa, IFNAMSIZ, LOG2, and mn.

Referenced by start_tunneling().

{
        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;
}

Here is the call graph for this function:

---

Variable Documentation

struct mn_config config

Definition at line 45 of file mn.c.

struct mn_data mn

Definition at line 44 of file mn.c.

Referenced by adv_ok_fa(), at_home(), check_expired_agent_advs(), clean_agentadv(), clean_up(), close_for_home(), connected(), create_mobile(), degrade_current_fa_priority(), device_up(), disconnect(), find_agent(), get_fa(), handle_api(), handle_icmp(), handle_registration(), load_mn(), main_vanha(), mn_init(), mn_parse_command_line(), mn_remove_dynamic_home_addr(), monitor_poll_ap_addresses(), passive_find(), remove_fa_host_routes(), reply_waiting_api(), request_tunnel(), restart_tunneling(), send_registration(), start_tunneling(), stop_tunneling(), and update_fa_decaps_routes().

char* opt_config

Referenced by mn_init().

int opt_foreground

char* program_name

Definition at line 48 of file mn.c.

Referenced by main_vanha(), and mn_init().

int real_tunnel_up

Definition at line 30 of file mn_tunnel.c.

struct timeval timers[TIMER_COUNT]

Definition at line 47 of file mn.c.

Referenced by at_home(), close_for_home(), connected(), disconnect(), find_agent(), mn_init(), request_tunnel(), and send_registration().

---