mn_reg.c File Reference

#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include "agentapi.h"
#include "auth.h"
#include "debug.h"
#include "msgparser.h"
#include "proxyarp.h"
#include "util.h"
#include "mn.h"
#include "fileio.h"

Include dependency graph for mn_reg.c:

Go to the source code of this file.

Data Structures
struct	rowdata
struct	device
struct	mobile
Typedefs
typedef device	DEVICE
typedef rowdata	ROWDATA
Functions
int	send_registration (int request_type)
int	handle_registration (int s)
int	send_messages (int interval)
	DYNAMO - seconds between messages Returns 1 on success.
int	create_mobile ()
	DYNAMO.
int	readfile (char file[])
int	parse_rows (int i)
	DYNAMO parse_rows: - Rows to parse.
int	main (int argc, char *argv[])
Variables
mn_data	mn
mn_config	config
timeval	timers [TIMER_COUNT]
int	intervals [5000]
int	rownumber = 0
DEVICE	devices [5000]
ROWDATA	rows [5000]
int	sent_regs
int	sent_deregs
tm *	tmptr
time_t	tm
char	timestr [60]
mobile	mobile_array [20]
int	cur_mobile = 0
int	mobiles = 0

---

Typedef Documentation

typedef struct device DEVICE

Definition at line 56 of file mn_reg.c.

typedef struct rowdata ROWDATA

Definition at line 57 of file mn_reg.c.

---

Function Documentation

int create_mobile

(

)

DYNAMO.

Returns 1 on success

Creates virtual mobile nodes in mobile_array from devices array which is read from mobiles.txt

Definition at line 1528 of file mn_reg.c.

References mn_data::co_addr, mobile::config, devices, mn_config::ha_ip_addr_orig, mn, mobile::mn, mn_config::mn_home_ip_addr_orig, mn_config::mn_nai, mn_config::mn_nai_len, mobile_array, mobiles, device::nai, rownumber, and mobile::state.

Referenced by main().

{
int i =0;

        for(i=0;i<rownumber-1;i++)
        {
                if(devices[i].ip_home==NULL) return -1;//file read but it was empty, quit!
                mobile_array[i].mn=mn;
                mobile_array[i].config=config;
                mobile_array[i].config.mn_home_ip_addr.s_addr=inet_addr(devices[i].ip_home);
                mobile_array[i].config.mn_home_ip_addr_orig.s_addr=inet_addr(devices[i].ip_home);
                mobile_array[i].config.ha_ip_addr.s_addr=inet_addr(devices[i].ip_homeagent);
                mobile_array[i].config.ha_ip_addr_orig.s_addr=inet_addr(devices[i].ip_homeagent);
                mobile_array[i].config.mn_nai_len=sizeof(devices[i].nai);
                memcpy(mobile_array[i].config.mn_nai, devices[i].nai,sizeof(devices[i].nai));
                mobile_array[i].mn.co_addr.s_addr=inet_addr(devices[i].ip_careoff);
                mobile_array[i].state=atoi(devices[i].state);
                mobiles=mobiles+1;
        }

}

int handle_registration

(

int

s

)

Definition at line 1402 of file mn_reg.c.

References DEBUG(), DEBUG_INFO, DEBUG_MESSAGES, mn_data::discarded_msgs, mn_data::last_challenge_ext, mn_data::last_challenge_time, mn_data::last_nonce, mn_data::last_reply_code, mn_data::last_reply_rcvd, LOG2, MAXMSG, mn, mobile::mn, mobile_array, mn_data::prev_req_replied, and mn_data::try_to_fix_sec_assoc.

Referenced by main_vanha().

