hawaii-lib.tcl

运行于linux上的CIMS套件

############################################################
# Hawaii routing library for per-host routing simulation.  #
############################################################
# Implemented by Chieh-Yih Wan.   Nov, 1999                #
# [e-mail]                                   #
############################################################

proc createAddrTable { node } {
    global addrTable_

    set addr [$node address?] 
    set addrTable_($addr) [$node set address_] 
}

proc addrToString { addr } {
    global addrTable_

    if {[info exists addrTable_($addr)]} {
	return $addrTable_($addr)
    }
    return -1
}

proc checkHawaii {} {
    global HawaiiRouting

}

proc makeHawaiiRouter { node DRRaddress } {
    createAddrTable $node
    set hawaiiagent_ [new Agent/Hawaii $node]
    $node attach $hawaiiagent_ 0
    $hawaiiagent_ set_node $node
    $hawaiiagent_ set domain_root_router_ $DRRaddress
}

proc makeHawaiiBS { baseStation DRRaddress } {
    $baseStation color "blue"
    createAddrTable $baseStation
    [$baseStation set regagent_] set_node $baseStation
    [$baseStation set classifiers_(1)] set foreignBS_ 1
    [$baseStation set classifiers_(1)] set mynode_ $baseStation
    [$baseStation set regagent_] set domain_root_router_ $DRRaddress
    [$baseStation set regagent_] selectHandoffScheme
}

proc createMsfBuffer { hawaiiBS pkts time} {
    [$hawaiiBS set classifiers_(1)] hawaii-buffer $pkts $time 
}

proc makeHawaiiMH { Mobile DRRaddress } {
    [$Mobile set regagent_] set reg_lifetime_ 3
    [$Mobile set regagent_] set home_agent_ $DRRaddress
}

Agent/MIPBS instproc selectHandoffScheme { } {
  global HawaiiRoutingMSF

    if {[info exists HawaiiRoutingMSF]} {
	if { $HawaiiRoutingMSF == 1} {
	    $self set HawaiiRoutingMSF 1
	}
    }
}

# Value: 1 -> MH is attach to this BS
# Value: 2 -> MH is attach to other BS
Classifier instproc BS_update_routing_table { m_addr } {
  $self instvar mynode_ rt_table_

  set ns_ [Simulator instance]
 
  set rt_table_($m_addr) 1
}

Classifier instproc BS_Handoff_Update { m_addr } {
  $self instvar mynode_ rt_table_

  set ns_ [Simulator instance]
 
  puts "BS_Handoff_Update called at [$ns_ now]"

  set rt_table_($m_addr) 2
}

Classifier instproc Lookup_Hawaii_RT { m_addr } {
  $self instvar mynode_ rt_table_

  if {[info exists rt_table_($m_addr)]} {
       return $rt_table_($m_addr)
  }
  return -1 
}

Agent/MIPBS instproc myNodeID { } {
        $self instvar node_
        return [$node_ id]
}
                
Agent/Hawaii instproc myNodeID { } {
        $self instvar node_
        return [$node_ id]
}

Classifier instproc myNodeID {} {
    $self instvar mynode_

    return [$mynode_ id]
}

Agent/MIPBS instproc set_node { node } {
  $self instvar mynode_ hawaii_rt_

  set mynode_ $node
}


Agent/MIPBS instproc create-route { m_addr } {
   $self instvar mynode_ hawaii_rt_

   set ns_ [Simulator instance]

   [$mynode_ set classifiers_(1)] BS_update_routing_table $m_addr 
}

# ============================================================
# MSF specific API

Agent/MIPBS instproc change-route { m_addr nodeaddr } {
   global addrTable_
   $self instvar mynode_ hawaii_rt_


    if {[info exists addrTable_($nodeaddr)]} {
        set dotaddr $addrTable_($nodeaddr)
    } else {
        puts "ERROR on address conversion"
        return 
    }

   set ns_ [Simulator instance]

   set pnode [$ns_ get-node-by-addr $dotaddr]

   [$mynode_ set classifiers_(1)] update_routing_table $m_addr $pnode
}

