mip-reg.cc

ns2--网络仿真软件扩展！·

                        // found new COA -> clear AD cache
                        force_handoff_ = 0;
                        ad_nr = 0;
                        for(int i = 0; i < AD_CACHE_SIZE; ++i)
                                ad_cache[i] = -1;

                        // register new coa
                        coa_ = miph->coa_;
                        cur_prio_ = miph->priority_;

                        if(node_)
                                node_->set_base_stn(coa_);
#ifndef MIP_QUIET
                        printf("%f MH %s has new coa (%s)\n",
                               Scheduler::instance().clock(), 
                               Address::instance().print_nodeaddr(addr()),
                               Address::instance().print_nodeaddr(coa_)); // JCW
#endif
                } else {
                        if (!force_handoff_) {
                                // refreshed old COA and no handoff needed -> clear AD cache
                                ad_nr = 0;
                                for(int i = 0; i < AD_CACHE_SIZE; ++i)
                                        ad_cache[i] = -1;
                        }
                }

                adlftm_ = miph->lifetime_;

                tcl.evalf("%s update-reg %d", name_, coa_);
                if (rtx_timer_.status() == TIMER_PENDING)
                        rtx_timer_.cancel();
        }
        break;

        case MIPT_ADS: {
#ifndef MIP_QUIET
                printf("%f MH %s received ADS with coa %s\n",
                       Scheduler::instance().clock(), 
                       Address::instance().print_nodeaddr(addr()),
                       Address::instance().print_nodeaddr(miph->coa_)); // JCW
#endif                
                AgentList **ppagts = &agts_, *ptr;
                while (*ppagts) {
                        if ((*ppagts)->node_ == miph->coa_) break;
                        ppagts = &(*ppagts)->next_;
                }

                if (*ppagts) { // refresh
                        ptr = *ppagts;
                        *ppagts = ptr->next_;
                } else { // new AD
                        ptr = new AgentList;
                        ptr->node_ = miph->coa_;
                }
                // update distance to MH and sending range
                ptr->priority_ = miph->priority_;
                ptr->distance_ = distance(p->txinfo_.getNode());
                ptr->txpr_ = p->txinfo_.getTxPr();
                ptr->expire_time_ = 2 * beacon_ + Scheduler::instance().clock();
                ptr->lifetime_ = miph->lifetime_;
                ptr->next_ = agts_;
                agts_ = ptr;

                if (coa_ == -1) {
                        /* send REQUEST if MH has no coa_ */
                        seqno_++;
                        ad_cache[(++ad_nr) % AD_CACHE_SIZE] = reg(agts_);
#ifdef OPTIMIZED_HANDOFF
                } else if ((ptr->priority_ > cur_prio_) &&
                        (ptr->distance_ / ptr->txpr_ <= (1 - HANDOFF_RATIO))) {
                        /* send REQUEST if AD was from "nearby" BS with higher priority */
                        force_handoff_ = 1;
                        seqno_++;
                        ad_cache[(++ad_nr) % AD_CACHE_SIZE] = reg(agts_);
#else
                } else if (ptr->priority_ > cur_prio_) {
                        /* send REQUEST if AD was from BS with higher priority */
                        seqno_++;
                        ad_cache[(++ad_nr) % AD_CACHE_SIZE] = reg(agts_);
#endif
                } else if (miph->coa_ == coa_) {
                        /* refresh */
                        seqno_++;
                        ad_cache[(++ad_nr) % AD_CACHE_SIZE] = reg(agts_);
#ifdef OPTIMIZED_HANDOFF
                        if (ptr->distance_ / ptr->txpr_ > (1 - HANDOFF_RATIO)) {
                                /* handoff needed -> also try to register with preferred BS */
                                force_handoff_ = 1;
                                seqno_++;
                                ad_cache[(++ad_nr) % AD_CACHE_SIZE] = reg();
                        }
#endif
                }

#ifndef MIP_QUIET
                printf("%f MH agent list [COA %s]: ", Scheduler::instance().clock(),
                       Address::instance().print_nodeaddr(coa_));
                ptr = agts_;
                while (ptr) {
                        if (ptr->node_ == coa_) {
                                printf("[%s-(%.0f/%.0f %i)] ", Address::instance().print_nodeaddr(ptr->node_),
                                       ptr->distance_, ptr->txpr_, ptr->priority_);
                        } else {
                                printf("%s-(%.0f/%.0f %i) ", Address::instance().print_nodeaddr(ptr->node_),
                                       ptr->distance_, ptr->txpr_, ptr->priority_);
                        }
                        ptr = ptr->next_;
                }
                printf("\n");
#endif                
        }
        break;

        default:
                break;
        }
	Packet::free(p);
}

void MIPMHAgent::timeout(int tno)
{
	switch (tno) {
	case MIP_TIMER_SIMPLE: {
                printf("%f simple timeout %f [COA %s]\n",
                       Scheduler::instance().clock(), reg_rtx_,
                       Address::instance().print_nodeaddr(coa_));

                // JCW
                AgentList *ptr = agts_;
                if (ptr) {
                        while (ptr) {
                                if (ptr->node_ == coa_)
                                        printf("-->");
                                printf("%s (%f), ", Address::instance().print_nodeaddr(ptr->node_),
                                       ptr->expire_time_);
                                ptr = ptr->next_;
                        }
                        printf("\n");
                } else {
                        printf("\t no BSs in range\n");
                }
                reg(); // try to register (preferred) coa
        }
        break;
	case MIP_TIMER_AGTLIST: {
                double now = Scheduler::instance().clock();
                AgentList **ppagts = &agts_, *ptr;
                int coalost = 0;
                while (*ppagts) {
                        if ((*ppagts)->expire_time_ < now) {
                                ptr = *ppagts;
                                *ppagts = ptr->next_;
                                if (ptr->node_ == coa_) {
                                        // forced switch to new coa_ JCW
                                        printf("%f current coa (%s) timed out\n",
                                               Scheduler::instance().clock(),
                                               Address::instance().print_nodeaddr(coa_));
                                        coa_ = -1;
                                        coalost = 1;
                                }
                                delete ptr;
                        } else
                                ppagts = &(*ppagts)->next_;
                }
                agtlist_timer_.resched(beacon_);
                if (coalost) {
                        seqno_++;
                        ad_cache[(++ad_nr) % AD_CACHE_SIZE] = reg();
                }
        }
        break;
	default:
		break;
	}
}

