开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
classifier-addr-mpls.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：31k
源码类别：

通讯编程

开发平台：

Visual C++

classifier-addr-mpls.cc：源码内容
  1. // -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*-
  3. /*
  4.  * classifier-addr-mpls.cc
  5.  * Copyright (C) 2000 by the University of Southern California
  6.  * $Id: classifier-addr-mpls.cc,v 1.7 2005/08/25 18:58:09 johnh Exp $
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License,
  10.  * version 2, as published by the Free Software Foundation.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License along
  18.  * with this program; if not, write to the Free Software Foundation, Inc.,
  19.  * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  20.  *
  21.  *
  22.  * The copyright of this module includes the following
  23.  * linking-with-specific-other-licenses addition:
  24.  *
  25.  * In addition, as a special exception, the copyright holders of
  26.  * this module give you permission to combine (via static or
  27.  * dynamic linking) this module with free software programs or
  28.  * libraries that are released under the GNU LGPL and with code
  29.  * included in the standard release of ns-2 under the Apache 2.0
  30.  * license or under otherwise-compatible licenses with advertising
  31.  * requirements (or modified versions of such code, with unchanged
  32.  * license).  You may copy and distribute such a system following the
  33.  * terms of the GNU GPL for this module and the licenses of the
  34.  * other code concerned, provided that you include the source code of
  35.  * that other code when and as the GNU GPL requires distribution of
  36.  * source code.
  37.  *
  38.  * Note that people who make modified versions of this module
  39.  * are not obligated to grant this special exception for their
  40.  * modified versions; it is their choice whether to do so.  The GNU
  41.  * General Public License gives permission to release a modified
  42.  * version without this exception; this exception also makes it
  43.  * possible to release a modified version which carries forward this
  44.  * exception.
  45.  *
  46.  */
  48. //
  49. // Original source contributed by Gaeil Ahn. See below.
  50. //
  51. // $Header: /cvsroot/nsnam/ns-2/mpls/classifier-addr-mpls.cc,v 1.7 2005/08/25 18:58:09 johnh Exp $
  53. // XXX
  54. //
  55. // - Because MPLS header contains pointers, it cannot be used WITH multicast 
  56. //   routing which replicates packets
  57. // - Currently it works only with flat routing.
  59. /**************************************************************************
  60.  * Copyright (c) 2000 by Gaeil Ahn                                      *
  61.  * Everyone is permitted to copy and distribute this software.   *
  62.  * Please send mail to fog1@ce.cnu.ac.kr when you modify or distribute    *
  63.  * this sources.   *
  64.  **************************************************************************/
  66. /************************************************************
  67.  *                                                          *
  68.  *    File: File for packet switching in MPLS node          *
  69.  *    Author: Gaeil Ahn (fog1@ce.cnu.ac.kr), Dec. 1999      *
  70.  *                                                          *
  71.  ************************************************************/
  73. #include "packet.h"
  74. #include "trace.h"
  75. #include "classifier-addr-mpls.h"
  77. int hdr_mpls::offset_;
  79. static class shimhdreaderClass : public PacketHeaderClass {
  80. public:
  81. shimhdreaderClass() : PacketHeaderClass("PacketHeader/MPLS", 
  82. sizeof(hdr_mpls)) {
  83. bind_offset(&hdr_mpls::offset_);
  84. }
  85. } class_shimhdreader;
  87. static class MPLSAddrClassifierClass : public TclClass {
  88. public:
  89. MPLSAddrClassifierClass() : TclClass("Classifier/Addr/MPLS") {}
  90. virtual TclObject* create(int, const char*const*) {
  91. return (new MPLSAddressClassifier());
  92. }
  93. virtual void bind();
  94. virtual int method(int argc, const char*const* argv);
  95. } class_mpls_addr_classifier;
  97. void MPLSAddrClassifierClass::bind()
  98. {
  99. TclClass::bind();
  100. add_method("minimum-lspid");
  101. add_method("dont-care");
  102. add_method("ordered-control?");
  103. add_method("on-demand?");
  104. add_method("enable-ordered-control");
  105. add_method("enable-on-demand");
  106. }
  108. int MPLSAddrClassifierClass::method(int ac, const char*const* av)
  109. {
  110. Tcl& tcl = Tcl::instance();
  111. int argc = ac - 2;
  112. const char*const* argv = av + 2;
  114. if (argc == 2) {
  115. if (strcmp(argv[1], "minimum-lspid") == 0) {
  116. tcl.resultf("%d", MPLS_MINIMUM_LSPID);
  117. return (TCL_OK);
  118. } else if (strcmp(argv[1], "dont-care") == 0) {
  119. tcl.resultf("%d", MPLS_DONTCARE);
  120. return (TCL_OK);
  121. } if (strcmp(argv[1], "ordered-control?") == 0) {
  122. tcl.resultf("%d", 
  123.     MPLSAddressClassifier::ordered_control_);
  124. return (TCL_OK);
  125. } else if (strcmp(argv[1], "on-demand?") == 0) {
  126. tcl.resultf("%d", MPLSAddressClassifier::on_demand_);
  127. return (TCL_OK);
  128. } else if (strcmp(argv[1], "enable-ordered-control") == 0) {
  129. MPLSAddressClassifier::ordered_control_ = 1;
  130. return (TCL_OK);
  131. } else if (strcmp(argv[1], "enable-on-demand") == 0) {
  132. MPLSAddressClassifier::on_demand_ = 1;
  133. return (TCL_OK);
  134. }
  135. }
  136. return TclClass::method(ac, av);
  137. }
  139. int MPLSAddressClassifier::on_demand_ = 0;
  140. int MPLSAddressClassifier::ordered_control_ = 0;
  142. MPLSAddressClassifier::MPLSAddressClassifier() : 
  143. data_driven_(0), control_driven_(0)
  144. {
  145. PFT_.NB_ = 0;
  146. ERB_.NB_ = 0;
  147. LIB_.NB_ = 0;
  148. ttl_ = 32;
  149. }
  151. void MPLSAddressClassifier::delay_bind_init_all()
  152. {
  153. delay_bind_init_one("ttl_");
  154. delay_bind_init_one("trace_mpls_");   
  155. delay_bind_init_one("label_");
  156. delay_bind_init_one("enable_reroute_");
  157. delay_bind_init_one("reroute_option_");
  158. delay_bind_init_one("data_driven_");
  159. delay_bind_init_one("control_driven_");
  160. AddressClassifier::delay_bind_init_all();
  161. }
  163. // Arguments: varName, localName, tracer
  164. int MPLSAddressClassifier::delay_bind_dispatch(const char *vn, 
  165.        const char* ln, TclObject *t)
  166. {
  167. if (delay_bind(vn, ln, "ttl_", &ttl_, t))
  168. return TCL_OK;
  169. if (delay_bind(vn, ln, "trace_mpls_", &trace_mpls_, t)) 
  170. return TCL_OK;
  171. if (delay_bind(vn, ln, "label_", &label_, t)) 
  172. return TCL_OK;
  173. if (delay_bind(vn, ln, "enable_reroute_", &enable_reroute_, t))
  174. return TCL_OK;
  175. if (delay_bind(vn, ln, "reroute_option_", &reroute_option_, t))
  176. return TCL_OK;
  177. if (delay_bind(vn, ln, "data_driven_", &data_driven_, t))
  178. return TCL_OK;
  179. if (delay_bind(vn, ln, "control_driven_", &control_driven_, t))
  180. return TCL_OK;
  181. return AddressClassifier::delay_bind_dispatch(vn, ln, t);
  182. }
  184. int MPLSAddressClassifier::classify(Packet* p)
  185. {
  186. int nexthop = MPLSclassify(p);
  188. if ((enable_reroute_ == 1) && (size_ > 0) && 
  189.     (is_link_down(nexthop)))
  190. // Use alternative path if it exist
  191. nexthop = do_reroute(p);
  192. if (nexthop == MPLS_GOTO_L3)
  193. return AddressClassifier::classify(p);
  194. // XXX Do NOT return -1, which lets the classifier to process this 
  195. // packet twice!!
  196. return (nexthop == -1) ? Classifier::ONCE : nexthop;
  197. }
  199. int MPLSAddressClassifier::is_link_down(int node)
  200. {
  201. Tcl& tcl = Tcl::instance();   
  202. tcl.evalf("[%s set mpls_mod_] get-link-status %d", name(), node);
  203. return (strcmp(tcl.result(), "down") == 0) ? 1 : 0;
  204. }
  206. int MPLSAddressClassifier::do_reroute(Packet* p)
  207. {
  208. int oIface, oLabel, LIBptr;
  209. PI_.shimhdr_ = GetShimHeader(p);
  210. int iLabel = PI_.shimhdr_->label_;
  212. if (aPathLookup(PI_.dst_.addr_, PI_.phb_, oIface, oLabel, LIBptr) == 0)
  213. return convertL2toL2(iLabel, oIface, oLabel, LIBptr);
  214. else {
  215. PI_.shimhdr_ = DelAllShimHeader(PI_.shimhdr_);
  216. trace("L", size_, iLabel, "Drop(linkFail)", -1, -1, -1);
  217. switch (reroute_option_) {
  218. case MPLS_DROPPACKET:
  219. return -1;
  220. case MPLS_L3FORWARDING:
  221. return MPLS_GOTO_L3;
  222. case MPLS_MAKENEWLSP:
  223. Tcl& tcl = Tcl::instance();   
  224. if (!control_driven_)
  225. tcl.evalf("%s ldp-trigger-by-switch %d", 
  226.   name(), PI_.dst_.addr_);
  227. return -1;
  228. }
  229. return -1;
  230. }
  231. }
  233. int MPLSAddressClassifier::convertL3toL2(int oIface, int oLabel, int LIBptr)
  234. {
  235. int iLabel= -1;
  236. int ptr;
  237.               
  238. while (oLabel >= 0) {
  239. /* penultimate hop */
  240. if (oLabel == 0)  {
  241. /* no operation */
  242. trace("U",size_, iLabel, "Push(penultimate)", 
  243.       oIface, oLabel, ttl_);
  244. } else {
  245. /* push operation in ingerss LSR */
  246. PI_.shimhdr_ = push(PI_.shimhdr_,oLabel);
  247. trace("U",size_, iLabel, "Push(ingress)", 
  248.       oIface, oLabel, ttl_);
  249. }
  250. if (LIBptr >= 0) {
  251. /* stack operation */
  252. iLabel = oLabel;
  253. ptr = LIBptr;
  254. LIBlookup(ptr, oIface, oLabel, LIBptr);
  255. } else
  256. break;
  257. }
  259. if (oLabel < 0) {
  260. if (size_ > 0)
  261. PI_.shimhdr_ = DelAllShimHeader(PI_.shimhdr_);
  262. trace("U",size_, iLabel , "L3(errorLabel)", -1,-1, -1);
  263. return MPLS_GOTO_L3;
  264. }
  265. if (oIface < 0) {  
  266. PI_.shimhdr_ = DelAllShimHeader(PI_.shimhdr_);
  267. trace("U", size_, iLabel, "L3(errorOIF)", -1 , -1, -1);
  268. return MPLS_GOTO_L3;
  269. } else
  270. // Guaranteed returned oIface is >= 0 or MPLS_GOTO_L3
  271. return oIface;
  272. }
  274. int MPLSAddressClassifier::convertL2toL2(int iLabel, int oIface, 
  275.  int oLabel, int LIBptr)
  276. {
  277. int  ttl = PI_.shimhdr_->ttl_;
  278. int  ptr;
  280. // push(stack) operation after swap or pop
  281. if (oLabel == 0) {
  282. // in penultimate hop
  283. PI_.shimhdr_ = pop(PI_.shimhdr_);
  284. trace("L", size_, iLabel, "Pop(penultimate)", 
  285.       oIface, oLabel, ttl);
  286. } else if (oLabel > 0) {
  287. // swap operation 
  288. swap(PI_.shimhdr_,oLabel);
  289. trace("L", size_, iLabel, "Swap", oIface, oLabel, ttl);
  290. } else {
  291. // Errored Label
  292. PI_.shimhdr_ = DelAllShimHeader(PI_.shimhdr_);
  293. trace("L", size_, iLabel, "L3(errorLabel)", -1, -1, -1);
  294. return MPLS_GOTO_L3;
  295. }
  296. while (LIBptr >= 0) {
  297. // stack operation
  298. iLabel= oLabel;
  299. ptr = LIBptr;
  300. LIBlookup(ptr, oIface, oLabel, LIBptr);
  301. PI_.shimhdr_ = push(PI_.shimhdr_,oLabel);
  302. trace("L", size_, iLabel, "Push(tunnel)", 
  303.       oIface, oLabel, ttl_);
  304. }   
  305. if (oIface < 0) {  
  306. if (size_ > 0)
  307. PI_.shimhdr_ = DelAllShimHeader(PI_.shimhdr_);
  308. trace("L",size_, iLabel , "L3(errorOIf)", -1 , -1, -1);
  309. return MPLS_GOTO_L3;
  310. }
  311. // Guaranteed returned oIface >= 0
  312. return oIface;
  313. }
  315. // Process unlabeled packet
  316. int MPLSAddressClassifier::processIP()
  317. {
  318. int oIface,oLabel,LIBptr;
  319. int iLabel = -1;
  321. // Insert code to manipulate PHB
  322. if (PFTlookup(PI_.dst_.addr_, PI_.phb_, oIface, oLabel, LIBptr) == 0)
  323. // Push operation
  324. return convertL3toL2(oIface,oLabel,LIBptr);
  326. // L3 forwarding
  327. // Traffic-driven, triggered by MPLS switch
  328. if (data_driven_) 
  329. Tcl::instance().evalf("%s ldp-trigger-by-switch %d", 
  330.       name(), PI_.dst_.addr_);
  331. trace("U", size_, iLabel, "L3", -1, -1, -1);               
  332. return MPLS_GOTO_L3;
  333. }
  335. // Process labeled packet
  336. int MPLSAddressClassifier::processLabelP()
  337. {
  338. int oIface,oLabel,LIBptr;
  339. int iLabel = PI_.shimhdr_->label_;
  341. PI_.shimhdr_ = checkTTL(PI_.shimhdr_);
  343. if (size_ == 0)
  344. // TTL check
  345. return MPLS_GOTO_L3;
  347. // Label swapping operation 
  348. if (LIBlookup(-1, iLabel, oIface, oLabel, LIBptr) == 0)
  349. return convertL2toL2(iLabel,oIface,oLabel,LIBptr);
  351. PI_.shimhdr_ = DelAllShimHeader(PI_.shimhdr_);
  352. trace("L",size_, iLabel,"L3(errorLabel)", -1, -1, -1);
  353. return ( MPLS_GOTO_L3 );
  354. }
  356. int MPLSAddressClassifier::MPLSclassify(Packet* p)
  357. {
  358. GetIPInfo(p, PI_.dst_, PI_.phb_, PI_.srcnode_);
  359. PI_.shimhdr_ = GetShimHeader(p);
  360.    
  361. // XXX Using header size to determine if this is a MPLS-labeled packet
  362. // is a very bad method. We should have some explicit flag that labels
  363. // every packet; this flag will only be set on for every MPLS-labeled
  364. // packet. This can be done by a bitmap field in the common header.
  365. if (size_ == 0) 
  366. // Unlabeled packet
  367. return processIP();
  369. // Labeled packet 
  370. int ret = processLabelP();
  371. if (ret == MPLS_GOTO_L3) {  
  372. PI_.shimhdr_ = GetShimHeader(p);
  373. return processIP();
  374. }
  375. return ret;   
  376. }
  378. hdr_mpls *MPLSAddressClassifier::checkTTL(hdr_mpls *shimhdr)
  379. {
  380. shimhdr->ttl_--;
  381. int ttl   = shimhdr->ttl_;
  382. int iLabel= shimhdr->label_;
  383.    
  384. if (ttl == 0) {
  385. shimhdr = DelAllShimHeader(shimhdr);
  386. trace("L", size_, iLabel, "L3(TTL=0)", -1, -1, ttl);
  387. }
  388. return shimhdr;
  389. }
  391. void MPLSAddressClassifier::GetIPInfo(Packet* p, ns_addr_t &dst,
  392.       int &phb, int &srcnode)
  393. {
  394. hdr_ip* iphdr = hdr_ip::access(p);
  395. dst = iphdr->dst_;
  396. srcnode = iphdr->src_.addr_;
  397. phb = MPLS_DEFAULT_PHB;
  398. }
  400. hdr_mpls *MPLSAddressClassifier::GetShimHeader(Packet* p)
  401. {
  402. hdr_mpls *shimhdr = hdr_mpls::access(p);
  403. size_ = 0;
  404. if ((shimhdr->label_ == 0) && (shimhdr->bflag_ == 0) && 
  405.     (shimhdr->ttl_ == 0)) {
  406. shimhdr->bflag_ = -1;
  407. shimhdr->label_ = -1;
  408. shimhdr->ttl_ = -1;
  409. shimhdr->top_    = shimhdr;
  410. shimhdr->nexthdr_= shimhdr;
  411. } else {
  412. while (shimhdr->top_ != shimhdr) { 
  413. shimhdr = shimhdr->top_;
  414. size_ += 4;
  415. }
  416. } 
  417. return shimhdr;
  418. }
  420. hdr_mpls *MPLSAddressClassifier::DelAllShimHeader(hdr_mpls *shimhdr)
  421. {
  422. while (shimhdr->bflag_ != -1)
  423. shimhdr = pop(shimhdr);
  424. return(shimhdr);
  425. }
  427. hdr_mpls *MPLSAddressClassifier::push(hdr_mpls *shimhdr, int oLabel)
  428. {
  429. hdr_mpls *newhdr;
  431. newhdr = (hdr_mpls *) malloc( sizeof(hdr_mpls) );
  432. newhdr->label_ = oLabel;
  433. newhdr->bflag_ = 1;
  434. newhdr->ttl_ = ttl_;
  435. newhdr->top_  = newhdr;
  436. newhdr->nexthdr_ = shimhdr;
  438. shimhdr->top_ = newhdr;
  439. size_ += 4;
  440.     
  441. return newhdr;
  442. }
  444. hdr_mpls *MPLSAddressClassifier::pop(hdr_mpls *shimhdr)
  445. {
  446. shimhdr = shimhdr->nexthdr_;
  447. free(shimhdr->top_);
  448. shimhdr->top_ = shimhdr;
  449. size_ -= 4;
  450. return shimhdr;
  451. }
  453. void MPLSAddressClassifier::install(int slot, NsObject *target) {
  454. Tcl& tcl = Tcl::instance();
  455. if ((slot >= 0) && (slot < nslot_) && 
  456.     (slot_[slot] != NULL)) {
  457. if (strcmp(slot_[slot]->name(), target->name()) != 0)
  458. tcl.evalf("%s routing-update %d %.15g",
  459.   name(), slot,
  460.   Scheduler::instance().clock());
  461. else
  462. tcl.evalf("%s routing-nochange %d %.15g",
  463.   name(), slot,
  464.   Scheduler::instance().clock());
  465. } else
  466. tcl.evalf("%s routing-new %d %.15g",
  467.   name(), slot,
  468.   Scheduler::instance().clock());
  469. Classifier::install(slot,target);
  470. }
  472. int MPLSAddressClassifier::command(int argc, const char*const* argv)
  473. {
  474. Tcl& tcl = Tcl::instance();
  475. if (argc == 2) {
  476. if (strcmp(argv[1], "control-driven?") == 0) {
  477. tcl.resultf("%d", control_driven_);
  478. return (TCL_OK);
  479. } else if (strcmp(argv[1], "data-driven?") == 0) {
  480. tcl.resultf("%d", data_driven_);
  481. return (TCL_OK);
  482. } else if (strcmp(argv[1], "enable-control-driven") == 0) {
  483. // XXX data-driven and control-driven triggers are
  484. // exclusive 
  485. control_driven_ = 1;
  486. data_driven_ = 0;
  487. return (TCL_OK);
  488. } else if (strcmp(argv[1], "enable-data-driven") == 0) {
  489. control_driven_ = 0;
  490. data_driven_ = 1;
  491. return (TCL_OK);
  492. }
  493. } else if (argc == 3) {      
  494. if (strcmp(argv[1], "PFTdump") == 0) {
  495. // <classifier> PFTdump nodeid*/
  496. PFTdump(argv[2]);
  497. return (TCL_OK);
  498. } else if (strcmp(argv[1], "ERBdump") == 0) {
  499. ERBdump(argv[2]);
  500. return (TCL_OK);
  501. } else if (strcmp(argv[1], "LIBdump") == 0) {
  502. LIBdump(argv[2]);
  503. return (TCL_OK);
  504. } else if (strcmp(argv[1], "get-fec-for-lspid") == 0) {
  505. // <classifier get-fec-for-lspid LSPid
  506. int LSPid  = atoi(argv[2]);
  507. int LIBptr = -1;
  508. int ERBnb;
  509. ERBnb = ERBlocate(LSPid, -1, LIBptr);
  510. if (ERBnb >= 0)
  511. tcl.resultf("%d", ERB_.Entry_[ERBnb].FEC_);
  512. else   
  513. tcl.result("-1");
  514. return (TCL_OK);
  515. } 
  516. } else if (argc == 4) {
  517. if (strcmp(argv[1], "exist-fec") == 0) {
  518. // <classifier> exist-fec <fec> <phb>
  519. int LIBptr;
  520. int PFTnb = PFTlocate(atoi(argv[2]), atoi(argv[3]),
  521.       LIBptr);         
  522. if (PFTnb > -1)
  523. tcl.result("1");
  524. else
  525. tcl.result("-1");
  526. return (TCL_OK);
  527. }
  528. int PFTnb = -1;
  529. int LIBptr = -1;
  530. int iLabel, oLabel, iIface, oIface;
  531. int fec   = atoi(argv[2]);
  532. int LSPid = atoi(argv[3]);
  533. int PHB   = LSPid;
  534. if (LSPid < 0)     // topology-based LSP
  535. PFTnb = PFTlocate(fec,PHB, LIBptr);
  536. else               // ER-LSP
  537. ERBlocate(LSPid,fec, LIBptr);
  539. if (strcmp(argv[1], "GetInIface") == 0) {
  540. // <classifier> GetInIface <FEC> <LSPid>
  541. if (LIBptr > -1) {
  542. LIBgetIncoming(LIBptr,iIface,iLabel);
  543. tcl.resultf("%d", iIface);
  544. } else
  545. tcl.result("-1");
  546. return (TCL_OK);
  547. } else if (strcmp(argv[1], "GetInLabel") == 0) {
  548. // <classifier> GetInLabel <FEC> <LSPid>
  549. if (LIBptr > -1) {
  550. LIBgetIncoming(LIBptr,iIface,iLabel);
  551. tcl.resultf("%d", iLabel);
  552. } else 
  553. tcl.result("-1");
  554. return (TCL_OK);
  555. } else if (strcmp(argv[1], "GetOutIface") == 0) {
  556. // <classifier> GetOutIface <FEC> <phb/LSPid>
  557. if (LIBptr > -1) {
  558. LIBlookup(LIBptr, oIface, oLabel, LIBptr);
  559. tcl.resultf("%d", oIface);
  560. } else
  561. tcl.result("-1");
  562. return (TCL_OK);
  563. } else if (strcmp(argv[1], "GetOutLabel") == 0) {
  564. // <classifier> GetOutLabel <FEC> <phb/LSPid>
  565. if (LIBptr > -1) {
  566. LIBlookup(LIBptr, oIface, oLabel, LIBptr);
  567. tcl.resultf("%d", oLabel);
  568. } else
  569. tcl.result("-1");
  570. return (TCL_OK);
  571. } else if (strcmp(argv[1], "install") == 0) { 
  572. int slot = atoi(argv[2]);
  573. //if ((slot >= 0) && (slot < nslot_) && 
  574. //  (slot_[slot] != NULL)) {
  575. // if (strcmp(slot_[slot]->name(),argv[3]) != 0)
  576. // tcl.evalf("%s routing-update %s %.15g",
  577. //   name(), argv[2],
  578. // Scheduler::instance().clock());
  579. // else
  580. //       tcl.evalf("%s routing-nochange %s %.15g",
  581. // name(), argv[2],
  582. // Scheduler::instance().clock());
  583. //} else
  584. // tcl.evalf("%s routing-new %s %.15g",
  585. //   name(), argv[2],
  586. //   Scheduler::instance().clock());
  587. // Then the control is passed on the the base
  588. // address classifier!
  589. //return AddressClassifier::command(argc, argv);
  590. //not a good idea since it would start an infinite loop incase MPLSAddressClassifier::install is defined; 
  591. //so call Classifier::install explicitly.
  592. NsObject* target = (NsObject*)TclObject::lookup(argv[3]);
  593. //Classifier::install(slot, target);
  595. install(slot,target);
  596. return (TCL_OK);
  597. }
  598. } else if (argc == 5) {      
  599. if (strcmp(argv[1], "ErLspBinding") == 0) {
  600. // <classifier> ErLspBinding <FEC> <PHB> <lspid>
  601. int addr   = atoi(argv[2]);
  602. int PHB    = atoi(argv[3]);
  603. int LSPid  = atoi(argv[4]);
  604. if ( !ErLspBinding(addr, PHB,-1, LSPid) )
  605. tcl.result("1");
  606. else     
  607. tcl.result("-1");
  608. return (TCL_OK);
  609. }
  610. } else if (argc == 6) {
  611. // <classifier> ErLspStacking fec0 erlspid0 fec erfecid
  612. if (strcmp(argv[1], "ErLspStacking") == 0) {
  613. int erfec0   = atoi(argv[2]);
  614. int erlspid0 = atoi(argv[3]);
  615. int erfec    = atoi(argv[4]);
  616. int erlspid  = atoi(argv[5]);
  617. if (ErLspStacking(erfec0,erlspid0,erfec,erlspid) == 0)
  618. tcl.result("1");
  619. else     
  620. tcl.result("-1");
  621. return (TCL_OK);
  622. } else if (strcmp(argv[1], "FlowAggregation") == 0) {
  623. // <classifier> FlowAggregation <fineFEC> <finePHB>
  624. //              <coarseFEC> <coarsePHB>
  625. int fineaddr   = atoi(argv[2]);
  626. int finePHB    = atoi(argv[3]);
  627. int coarseaddr = atoi(argv[4]);
  628. int coarsePHB  = atoi(argv[5]);
  629. if (FlowAggregation(fineaddr, finePHB, coarseaddr,
  630.     coarsePHB) == 0)
  631. tcl.result("1");
  632. else     
  633. tcl.result("-1");
  634. return (TCL_OK);
  635. } else if (strcmp(argv[1], "aPathBinding") == 0) {
  636. // <classifier> aPathBinding <FEC> <PHB> 
  637. // <erFEC> <LSPid>
  638. int FEC   = atoi(argv[2]);
  639. int PHB   = atoi(argv[3]);
  640. int erFEC = atoi(argv[4]);
  641. int LSPid = atoi(argv[5]);
  642. if (aPathBinding(FEC, PHB, erFEC, LSPid) == 0)
  643. tcl.result("1");
  644. else     
  645. tcl.result("-1");
  646. return (TCL_OK);
  647. }
  648. } else if (argc == 8) {      
  649. int addr  = atoi(argv[2]);
  650. int LSPid = atoi(argv[3]);
  651. int LIBptr;
  652. if (LSPid == MPLS_DEFAULT_PHB)  {
  653. // topology-based LSP
  654. int PHB   = LSPid;
  655. int PFTnb = PFTlocate(addr,PHB,LIBptr);
  656. if (strcmp(argv[1], "LSPrelease") == 0) {
  657. if (PFTnb >= 0) {
  658. // PFT entry exist
  659. LIBupdate(LIBptr, atoi(argv[4]), 
  660.   atoi(argv[5]), atoi(argv[6]),
  661.   atoi(argv[7]));
  662. if (LIBisdeleted(LIBptr) == 0)
  663. PFTdeleteLIBptr(LIBptr);
  664. }
  665. return (TCL_OK);
  666. } else if (strcmp(argv[1], "LSPsetup") == 0) {
  667. if (PFTnb < 0) {
  668. // PFT entry not exist
  669. int ptr = LIBinsert(atoi(argv[4]),
  670.     atoi(argv[5]),
  671.     atoi(argv[6]),
  672.     atoi(argv[7]));
  673. if (ptr > -1) {
  674. PFTinsert(addr, 
  675.   MPLS_DEFAULT_PHB,
  676.   ptr);
  677. return (TCL_OK);
  678. } else
  679. return (TCL_ERROR);
  680. }
  681. // PFTnb >= 0
  682. // PFT entry already exist
  683. if (LIBptr <= -1) {
  684. int ptr = LIBinsert(atoi(argv[4]),
  685.     atoi(argv[5]),
  686.     atoi(argv[6]),
  687.     atoi(argv[7]));
  688. if (ptr > -1) {
  689. PFTupdate(PFTnb, ptr);
  690. return (TCL_OK);
  691. } else
  692. return (TCL_ERROR);
  693. }
  694. // LIBptr > -1
  695. // Check whether or not altanative path setup
  696. if (!((enable_reroute_ == 1) &&
  697.       (LIB_.Entry_[LIBptr].oIface_ > -1) && 
  698.       (reroute_option_ == MPLS_MAKENEWLSP) &&
  699.       (atoi(argv[6]) > -1) && 
  700.       (is_link_down(LIB_.Entry_[LIBptr].oIface_))
  701.       )) { 
  702. LIBupdate(LIBptr, atoi(argv[4]),
  703.   atoi(argv[5]), atoi(argv[6]),
  704.   atoi(argv[7]));
  705. return (TCL_OK);
  706. }
  707. PFT_.Entry_[PFTnb].aPATHptr_ = 
  708. LIBinsert(atoi(argv[4]), atoi(argv[5]),
  709.   atoi(argv[6]),atoi(argv[7]));
  710. for (int i=0; i < LIB_.NB_; i++) {
  711. if (LIB_.Entry_[i].oIface_!=atoi(argv[2]))
  712. continue;
  713. for (int k=0; k<PFT_.NB_; k++) {
  714. if (PFT_.Entry_[k].LIBptr_ != i)
  715. continue;
  716. PFT_.Entry_[k].aPATHptr_ = 
  717.   PFT_.Entry_[PFTnb].aPATHptr_;
  718. }
  719. }
  720. return (TCL_OK);
  721. }
  722. } else {
  723. // ER-LSP
  724. int ERBnb = ERBlocate(LSPid,addr,LIBptr);
  725. if (strcmp(argv[1], "LSPrelease") == 0) {
  726. if ( ERBnb >= 0 ) {
  727. // ERB entry exist
  728. LIBupdate(LIBptr, atoi(argv[4]),
  729.   atoi(argv[5]), atoi(argv[6]),
  730.   atoi(argv[7]));
  731. if (LIBisdeleted(LIBptr) == 0) {
  732. ERBdelete(ERBnb);
  733. PFTdeleteLIBptr(LIBptr);
  734. }
  735. }
  736. return (TCL_OK);
  737. } else if (strcmp(argv[1], "LSPsetup") == 0) {
  738. if (ERBnb < 0) {
  739. // ERB entry not exist
  740. int ptr = LIBinsert(atoi(argv[4]),
  741.     atoi(argv[5]),
  742.     atoi(argv[6]),
  743.     atoi(argv[7]));
  744. if (ptr > -1) {
  745. ERBinsert(LSPid,addr,ptr);
  746. return (TCL_OK);
  747. } else
  748. return (TCL_ERROR);
  749. } 
  750. // ERBnb >= 0
  751. // ERB entry already exist
  752. if (LIBptr > -1)
  753. LIBupdate(LIBptr, atoi(argv[4]), atoi(argv[5]),
  754.   atoi(argv[6]), atoi(argv[7]));
  755. else {
  756. int ptr = 
  757. LIBinsert(atoi(argv[4]),atoi(argv[5]),
  758.   atoi(argv[6]),atoi(argv[7]));
  759. if (ptr > -1)
  760. ERBupdate(ERBnb, ptr);
  761. else
  762. return (TCL_ERROR);
  763. }
  764. return (TCL_OK);
  765. }
  766. }
  767. }
  768.   
  769. return (AddressClassifier::command(argc, argv));
  770. }
  772. //--------------------------------------------------
  773. // PFT(Partial Forwarding Table)
  774. //--------------------------------------------------
  776. void MPLSAddressClassifier::PFTinsert(int FEC, int PHB, int LIBptr)
  777. {
  778. PFT_.Entry_[PFT_.NB_].FEC_    = FEC;
  779. PFT_.Entry_[PFT_.NB_].PHB_    = PHB;
  780. PFT_.Entry_[PFT_.NB_].LIBptr_ = LIBptr;
  781. PFT_.Entry_[PFT_.NB_].aPATHptr_  = -1;
  782. PFT_.NB_++;
  783. }
  785. void MPLSAddressClassifier::PFTdelete(int entrynb)
  786. {
  787. PFT_.Entry_[entrynb].FEC_    = -1;
  788. PFT_.Entry_[entrynb].PHB_    = -1;
  789. PFT_.Entry_[entrynb].LIBptr_ = -1;
  790. }
  792. void MPLSAddressClassifier::PFTdeleteLIBptr(int LIBptr)
  793. {
  794. for (int i = 0; i < PFT_.NB_; i++) {
  795. if (PFT_.Entry_[i].LIBptr_ != LIBptr)
  796. continue; 
  797. PFT_.Entry_[i].FEC_    = -1;
  798. PFT_.Entry_[i].PHB_    = -1;
  799. PFT_.Entry_[i].LIBptr_ = -1;
  800. }  
  801. }
  803. void MPLSAddressClassifier::PFTupdate(int entrynb, int LIBptr)
  804. {
  805. PFT_.Entry_[entrynb].LIBptr_ = LIBptr;
  806. }
  808. int MPLSAddressClassifier::PFTlocate(int FEC, int PHB, int &LIBptr)
  809. {
  810. LIBptr = -1;
  811. if (FEC < 0) 
  812. return -1;
  813. for (int i = 0; i < PFT_.NB_; i++)
  814. if ((PFT_.Entry_[i].FEC_ == FEC) && (PFT_.Entry_[i].PHB_ == PHB)) {
  815. LIBptr = PFT_.Entry_[i].LIBptr_;
  816. return i;
  817. }
  818. return -1;
  819. }
  821. int MPLSAddressClassifier::PFTlookup(int FEC, int PHB, int &oIface, 
  822.      int &oLabel, int &LIBptr)
  823. {
  824. oIface = oLabel = LIBptr = -1;
  825. if (FEC < 0) 
  826. return -1;
  827. for (int i = 0; i < PFT_.NB_; i++)
  828. if ((PFT_.Entry_[i].FEC_ == FEC) && (PFT_.Entry_[i].PHB_ == PHB))
  829. return LIBlookup(PFT_.Entry_[i].LIBptr_,
  830.  oIface, oLabel, LIBptr);
  831. return -1;
  832. }
  834. void MPLSAddressClassifier::PFTdump(const char *id)
  835. {
  836. fflush(stdout);
  837. printf("      --) ___PFT dump___ [node: %s] (--n", id);
  838. printf("---------------------------------------------n");
  839. printf("     FEC       PHB       LIBptr  AltanativePathn");
  840. for (int i = 0; i < PFT_.NB_; i++) {
  841. if (PFT_.Entry_[i].FEC_ == -1) 
  842. continue;
  843. printf("     %d    ", PFT_.Entry_[i].FEC_);
  844. printf("     %d    ", PFT_.Entry_[i].PHB_);
  845. printf("     %d    ", PFT_.Entry_[i].LIBptr_);
  846. printf("     %dn", PFT_.Entry_[i].aPATHptr_);
  847. }
  848. printf("n");
  849. }
  851. //--------------------------------------------------
  852. // ER-LSP Table
  853. //--------------------------------------------------
  855. void MPLSAddressClassifier::ERBinsert(int LSPid, int FEC, int LIBptr)
  856. {
  857. ERB_.Entry_[ERB_.NB_].LSPid_  = LSPid;
  858. ERB_.Entry_[ERB_.NB_].FEC_    = FEC;
  859. ERB_.Entry_[ERB_.NB_].LIBptr_ = LIBptr;
  860. ERB_.NB_++;
  861. }
  862.  
  863. void MPLSAddressClassifier::ERBdelete(int entrynb)
  864. {
  865. ERB_.Entry_[entrynb].FEC_    = -1;
  866. ERB_.Entry_[entrynb].LSPid_  = -1;
  867. ERB_.Entry_[entrynb].LIBptr_ = -1;
  868. }
  870. void MPLSAddressClassifier::ERBupdate(int entrynb, int LIBptr)
  871. {
  872. ERB_.Entry_[entrynb].LIBptr_ = LIBptr;
  873. }
  875. int  MPLSAddressClassifier::ERBlocate(int LSPid, int FEC, int &LIBptr)
  876. {
  877. LIBptr = -1;
  878. for (int i = 0; i < ERB_.NB_; i++)
  879. if (ERB_.Entry_[i].LSPid_ == LSPid) {
  880. LIBptr = ERB_.Entry_[i].LIBptr_;
  881. return(i);
  882. }
  883. return -1;
  884. }
  886. void MPLSAddressClassifier::ERBdump(const char *id)
  887. {
  888. fflush(stdout);
  889. printf("      --) ___ERB dump___ [node: %s] (--n", id);
  890. printf("---------------------------------------------n");
  891. printf("     FEC       LSPid      LIBptrn");
  892. for (int i = 0; i < ERB_.NB_; i++) {
  893. if (ERB_.Entry_[i].FEC_ == -1) 
  894. continue;
  895. printf("     %d    ", ERB_.Entry_[i].FEC_);
  896. printf("     %d    ", ERB_.Entry_[i].LSPid_);
  897. printf("     %dn", ERB_.Entry_[i].LIBptr_);
  898. }
  899. printf("n");
  900. }
  902. //--------------------------------------------------
  903. // LIB (Label Information Base)
  904. //--------------------------------------------------
  905. int MPLSAddressClassifier::LIBinsert(int iIface, int iLabel, 
  906.      int oIface, int oLabel)
  907. {
  908. if (LIB_.NB_ == MPLS_MaxLIBEntryNB - 1) {
  909. fprintf(stderr, 
  910. "Error in LIBinstall: higher than MaxLIBEntryNBn");
  911. return -1;
  912. }
  914. LIB_.Entry_[LIB_.NB_].iIface_ = -1;
  915. LIB_.Entry_[LIB_.NB_].iLabel_ = -1;
  916. LIB_.Entry_[LIB_.NB_].oIface_ = -1;
  917. LIB_.Entry_[LIB_.NB_].oLabel_ = -1;
  919. if (iIface < 0) iIface = -1;
  920. if (iLabel < 0) iLabel = -1;
  921. if (oIface < 0) oIface = -1;
  922. if (oLabel < 0) oLabel = -1;
  924. LIB_.Entry_[LIB_.NB_].iIface_  = iIface;
  925. LIB_.Entry_[LIB_.NB_].iLabel_  = iLabel;
  926. LIB_.Entry_[LIB_.NB_].oIface_  = oIface;
  927. LIB_.Entry_[LIB_.NB_].oLabel_  = oLabel;
  928. LIB_.Entry_[LIB_.NB_].LIBptr_  = -1;
  930. LIB_.NB_++;
  931. return(LIB_.NB_-1);
  932. }
  934. int MPLSAddressClassifier::LIBisdeleted(int entrynb)
  935. {
  936. if ((LIB_.Entry_[entrynb].iIface_ == -1) &&
  937.     (LIB_.Entry_[entrynb].iLabel_ == -1) &&
  938.     (LIB_.Entry_[entrynb].oIface_ == -1) &&
  939.     (LIB_.Entry_[entrynb].oLabel_ == -1)) {
  941. LIB_.Entry_[entrynb].LIBptr_ = -1;
  942. // delete a entry referencing self in LIB
  943. for (int i = 0; i < LIB_.NB_; i++)
  944. if ((LIB_.Entry_[i].LIBptr_ == entrynb))
  945. LIB_.Entry_[i].LIBptr_ = -1;
  946. return 0;
  947. }
  948. return -1;
  949. }
  951. void MPLSAddressClassifier::LIBupdate(int entrynb, int iIface, int iLabel, 
  952.       int oIface, int oLabel)
  953. {
  954. if (iIface != MPLS_DONTCARE)
  955. LIB_.Entry_[entrynb].iIface_ = iIface;
  956. if (iLabel != MPLS_DONTCARE)    
  957. LIB_.Entry_[entrynb].iLabel_ = iLabel;
  958. if (oIface != MPLS_DONTCARE)
  959. LIB_.Entry_[entrynb].oIface_ = oIface;
  960. if (oLabel != MPLS_DONTCARE)
  961. LIB_.Entry_[entrynb].oLabel_ = oLabel;
  962. }
  964. int MPLSAddressClassifier::LIBlookup(int entrynb, int &oIface, 
  965.       int &oLabel, int &LIBptr)
  966. {
  967. oIface = oLabel = LIBptr = -1;
  969. if (entrynb < 0)
  970. return -1;
  971. oIface = LIB_.Entry_[entrynb].oIface_;
  972. oLabel = LIB_.Entry_[entrynb].oLabel_;
  973. LIBptr = LIB_.Entry_[entrynb].LIBptr_;
  974. return 0;
  975. }
  977. int MPLSAddressClassifier::LIBlookup(int iIface, int iLabel, int &oIface, 
  978.      int &oLabel, int &LIBptr)
  979. {
  980. oIface = oLabel = LIBptr = -1;
  981. if (iLabel < 0)
  982. return -1;
  983. for (int i = 0; i < LIB_.NB_; i++)
  984. if ((LIB_.Entry_[i].iLabel_ == iLabel)) {
  985. oIface = LIB_.Entry_[i].oIface_;
  986. oLabel = LIB_.Entry_[i].oLabel_;
  987. LIBptr = LIB_.Entry_[i].LIBptr_;
  988. return 0;
  989. } 
  990. return -1;
  991. }
  993. int MPLSAddressClassifier::LIBgetIncoming(int entrynb, int &iIface, 
  994.   int &iLabel)
  995. {
  996. if (entrynb < 0)
  997. return -1;
  998. iIface = LIB_.Entry_[entrynb].iIface_;
  999. iLabel = LIB_.Entry_[entrynb].iLabel_;
  1000. return 0;
  1001. }
  1003. void MPLSAddressClassifier::LIBdump(const char *id)
  1004. {
  1005. fflush(stdout);
  1006. printf("    ___LIB dump___ [node: %s]n", id);
  1007. printf("---------------------------------------------n");
  1008. printf("       #       iIface     iLabel      oIface     oLabel    LIBptrn");
  1009. for (int i = 0; i < LIB_.NB_; i++) {
  1010. if (!LIBisdeleted(i))
  1011. continue;
  1012. printf("     %d: ", i);
  1013. printf("     %d    ", LIB_.Entry_[i].iIface_);
  1014. printf("     %d  ", LIB_.Entry_[i].iLabel_);
  1015. printf("     %d    ", LIB_.Entry_[i].oIface_);
  1016. printf("     %d    ", LIB_.Entry_[i].oLabel_);
  1017. printf("     %dn", LIB_.Entry_[i].LIBptr_);
  1018. }
  1019. printf("n");
  1020. }
  1022. //--------------------------------------------------
  1023. // MPLS applications
  1024. //--------------------------------------------------
  1026. int MPLSAddressClassifier::ErLspStacking(int erFEC0,int erLSPid0, 
  1027.  int erFEC, int erLSPid)
  1028. {
  1029. int erLIBptr0  =-1, erLIBptr  =-1;
  1031. if ((ERBlocate(erLSPid0,erFEC0,erLIBptr0) < 0) || (erLIBptr0 < 0))
  1032. return -1;
  1033. if ((ERBlocate(erLSPid,erFEC,erLIBptr) < 0) || (erLIBptr < 0))
  1034. return -1;
  1035. LIB_.Entry_[erLIBptr0].LIBptr_ = erLIBptr;
  1036. return 0;
  1037. }
  1039. int MPLSAddressClassifier::ErLspBinding(int FEC,int PHB, int erFEC, int LSPid)
  1040. {
  1041. int LIBptr=-1;
  1042. int erLIBptr=-1;
  1044. if ((ERBlocate(LSPid, erFEC, erLIBptr) < 0) || (erLIBptr < 0))
  1045. return -1;
  1047. int PFTnb = PFTlocate(FEC,PHB, LIBptr);
  1048. if ((PFTnb < 0))
  1049. PFTinsert(FEC,PHB, erLIBptr);
  1050. else {
  1051. if (LIBptr < 0)
  1052. PFTupdate(PFTnb, LIBptr);
  1053. else {  
  1054. int i = LIBptr;
  1055. while (i < 0) {
  1056. LIBptr = i;;
  1057. i = LIB_.Entry_[LIBptr].LIBptr_;
  1058. }
  1059. LIB_.Entry_[LIBptr].LIBptr_ = erLIBptr;
  1060. }
  1061. }
  1062. return 0;
  1063. }
  1065. int MPLSAddressClassifier::FlowAggregation(int fineFEC, int finePHB, 
  1066.    int coarseFEC, int coarsePHB)
  1067. {
  1068. int fLIBptr=-1;
  1069. int cLIBptr=-1;
  1071. if ((PFTlocate(coarseFEC,coarsePHB, cLIBptr) < 0) || (cLIBptr < 0))
  1072. return -1;
  1074. int PFTnb = PFTlocate(fineFEC,finePHB, fLIBptr);
  1075. if ((PFTnb < 0))
  1076. PFTinsert(fineFEC,finePHB, cLIBptr);
  1077. else {
  1078. if (fLIBptr < 0)
  1079. PFTupdate(PFTnb, cLIBptr);
  1080. else {
  1081. int i=fLIBptr;
  1082. while (i < 0) {
  1083. fLIBptr = i;;
  1084. i = LIB_.Entry_[fLIBptr].LIBptr_;
  1085. }
  1086. LIB_.Entry_[fLIBptr].LIBptr_ = cLIBptr;
  1087. }
  1088. }
  1089.         return 0;
  1090. }
  1092. int MPLSAddressClassifier::aPathBinding(int FEC, int PHB, int erFEC, int LSPid)
  1093. {
  1094. int entrynb,tmp,erLIBptr;
  1095.       
  1096. entrynb = PFTlocate(FEC,PHB,tmp);
  1097. if ((entrynb < 0) || (ERBlocate(LSPid,erFEC,erLIBptr) < 0))
  1098. return -1;
  1099. PFT_.Entry_[entrynb].aPATHptr_ = erLIBptr;
  1100. return 0;
  1101. }
  1103. int MPLSAddressClassifier::aPathLookup(int FEC,int PHB, int &oIface,
  1104.        int &oLabel, int &LIBptr)
  1105. {
  1106. oIface = oLabel = LIBptr = -1;
  1108. if (FEC < 0) 
  1109. return -1;
  1110. for (int i = 0; i < PFT_.NB_; i++)
  1111. if ((PFT_.Entry_[i].FEC_ == FEC) && 
  1112.     (PFT_.Entry_[i].PHB_ == PHB))
  1113. return LIBlookup(PFT_.Entry_[i].aPATHptr_,
  1114.  oIface, oLabel, LIBptr);
  1115. return -1;
  1116. }
  1118. void MPLSAddressClassifier::trace(char *ptype, int psize, int ilabel, 
  1119.   char *op, int oiface, int olabel, int ttl)
  1120. {
  1121. if (trace_mpls_ != 1)
  1122. return;
  1123. Tcl::instance().evalf("%s trace-packet-switching " TIME_FORMAT 
  1124.       " %d %d %s %d %s %d %d %d %d",
  1125.       name(),
  1126.       Scheduler::instance().clock(),
  1127.       PI_.srcnode_,
  1128.       PI_.dst_.addr_,
  1129.       ptype,
  1130.       ilabel,
  1131.       op,
  1132.       oiface,
  1133.       olabel,
  1134.       ttl,
  1135.       psize);
  1136. }