{
        char msg[MAXMSG];
        unsigned int len;
        struct sockaddr_in addr;
        int n, res;
        struct msg_extensions ext;

        len = sizeof(addr);

        n = recvfrom(s, msg, MAXMSG, 0, (struct sockaddr*) &addr, &len);
        if (n < 0) {
                LOG2(LOG_ERR, "registration recv: %s\n", strerror(errno));
                return 0;
        }
        DEBUG(DEBUG_MESSAGES, "Received %d bytes from %s:%d\n", n,
               inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

        res = parse_msg(msg, n, &ext);
        if (res != 0 || ext.double_auth_ext != 0) {
                char *reason = "N/A";
                DEBUG(DEBUG_MESSAGES, "Dropping invalid message\n");
                mobile_array[cur_mobile].mn.discarded_msgs++;
                if (res == -1)
                        reason = "unknown extension";
                else if (res == -2)
                        reason = "malformed message";
                else if (res == -3 || res == -4 || res == -5)
                        reason = "unknown vendor extension";
                else if (ext.double_auth_ext != 0)
                        reason = "double authentication extension";
                report_discarded_msg(msg, n, &addr, reason);
                return 0;
        }

        mobile_array[cur_mobile].mn.try_to_fix_sec_assoc = 0;
        if (is_valid_reply(&ext, addr)) {
                mobile_array[cur_mobile].mn.prev_req_replied = 1;
                time(&mobile_array[cur_mobile].mn.last_reply_rcvd);
                mobile_array[cur_mobile].mn.last_reply_code = ext.rep->code;
                mobile_array[cur_mobile].mn.last_nonce = ext.rep->id[0];
                if (ext.challenge != NULL) {
                        int len;
                        gettimeofday(&mobile_array[cur_mobile].mn.last_challenge_time, NULL);
                        len = GET_CHALLENGE_EXT_LEN(ext.challenge);
                        if (mobile_array[cur_mobile].mn.last_challenge_ext == NULL ||
                            GET_CHALLENGE_EXT_LEN(mobile_array[cur_mobile].mn.last_challenge_ext) !=
                            len) {
                                if (mobile_array[cur_mobile].mn.last_challenge_ext != NULL)
                                        free(mobile_array[cur_mobile].mn.last_challenge_ext);
                                mobile_array[cur_mobile].mn.last_challenge_ext =
                                        (struct challenge_ext *) malloc(len);
                        }

                        if (mobile_array[cur_mobile].mn.last_challenge_ext != NULL)
                                memcpy(mobile_array[cur_mobile].mn.last_challenge_ext, ext.challenge,
                                       len);
                        else
                                DEBUG(DEBUG_INFO, "Could not malloc() memory "
                                      "for challenge extension\n");
                }
                if (IS_REGREP_ACCEPTED(ext.rep->code))
                        handle_reg_accept(&ext);
                else
                        return handle_reg_denied(&ext);
        } else {
                report_discarded_msg(msg, n, &addr, "invalid reply");
                mobile_array[cur_mobile].mn.discarded_msgs++;
        }

        return 0;
}

Here is the call graph for this function:

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

Definition at line 1607 of file mn_reg.c.

References create_mobile(), mn_init(), parse_rows(), readfile(), rownumber, send_messages(), sent_deregs, and sent_regs.

{
        printf("Virtual foreign agent v0.1. \n Sending registeration messages with interval: %i \n", 3);
        mn_init(); //read dynmnd.conf to make "meta mobile node"
        if(argc==2) readfile(argv[1]); 
        else
        {
                printf("No filename given - using default /home/dynamo/mobiles.txt \n");
                readfile("/home/dynamo/mobiles.txt"); //read cfg
        }

  parse_rows(rownumber); //parse lines
        create_mobile(); //creates virtual mobile nodes into array
        send_messages(3); //sends register messages with given interval
        printf("Sent %i REGISTER messages and %i DEREGISTER messages \n", sent_regs, sent_deregs);
        
  return EXIT_SUCCESS;
}

Here is the call graph for this function:

int parse_rows

(

int

i

)

DYNAMO parse_rows: - Rows to parse.

Parse rows

Definition at line 1592 of file mn_reg.c.

References devices, and rows.

Referenced by main().

                      {

int j;

for (j=0; j<i; j++)
 {
        sscanf (rows[j].row,"%s %s %s %s %s %s ",devices[j].timestart,devices[j].state,devices[j].ip_home,devices[j].ip_homeagent,devices[j].ip_careoff,devices[j].nai,);

        }

return 1;
}

int readfile

(

char

file[]

)

Definition at line 1560 of file mn_reg.c.

References rownumber, and rows.

Referenced by main().

                         {

 FILE *fileo;
 
 fileo = fopen(file,"r"); 

  if(file==NULL) {
    printf("Do not Open.\n");
    return 1;
  }

int i=0;

while (!feof(fileo))
{
        fgets(rows[i].row, sizeof(rows[i].row), fileo);    
  i=i+1;
  rownumber=rownumber+1;
}


return 1;
}

int send_messages

(

int

interval

)

DYNAMO - seconds between messages Returns 1 on success.

Sends registeration and deregesteration messages

Definition at line 1483 of file mn_reg.c.

References mobile::config, devices, mobile::mn, mn_config::mn_nai, mobile_array, mobiles, REG_CONNECT, REG_DISC, mn_data::req_lifetime, send_registration(), sent_deregs, sent_regs, timestr, tm, and tmptr.

Referenced by main().

{
int i=0;
        for(i;i<mobiles-1;i++){
                tm=time(NULL);
                tmptr =localtime(&tm);
                strftime(timestr,100, " %X",tmptr); //get time 
                if((i+1)<mobiles) //check that we're not trying to go out of array 
                {
                if(interval=atoi(devices[i+1].timestart)-atoi(devices[i].timestart)<0) interval=3; //timeline fuxxored, no negative times->use default 3 seconds TODO: read from given interval
                else interval=atoi(devices[i+1].timestart)-atoi(devices[i].timestart); //given wait ok
                }
                else interval=3; //wait 3 seconds after quit TODO read from given interval

                
                if(mobile_array[cur_mobile].state==0) //joint
                {
                        mobile_array[cur_mobile].mn.req_lifetime = 600;
                        printf("%s REGISTERATION message with home address: %s , NAI: %s and interval: %i \n" , timestr, inet_ntoa(mobile_array[cur_mobile].config.mn_home_ip_addr),mobile_array[cur_mobile].config.mn_nai, interval);
                        send_registration(REG_CONNECT); //send reg
                        sent_regs++;
                }
                else //leave TODO if state==1 and if state==2 !!
         {
                        printf("%s DEREGISTERATION message with home address: %s and NAI: %s and interval %i \n", timestr, inet_ntoa(mobile_array[cur_mobile].config.mn_home_ip_addr), mobile_array[cur_mobile].config.mn_nai, interval);
                        mobile_array[cur_mobile].mn.req_lifetime = 0;
                        send_registration(REG_DISC); //send dereg
                        sent_deregs++;
                }
                cur_mobile=cur_mobile+1; //next mobile
                
                sleep(interval);
        }
        cur_mobile=0; //back to start, just in case

return 1;
}

Here is the call graph for this function:

int send_registration

(

int

request_type

)

Definition at line 580 of file mn_reg.c.

References add_fa_host_route(), agentadv_data::addr, agentadv_data::adv, agentadv_data::adv_type, mn_data::agentadv, agentadv_data::arpentry, mobile::config, mn_data::current_adv, DEBUG(), DEBUG_INFO, DEBUG_MESSAGES, DEBUG_TIMERS, mn_config::enable_fa_decapsulation, mn_data::fa_addr, agentadv_data::ifindex, agentadv_data::ifname, agentadv_data::in_use, mn_data::last_reg_send_time, mn_data::last_request_sent, LOG2, MAXMSG, mobile::mn, mn, MN_ADV_TYPE_FA, mobile_array, REG_DISC, agentadv_data::reg_failed, mn_data::registration_id, mn_data::registration_socket, agentadv_data::routeentry, TIMER_REQUEST, timers, TUNMODE_AUTO_REVERSE, TUNMODE_AUTO_TRIANGLE, TUNMODE_REVERSE, TUNMODE_TRIANGLE, mn_config::tunneling_mode, and mn_config::udp_port.

Referenced by clean_up(), close_for_home(), disconnect(), request_tunnel(), and send_messages().

{
        char sendbuf[MAXMSG];
        char *pos; /* pointer to next byte to write in sendbuf */
        int n, len;
        struct sockaddr_in addr;
        int use_reverse;
        struct msg_extensions ext;

        if (MAXMSG < (sizeof(struct reg_req) +
                      2 * (sizeof(struct msg_auth) + 16))) {
                DEBUG(DEBUG_INFO, "MN: send_reg: too small send buffer!");

                return -1;
        }

        use_reverse = mobile_array[cur_mobile].config.tunneling_mode == TUNMODE_AUTO_REVERSE ||
                mobile_array[cur_mobile].config.tunneling_mode == TUNMODE_REVERSE;

        if (mobile_array[cur_mobile].mn.current_adv != NULL) {
                if (mobile_array[cur_mobile].mn.current_adv->addr.s_addr != mobile_array[cur_mobile].mn.fa_addr.s_addr) {
                        DEBUG(DEBUG_INFO, "fa_addr=%s != ",
                              inet_ntoa(mobile_array[cur_mobile].mn.fa_addr));
                        DEBUG(DEBUG_INFO, "current_adv->addr=%s\n",
                              inet_ntoa(mobile_array[cur_mobile].mn.current_adv->addr));
                }

                DEBUG(DEBUG_INFO, "Setting in_use=%i for FA %s (send reg)\n",
                      request_type == REG_DISC ? 0 : 1,
                      inet_ntoa(mobile_array[cur_mobile].mn.current_adv->addr));
                mobile_array[cur_mobile].mn.current_adv->in_use = request_type == REG_DISC ? 0 : 1;
                if (mobile_array[cur_mobile].config.tunneling_mode == TUNMODE_AUTO_REVERSE &&
                    (ntohs(mobile_array[cur_mobile].mn.current_adv->adv.ext->opts) &
                     AGENT_ADV_BIDIR_TUNNELING) == 0)
                        use_reverse = 0;
                if (mobile_array[cur_mobile].config.tunneling_mode == TUNMODE_AUTO_TRIANGLE &&
                    mobile_array[cur_mobile].mn.current_adv->adv.own_ext != NULL &&
                    (mobile_array[cur_mobile].mn.current_adv->adv.own_ext->opts &
                     AGENT_ADV_OWN_TRIANGLE_TUNNELING) == 0)
                        use_reverse = 1;
        } else {
                DEBUG(DEBUG_INFO,
                      "send_registration: current_adv == NULL!?\n");
        }

        if ((use_reverse && mobile_array[cur_mobile].config.tunneling_mode == TUNMODE_TRIANGLE) ||
            (!use_reverse && mobile_array[cur_mobile].config.tunneling_mode == TUNMODE_REVERSE)) {
                DEBUG(DEBUG_INFO, "FA does not support wanted tunneling mode -"
                      " aborting registration\n");
                if (mobile_array[cur_mobile].mn.current_adv != NULL)
                        mobile_array[cur_mobile].mn.current_adv->reg_failed = 1;
                return -1;
        }

        if (use_reverse)
                DEBUG(DEBUG_MESSAGES, "Requesting reverse tunneling\n");

        pos = sendbuf;

        DEBUG(DEBUG_MESSAGES, "Sending registration message:\n * header\n");
        n = fill_req_header(pos, request_type, use_reverse);
        if (n < 0) return -1;
        pos += n;

        n = add_req_extensions(pos, MAXMSG - n, sendbuf, request_type,
                               use_reverse);
        if (n < 0) {
                LOG2(LOG_ERR, "Registration request buffer overflow - unable"
                     " to send the request\n");
                return -1;
        }
        pos += n;

        len = (int) (pos - sendbuf);
        assert(len <= MAXMSG);

        /* call parse_msg() to parse the message in order to get the details
         * of the sent message into debug output; in addition, this validates
         * the format of the request */
        if (parse_msg(sendbuf, len, &ext) != 0) {
                DEBUG(DEBUG_INFO, "WARNING! Own registration request was not "
                      "valid!\n");
        }

        /* add ARP entry, if not already added */
        if (mobile_array[cur_mobile].mn.current_adv != NULL &&
            mobile_array[cur_mobile].mn.current_adv->adv_type == MN_ADV_TYPE_FA &&
            !mobile_array[cur_mobile].mn.current_adv->arpentry) {
                struct sockaddr hwaddr;
                DEBUG(DEBUG_INFO, "Adding ARP entry for FA\n");
                memset(&hwaddr, 0, sizeof(hwaddr));
                hwaddr.sa_family = ARPHRD_ETHER;
#ifdef DYN_TARGET_LINUX
                memcpy(hwaddr.sa_data, mobile_array[cur_mobile].mn.current_adv->adv.from.sll_addr,
                       mobile_array[cur_mobile].mn.current_adv->adv.from.sll_halen);
#else
                memcpy(hwaddr.sa_data, mobile_array[cur_mobile].mn.current_adv->adv.eth->h_source,
                       ETH_ALEN);
#endif
                if (arp_add_permanent_item(mobile_array[cur_mobile].mn.current_adv->addr,
                                           mobile_array[cur_mobile].mn.current_adv->ifname,
                                           &hwaddr) < 0) {
                        LOG2(LOG_WARNING, "arp_add_permanent_item(%s, %s, %s) "
                             "failed\n", inet_ntoa(mobile_array[cur_mobile].mn.current_adv->addr),
                             mobile_array[cur_mobile].mn.current_adv->ifname,
                             ether_hwtoa((unsigned char *)hwaddr.sa_data));
                }
                mobile_array[cur_mobile].mn.current_adv->arpentry = 1;
        }

        /* add host route to FA, if not already added */
        if (mobile_array[cur_mobile].config.enable_fa_decapsulation &&
            mobile_array[cur_mobile].mn.current_adv != NULL &&
            mobile_array[cur_mobile].mn.current_adv->adv_type == MN_ADV_TYPE_FA &&
            !mobile_array[cur_mobile].mn.current_adv->routeentry) {
                DEBUG(DEBUG_INFO, "Adding routing entry for FA\n");
                add_fa_host_route(mobile_array[cur_mobile].mn.current_adv->ifname, mobile_array[cur_mobile].mn.agentadv,
                                  mobile_array[cur_mobile].mn.current_adv->ifindex, mobile_array[cur_mobile].mn.fa_addr);
        }

        /* send the message */
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
       // addr.sin_addr.s_addr = mobile_array[cur_mobile].mn.fa_addr.s_addr;
         //addr.sin_addr.s_addr = inet_addr("172.16.0.2");
        addr.sin_addr.s_addr=mobile_array[cur_mobile].config.ha_ip_addr.s_addr;
        addr.sin_port = htons(mobile_array[cur_mobile].config.udp_port);
        DEBUG(DEBUG_MESSAGES, "sending registration request to %s:%i, "
              "type=%i\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port),
              request_type);

        gettimeofday(&mobile_array[cur_mobile].mn.last_reg_send_time, NULL);
        DEBUG(DEBUG_TIMERS, "last_reg_send_time=%li.%06li (FA=%s)\n",
              mobile_array[cur_mobile].mn.last_reg_send_time.tv_sec,
              mobile_array[cur_mobile].mn.last_reg_send_time.tv_usec,
              inet_ntoa(addr.sin_addr));

        


        n = sendto(mobile_array[cur_mobile].mn.registration_socket, sendbuf, len, 0,
                   (struct sockaddr *) &addr, sizeof(addr));
        if (n == len) {
                /* store id for reply */
                mobile_array[cur_mobile].mn.registration_id[0] =
                        ntohl(((struct reg_req *)sendbuf)->id[0]);
                mobile_array[cur_mobile].mn.registration_id[1] =
                        ntohl(((struct reg_req *)sendbuf)->id[1]);
                /* set registration time */
                gettimeofday(&timers[TIMER_REQUEST], NULL);
                mobile_array[cur_mobile].mn.last_request_sent = timers[TIMER_REQUEST].tv_sec;
                return 0;
        } else {
                LOG2(LOG_ERR, "send_reg - sendto: %s\n", strerror(errno));
                return -1;
        }
}

Here is the call graph for this function:

---

Variable Documentation

struct mn_config config

Definition at line 45 of file mn.c.

int cur_mobile = 0

Definition at line 102 of file mn_reg.c.

DEVICE devices[5000]

Definition at line 81 of file mn_reg.c.

Referenced by create_mobile(), parse_rows(), and send_messages().

int intervals[5000]

Definition at line 52 of file mn_reg.c.

struct mn_data mn

Definition at line 44 of file mn.c.

struct mobile mobile_array[20]

Definition at line 101 of file mn_reg.c.

Referenced by create_mobile(), handle_registration(), send_messages(), and send_registration().

int mobiles = 0

Definition at line 103 of file mn_reg.c.

Referenced by create_mobile(), and send_messages().

int rownumber = 0

Definition at line 55 of file mn_reg.c.

Referenced by create_mobile(), main(), and readfile().

ROWDATA rows[5000]

Definition at line 82 of file mn_reg.c.

Referenced by parse_rows(), and readfile().

int sent_deregs

Definition at line 85 of file mn_reg.c.

Referenced by main(), and send_messages().

int sent_regs

Definition at line 84 of file mn_reg.c.

Referenced by main(), and send_messages().

struct timeval timers[TIMER_COUNT]

Definition at line 47 of file mn.c.

char timestr[60]

Definition at line 89 of file mn_reg.c.

Referenced by send_messages().

time_t tm

Definition at line 88 of file mn_reg.c.

Referenced by send_messages().

struct tm* tmptr

Definition at line 87 of file mn_reg.c.

Referenced by send_messages().

---