int MIPMHAgent::command(int argc, const char*const* argv)
{
	if (argc == 3) {
		if (strcmp(argv[1], "beacon-period") == 0) {
			beacon_ = atof(argv[2]);
			timeout(MIP_TIMER_AGTLIST);
			agtlist_timer_.resched(beacon_);
			rtx_timer_.resched(Random::uniform(0, beacon_));
			return TCL_OK;
		}
		else if (strcmp(argv[1], "bcast-target") == 0) {
			bcast_target_ = (NsObject *)TclObject::lookup(argv[2]);
			return TCL_OK;
		}
		else if (strcmp (argv[1], "node") == 0) {
		        node_ = (MobileNode*)TclObject::lookup(argv[2]);
		        if (node_ == 0) {
			        fprintf (stderr, "%s: %s lookup of %s failed\n", __FILE__, argv[1], argv[2]);
			        return TCL_ERROR;
		        }
		        return TCL_OK;
		}
	}
	return (Agent::command(argc, argv));
}

AgentList* MIPMHAgent::preferredAgent()
{
        AgentList *ptr = agts_, *pref_agt = 0;
        int max_prio = -1, near;
        double min_dist = DBL_MAX;

        /* return Agent with highest priority (and smallest distance) */
        near = 0;
        while (ptr) {
#ifdef OPTIMIZED_HANDOFF
                if (ptr->distance_ / ptr->txpr_ <= (1 - HANDOFF_RATIO)) {
                        if (!near) { // use "near" BS if only "far" BS found so far
                                max_prio = -1;
                                near = 1;
                        }
                } else {
                        if (near) { // skip "far" BS if "near" BS possible
                                ptr = ptr->next_;
                                continue;
                        }
                }

                if ((ptr->priority_ > max_prio) ||
                    (ptr->priority_ == max_prio && ptr->distance_ < min_dist)) {
                        pref_agt = ptr;
                        max_prio = ptr->priority_;
                        min_dist = ptr->distance_;
                }
#else
                if (ptr->priority_ > max_prio) {
                        pref_agt = ptr;
                        max_prio = ptr->priority_;
                        min_dist = ptr->distance_;
                }
#endif
                ptr = ptr->next_;
        }
        return pref_agt;
}

int MIPMHAgent::reg()
{
        return reg(preferredAgent());
}

int MIPMHAgent::reg(AgentList* agt)
{
        int reg_coa_;

	rtx_timer_.resched(reg_rtx_);
	if (agt == 0) {
		send_sols();
		return -1;
	}
	reg_coa_ = agt->node_;

	Tcl& tcl = Tcl::instance();
	Packet *p = allocpkt();
	hdr_ip *iph = hdr_ip::access(p);
	iph->daddr() = reg_coa_;
	iph->dport() = 0;
	hdr_mip *h = hdr_mip::access(p);
	h->haddr_ = Address::instance().get_nodeaddr(addr());
	h->ha_ = ha_;
	h->coa_ = reg_coa_;
	h->type_ = MIPT_REG_REQUEST;
	h->lifetime_ = min(reglftm_, agt->lifetime_);
	h->seqno_ = seqno_;

        hdr_cmn *ch = HDR_CMN (p);
        ch->next_hop_ = Address::instance().get_nodeaddr(iph->daddr());

#ifndef MIP_QUIET
		printf("%f MH %s sends request to %s\n", Scheduler::instance().clock(),
		       Address::instance().print_nodeaddr(h->haddr_),
		       Address::instance().print_nodeaddr(reg_coa_));
#endif

	tcl.evalf("%s get-link %d %d", name_, h->haddr_,reg_coa_);
	NsObject *target = (NsObject *)tcl.lookup(tcl.result());
	if (target != NULL) {
	          ((NsObject *)tcl.lookup(tcl.result()))->recv(p, (Handler*) 0);
	}
        else 
	        send(p, 0);
        return reg_coa_;
}

void MIPMHAgent::send_sols()
{
	Packet *p = allocpkt();
	hdr_mip *h = hdr_mip::access(p);
	h->coa_ = -1;
	h->haddr_ = Address::instance().get_nodeaddr(addr());
	h->ha_ = ha_;
	h->type_ = MIPT_SOL;
	h->lifetime_ = reglftm_;
	h->seqno_ = seqno_;

	hdr_ip *iph = hdr_ip::access(p);
        hdr_cmn *ch = hdr_cmn::access(p);
        ch->next_hop_ = IP_BROADCAST;
        ch->addr_type_ = NS_AF_INET;
        iph->daddr() = IP_BROADCAST;
        iph->dport() = 0;

	if (bcast_target_) 
		bcast_target_->recv(p, (Handler*) 0);
	else if (target_) 
		target_->recv(p, (Handler*) 0);
	else 
		Packet::free(p); // drop; may log in future code
}