Agent/MIPBS instproc block-packet { m_addr } {
    $self instvar mynode_
    [$mynode_ set classifiers_(1)] BS_Handoff_Update $m_addr  
}

Agent/MIPBS instproc dump-buffer {} {
    $self instvar mynode_
    puts "dump-biffer in tcl"
    [$mynode_ set classifiers_(1)] dump-buffer 0
}

Agent/MIPBS instproc clear-route { m_addr old_BS} {
    $self instvar mynode_ hawaii_rt_

    set ns_ [Simulator instance]
    
    set old_BS [$ns_ get-node-by-addr [addrToString $old_BS]]
   [$old_BS set classifiers_(1)] BS_Handoff_Update $m_addr
}

Agent/MIPMH instproc myNode {} {
    $self instvar node_
    return $node_
}

# ============================================================

#######################################################
#      Hawaii hop-by-hop routing upadate module       #
#######################################################
Classifier set top_ 0
Classifier/Addr set top_ 0

Classifier/Addr instproc Lookup_Hawaii_RT { m_addr } {
  $self instvar mynode_ rt_table_

  if {[info exists rt_table_($m_addr)]} {
       return $rt_table_($m_addr)
  }
  return -1 
} 

Classifier/Addr instproc update_routing_table { m_addr pnode } {
  $self instvar mynode_ rt_table_

  set ns_ [Simulator instance]
 
  puts "update_routing_table called"

  set rt_table_($m_addr) [[$ns_ set link_([$mynode_ set id_]:[$pnode set id_])] head]
}

Agent/Hawaii instproc change-route { m_addr pnodeid } {
   $self instvar mynode_ hawaii_rt_

   set ns_ [Simulator instance]

   set pnode [$ns_ get-node-by-id $pnodeid]
   
   [$mynode_ set classifiers_(1)] update_routing_table $m_addr $pnode 
}

Agent/Hawaii instproc change-route-addr { m_addr nodeaddr } {
   global addrTable_
   $self instvar mynode_ hawaii_rt_

    if {[info exists addrTable_($nodeaddr)]} {
        set dotaddr $addrTable_($nodeaddr)
    } else {
        puts "ERROR on address conversion"
        return
    }

   set ns_ [Simulator instance]

   set pnode [$ns_ get-node-by-addr $dotaddr]
 
   [$mynode_ set classifiers_(1)] update_routing_table $m_addr $pnode
}


Agent instproc set_node { node } {
  $self instvar mynode_ hawaii_rt_

  set mynode_ $node
}

Agent instproc  get-nexthop { dst_addr } {
   $self instvar mynode_

   set ns_ [Simulator instance]

   # assume that dest_addr is x.y.z form
   set dest_al [$mynode_ split-addrstr $dst_addr]
   set dest_l [llength $dest_al]

   # get this node's address as a form of x.y.z
   # How? my_addr 
   set my_addr [$mynode_ set address_] 

   set my_al [$mynode_ split-addrstr $my_addr]
   set my_l [llength $my_al]

   if { $dest_l != $my_l } {
        puts "**WARNING level of hierarchiy is different"
      }

   # compare each filed of address until it is different
   for {set i 1} {$i <= $dest_l} {incr i} {
        set dst  [lindex $dest_al [expr $i-1]]
        set mine [lindex $my_al [expr $i-1]]
        if {$dst != $mine} { 
            # This mean classifier points to nextHop
            # get the nextHop from classifier

            #[$mynode_ set classifiers_($i)] dump

            set nh [[$mynode_ set classifiers_($i)] set slots_($dst)]

            foreach nbr [$mynode_ set neighbor_] {
                set link [$ns_ link $mynode_ $nbr]
                if { $nh == [$link head]} {
                     #return [$nbr node-addr]
                     return [$nbr address?]
                }
            }   

        }
   }
}