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

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

通讯编程

开发平台：

Visual C++

errmodel.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Daedalus Research
  17.  * Group at the University of California Berkeley.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  *
  34.  * Contributed by the Daedalus Research Group, UC Berkeley 
  35.  * (http://daedalus.cs.berkeley.edu)
  36.  *
  37.  * Multi-state error model patches contributed by Jianping Pan 
  38.  * (jpan@bbcr.uwaterloo.ca).
  39.  *
  40.  * @(#) $Header: /cvsroot/nsnam/ns-2/queue/errmodel.cc,v 1.83 2006/03/01 19:28:04 padmah Exp $ (UCB)
  41.  */
  43. #ifndef lint
  44. static const char rcsid[] =
  45.     "@(#) $Header: /cvsroot/nsnam/ns-2/queue/errmodel.cc,v 1.83 2006/03/01 19:28:04 padmah Exp $ (UCB)";
  46. #endif
  48. #include "config.h"
  49. #include <stdio.h>
  50. #include <ctype.h>
  51. #include "packet.h"
  52. #include "flags.h"
  53. #include "mcast_ctrl.h"
  54. #include "errmodel.h"
  55. #include "srm-headers.h" // to get the hdr_srm structure
  56. #include "classifier.h"
  58. static class ErrorModelClass : public TclClass {
  59. public:
  60. ErrorModelClass() : TclClass("ErrorModel") {}
  61. TclObject* create(int, const char*const*) {
  62. return (new ErrorModel);
  63. }
  64. } class_errormodel;
  66. static class TwoStateErrorModelClass : public TclClass {
  67. public:
  68. TwoStateErrorModelClass() : TclClass("ErrorModel/TwoState") {}
  69. TclObject* create(int, const char*const*) {
  70. return (new TwoStateErrorModel);
  71. }
  72. } class_errormodel_twostate;
  74. static class ComplexTwoStateMarkovModelClass : public TclClass {
  75. public:
  76.   ComplexTwoStateMarkovModelClass() : TclClass("ErrorModel/ComplexTwoStateMarkov") {}
  77.   TclObject* create(int, const char*const*) {
  78.   return (new ComplexTwoStateErrorModel);
  79.   }
  80. } class_errormodel_complextwostatemarkov;
  83. static class MultiStateErrorModelClass : public TclClass {
  84. public:
  85. MultiStateErrorModelClass() : TclClass("ErrorModel/MultiState") {}
  86. TclObject* create(int, const char*const*) {
  87. return (new MultiStateErrorModel);
  88. }
  89. } class_errormodel_multistate;
  91. static class TraceErrorModelClass : public TclClass {
  92. public:
  93. TraceErrorModelClass() : TclClass("ErrorModel/Trace") {}
  94. TclObject* create(int, const char*const*) {
  95. return (new TraceErrorModel);
  96. }
  97. } class_traceerrormodel;
  99. static char* eu_names[] = { EU_NAMES };
  101. inline double comb(int n, int k) {
  102. int i;
  103. double sum = 1.0;
  105. for(i = 0; i < k; i++) 
  106. sum *= (n - i)/(i + 1);
  107. return sum;
  108. }
  111. ErrorModel::ErrorModel() : et_(0), firstTime_(1), unit_(EU_PKT), ranvar_(0), FECstrength_(1)
  112. {
  113. bind("enable_", &enable_);
  114. bind("rate_", &rate_);
  115. bind("delay_", &delay_);
  116. bind_bw("bandwidth_", &bandwidth_); // required for EU_TIME
  117. bind_bool("markecn_", &markecn_);
  118. bind_bool("delay_pkt_", &delay_pkt_);
  120. }
  122. int ErrorModel::command(int argc, const char*const* argv)
  123. {
  124. Tcl& tcl = Tcl::instance();
  125. //ErrorModel *em;
  126. if (argc == 3) {
  127. if (strcmp(argv[1], "unit") == 0) {
  128. unit_ = STR2EU(argv[2]);
  129. return (TCL_OK);
  130. } 
  131. if (strcmp(argv[1], "ranvar") == 0) {
  132. ranvar_ = (RandomVariable*) TclObject::lookup(argv[2]);
  133. return (TCL_OK);
  134. }
  135. if (strcmp(argv[1], "FECstrength") == 0) {
  136. FECstrength_ = atoi(argv[2]);
  137. return (TCL_OK);
  138. }
  139. if (strcmp(argv[1], "datapktsize") == 0) {
  140. datapktsize_ = atoi(argv[2]);
  141. return (TCL_OK);
  142. }
  143. if (strcmp(argv[1], "cntrlpktsize") == 0) {
  144. cntrlpktsize_ = atoi(argv[2]);
  145. return (TCL_OK);
  146. }
  147. if (strcmp(argv[1], "eventtrace") == 0) {
  148. et_ = (EventTrace *)TclObject::lookup(argv[2]);
  149. return (TCL_OK);
  150. }
  151. } else if (argc == 2) {
  152. if (strcmp(argv[1], "unit") == 0) {
  153. tcl.resultf("%s", eu_names[unit_]);
  154. return (TCL_OK);
  155. }
  156. if (strcmp(argv[1], "ranvar") == 0) {
  157. tcl.resultf("%s", ranvar_->name());
  158. return (TCL_OK);
  159. } 
  160. if (strcmp(argv[1], "FECstrength") == 0) {
  161. tcl.resultf("%d", FECstrength_);
  162. return (TCL_OK);
  163. } 
  164. } 
  165. return Connector::command(argc, argv);
  166. }
  168. void ErrorModel::reset()
  169. {
  170. firstTime_ = 1;
  171. }
  173. void ErrorModel::recv(Packet* p, Handler* h)
  174. {
  175. // 1.  Determine the error by calling corrupt(p)
  176. // 2.  Set the packet's error flag if it is corrupted
  177. // 3.  If there is no error,  no drop_ target or markecn is true,
  178. // let pkt continue, otherwise hand the corrupted packet to drop_
  180. hdr_cmn* ch = hdr_cmn::access(p);
  181. int error = corrupt(p);
  183. // XXX When we do ECN, the packet is marked but NOT dropped.
  184. // So we don't resume handler here. 
  185. if (!markecn_ && !delay_pkt_ && (h && ((error && drop_) || !target_))) {
  186. // if we drop or there is no target_, then resume handler
  187. double delay = Random::uniform(8.0 * ch->size() / bandwidth_);
  188. if (intr_.uid_ <= 0 ) 
  189. // schedule only if nothing scheduled already
  190. Scheduler::instance().schedule(h, &intr_, delay);
  191. } 
  192. if (error) {
  193. ch->error() |= error;
  195. if (markecn_) {
  196. hdr_flags* hf = hdr_flags::access(p);
  197. hf->ce() = 1;
  198. } else if (delay_pkt_) {
  199. // Delay the packet.
  200. Scheduler::instance().schedule(target_, p, delay_);
  201. return;
  202. } else if (drop_) {
  203. drop_->recv(p);
  204. return;
  205. }
  206. }
  208. if (target_) {
  209.         target_->recv(p, h);
  210. }
  211. }
  213. int ErrorModel::corrupt(Packet* p)
  214. {
  215. hdr_cmn* ch;
  216. // a temp hack
  218. ch = HDR_CMN(p);
  220. if (enable_ == 0)
  221. return 0;
  222. switch (unit_) {
  223. case EU_TIME:
  224. return (CorruptTime(p) != 0);
  225. case EU_BYTE:
  226. return (CorruptByte(p) != 0);
  227. case EU_BIT:
  228. ch = hdr_cmn::access(p);
  229. ch->errbitcnt() = CorruptBit(p);
  230. return (ch->errbitcnt() != 0);
  231. default:
  232. return (CorruptPkt(p) != 0);
  233. }
  234. return 0;
  235. }
  237. double ErrorModel::PktLength(Packet* p)
  238. {
  239. //double now;
  240. if (unit_ == EU_PKT)
  241. return 1;
  242. int byte = hdr_cmn::access(p)->size();
  243. if (unit_ == EU_BYTE)
  244. return byte;
  245. if (unit_ == EU_BIT)
  246. return 8.0 * byte;
  247. return 8.0 * byte / bandwidth_;
  248. }
  250. double * ErrorModel::ComputeBitErrProb(int size) 
  251. {
  252. double *dptr;
  253. int i;
  255.         dptr = (double *)calloc((FECstrength_ + 2), sizeof(double));
  257.         for (i = 0; i < (FECstrength_ + 1) ; i++) 
  258. dptr[i] = comb(size, i) * pow(rate_, (double)i) * pow(1.0 - rate_, (double)(size - i));
  260. // Cumulative probability
  261. for (i = 0; i < FECstrength_ ; i++) 
  262. dptr[i + 1] += dptr[i];
  264. dptr[FECstrength_ + 1] = 1.0;
  266. /* printf("Size = %dn", size);
  267. for (i = 0; i <(FECstrength_ + 2); i++)
  268. printf("Ptr[%d] = %gn", i, dptr[i]); */
  270. return dptr;
  272. }
  274. int ErrorModel::CorruptPkt(Packet*) 
  275. {
  276. // if no random var is specified, assume uniform random variable
  277. double u = ranvar_ ? ranvar_->value() : Random::uniform();
  278. return (u < rate_);
  279. }
  281. int ErrorModel::CorruptByte(Packet* p)
  282. {
  283. // compute pkt error rate, assume uniformly distributed byte error
  284. double per = 1 - pow(1.0 - rate_, PktLength(p));
  285. double u = ranvar_ ? ranvar_->value() : Random::uniform();
  286. return (u < per);
  287. }
  289. int ErrorModel::CorruptBit(Packet* p)
  290. {
  291. double u, *dptr;
  292. int i;
  294. if (firstTime_ && FECstrength_) {
  295. // precompute the probabilies for each bit-error cnts
  296. cntrlprb_ = ComputeBitErrProb(cntrlpktsize_);
  297. dataprb_ = ComputeBitErrProb(datapktsize_);
  299. firstTime_ = 0;
  300. }
  302. u = ranvar_ ? ranvar_->value() : Random::uniform();
  303. dptr = (hdr_cmn::access(p)->size() >= datapktsize_) ? dataprb_ : cntrlprb_;
  304.         for (i = 0; i < (FECstrength_ + 2); i++)
  305. if (dptr[i] > u) break;
  306. return(i);
  307. }
  309. int ErrorModel::CorruptTime(Packet *)
  310. {
  311. fprintf(stderr, "Warning:  uniform rate error cannot be time-basedn");
  312. return 0;
  313. }
  315. #if 0
  316. /*
  317.  * Decide whether or not to corrupt this packet, for a continuous 
  318.  * time-based error model.  The main parameter used is errLength,
  319.  * which is the time to the next error, from the last time an error 
  320.  * occured on  the channel.  It is dependent on the random variable 
  321.  * being used  internally.
  322.  * rate_ is the user-specified mean
  323.  */
  324. int ErrorModel::CorruptTime(Packet *p)
  325. {
  326. /* 
  327.  * First get MAC header.  It has the transmission time (txtime)
  328.  * of the packet in one of it's fields.  Then, get the time
  329.  * interval [t-txtime, t], where t is the current time.  The
  330.  * goal is to figure out whether the channel would have
  331.  * corrupted the packet during that interval. 
  332.  */
  333. Scheduler &s = Scheduler::instance();
  334. double now = s.clock(), rv;
  335. int numerrs = 0;
  336. double start = now - hdr_mac::access(p)->txtime();
  338. while (remainLen_ < start) {
  339. rv = ranvar_ ? ranvar_->value() : Random::uniform(rate_);
  340. remainLen_ += rv;
  341. }
  343. while (remainLen_ < now) { /* corrupt the packet */
  344. numerrs++;
  345. rv = ranvar_ ? ranvar_->value() : Random::uniform(rate_);
  346. remainLen_ += rv;
  347. }
  348. return numerrs;
  349. }
  350. #endif
  352. void ErrorModel::trace_event(char *eventtype)
  353. {
  354. if (et_ == NULL) return;
  355. char *wrk = et_->buffer();
  356. char *nwrk = et_->nbuffer();
  357. if (wrk != 0)
  358. sprintf(wrk,
  359. "E "TIME_FORMAT" ErrModelTimer %p %s",
  360. et_->round(Scheduler::instance().clock()),   // time
  361. this,
  362. eventtype                    // event type
  363. );
  365. if (nwrk != 0)
  366. sprintf(nwrk,
  367. "E -t "TIME_FORMAT" ErrModelTimer %p %s",
  368. et_->round(Scheduler::instance().clock()),   // time
  369. this,
  370. eventtype                    // event type
  371. );
  372. et_->trace();
  373. }
  377. /*
  378.  * Two-State:  error-free and error
  379.  */
  380. TwoStateErrorModel::TwoStateErrorModel() : remainLen_(0), twoStateTimer_(NULL)
  381. {
  382. ranvar_[0] = ranvar_[1] = 0;
  383. }
  385. int TwoStateErrorModel::command(int argc, const char*const* argv)
  386. {
  387. Tcl& tcl = Tcl::instance();
  388. if (strcmp(argv[1], "ranvar") == 0) {
  389. int i = atoi(argv[2]);
  390. if (i < 0 || i > 1) {
  391. tcl.resultf("%s does not has ranvar_[%d]", name_, i);
  392. return (TCL_ERROR);
  393. }
  394. if (argc == 3) {
  395. tcl.resultf("%s", ranvar_[i]->name());
  396. return (TCL_OK);
  397. }
  398. if (argc == 4) {
  399. ranvar_[i] = (RandomVariable*)TclObject::lookup(argv[3]);
  400. if (ranvar_[0] != 0 && ranvar_[1] != 0)
  401. checkUnit();
  402. return (TCL_OK);
  403. } 
  404. }
  405. return ErrorModel::command(argc, argv);
  406. }
  408. int TwoStateErrorModel::corruptPkt(Packet* p)
  409. {
  410. #define ZERO 0.00000
  411. int error;
  412. if (firstTime_) {
  413. firstTime_ = 0;
  414. state_ = 0;
  415. remainLen_ = ranvar_[state_]->value();
  416. }
  418. // if remainLen_ is outside the range of 0, then error = state_
  419. error = state_ && (remainLen_ > ZERO);
  420. remainLen_ -= PktLength(p);
  422. // state transition until remainLen_ > 0 to covers the packet length
  423. while (remainLen_ <= ZERO) {
  424. state_ ^= 1; // state transition: 0 <-> 1
  425. remainLen_ += ranvar_[state_]->value();
  426. error |= state_;
  427. }
  428. return error;
  429. }
  431. void TwoStateErrorModel::checkUnit() 
  432. {
  433. if (unit_ == EU_TIME) {
  434. // setup timer for keeping states in time
  435. twoStateTimer_ = new TwoStateErrModelTimer(this, &TwoStateErrorModel::transitionState);
  436. transitionState();
  437. }
  439. }
  441. void TwoStateErrorModel::transitionState()
  442. {
  443. char buf[SMALL_LEN];
  445. if (firstTime_) {
  446. firstTime_ = 0;
  447. state_ = 0;
  448. remainLen_ = ranvar_[state_]->value();
  449. twoStateTimer_->sched(remainLen_);
  450. sprintf (buf,"STATE %d, DURATION %f",state_,remainLen_);
  451. trace_event(buf);
  452. return;
  453. }
  454. state_ ^= 1;
  455. remainLen_ = ranvar_[state_]->value();
  456. if (state_ == 1 && remainLen_ > 120)
  457. remainLen_ = 120;
  459. twoStateTimer_->resched(remainLen_);
  460. sprintf (buf,"STATE %d, DURATION %f",state_,remainLen_);
  461. trace_event(buf);
  463. }
  467. int TwoStateErrorModel::corrupt(Packet* p)
  468. {
  469. if (unit_ == EU_TIME)
  470. return corruptTime(p);
  471. else
  472. return corruptPkt(p);
  473. }
  475. int TwoStateErrorModel::corruptTime(Packet* p)
  476. {
  477. int error = 0;
  478. if (state_ == 1)
  479. error = 1;
  480. return error;
  482. }
  484. ComplexTwoStateErrorModel::ComplexTwoStateErrorModel() 
  485. {
  486. em_[0] = new TwoStateErrorModel();
  487. em_[1] = new TwoStateErrorModel();
  488. }
  490. ComplexTwoStateErrorModel::~ComplexTwoStateErrorModel()
  491. {
  492. delete em_[0];
  493. delete em_[1];
  494. }
  496. int ComplexTwoStateErrorModel::command(int argc, const char*const* argv)
  497. {
  498. Tcl& tcl = Tcl::instance();
  499. if (argc == 3) {
  500. if (strcmp(argv[1], "unit") == 0) {
  501. unit_ = STR2EU(argv[2]);
  502. em_[0]->setunit(unit_); 
  503. em_[1]->setunit(unit_);
  504. return TCL_OK;
  505. }
  506. if (strcmp(argv[1], "eventtrace") == 0) {
  507. EventTrace* et = (EventTrace *)TclObject::lookup(argv[2]);
  508. em_[0]->et_ = et;
  509. em_[1]->et_ = et;
  510. return (TCL_OK);
  511. }
  512. }
  513. else if (argc == 5) {
  514. if (strcmp(argv[1], "ranvar") == 0) {
  515. int i = atoi(argv[2]);
  516. int j = atoi(argv[3]);
  517. if (i < 0 || i > 1) {
  518. tcl.add_errorf("%s does not has em_[%d]", name_, i);
  519. return (TCL_ERROR);
  520. }
  521. if (j < 0 || j > 1) {
  522. tcl.add_errorf("%s does not has ranvar_[%d]", name_, i);
  523. return (TCL_ERROR);
  524. }
  526. em_[i]->ranvar_[j] = (RandomVariable*)TclObject::lookup(argv[4]);
  527. if (em_[i]->ranvar_[0] != 0 && em_[i]->ranvar_[1] != 0)
  528. em_[i]->checkUnit();
  529. return (TCL_OK);
  530. }
  532. }
  533. return ErrorModel::command(argc, argv);
  534. }
  537. int ComplexTwoStateErrorModel::corruptTime(Packet* p)
  538. {
  539. int error = 0;
  540. if (em_[0]->state_ == 1 && em_[1]->state_ == 1) 
  541. error = 1;
  542. return error;
  543. }
  545. int ComplexTwoStateErrorModel::corruptPkt(Packet* p)
  546. {
  547. fprintf(stderr, "Error model defined in time; not in packetsn");
  548. return -1;
  550. }
  554. static char * st_names[]={ST_NAMES};
  556. /*
  557. // MultiState ErrorModel:
  558. //   corrupt(pkt) invoke Tcl method "corrupt" to do state transition
  559. // Tcl corrupt either:
  560. //    - assign em_, the error-model to be use
  561. //    - return the status of the packet
  562. // If em_ is assigned, then invoke em_->corrupt(p)
  563. */
  565. MultiStateErrorModel::MultiStateErrorModel() : prevTime_(0.0), em_(0)
  566. {
  567. bind("sttype_", &sttype_);
  568. bind("texpired_", &texpired_);
  569. bind("curperiod_", &curperiod_);
  570. }
  572. int MultiStateErrorModel::command(int argc, const char*const* argv)
  573. {
  575. Tcl& tcl = Tcl::instance();
  577. if (argc == 3) {
  578. if (strcmp(argv[1], "error-model") == 0) {
  579. em_ = (ErrorModel*) TclObject::lookup(argv[2]);
  580. return TCL_OK;
  581. }
  582. if (strcmp(argv[1], "sttype") == 0) {
  583. sttype_ = STR2ST(argv[2]);
  584. return TCL_OK;
  585. }
  586. } else if (argc == 2) {
  587. if (strcmp(argv[1], "sttype") == 0) {
  588. tcl.resultf("%s", st_names[sttype_]);
  589. return TCL_OK;
  590. }
  591. if (strcmp(argv[1], "error-model") == 0) {
  592. tcl.resultf("%s", (ErrorModel*) em_->name());
  593. return TCL_OK;
  594. }
  595. }
  596. return ErrorModel::command(argc, argv);
  597. }
  599. int MultiStateErrorModel::corrupt(Packet* p)
  600. {
  601. int retval;
  602. double now;
  603. // static double prevTime_ = 0.0;
  604. Scheduler & s = Scheduler::instance();
  606. now = s.clock();
  608. if (sttype_ == ST_TIME)
  609. if ((now - prevTime_) >= curperiod_)
  610. texpired_ = 1;
  612. Tcl& tcl = Tcl::instance();
  613. tcl.evalf("%s corrupt", name());
  615. retval = em_ ? em_->corrupt(p) : atoi(tcl.result());
  617. if (firstTime_) {
  618. firstTime_ = 0;
  619. prevTime_ = s.clock();
  620. texpired_ = 0;
  621. }
  623. return (retval);
  625. }
  628. TraceErrorModel::TraceErrorModel() : loss_(0), good_(123456789)
  629. {
  630. bind("good_", &good_);
  631. bind("loss_", &loss_);
  632. }
  634. /* opening and reading the trace file/info is done in OTcl */
  635. int TraceErrorModel::corrupt(Packet* p)
  636. {
  637. Tcl& tcl = Tcl::instance();
  638. if (! match(p))
  639. return 0;
  640. if ((good_ <= 0) && (loss_ <= 0)) {
  641. tcl.evalf("%s read",name());
  642. if (good_ < 0)
  643. good_ = 123456789;
  644. }
  645. if (good_-- > 0)
  646. return 0;
  647. return (loss_-- > 0);
  648. }
  650. int TraceErrorModel::match(Packet*)
  651. {
  652. return 1;
  653. }
  656. /*
  657.  * Periodic ErrorModel
  658.  */
  659. static class PeriodicErrorModelClass : public TclClass {
  660. public:
  661. PeriodicErrorModelClass() : TclClass("ErrorModel/Periodic") {}
  662. TclObject* create(int, const char*const*) {
  663. return (new PeriodicErrorModel);
  664. }
  665. } class_periodic_error_model;
  667. PeriodicErrorModel::PeriodicErrorModel() : cnt_(0), last_time_(0.0), first_time_(-1.0)
  668. {
  669. bind("period_", &period_);
  670. bind("offset_", &offset_);
  671. bind("burstlen_", &burstlen_);
  672. bind("default_drop_", &default_drop_);
  673. }
  675. int PeriodicErrorModel::corrupt(Packet* p)
  676. {
  677. hdr_cmn *ch = hdr_cmn::access(p);
  678. double now = Scheduler::instance().clock();
  680. if (unit_ == EU_TIME) {
  681. if (first_time_ < 0.0) {
  682. if (now >= offset_) {
  683. first_time_ = last_time_ = now;
  684. return 1;
  685. }
  686. } else {
  687. if ((now - last_time_) > period_) {
  688. last_time_ = now;
  689. return 1;
  690. }
  691. if ((now - last_time_) < burstlen_) {
  692. return 1;
  693. }
  694. }
  695. return 0;
  696. }
  697. cnt_ += (unit_ == EU_PKT) ? 1 : ch->size();
  698. if (default_drop_) {
  699. if (int(first_time_) < 0) {
  700. if (cnt_ >= int(offset_)) {
  701. last_time_ = first_time_ = 1.0;
  702. cnt_ = 0;
  703. return 0;
  704. }
  705. return 0;
  706. } else {
  707. if (cnt_ >= int(period_)) {
  708. cnt_ = 0;
  709. return 0;
  710. }
  711. }
  712. return 1;
  713. } else {
  714. if (int(first_time_) < 0) {
  715. if (cnt_ >= int(offset_)) {
  716. last_time_ = first_time_ = 1.0;
  717. cnt_ = 0;
  718. return 1;
  719. }
  720. return 0;
  721. } else {
  722. if (cnt_ >= int(period_)) {
  723. cnt_ = 0;
  724. return 1;
  725. }
  726. if (cnt_ < burstlen_)
  727. return 1;
  728. }
  729. return 0;
  730. }
  731. }
  733. /*
  734.  * List ErrorModel: specify a list of packets/bytes to drop
  735.  * can be specified in any order
  736.  */
  737. static class ListErrorModelClass : public TclClass {
  738. public:
  739. ListErrorModelClass() : TclClass("ErrorModel/List") {}
  740. TclObject* create(int, const char*const*) {
  741. return (new ListErrorModel);
  742. }
  743. } class_list_error_model;
  745. int ListErrorModel::corrupt(Packet* p)
  746. {
  747. /* assumes droplist_ is sorted */
  748. int rval = 0; // no drop
  750. if (unit_ == EU_TIME) {
  751. fprintf(stderr,
  752. "ListErrorModel: error, EU_TIME not supportedn");
  753. return 0;
  754. }
  756. if (droplist_ == NULL || dropcnt_ == 0) {
  757. fprintf(stderr, "warning: ListErrorModel: null drop listn");
  758. return 0;
  759. }
  761. if (unit_ == EU_PKT) {
  762. //printf("TEST: cur_:%d, dropcnt_:%d, droplist_[cur_]:%d, cnt_:%dn",
  763. //cur_, dropcnt_, droplist_[cur_], cnt_);
  764. if ((cur_ < dropcnt_) && droplist_[cur_] == cnt_) {
  765. rval = 1;
  766. cur_++;
  767. }
  768. cnt_++;
  770. } else if (unit_ == EU_BYTE) {
  771. int sz = hdr_cmn::access(p)->size();
  772. if ((cur_ < dropcnt_) && (cnt_ + sz) >= droplist_[cur_]) {
  773. rval = 1;
  774. cur_++;
  775. }
  776. cnt_ += sz;
  777. }
  779. return (rval);
  780. }
  782. int
  783. ListErrorModel::command(int argc, const char*const* argv)
  784. {
  785. /*
  786.  * works for variable args:
  787.  * $lem droplist "1 3 4 5"
  788.  * and
  789.  * $lem droplist 1 3 4 5
  790.  */
  791. Tcl& tcl = Tcl::instance();
  792. if (strcmp(argv[1], "droplist") == 0) {
  793. int cnt;
  794. if ((cnt = parse_droplist(argc-2, argv + 2)) < 0)
  795. return (TCL_ERROR);
  796. tcl.resultf("%u", cnt);
  797. return(TCL_OK);
  798. }
  799. return (ErrorModel::command(argc, argv));
  800. }
  802. int
  803. ListErrorModel::intcomp(const void *p1, const void *p2)
  804. {
  805. int a = *((int*) p1);
  806. int b = *((int*) p2);
  807. return (a - b);
  808. }
  810. /*
  811.  * nextval: find the next value in the string
  812.  *
  813.  * skip white space, update pointer to first non-white-space
  814.  * character.  Return the number of characters in the next
  815.  * token.
  816.  */
  817. int
  818. ListErrorModel::nextval(const char*& p)
  819. {
  820. while (*p && isspace(*p))
  821. ++p;
  823. if (!*p) {
  824. /* end of string */
  825. return (0);
  826. }
  827. const char *q = p;
  828. while (*q && !isspace(*q))
  829. ++q;
  830. return (q-p);
  831. }
  833. int
  834. ListErrorModel::parse_droplist(int argc, const char *const* argv)
  835. {
  837. int cnt = 0; // counter for argc list
  838. int spaces = 0; // counts # of spaces in an argv entry
  839. int total = 0; // total entries in the drop list
  840. int n; // # of chars in the next drop number
  841. const char *p; // ptr into current string
  843. /*
  844.  * loop over argc list:  figure out how many numbers
  845.  * have been specified
  846.  */
  847. while (cnt < argc) {
  848. p = argv[cnt];
  849. spaces = 0;
  850. while ((n = nextval(p))) {
  851. if (!isdigit(*p)) {
  852. /* problem... */
  853. fprintf(stderr, "ListErrorModel(%s): parse_droplist: unknown drop specifier starting at >>>%sn",
  854. name(), p);
  855. return (-1);
  856. }
  857. ++spaces;
  858. p += n;
  859. }
  860. total += spaces;
  861. cnt++;
  862. }
  864. /*
  865.  * parse the numbers, put them in an array (droplist_)
  866.  * set dropcnt_ to the total # of drops.  Also, free any
  867.  * previous drop list.
  868.  */
  870. if ((total == 0) || (dropcnt_ > 0 && droplist_ != NULL)) {
  871. delete[] droplist_;
  872. droplist_ = NULL;
  873. }
  875. if ((dropcnt_ = total) == 0)
  876. return (0);
  878. droplist_ = new int[dropcnt_];
  879. if (droplist_ == NULL) {
  880. fprintf(stderr,
  881. "ListErrorModel(%s): no memory for drop list!n",
  882. name());
  883. return (-1);
  884. }
  886. int idx = 0;
  887. cnt = 0;
  888. while (cnt < argc) {
  889. p = argv[cnt];
  890. while ((n = nextval(p))) {
  891. /*
  892.  * this depends on atoi(s) returning the
  893.  * value of the first number in s
  894.  */
  895. droplist_[idx++] = atoi(p);
  896. p += n;
  897. }
  898. cnt++;
  899. }
  900. qsort(droplist_, dropcnt_, sizeof(int), intcomp);
  902. /*
  903.  * sanity check the array, looking for (wrong) dups
  904.  */
  905. cnt = 0;
  906. while (cnt < (dropcnt_ - 1)) {
  907. if (droplist_[cnt] == droplist_[cnt+1]) {
  908. fprintf(stderr,
  909. "ListErrorModel: error: dup %d in listn",
  910. droplist_[cnt]);
  911. total = -1; /* error */
  912. }
  913. ++cnt;
  914. }
  916. if (total < 0) {
  917. if (droplist_)
  918. delete[] droplist_;
  919. dropcnt_ = 0;
  920. droplist_ = NULL;
  921. return (-1);
  922. }
  924. #ifdef notdef
  925. printf("sorted list:n");
  926. {
  927. register i;
  928. for (i =0; i < dropcnt_; i++) {
  929. printf("list[%d] = %dn", i, droplist_[i]);
  930. }
  931. }
  932. #endif
  933. return dropcnt_;
  934. }
  936. /***** ***/
  938. static class SelectErrorModelClass : public TclClass {
  939. public:
  940. SelectErrorModelClass() : TclClass("SelectErrorModel") {}
  941. TclObject* create(int, const char*const*) {
  942. return (new SelectErrorModel);
  943. }
  944. } class_selecterrormodel;
  946. SelectErrorModel::SelectErrorModel()
  947. {
  948. bind("pkt_type_", (int*)&pkt_type_);
  949. bind("drop_cycle_", &drop_cycle_);
  950. bind("drop_offset_", &drop_offset_);
  951. }
  953. int SelectErrorModel::command(int argc, const char*const* argv)
  954. {
  955. if (strcmp(argv[1], "drop-packet") == 0) {
  956. pkt_type_ = packet_t(atoi(argv[2]));
  957. drop_cycle_ = atoi(argv[3]);
  958. drop_offset_ = atoi(argv[4]);
  959. return TCL_OK;
  960. }
  961. return ErrorModel::command(argc, argv);
  962. }
  964. int SelectErrorModel::corrupt(Packet* p)
  965. {
  966. if (unit_ == EU_PKT) {
  967. hdr_cmn *ch = hdr_cmn::access(p);
  968. // XXX Backward compatibility for cbr agents
  969. if (ch->ptype() == PT_UDP && pkt_type_ == PT_CBR)
  970. pkt_type_ = PT_UDP; // "udp" rather than "cbr"
  971. if (ch->ptype() == pkt_type_ && ch->uid() % drop_cycle_ 
  972.     == drop_offset_) {
  973. //printf ("dropping packet type %d, uid %dn", 
  974. // ch->ptype(), ch->uid());
  975. return 1;
  976. }
  977. }
  978. return 0;
  979. }
  981. /* Error model for srm experiments */
  982. class SRMErrorModel : public SelectErrorModel {
  983. public:
  984. SRMErrorModel();
  985. virtual int corrupt(Packet*);
  986. protected:
  987. int command(int argc, const char*const* argv);
  988. };
  990. static class SRMErrorModelClass : public TclClass {
  991. public:
  992. SRMErrorModelClass() : TclClass("SRMErrorModel") {}
  993. TclObject* create(int, const char*const*) {
  994. return (new SRMErrorModel);
  995. }
  996. } class_srmerrormodel;
  998. SRMErrorModel::SRMErrorModel()
  999. {
  1000. }
  1002. int SRMErrorModel::command(int argc, const char*const* argv)
  1003. {
  1004. //int ac = 0;
  1005. if (strcmp(argv[1], "drop-packet") == 0) {
  1006. pkt_type_ = packet_t(atoi(argv[2]));
  1007. drop_cycle_ = atoi(argv[3]);
  1008. drop_offset_ = atoi(argv[4]);
  1009. return TCL_OK;
  1010. }
  1011. return ErrorModel::command(argc, argv);
  1012. }
  1014. int SRMErrorModel::corrupt(Packet* p)
  1015. {
  1016. if (unit_ == EU_PKT) {
  1017. hdr_srm *sh = hdr_srm::access(p);
  1018. hdr_cmn *ch = hdr_cmn::access(p);
  1019. // XXX Backward compatibility for cbr agents
  1020. if (ch->ptype()==PT_UDP && pkt_type_==PT_CBR && sh->type() == SRM_DATA)
  1021. pkt_type_ = PT_UDP; // "udp" rather than "cbr"
  1022. if ((ch->ptype() == pkt_type_) && (sh->type() == SRM_DATA) && 
  1023.     (sh->seqnum() % drop_cycle_ == drop_offset_)) {
  1024. //printf ("dropping packet type SRM-DATA, seqno %dn", 
  1025. //sh->seqnum());
  1026. return 1;
  1027. }
  1028. }
  1029. return 0;
  1030. }
  1033. static class MrouteErrorModelClass : public TclClass {
  1034. public:
  1035. MrouteErrorModelClass() : TclClass("ErrorModel/Trace/Mroute") {}
  1036. TclObject* create(int, const char*const*) {
  1037. return (new MrouteErrorModel);
  1038. }
  1039. } class_mrouteerrormodel;
  1040.  
  1041. MrouteErrorModel::MrouteErrorModel() : TraceErrorModel()
  1042. {
  1043. }
  1045. int MrouteErrorModel::command(int argc, const char*const* argv)
  1046. {
  1047. if (argc == 3) {
  1048. if (strcmp(argv[1], "drop-packet") == 0) {
  1049. const char* s = argv[2];
  1050. int n = strlen(s);
  1051. if (n >= this->maxtype()) {
  1052. // tcl.result("message type too big");
  1053. return (TCL_ERROR);
  1054. }
  1055. strcpy(msg_type,s);
  1056. return(TCL_OK);
  1057. }
  1058. }
  1059. return TraceErrorModel::command(argc, argv);
  1060. }
  1062. int MrouteErrorModel::match(Packet* p)
  1063. {
  1064. hdr_mcast_ctrl* ph = hdr_mcast_ctrl::access(p);
  1065. int indx = strcspn(ph->type(),"/");
  1066. if (!strncmp(ph->type(),msg_type,indx)) {
  1067. return 1;
  1068. }
  1069. return 0;
  1070. }
  1073. static class ErrorModuleClass : public TclClass {
  1074. public:
  1075. ErrorModuleClass() : TclClass("ErrorModule") {}
  1076. TclObject* create(int, const char*const*) {
  1077. return (new ErrorModule);
  1078. }
  1079. } class_errormodule;
  1081. void ErrorModule::recv(Packet *p, Handler *h)
  1082. {
  1083. classifier_->recv(p, h);
  1084. }
  1086. int ErrorModule::command(int argc, const char*const* argv)
  1087. {
  1088. Tcl& tcl = Tcl::instance();
  1089. if (argc == 2) {
  1090. if (strcmp(argv[1], "classifier") == 0) {
  1091. if (classifier_)
  1092. tcl.resultf("%s", classifier_->name());
  1093. else
  1094. tcl.resultf("");
  1095. return (TCL_OK);
  1096. }
  1097. } else if (argc == 3) {
  1098. if (strcmp(argv[1], "classifier") == 0) {
  1099. classifier_ = (Classifier*)
  1100. TclObject::lookup(argv[2]);
  1101. if (classifier_ == NULL) {
  1102. tcl.resultf("Couldn't look up classifier %s", argv[2]);
  1103. return (TCL_ERROR);
  1104. }
  1105. return (TCL_OK);
  1106. }
  1107. }
  1108. return (Connector::command(argc, argv));
  1109. }
  1111. #include "config.h"
  1112. #ifdef HAVE_STL //pgm uses STL
  1114. #include "pgm/pgm.h"
  1116. static class PGMErrorModelClass : public TclClass {
  1117. public:
  1118.        PGMErrorModelClass() : TclClass("PGMErrorModel") {}
  1119.         TclObject* create(int, const char*const*) {
  1120.                 return (new PGMErrorModel);
  1121.         }
  1122. } class_pgm_errormodel;
  1124. PGMErrorModel::PGMErrorModel() : ErrorModel(), pgm_type_(-1), count_(0)
  1125. {
  1126.         ndrops_ = 0;
  1128.         bind("ndrops_", &ndrops_);
  1129. }
  1131. int PGMErrorModel::command(int argc, const char*const* argv)
  1132. {
  1133.         if (strcmp(argv[1], "drop-packet") == 0) {
  1134. if (!strcasecmp(argv[2], "SPM")) {
  1135. pgm_type_ = PGM_SPM;
  1136. }
  1137. else if (!strcasecmp(argv[2], "ODATA")) {
  1138. pgm_type_ = PGM_ODATA;
  1139. }
  1140. else if (!strcasecmp(argv[2], "RDATA")) {
  1141. pgm_type_ = PGM_RDATA;
  1142. }
  1143. else if (!strcasecmp(argv[2], "NAK")) {
  1144. pgm_type_ = PGM_NAK;
  1145. }
  1146. else if (!strcasecmp(argv[2], "NCF")) {
  1147. pgm_type_ = PGM_NCF;
  1148. }
  1149. else {
  1150. fprintf(stderr, "PGMErrorModel: drop-packet PGM type "%s" unknown.n", argv[2]);
  1151. return TCL_ERROR;
  1152. }
  1154.                 drop_cycle_ = atoi(argv[3]);
  1155.                 drop_offset_ = atoi(argv[4]);
  1156.                 return TCL_OK;
  1157.         }
  1158.         return ErrorModel::command(argc, argv);
  1159. }
  1161. int PGMErrorModel::corrupt(Packet* p)
  1162. {
  1163.         if (unit_ == EU_PKT) {
  1165.                 hdr_cmn *ch = HDR_CMN(p);
  1166.                 hdr_pgm *hp = HDR_PGM(p);
  1168.                 if ((ch->ptype() == PT_PGM) && (hp->type_ == pgm_type_)) {
  1169. count_++;
  1170. if (count_ % drop_cycle_ == drop_offset_) {
  1171. #ifdef PGM_DEBUG
  1172. printf ("DROPPING PGM packet type %d, seqno %dn", pgm_type_, hp->seqno_);
  1173. #endif
  1174. ++ndrops_;
  1175. return 1;
  1176. }
  1177. }
  1178.         }
  1179.         return 0;
  1180. }
  1182. #endif //HAVE_STL
  1184. //
  1185. // LMS Error Model
  1186. //
  1187. #include "rtp.h"                
  1188. #include "mcast/lms.h"
  1190. static class LMSErrorModelClass : public TclClass {
  1191. public:
  1192.         LMSErrorModelClass() : TclClass("LMSErrorModel") {}
  1193.         TclObject* create(int, const char*const*) {
  1194.                 return (new LMSErrorModel);
  1195.         }
  1196. } class_lms_errormodel;
  1197.  
  1198.  
  1199. LMSErrorModel::LMSErrorModel() : ErrorModel()
  1200. {
  1201.         ndrops_ = 0;
  1202.         bind("ndrops_", &ndrops_);
  1203. }
  1204.  
  1205. int LMSErrorModel::command(int argc, const char*const* argv)
  1206. {
  1207.         if (strcmp(argv[1], "drop-packet") == 0)
  1208. {
  1209.                 pkt_type_ = packet_t(atoi(argv[2]));
  1210.                 drop_cycle_ = atoi(argv[3]);
  1211.                 drop_offset_ = atoi(argv[4]);
  1212.                 return TCL_OK;
  1213. }
  1214.         return ErrorModel::command(argc, argv);
  1215. }
  1217. int LMSErrorModel::corrupt(Packet* p)
  1218. {
  1219.         if (unit_ == EU_PKT)
  1220. {
  1221.                 hdr_cmn *ch = HDR_CMN(p);
  1222.                 hdr_lms *lh = HDR_LMS(p);
  1223.                 hdr_rtp *rh = HDR_RTP(p);
  1224.  
  1225.                 if ((ch->ptype() == pkt_type_) && (lh->type_ != LMS_DMCAST) &&
  1226.                     (rh->seqno() % drop_cycle_ == drop_offset_))
  1227. {
  1228. #ifdef LMS_DEBUG
  1229. printf ("Error Model: DROPPING pkt type %d, seqno %dn", pkt_type_, rh->seqno());
  1230. #endif
  1231.                         ++ndrops_;
  1232. return 1;
  1233. }
  1234.          }
  1235. return 0;
  1236. }
  1238. void TwoStateErrModelTimer::expire(Event *e) 
  1239. {
  1240. (*a_.*call_back_)();
  1241. }