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

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

通讯编程

开发平台：

Visual C++

ldp.cc：源码内容
  1. // -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*-
  3. /*
  4.  * ldp.cc
  5.  * Copyright (C) 2000 by the University of Southern California
  6.  * $Id: ldp.cc,v 1.9 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/ldp.cc,v 1.9 2005/08/25 18:58:09 johnh Exp $
  53. /**************************************************************************
  54. * Copyright (c) 2000 by Gaeil Ahn                                      *
  55. * Everyone is permitted to copy and distribute this software.   *
  56. * Please send mail to fog1@ce.cnu.ac.kr when you modify or distribute     *
  57. * this sources.   *
  58. **************************************************************************/
  60. /***********************************************************
  61. *                                                          *
  62. *    File: File for LDP & CR-LDP protocol                   *
  63. *    Author: Gaeil Ahn (fog1@ce.cnu.ac.kr), Jan. 2000      *
  64. *                                                          *
  65. ***********************************************************/
  67. #include "config.h"
  69. #include <iostream>
  71. #include "ldp.h"
  73. int hdr_ldp::offset_;
  75. static class LDPHeaderClass : public PacketHeaderClass {
  76. public:
  77. LDPHeaderClass() : PacketHeaderClass("PacketHeader/LDP", 
  78.      sizeof(hdr_ldp)) {
  79. bind_offset(&hdr_ldp::offset_);
  80. }
  81. } class_ldphdr;
  83. static class LDPClass : public TclClass {
  84. public:
  85. LDPClass() : TclClass("Agent/LDP") {}
  86. TclObject* create(int, const char*const*) {
  87. return (new LDPAgent());
  88. }
  89. } class_agentldp;
  91. LDPAgent::LDPAgent() : Agent(PT_LDP), 
  92. new_msgid_(0), trace_ldp_(0), peer_(0)
  93. {
  94. MSGT_.NB      = 0;
  95. }
  97. void LDPAgent::delay_bind_init_all()
  98. {
  99. delay_bind_init_one("trace_ldp_");
  100. Agent::delay_bind_init_all();
  101. }
  103. int LDPAgent::delay_bind_dispatch(const char *varName, const char *localName, 
  104.   TclObject *tracer)
  105. {
  106. if (delay_bind_bool(varName,localName,"trace_ldp_",&trace_ldp_,tracer))
  107. return TCL_OK;
  108. return Agent::delay_bind_dispatch(varName, localName, tracer);
  109. }
  111. int LDPAgent::PKTsize(const char *pathvec, const char *er)
  112. {
  113. // header size for Version, PDU Length, and LDP Identifier
  114. int psize = 10; 
  115. // size for message type and message id
  116. psize += 8; 
  117.     
  118. int len = strlen(pathvec);
  119. if (len > 1) {
  120. psize += 4;   // size for path vector header
  121. for (int i=0; i<len; i++)
  122. if ( *(pathvec+i) == ' ' ) {
  123. psize += 4;   // size for path vector data
  124. }  
  125. }     
  127. len = strlen(er);
  128. if (len > 1) { 
  129. psize += 4;   // size for explicit route header
  130. for (int i=0; i<len; i++)
  131. if (*(er+i) == ' ')
  132. psize += 4;   // size for explicit route data 
  133. }
  134. return (psize);
  135. }
  137. void LDPAgent::PKTinit(hdr_ldp *hdrldp, int msgtype, 
  138.        const char *pathvec, const char *er)
  139. {
  140. hdrldp->msgtype = msgtype;
  141. hdrldp->msgid   = new_msgid_;
  142. hdrldp->fec     = -1;
  143. hdrldp->label   = -1;
  144. hdrldp->reqmsgid= -1;
  145. hdrldp->status  = -1;
  147. int i;
  148. int len = strlen(pathvec);
  149. hdrldp->pathvec = (char *) malloc(len+1);
  150. for (i=0; i<len; i++) { 
  151. if ( *(pathvec+i) == ' ' )
  152. *(hdrldp->pathvec+i) = '_';
  153. else
  154. *(hdrldp->pathvec+i) = *(pathvec+i);
  155. }
  156. *(hdrldp->pathvec+len) = '';
  158. len = strlen(er);
  159. hdrldp->er = (char *) malloc(len+1);
  160. for (i=0; i<len; i++) { 
  161. if ( *(er+i) == ' ' )
  162. *(hdrldp->er+i) = '_';
  163. else
  164. *(hdrldp->er+i) = *(er+i);
  165. }
  166. *(hdrldp->er+len) = '';
  168. hdrldp->lspid = -1;
  169. hdrldp->rc    = -1;
  170. }
  172. int LDPAgent::command(int argc, const char*const* argv)
  173. {
  174. Tcl& tcl = Tcl::instance();
  175. if (argc == 2) {      
  176. if (strcmp(argv[1], "msgtbl-dump") == 0) {              
  177. MSGTdump();
  178. return (TCL_OK);
  179. } else if (strcmp(argv[1], "new-msgid") == 0) {
  180. tcl.resultf("%d", ++new_msgid_);
  181. return (TCL_OK);
  182. } else if (strcmp(argv[1], "peer-ldpnode") == 0) {
  183. tcl.resultf("%d", peer_);
  184. return (TCL_OK);
  185. }
  186. } else if (argc == 3) {
  187. if (strcmp(argv[1], "set-peer") == 0) {
  188. peer_ = atoi(argv[2]);
  189. return (TCL_OK);
  190. }
  192. // The following is shared by all if-s in this branch
  193. int MsgID = atoi(argv[2]);
  194. int msgid,fec,lspid,src,pmsgid,labelop;
  195. int entrynb = MSGTlocate(MsgID);
  196. MSGTlookup(entrynb,msgid,fec,lspid,src,pmsgid,labelop);
  198. if (strcmp(argv[1], "msgtbl-clear") == 0) {
  199. /* <agent> MSGTdelete MsgID */
  200. if (entrynb > -1)  
  201. MSGTdelete(entrynb);
  202. return (TCL_OK);
  203. } else if (strcmp(argv[1], "msgtbl-get-src") == 0) {
  204. /* <agent> GetMSGTsrc MsgID */
  205. tcl.resultf("%d", src);
  206. return (TCL_OK);
  207. } else if (strcmp(argv[1], "msgtbl-get-reqmsgid") == 0) {
  208. /* <agent> GetMSGTpmsgid msgid */
  209. tcl.resultf("%d",pmsgid);
  210. return (TCL_OK);
  211. } else if (strcmp(argv[1], "msgtbl-get-labelop") == 0) {
  212. /* <agent> GetMSGTlabelpass msgid */
  213. tcl.resultf("%d", labelop);
  214. return (TCL_OK);
  215. } else if (strcmp(argv[1], "msgtbl-get-erlspid") == 0) {
  216. /* 
  217.  * <agent> msgtbl-get-erlspid <msgid>
  218.  */
  219. tcl.resultf("%d",MSGT_.Entry[entrynb].ERLspID);
  220. return (TCL_OK);
  221. } else if (strcmp(argv[1], "msgtbl-set-labelpass") == 0) {
  222. /* 
  223.  * <agent> msgtbl-set-labelpass <msgid>
  224.  */
  225. MSGT_.Entry[entrynb].LabelOp = LDP_LabelPASS;
  226. return (TCL_OK);
  227. } 
  228. } else if (argc == 4) {      
  229. if (strcmp(argv[1], "notification-msg") == 0) {
  230. /* 
  231.  * <agent> notification-msg <status> <lspid>
  232.  */
  233. size_ = PKTsize("*", "*");
  234. if ( atoi(argv[3]) > -1 )  /* packet size adjustment */
  235. size_ += 16;
  236. else
  237. size_ += 8;
  238. Packet* pkt = allocpkt();
  239. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  240. PKTinit(hdrldp, LDP_NotificationMSG, "*", "*");
  242. if (strcmp(argv[2], "LoopDetected") == 0)
  243. hdrldp->status = LDP_LoopDetected;
  244. else if (strcmp(argv[2], "NoRoute") == 0)
  245. hdrldp->status  = LDP_NoRoute;
  246.        
  247. hdrldp->lspid   = atoi(argv[3]);
  248. send(pkt, 0);
  249. return (TCL_OK);
  250. } else if (strcmp(argv[1], "withdraw-msg") == 0) {
  251. /* 
  252.  * <agent> withdraw-msg <fec> <lspid>
  253.  */
  254. size_ = PKTsize("*","*");
  255. if ( atoi(argv[3]) > -1 )  /* packet size adjustment */
  256. size_ += 16;
  257. else
  258. size_ += 8;
  259. Packet* pkt = allocpkt();
  260. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  261. PKTinit(hdrldp, LDP_WithdrawMSG, "*", "*");
  262. hdrldp->fec    = atoi(argv[2]);
  263. hdrldp->lspid  = atoi(argv[3]);
  264. send(pkt, 0);
  265. return (TCL_OK);
  266. } else if (strcmp(argv[1], "release-msg") == 0) {
  267. /* 
  268.  * <agent> release-msg <fec> <lspid>
  269.  */
  270. size_ = PKTsize("*","*");
  271. if ( atoi(argv[3]) > -1 )  /* packet size adjustment */
  272. size_ += 16;
  273. else
  274. size_ += 8;
  275. Packet* pkt = allocpkt();
  276. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  277. PKTinit(hdrldp, LDP_ReleaseMSG,"*","*");
  278. hdrldp->fec     = atoi(argv[2]);
  279. hdrldp->lspid   = atoi(argv[3]);
  280. send(pkt, 0);
  281. return (TCL_OK);
  282. } else if (strcmp(argv[1], "request-msg") == 0) {
  283. /* 
  284.  * <agent> request-msg <fec> <pathvec>
  285.  */
  286. size_ = PKTsize(argv[3],"*");
  287. size_ += 8;      /* packet size adjustment */
  288. Packet* pkt = allocpkt();
  289. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  290. PKTinit(hdrldp, LDP_RequestMSG, argv[3], "*");
  291. hdrldp->fec     = atoi(argv[2]);
  292. send(pkt, 0);
  293. return (TCL_OK);
  294. } else if (strcmp(argv[1], "msgtbl-set-labelstack") == 0) {
  295. /*
  296.  * <agent> msgtbl-set-labelstack <msgid> <erlspid>
  297.  */
  298. int MsgID   = atoi(argv[2]);
  299. int ERLspID = atoi(argv[3]);
  300. int entrynb = MSGTlocate(MsgID);
  301. MSGT_.Entry[entrynb].LabelOp = LDP_LabelSTACK;
  302. MSGT_.Entry[entrynb].ERLspID = ERLspID;
  303. return (TCL_OK);
  304. } 
  305. } else if (argc == 5) {      
  306. if (strcmp(argv[1], "msgtbl-get-msgid") == 0) {
  307. /* 
  308.  * <classifier> msgtbl-get-msgid <FEC> <LspID> <Src>
  309.  */
  310. int msgid,tmp;
  311. int fec    = atoi(argv[2]);
  312. int LspID  = atoi(argv[3]);
  313. int src    = atoi(argv[4]);     
  314. int entrynb = MSGTlocate(fec,LspID,src);
  316. MSGTlookup(entrynb,msgid,tmp,tmp,tmp,tmp,tmp);
  317. tcl.resultf("%d", msgid);
  318. return (TCL_OK);
  319. }
  320. } else if (argc == 6) {
  321. if (strcmp(argv[1], "mapping-msg") == 0) {
  322. /* 
  323.  * <agent> mapping <fec> <label> <pathvec> <premsgid>
  324.  */
  325. size_ = PKTsize(argv[4],"*");
  326. if ( atoi(argv[5]) > -1 )  /* packet size adjustment*/
  327. size_ += 24;
  328. else
  329. size_ += 16;
  330.           Packet* pkt = allocpkt();
  331. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  332. PKTinit(hdrldp, LDP_MappingMSG, argv[4], "*");
  333. hdrldp->fec     = atoi(argv[2]);
  334. hdrldp->label   = atoi(argv[3]);
  335. hdrldp->reqmsgid= atoi(argv[5]);
  336. send(pkt, 0);
  337. return (TCL_OK);
  338. } else if (strcmp(argv[1], "cr-mapping-msg") == 0) {
  339. /* 
  340.  * <agent> cr-mapping-msg <fec> <label> <lspid>
  341.  *         <premsgid>
  342.  */
  343. size_ = PKTsize("*","*");
  344. size_ += 32;      /* packet size adjustment */
  345. Packet* pkt = allocpkt();
  346. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  347. PKTinit(hdrldp, LDP_MappingMSG, "*", "*");
  348. hdrldp->fec     = atoi(argv[2]);
  349. hdrldp->label   = atoi(argv[3]);
  350. hdrldp->lspid   = atoi(argv[4]);
  351. hdrldp->reqmsgid= atoi(argv[5]);
  352. send(pkt, 0);
  353. return (TCL_OK);
  354. }
  355. } else if (argc == 7) {      
  356. if (strcmp(argv[1], "cr-request-msg") == 0) {
  357. /* 
  358.  * <agent> cr-request <fec> <pathvec> <er> <lspid> <rc>
  359.  */
  360. size_ = PKTsize(argv[3],argv[4]);
  361. if (atoi(argv[6]) > -1)  /* packet size adjustment */
  362. size_ += 24;
  363. else
  364. size_ += 16;
  365. Packet* pkt = allocpkt();
  366. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  367. PKTinit(hdrldp, LDP_RequestMSG, argv[3], argv[4]);
  368. hdrldp->fec     = atoi(argv[2]);
  369. hdrldp->lspid   = atoi(argv[5]);
  370. hdrldp->rc      = atoi(argv[6]);
  371. send(pkt, 0);
  372. return (TCL_OK);
  373. } else if (strcmp(argv[1], "msgtbl-install") == 0) {
  374. /* 
  375.  * <agent> msgtbl-install <msgid> <FEC> <LspID> 
  376.  *         <Src> <Pmsgid>
  377.  */
  378. int msgid  = atoi(argv[2]);
  379. int fec    = atoi(argv[3]);
  380. int LspID  = atoi(argv[4]);
  381. int src    = atoi(argv[5]);     
  382. int PMsgID = atoi(argv[6]);     
  383. int entrynb = MSGTinsert(msgid,fec,LspID,src,PMsgID);
  384. tcl.resultf("%d", entrynb);
  385. return (TCL_OK);
  386. }
  387. }
  388. return (Agent::command(argc, argv));
  389. }
  391. void LDPAgent::recv(Packet* pkt, Handler*)
  392. {
  393. char out[400];  
  394. Tcl& tcl = Tcl::instance();
  396. hdr_ldp *hdrldp = hdr_ldp::access(pkt);
  397. int msgtype = hdrldp->msgtype;
  398. int msgid   = hdrldp->msgid;
  399. int fec     = hdrldp->fec;
  400. int label   = hdrldp->label;
  401. int reqmsgid= hdrldp->reqmsgid;
  402. int status  = hdrldp->status;
  403. int lspid   = hdrldp->lspid;
  404. int rc      = hdrldp->rc;
  405.   
  406. char pathvec[400];
  407. char er[400];
  408. strcpy(pathvec, hdrldp->pathvec);
  409. strcpy(er, hdrldp->er);
  411. ns_addr_t src = hdr_ip::access(pkt)->src_;
  412. trace(src, hdrldp);
  414. free(hdrldp->pathvec);
  415. free(hdrldp->er);
  416. Packet::free(pkt);
  418. switch (msgtype) {
  419. case LDP_NotificationMSG:    /* Notification   */
  420. char code[30];
  421. strcpy(code, parse_status(status));
  422. sprintf(out, "%s get-notification-msg %d %s %d", 
  423. name(), src.addr_, code, lspid);
  424. tcl.eval(out);
  425. break;
  427. case LDP_MappingMSG:    /* Label Mapping  */
  428. if (lspid >= 0) {
  429. /* CR-LDP */
  430. sprintf(out, "%s get-cr-mapping-msg %d %d %d %d %d %d",
  431. name(), msgid, src.addr_, fec, 
  432. label, lspid, reqmsgid);
  433. } else { 
  434. sprintf(out, "%s get-mapping-msg %d %d %d %d %s %d", 
  435. name(), msgid, src.addr_, fec, 
  436. label, pathvec, reqmsgid);
  437. }
  438. tcl.eval(out);
  439. break;
  441. case LDP_RequestMSG:    /* Label Request  */
  442. if (lspid >= 0) { 
  443. sprintf(out,
  444. "%s get-cr-request-msg %d %d %d %s %s %d %d", 
  445. name(), msgid, src.addr_, fec, pathvec,
  446. er, lspid, rc);
  447. } else { 
  448. sprintf(out, "%s get-request-msg %d %d %d %s", 
  449. name(), msgid, src.addr_, fec, pathvec);
  450. }
  451. tcl.eval(out);
  452. break;
  454. case LDP_WithdrawMSG:    /* Label Withdraw */
  455. sprintf(out, "%s get-withdraw-msg %d %d %d", 
  456. name(), src.addr_, fec, lspid);
  457. tcl.eval(out);
  458. break;
  460. case LDP_ReleaseMSG:    /* Label Release */
  461. sprintf(out, "%s get-release-msg %d %d %d", 
  462. name(), src.addr_, fec, lspid);
  463. tcl.eval(out);
  464. break;
  465. }
  466. }
  468. int LDPAgent::MSGTinsert(int MsgID, int FEC, int LspID, int Src, int PMsgID)
  469. {
  470. if (MSGT_.NB == LDP_MaxMSGTEntryNB - 1)
  471. return(-1);
  473. if (MSGTlocate(FEC, LspID, Src) > -1)
  474. return(-1);
  475.     
  476. MSGT_.Entry[MSGT_.NB].MsgID     = MsgID;
  477. MSGT_.Entry[MSGT_.NB].FEC       = FEC;
  478. MSGT_.Entry[MSGT_.NB].LspID     = LspID;
  479. MSGT_.Entry[MSGT_.NB].Src       = Src;
  480. MSGT_.Entry[MSGT_.NB].PMsgID    = PMsgID;
  481. MSGT_.Entry[MSGT_.NB].LabelOp   = LDP_LabelALLOC;
  482. MSGT_.Entry[MSGT_.NB].ERLspID   = -1;
  483.     
  484. MSGT_.NB++;
  486. return(MSGT_.NB-1);
  487. }
  489. void LDPAgent::MSGTdelete(int entrynb)
  490. {
  491. if ( (entrynb > -1) && (entrynb < MSGT_.NB) ) {
  492. MSGT_.Entry[entrynb].MsgID = -1;
  493. MSGT_.Entry[entrynb].FEC   = MSGT_.Entry[entrynb].LspID  = -1;
  494. MSGT_.Entry[entrynb].Src   = MSGT_.Entry[entrynb].PMsgID = -1;
  495. MSGT_.Entry[entrynb].LabelOp = -1;
  496. MSGT_.Entry[entrynb].ERLspID = -1;
  497. }   
  498. }
  500. int LDPAgent::MSGTlocate(int MsgID)
  501. {
  502. if ( MsgID < 0 )
  503. return(-1);
  504.     
  505. for (int i=0; i<MSGT_.NB; i++) {
  506. if ( MSGT_.Entry[i].MsgID == MsgID )
  507. return(i);
  508. }
  510. return(-1);
  511. }
  513. int LDPAgent::MSGTlocate(int FEC, int LspID, int Src)
  514. {
  515. int i;
  516. if ( (FEC < 0) && (Src < 0) ) {
  517. if ( LspID > -1) {
  518. for (i=0; i<MSGT_.NB; i++)
  519. if ( MSGT_.Entry[i].LspID  == LspID )
  520. return(i);
  521. }
  522. return(-1);
  523. }
  524.        
  525. for (i=0; i<MSGT_.NB; i++) {
  526. if ( (MSGT_.Entry[i].FEC   == FEC  ) &&
  527.      (MSGT_.Entry[i].LspID == LspID) &&
  528.      (MSGT_.Entry[i].Src   == Src  ) )
  530. return(i);
  531. }
  533. return(-1);
  534. }
  536. void LDPAgent::MSGTlookup(int entrynb, int &MsgID, int &FEC, int &LspID, 
  537.   int &Src, int &PMsgID, int &LabelOp)
  538. {
  539. if ( (entrynb > -1) && (entrynb < MSGT_.NB) ) {  
  540. MsgID    = MSGT_.Entry[entrynb].MsgID;
  541. FEC      = MSGT_.Entry[entrynb].FEC;
  542. LspID    = MSGT_.Entry[entrynb].LspID;
  543. Src      = MSGT_.Entry[entrynb].Src;
  544. PMsgID   = MSGT_.Entry[entrynb].PMsgID;
  545. LabelOp= MSGT_.Entry[entrynb].LabelOp;
  546. } else {  
  547. MsgID = FEC = LspID = Src = PMsgID = LabelOp = -1;
  548. }
  549. }
  551. void LDPAgent::MSGTdump()
  552. {
  553. for (int i = 0; i < MSGT_.NB; i++) {
  554. cerr << "  # MsgID =" << MSGT_.Entry[i].MsgID << "  ";
  555. cerr << "  # FEC   =" << MSGT_.Entry[i].FEC   << "  ";
  556. cerr << "  # LspID =" << MSGT_.Entry[i].LspID << "  ";
  557. cerr << "  # Src   =" << MSGT_.Entry[i].Src   << "  ";
  558. cerr << "  # PMsgID=" << MSGT_.Entry[i].PMsgID<< "  ";
  559. cerr << "  # LabelOp=" << MSGT_.Entry[i].LabelOp << "n";
  560. }
  561. }
  563. void LDPAgent::trace(ns_addr_t src, hdr_ldp *hdrldp)
  564. {
  565. // XXX will be changed later to directly write to a output channel
  566. // instead of sending stuff to otcl
  567. if (trace_ldp_ == 1) { 
  568. const char *msgtype = parse_msgtype(hdrldp->msgtype,
  569.     hdrldp->lspid);
  570. const char *status = (hdrldp->msgtype == 0x0001) ? 
  571. parse_status(hdrldp->status) : "*";
  572. Tcl::instance().evalf("%s trace-ldp-packet %d %d %s %d %d %d "
  573.       "%s %d %s %d %d %s %7f",
  574.       name(),
  575.       src.addr_,
  576.       src.port_,
  577.       msgtype, 
  578.       hdrldp->msgid, 
  579.       hdrldp->fec, 
  580.       hdrldp->label, 
  581.       hdrldp->pathvec, 
  582.       hdrldp->lspid, 
  583.       hdrldp->er, 
  584.       hdrldp->rc, 
  585.       hdrldp->reqmsgid,
  586.       status,
  587.       Scheduler::instance().clock());  
  588. }
  589. }
  591. char* LDPAgent::parse_msgtype(int msgtype, int lspid)
  592. {
  594. switch (msgtype) {
  595. case LDP_NotificationMSG:    /* Notification   */
  596. return("Notification");
  598. case LDP_MappingMSG:    /* Label Mapping  */
  599. if (lspid >= 0)          /* CR-LDP */
  600. return("CR-Mapping");
  601. else
  602. return("Mapping");
  604. case LDP_RequestMSG:    /* Label Request  */
  605. if (lspid >= 0)
  606. return("CR-Request");
  607. else
  608. return("Request");
  610. case LDP_WithdrawMSG:    /* Label Withdraw */
  611. return("Withdraw");
  613. case LDP_ReleaseMSG:    /* Label Release */
  614. return("Release");
  615. }
  617. return ("Error");
  618. }
  620. char* LDPAgent::parse_status(int status)
  621. {
  622. switch (status) {
  623. case LDP_LoopDetected:
  624. return "LoopDetected";
  626. case LDP_NoRoute:
  627. return "NoRoute";
  629. default:
  630. return "Unknown";
  631. }
  632. }