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

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

通讯编程

开发平台：

Visual C++

rtmodule.cc：源码内容
  1. // -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- 
  3. /*
  4.  * Copyright (C) 2000 by the University of Southern California
  5.  * $Id: rtmodule.cc,v 1.16 2005/08/25 18:58:12 johnh Exp $
  6.  *
  7.  * This program is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License,
  9.  * version 2, as published by the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License along
  17.  * with this program; if not, write to the Free Software Foundation, Inc.,
  18.  * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19.  *
  20.  *
  21.  * The copyright of this module includes the following
  22.  * linking-with-specific-other-licenses addition:
  23.  *
  24.  * In addition, as a special exception, the copyright holders of
  25.  * this module give you permission to combine (via static or
  26.  * dynamic linking) this module with free software programs or
  27.  * libraries that are released under the GNU LGPL and with code
  28.  * included in the standard release of ns-2 under the Apache 2.0
  29.  * license or under otherwise-compatible licenses with advertising
  30.  * requirements (or modified versions of such code, with unchanged
  31.  * license).  You may copy and distribute such a system following the
  32.  * terms of the GNU GPL for this module and the licenses of the
  33.  * other code concerned, provided that you include the source code of
  34.  * that other code when and as the GNU GPL requires distribution of
  35.  * source code.
  36.  *
  37.  * Note that people who make modified versions of this module
  38.  * are not obligated to grant this special exception for their
  39.  * modified versions; it is their choice whether to do so.  The GNU
  40.  * General Public License gives permission to release a modified
  41.  * version without this exception; this exception also makes it
  42.  * possible to release a modified version which carries forward this
  43.  * exception.
  44.  *
  45.  */
  47. // $Header: /cvsroot/nsnam/ns-2/routing/rtmodule.cc,v 1.16 2005/08/25 18:58:12 johnh Exp $
  50. #include "rtmodule.h"
  51. #include <assert.h>
  52. #include "node.h"
  55. static class RoutingModuleClass : public TclClass {
  56. public:
  57. RoutingModuleClass() : TclClass("RtModule") {}
  58. TclObject* create(int, const char*const*) {
  59. return (new RoutingModule);
  60. }
  61. } class_routing_module;
  63. static class BaseRoutingModuleClass : public TclClass {
  64. public:
  65. BaseRoutingModuleClass() : TclClass("RtModule/Base") {}
  66. TclObject* create(int, const char*const*) {
  67. return (new BaseRoutingModule);
  68. }
  69. } class_base_routing_module;
  71. static class McastRoutingModuleClass : public TclClass {
  72. public:
  73. McastRoutingModuleClass() : TclClass("RtModule/Mcast") {}
  74. TclObject* create(int, const char*const*) {
  75. return (new McastRoutingModule);
  76. }
  77. } class_mcast_routing_module;
  79. static class HierRoutingModuleClass : public TclClass {
  80. public:
  81. HierRoutingModuleClass() : TclClass("RtModule/Hier") {}
  82. TclObject* create(int, const char*const*) {
  83. return (new HierRoutingModule);
  84. }
  85. } class_hier_routing_module;
  88. static class ManualRoutingModuleClass : public TclClass {
  89. public:
  90. ManualRoutingModuleClass() : TclClass("RtModule/Manual") {}
  91. TclObject* create(int, const char*const*) {
  92. return (new ManualRoutingModule);
  93. }
  94. } class_manual_routing_module;
  96. static class SourceRoutingModuleClass : public TclClass {
  97. public:
  98.         SourceRoutingModuleClass() : TclClass("RtModule/Source") {}
  99.         TclObject* create(int, const char*const*) {
  100.                 return (new SourceRoutingModule);
  101.         }
  102. } class_source_routing_module;
  104. static class QSRoutingModuleClass : public TclClass {
  105. public:
  106.         QSRoutingModuleClass() : TclClass("RtModule/QS") {}
  107.         TclObject* create(int, const char*const*) {
  108.                 return (new QSRoutingModule);
  109.         }
  110. } class_qs_routing_module;
  112. static class VcRoutingModuleClass : public TclClass {
  113. public:
  114. VcRoutingModuleClass() : TclClass("RtModule/VC") {}
  115. TclObject* create(int, const char*const*) {
  116. return (new VcRoutingModule);
  117. }
  118. } class_vc_routing_module;
  121. #ifdef HAVE_STL
  122. static class PgmRoutingModuleClass : public TclClass {
  123. public:
  124.         PgmRoutingModuleClass() : TclClass("RtModule/PGM") {}
  125.         TclObject* create(int, const char*const*) {
  126.                 return (new PgmRoutingModule);
  127.         }
  128. } class_pgm_routing_module;
  129. #endif //STL
  131. // LMS
  132. static class LmsRoutingModuleClass : public TclClass {
  133. public:
  134.         LmsRoutingModuleClass() : TclClass("RtModule/LMS") {}
  135.         TclObject* create(int, const char*const*) {
  136.                 return (new LmsRoutingModule);
  137.         }
  138. } class_lms_routing_module;
  140. RoutingModule::RoutingModule() : 
  141. next_rtm_(NULL), n_(NULL), classifier_(NULL) {
  142. bind("classifier_", (TclObject**)&classifier_);
  143. }
  145. int RoutingModule::command(int argc, const char*const* argv)
  146. {
  147. Tcl& tcl = Tcl::instance();
  148. if (argc == 2) {
  149. if (strcmp(argv[1], "node") == 0) {
  150. assert(n_ != NULL);
  151. tcl.resultf("%s", n_->name());
  152. return TCL_OK;
  153. } else if (strcmp(argv[1], "module-name") == 0) {
  154. if (module_name() != NULL)
  155. tcl.resultf("%s", module_name());
  156. else 
  157. tcl.result("");
  158. return TCL_OK;
  159. }
  161. } else if (argc == 3) {
  162. if (strcmp(argv[1], "attach-node") == 0) {
  163. n_ = (Node*)TclObject::lookup(argv[2]);
  164. if (n_ == NULL) {
  165. tcl.add_errorf("Wrong object name %s",argv[2]);
  166. return TCL_ERROR;
  167. }
  168. return TCL_OK;
  169. }
  170. //if (strcmp(argv[1], "attach-classifier") == 0) {
  171. //classifier_ = (Classifier*)(TclObject::lookup(argv[2]));
  172. //if (classifier_ == NULL) {
  173. //tcl.add_errorf("Wrong object name %s",argv[2]);
  174. //return TCL_ERROR;
  175. //}
  176. //return TCL_OK;
  177. //}
  178. }
  179. return TclObject::command(argc, argv);
  180. }
  182. int BaseRoutingModule::command(int argc, const char*const* argv) {
  183. Tcl& tcl = Tcl::instance();
  184. if (argc == 3) {
  185. if (strcmp(argv[1] , "route-notify") == 0) {
  186. Node *node = (Node *)(TclObject::lookup(argv[2]));
  187. if (node == NULL) {
  188. tcl.add_errorf("Invalid node object %s", argv[2]);
  189. return TCL_ERROR;
  190. }
  191. if (node != n_) {
  192. tcl.add_errorf("Node object %s different from n_", argv[2]);
  193. return TCL_ERROR;
  194. }
  195. n_->route_notify(this);
  196. return TCL_OK;
  197. }
  198. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  199. Node *node = (Node *)(TclObject::lookup(argv[2]));
  200. if (node == NULL) {
  201. tcl.add_errorf("Invalid node object %s", argv[2]);
  202. return TCL_ERROR;
  203. }
  204. if (node != n_) {
  205. tcl.add_errorf("Node object %s different from n_", argv[2]);
  206. return TCL_ERROR;
  207. }
  208. n_->unreg_route_notify(this);
  209. return TCL_OK;
  210. }
  211. }
  212. return (RoutingModule::command(argc, argv));
  213. }
  215. int SourceRoutingModule::command(int argc, const char*const* argv) {
  216. Tcl& tcl = Tcl::instance();
  217. if (argc == 3) {
  218. if (strcmp(argv[1] , "route-notify") == 0) {
  219. Node *node = (Node *)(TclObject::lookup(argv[2]));
  220. if (node == NULL) {
  221. tcl.add_errorf("Invalid node object %s", argv[2]);
  222. return TCL_ERROR;
  223. }
  224. if (node != n_) {
  225. tcl.add_errorf("Node object %s different from n_", argv[2]);
  226. return TCL_ERROR;
  227. }
  228. n_->route_notify(this);
  229. return TCL_OK;
  230. }
  231. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  232. Node *node = (Node *)(TclObject::lookup(argv[2]));
  233. if (node == NULL) {
  234. tcl.add_errorf("Invalid node object %s", argv[2]);
  235. return TCL_ERROR;
  236. }
  237. if (node != n_) {
  238. tcl.add_errorf("Node object %s different from n_", argv[2]);
  239. return TCL_ERROR;
  240. }
  241. n_->unreg_route_notify(this);
  242. return TCL_OK;
  243. }
  244. }
  245. return (RoutingModule::command(argc, argv));
  246. }
  248. int QSRoutingModule::command(int argc, const char*const* argv) {
  249. Tcl& tcl = Tcl::instance();
  250. if (argc == 3) {
  251. if (strcmp(argv[1] , "route-notify") == 0) {
  252. Node *node = (Node *)(TclObject::lookup(argv[2]));
  253. if (node == NULL) {
  254. tcl.add_errorf("Invalid node object %s", argv[2]);
  255. return TCL_ERROR;
  256. }
  257. if (node != n_) {
  258. tcl.add_errorf("Node object %s different from n_", argv[2]);
  259. return TCL_ERROR;
  260. }
  261. n_->route_notify(this);
  262. return TCL_OK;
  263. }
  264. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  265. Node *node = (Node *)(TclObject::lookup(argv[2]));
  266. if (node == NULL) {
  267. tcl.add_errorf("Invalid node object %s", argv[2]);
  268. return TCL_ERROR;
  269. }
  270. if (node != n_) {
  271. tcl.add_errorf("Node object %s different from n_", argv[2]);
  272. return TCL_ERROR;
  273. }
  274. n_->unreg_route_notify(this);
  275. return TCL_OK;
  276. }
  277. }
  278. return (RoutingModule::command(argc, argv));
  279. }
  281. int McastRoutingModule::command(int argc, const char*const* argv) {
  282. Tcl& tcl = Tcl::instance();
  283. if (argc == 3) {
  284. if (strcmp(argv[1] , "route-notify") == 0) {
  285. Node *node = (Node *)(TclObject::lookup(argv[2]));
  286. if (node == NULL) {
  287. tcl.add_errorf("Invalid node object %s", argv[2]);
  288. return TCL_ERROR;
  289. }
  290. if (node != n_) {
  291. tcl.add_errorf("Node object %s different from n_", argv[2]);
  292. return TCL_ERROR;
  293. }
  294. n_->route_notify(this);
  295. return TCL_OK;
  296. }
  297. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  298. Node *node = (Node *)(TclObject::lookup(argv[2]));
  299. if (node == NULL) {
  300. tcl.add_errorf("Invalid node object %s", argv[2]);
  301. return TCL_ERROR;
  302. }
  303. if (node != n_) {
  304. tcl.add_errorf("Node object %s different from n_", argv[2]);
  305. return TCL_ERROR;
  306. }
  307. n_->unreg_route_notify(this);
  308. return TCL_OK;
  309. }
  310. }
  311. return (RoutingModule::command(argc, argv));
  312. }
  314. int HierRoutingModule::command(int argc, const char*const* argv) {
  315. Tcl& tcl = Tcl::instance();
  316. if (argc == 3) {
  317. //if (strcmp(argv[1], "attach-classifier") == 0) {
  318. //classifier_ = (HierClassifier*)(TclObject::lookup(argv[2]));
  319. //if (classifier_ == NULL) {
  320. //tcl.add_errorf("Wrong object name %s",argv[2]);
  321. //return TCL_ERROR;
  322. //}
  323. //return TCL_OK;
  324. //}
  325. if (strcmp(argv[1] , "route-notify") == 0) {
  326. Node *node = (Node *)(TclObject::lookup(argv[2]));
  327. if (node == NULL) {
  328. tcl.add_errorf("Invalid node object %s", argv[2]);
  329. return TCL_ERROR;
  330. }
  331. if (node != n_) {
  332. tcl.add_errorf("Node object %s different from n_", argv[2]);
  333. return TCL_ERROR;
  334. }
  335. n_->route_notify(this);
  336. return TCL_OK;
  337. }
  338. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  339. Node *node = (Node *)(TclObject::lookup(argv[2]));
  340. if (node == NULL) {
  341. tcl.add_errorf("Invalid node object %s", argv[2]);
  342. return TCL_ERROR;
  343. }
  344. if (node != n_) {
  345. tcl.add_errorf("Node object %s different from n_", argv[2]);
  346. return TCL_ERROR;
  347. }
  348. n_->unreg_route_notify(this);
  349. return TCL_OK;
  350. }
  351. }
  352. return (RoutingModule::command(argc, argv));
  353. }
  356. int ManualRoutingModule::command(int argc, const char*const* argv) {
  357. Tcl& tcl = Tcl::instance();
  358. if (argc == 3) {
  359. if (strcmp(argv[1] , "route-notify") == 0) {
  360. Node *node = (Node *)(TclObject::lookup(argv[2]));
  361. if (node == NULL) {
  362. tcl.add_errorf("Invalid node object %s", argv[2]);
  363. return TCL_ERROR;
  364. }
  365. if (node != n_) {
  366. tcl.add_errorf("Node object %s different from node_", argv[2]);
  367. return TCL_ERROR;
  368. }
  369. n_->route_notify(this);
  370. return TCL_OK;
  371. }
  372. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  373. Node *node = (Node *)(TclObject::lookup(argv[2]));
  374. if (node == NULL) {
  375. tcl.add_errorf("Invalid node object %s", argv[2]);
  376. return TCL_ERROR;
  377. }
  378. if (node != n_) {
  379. tcl.add_errorf("Node object %s different from n_", argv[2]);
  380. return TCL_ERROR;
  381. }
  382. n_->unreg_route_notify(this);
  383. return TCL_OK;
  384. }
  385. }
  386. return (RoutingModule::command(argc, argv));
  387. }
  389. void VcRoutingModule::add_route(char *, NsObject *) { }
  392. int VcRoutingModule::command(int argc, const char*const* argv) {
  393. Tcl& tcl = Tcl::instance();
  394. if (argc == 3) {
  395. if (strcmp(argv[1] , "route-notify") == 0) {
  396. Node *node = (Node *)(TclObject::lookup(argv[2]));
  397. if (node == NULL) {
  398. tcl.add_errorf("Invalid node object %s", argv[2]);
  399. return TCL_ERROR;
  400. }
  401. if (node != n_) {
  402. tcl.add_errorf("Node object %s different from n_", argv[2]);
  403. return TCL_ERROR;
  404. }
  405. n_->route_notify(this);
  406. return TCL_OK;
  407. }
  408. if (strcmp(argv[1] , "unreg-route-notify") == 0) {
  409. Node *node = (Node *)(TclObject::lookup(argv[2]));
  410. if (node == NULL) {
  411. tcl.add_errorf("Invalid node object %s", argv[2]);
  412. return TCL_ERROR;
  413. }
  414. if (node != n_) {
  415. tcl.add_errorf("Node object %s different from n_", argv[2]);
  416. return TCL_ERROR;
  417. }
  418. n_->unreg_route_notify(this);
  419. return TCL_OK;
  420. }
  421. }
  422. return (RoutingModule::command(argc, argv));
  423. }
  425. void RoutingModule::route_notify(RoutingModule *rtm) {
  426. if (next_rtm_ != NULL)
  427. next_rtm_->route_notify(rtm);
  428. else
  429. next_rtm_ = rtm;
  430. }
  432. void RoutingModule::unreg_route_notify(RoutingModule *rtm) {
  433. if (next_rtm_) {
  434. if (next_rtm_ == rtm) {
  435. //RoutingModule *tmp = next_rtm_;
  436. next_rtm_ = next_rtm_->next_rtm_;
  437. //free (tmp);
  438. }
  439. else {
  440. next_rtm_->unreg_route_notify(rtm);
  441. }
  442. }
  443. }
  445. void RoutingModule::add_route(char *dst, NsObject *target) 
  446. {
  447. if (classifier_) 
  448. classifier_->do_install(dst,target); 
  449. if (next_rtm_ != NULL)
  450. next_rtm_->add_route(dst, target); 
  451. }
  453. void RoutingModule::delete_route(char *dst, NsObject *nullagent)
  454. {
  455. if (classifier_) 
  456. classifier_->do_install(dst, nullagent); 
  457. if (next_rtm_)
  458. next_rtm_->add_route(dst, nullagent); 
  459. }
  461. void RoutingModule::set_table_size(int nn)
  462. {
  463. if (classifier_)
  464. classifier_->set_table_size(nn);
  465. if (next_rtm_)
  466. next_rtm_->set_table_size(nn);
  467. }
  469. void RoutingModule::set_table_size(int level, int size)
  470. {
  471. if (classifier_)
  472. classifier_->set_table_size(level, size);
  473. if (next_rtm_)
  474. next_rtm_->set_table_size(level, size);
  475. }
  477. //  void BaseRoutingModule::add_route(char *dst, NsObject *target) {
  478. //   if (classifier_) 
  479. //   ((DestHashClassifier *)classifier_)->do_install(dst, target);
  480. //   if (next_rtm_ != NULL)
  481. //   next_rtm_->add_route(dst, target); 
  482. //  }
  484. //  void McastRoutingModule::add_route(char *dst, NsObject *target) {
  485. //   if (classifier_) 
  486. //   ((DestHashClassifier *)classifier_)->do_install(dst, target);
  487. //   if (next_rtm_ != NULL)
  488. //   next_rtm_->add_route(dst, target); 
  489. //  }
  491. //  void HierRoutingModule::add_route(char *dst, NsObject *target) {
  492. //   if (classifier_) 
  493. //   ((HierClassifier *)classifier_)->do_install(dst, target);
  494. //   if (next_rtm_ != NULL)
  495. //   next_rtm_->add_route(dst, target); 
  496. //  }
  498. void ManualRoutingModule::add_route(char *dst, NsObject *target) {
  499. int slot = classifier_->install_next(target);
  500. if (strcmp(dst, "default") == 0) {
  501. classifier_->set_default(slot);
  502. } else {
  503. int encoded_dst_address = 
  504. (atoi(dst)) << (AddrParamsClass::instance().node_shift(1));
  505. if (0 > (classifier_->do_set_hash(0, encoded_dst_address, 0, slot))) {
  506. fprintf(stderr, "HashClassifier::set_hash() return value less than 0n"); }
  507. }
  508. if (next_rtm_ != NULL)
  509. next_rtm_->add_route(dst, target); 
  510. }