ldp.cc

Go to the documentation of this file.

// -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*-

/*
 * ldp.cc
 * Copyright (C) 2000 by the University of Southern California
 * $Id: ldp.cc,v 1.9 2005/08/25 18:58:09 johnh Exp $
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * The copyright of this module includes the following
 * linking-with-specific-other-licenses addition:
 *
 * In addition, as a special exception, the copyright holders of
 * this module give you permission to combine (via static or
 * dynamic linking) this module with free software programs or
 * libraries that are released under the GNU LGPL and with code
 * included in the standard release of ns-2 under the Apache 2.0
 * license or under otherwise-compatible licenses with advertising
 * requirements (or modified versions of such code, with unchanged
 * license).  You may copy and distribute such a system following the
 * terms of the GNU GPL for this module and the licenses of the
 * other code concerned, provided that you include the source code of
 * that other code when and as the GNU GPL requires distribution of
 * source code.
 *
 * Note that people who make modified versions of this module
 * are not obligated to grant this special exception for their
 * modified versions; it is their choice whether to do so.  The GNU
 * General Public License gives permission to release a modified
 * version without this exception; this exception also makes it
 * possible to release a modified version which carries forward this
 * exception.
 *
 */

//
// Original source contributed by Gaeil Ahn. See below.
//
// $Header: /nfs/jade/vint/CVSROOT/ns-2/mpls/ldp.cc,v 1.9 2005/08/25 18:58:09 johnh Exp $

/**************************************************************************
* Copyright (c) 2000 by Gaeil Ahn                                         *
* Everyone is permitted to copy and distribute this software.         *
* Please send mail to fog1@ce.cnu.ac.kr when you modify or distribute     *
* this sources.                               *
**************************************************************************/

/***********************************************************
*                                                          *
*    File: File for LDP & CR-LDP protocol                   *
*    Author: Gaeil Ahn (fog1@ce.cnu.ac.kr), Jan. 2000      *
*                                                          *
***********************************************************/

#include "config.h"

#include <iostream>

#include "ldp.h"

int hdr_ldp::offset_;

static class LDPHeaderClass : public PacketHeaderClass {
public:
    LDPHeaderClass() : PacketHeaderClass("PacketHeader/LDP", 
                         sizeof(hdr_ldp)) {
        bind_offset(&hdr_ldp::offset_);
    }
} class_ldphdr;

static class LDPClass : public TclClass {
public:
    LDPClass() : TclClass("Agent/LDP") {}
    TclObject* create(int, const char*const*) {
        return (new LDPAgent());
    }
} class_agentldp;

LDPAgent::LDPAgent() : Agent(PT_LDP), 
    new_msgid_(0), trace_ldp_(0), peer_(0)
{
    MSGT_.NB      = 0;
}

void LDPAgent::delay_bind_init_all()
{
    delay_bind_init_one("trace_ldp_");
    Agent::delay_bind_init_all();
}

int LDPAgent::delay_bind_dispatch(const char *varName, const char *localName, 
                  TclObject *tracer)
{
    if (delay_bind_bool(varName,localName,"trace_ldp_",&trace_ldp_,tracer))
        return TCL_OK;
    return Agent::delay_bind_dispatch(varName, localName, tracer);
}

int LDPAgent::PKTsize(const char *pathvec, const char *er)
{
    // header size for Version, PDU Length, and LDP Identifier
    int psize = 10; 
    // size for message type and message id
    psize += 8; 
    
    int len = strlen(pathvec);
    if (len > 1) {
        psize += 4;   // size for path vector header
        for (int i=0; i<len; i++)
            if ( *(pathvec+i) == ' ' ) {
                psize += 4;   // size for path vector data
            }  
    }     

    len = strlen(er);
    if (len > 1) { 
        psize += 4;   // size for explicit route header
        for (int i=0; i<len; i++)
            if (*(er+i) == ' ')
                psize += 4;   // size for explicit route data 
    }
    return (psize);
}

void LDPAgent::PKTinit(hdr_ldp *hdrldp, int msgtype, 
               const char *pathvec, const char *er)
{
    hdrldp->msgtype = msgtype;
    hdrldp->msgid   = new_msgid_;
    hdrldp->fec     = -1;
    hdrldp->label   = -1;
    hdrldp->reqmsgid= -1;
    hdrldp->status  = -1;

    int i;
    int len = strlen(pathvec);
    hdrldp->pathvec = (char *) malloc(len+1);
    for (i=0; i<len; i++) { 
        if ( *(pathvec+i) == ' ' )
            *(hdrldp->pathvec+i) = '_';
        else
            *(hdrldp->pathvec+i) = *(pathvec+i);
    }
    *(hdrldp->pathvec+len) = '\0';

    len = strlen(er);
    hdrldp->er = (char *) malloc(len+1);
    for (i=0; i<len; i++) { 
        if ( *(er+i) == ' ' )
            *(hdrldp->er+i) = '_';
        else
            *(hdrldp->er+i) = *(er+i);
    }
    *(hdrldp->er+len) = '\0';

    hdrldp->lspid = -1;
    hdrldp->rc    = -1;
}

int LDPAgent::command(int argc, const char*const* argv)
{
    Tcl& tcl = Tcl::instance();
    if (argc == 2) {      
        if (strcmp(argv[1], "msgtbl-dump") == 0) {              
            MSGTdump();
            return (TCL_OK);
        } else if (strcmp(argv[1], "new-msgid") == 0) {
            tcl.resultf("%d", ++new_msgid_);
            return (TCL_OK);
        } else if (strcmp(argv[1], "peer-ldpnode") == 0) {
            tcl.resultf("%d", peer_);
            return (TCL_OK);
        }
    } else if (argc == 3) {
        if (strcmp(argv[1], "set-peer") == 0) {
            peer_ = atoi(argv[2]);
            return (TCL_OK);
        }

        // The following is shared by all if-s in this branch
        int MsgID = atoi(argv[2]);
        int msgid,fec,lspid,src,pmsgid,labelop;
        int entrynb = MSGTlocate(MsgID);
        MSGTlookup(entrynb,msgid,fec,lspid,src,pmsgid,labelop);

        if (strcmp(argv[1], "msgtbl-clear") == 0) {
            /* <agent> MSGTdelete MsgID */
            if (entrynb > -1)  
                MSGTdelete(entrynb);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-get-src") == 0) {
            /* <agent> GetMSGTsrc MsgID */
            tcl.resultf("%d", src);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-get-reqmsgid") == 0) {
            /* <agent> GetMSGTpmsgid msgid */
            tcl.resultf("%d",pmsgid);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-get-labelop") == 0) {
            /* <agent> GetMSGTlabelpass msgid */
            tcl.resultf("%d", labelop);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-get-erlspid") == 0) {
            /* 
             * <agent> msgtbl-get-erlspid <msgid>
             */
            tcl.resultf("%d",MSGT_.Entry[entrynb].ERLspID);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-set-labelpass") == 0) {
            /* 
             * <agent> msgtbl-set-labelpass <msgid>
             */
            MSGT_.Entry[entrynb].LabelOp = LDP_LabelPASS;
            return (TCL_OK);
        } 
    } else if (argc == 4) {      
        if (strcmp(argv[1], "notification-msg") == 0) {
            /* 
             * <agent> notification-msg <status> <lspid>
             */
            size_ = PKTsize("*", "*");
            if ( atoi(argv[3]) > -1 )  /* packet size adjustment */
                size_ += 16;
            else
                size_ += 8;
            Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_NotificationMSG, "*", "*");

            if (strcmp(argv[2], "LoopDetected") == 0)
                hdrldp->status = LDP_LoopDetected;
            else if (strcmp(argv[2], "NoRoute") == 0)
                hdrldp->status  = LDP_NoRoute;
       
            hdrldp->lspid   = atoi(argv[3]);
            send(pkt, 0);
            return (TCL_OK);
        } else if (strcmp(argv[1], "withdraw-msg") == 0) {
            /* 
             * <agent> withdraw-msg <fec> <lspid>
             */
            size_ = PKTsize("*","*");
            if ( atoi(argv[3]) > -1 )  /* packet size adjustment */
                size_ += 16;
            else
                size_ += 8;
            Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_WithdrawMSG, "*", "*");
            hdrldp->fec    = atoi(argv[2]);
            hdrldp->lspid  = atoi(argv[3]);
            send(pkt, 0);
            return (TCL_OK);
        } else if (strcmp(argv[1], "release-msg") == 0) {
            /* 
             * <agent> release-msg <fec> <lspid>
             */
            size_ = PKTsize("*","*");
            if ( atoi(argv[3]) > -1 )  /* packet size adjustment */
                size_ += 16;
            else
                size_ += 8;
            Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_ReleaseMSG,"*","*");
            hdrldp->fec     = atoi(argv[2]);
            hdrldp->lspid   = atoi(argv[3]);
            send(pkt, 0);
            return (TCL_OK);
        } else if (strcmp(argv[1], "request-msg") == 0) {
            /* 
             * <agent> request-msg <fec> <pathvec>
             */
            size_ = PKTsize(argv[3],"*");
            size_ += 8;      /* packet size adjustment */
            Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_RequestMSG, argv[3], "*");
            hdrldp->fec     = atoi(argv[2]);
            send(pkt, 0);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-set-labelstack") == 0) {
            /*
             * <agent> msgtbl-set-labelstack <msgid> <erlspid>
             */
            int MsgID   = atoi(argv[2]);
            int ERLspID = atoi(argv[3]);
            int entrynb = MSGTlocate(MsgID);
            MSGT_.Entry[entrynb].LabelOp = LDP_LabelSTACK;
            MSGT_.Entry[entrynb].ERLspID = ERLspID;
            return (TCL_OK);
        } 
    } else if (argc == 5) {      
        if (strcmp(argv[1], "msgtbl-get-msgid") == 0) {
            /* 
             * <classifier> msgtbl-get-msgid <FEC> <LspID> <Src>
             */
            int msgid,tmp;
            int fec    = atoi(argv[2]);
            int LspID  = atoi(argv[3]);
            int src    = atoi(argv[4]);     
            int entrynb = MSGTlocate(fec,LspID,src);

            MSGTlookup(entrynb,msgid,tmp,tmp,tmp,tmp,tmp);
            tcl.resultf("%d", msgid);
            return (TCL_OK);
        }
    } else if (argc == 6) {
        if (strcmp(argv[1], "mapping-msg") == 0) {
            /* 
             * <agent> mapping <fec> <label> <pathvec> <premsgid>
             */
            size_ = PKTsize(argv[4],"*");
            if ( atoi(argv[5]) > -1 )  /* packet size adjustment*/
                size_ += 24;
            else
                size_ += 16;
                Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_MappingMSG, argv[4], "*");
            hdrldp->fec     = atoi(argv[2]);
            hdrldp->label   = atoi(argv[3]);
            hdrldp->reqmsgid= atoi(argv[5]);
            send(pkt, 0);
            return (TCL_OK);
        } else if (strcmp(argv[1], "cr-mapping-msg") == 0) {
            /* 
             * <agent> cr-mapping-msg <fec> <label> <lspid>
             *         <premsgid>
             */
            size_ = PKTsize("*","*");
            size_ += 32;      /* packet size adjustment */
            Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_MappingMSG, "*", "*");
            hdrldp->fec     = atoi(argv[2]);
            hdrldp->label   = atoi(argv[3]);
            hdrldp->lspid   = atoi(argv[4]);
            hdrldp->reqmsgid= atoi(argv[5]);
            send(pkt, 0);
            return (TCL_OK);
        }
    } else if (argc == 7) {      
        if (strcmp(argv[1], "cr-request-msg") == 0) {
            /* 
             * <agent> cr-request <fec> <pathvec> <er> <lspid> <rc>
             */
            size_ = PKTsize(argv[3],argv[4]);
            if (atoi(argv[6]) > -1)  /* packet size adjustment */
                size_ += 24;
            else
                size_ += 16;
            Packet* pkt = allocpkt();
            hdr_ldp *hdrldp = hdr_ldp::access(pkt);
            PKTinit(hdrldp, LDP_RequestMSG, argv[3], argv[4]);
            hdrldp->fec     = atoi(argv[2]);
            hdrldp->lspid   = atoi(argv[5]);
            hdrldp->rc      = atoi(argv[6]);
            send(pkt, 0);
            return (TCL_OK);
        } else if (strcmp(argv[1], "msgtbl-install") == 0) {
            /* 
             * <agent> msgtbl-install <msgid> <FEC> <LspID> 
             *         <Src> <Pmsgid>
             */
            int msgid  = atoi(argv[2]);
            int fec    = atoi(argv[3]);
            int LspID  = atoi(argv[4]);
            int src    = atoi(argv[5]);     
            int PMsgID = atoi(argv[6]);     
            int entrynb = MSGTinsert(msgid,fec,LspID,src,PMsgID);
            tcl.resultf("%d", entrynb);
            return (TCL_OK);
        }
    }
    return (Agent::command(argc, argv));
}

void LDPAgent::recv(Packet* pkt, Handler*)
{
    char out[400];  
    Tcl& tcl = Tcl::instance();

    hdr_ldp *hdrldp = hdr_ldp::access(pkt);
    int msgtype = hdrldp->msgtype;
    int msgid   = hdrldp->msgid;
    int fec     = hdrldp->fec;
    int label   = hdrldp->label;
    int reqmsgid= hdrldp->reqmsgid;
    int status  = hdrldp->status;
    int lspid   = hdrldp->lspid;
    int rc      = hdrldp->rc;
  
    char pathvec[400];
    char er[400];
    strcpy(pathvec, hdrldp->pathvec);
    strcpy(er, hdrldp->er);

    ns_addr_t src = hdr_ip::access(pkt)->src_;
    trace(src, hdrldp);

    free(hdrldp->pathvec);
    free(hdrldp->er);
    Packet::free(pkt);

    switch (msgtype) {
    case LDP_NotificationMSG:    /* Notification   */
        char code[30];
        strcpy(code, parse_status(status));
        sprintf(out, "%s get-notification-msg %d %s %d", 
            name(), src.addr_, code, lspid);
        tcl.eval(out);
        break;

    case LDP_MappingMSG:    /* Label Mapping  */
        if (lspid >= 0) {
            /* CR-LDP */
            sprintf(out, "%s get-cr-mapping-msg %d %d %d %d %d %d",
                name(), msgid, src.addr_, fec, 
                label, lspid, reqmsgid);
        } else { 
            sprintf(out, "%s get-mapping-msg %d %d %d %d %s %d", 
                name(), msgid, src.addr_, fec, 
                label, pathvec, reqmsgid);
        }
        tcl.eval(out);
        break;

    case LDP_RequestMSG:    /* Label Request  */
        if (lspid >= 0) { 
            sprintf(out,
                "%s get-cr-request-msg %d %d %d %s %s %d %d", 
                name(), msgid, src.addr_, fec, pathvec,
                er, lspid, rc);
        } else { 
            sprintf(out, "%s get-request-msg %d %d %d %s", 
                name(), msgid, src.addr_, fec, pathvec);
        }
        tcl.eval(out);
        break;

    case LDP_WithdrawMSG:    /* Label Withdraw */
        sprintf(out, "%s get-withdraw-msg %d %d %d", 
            name(), src.addr_, fec, lspid);
        tcl.eval(out);
        break;

    case LDP_ReleaseMSG:    /* Label Release */
        sprintf(out, "%s get-release-msg %d %d %d", 
            name(), src.addr_, fec, lspid);
        tcl.eval(out);
        break;
    }
}

int LDPAgent::MSGTinsert(int MsgID, int FEC, int LspID, int Src, int PMsgID)
{
    if (MSGT_.NB == LDP_MaxMSGTEntryNB - 1)
        return(-1);

    if (MSGTlocate(FEC, LspID, Src) > -1)
        return(-1);
    
    MSGT_.Entry[MSGT_.NB].MsgID     = MsgID;
    MSGT_.Entry[MSGT_.NB].FEC       = FEC;
    MSGT_.Entry[MSGT_.NB].LspID     = LspID;
    MSGT_.Entry[MSGT_.NB].Src       = Src;
    MSGT_.Entry[MSGT_.NB].PMsgID    = PMsgID;
    MSGT_.Entry[MSGT_.NB].LabelOp   = LDP_LabelALLOC;
    MSGT_.Entry[MSGT_.NB].ERLspID   = -1;
    
    MSGT_.NB++;

    return(MSGT_.NB-1);
}

void LDPAgent::MSGTdelete(int entrynb)
{
    if ( (entrynb > -1) && (entrynb < MSGT_.NB) ) {
        MSGT_.Entry[entrynb].MsgID = -1;
        MSGT_.Entry[entrynb].FEC   = MSGT_.Entry[entrynb].LspID  = -1;
        MSGT_.Entry[entrynb].Src   = MSGT_.Entry[entrynb].PMsgID = -1;
        MSGT_.Entry[entrynb].LabelOp = -1;
        MSGT_.Entry[entrynb].ERLspID = -1;
    }   
}

int LDPAgent::MSGTlocate(int MsgID)
{
    if ( MsgID < 0 )
        return(-1);
    
    for (int i=0; i<MSGT_.NB; i++) {
        if ( MSGT_.Entry[i].MsgID == MsgID )
            return(i);
    }

    return(-1);
}

int LDPAgent::MSGTlocate(int FEC, int LspID, int Src)
{
    int i;
    if ( (FEC < 0) && (Src < 0) ) {
        if ( LspID > -1) {
            for (i=0; i<MSGT_.NB; i++)
                if ( MSGT_.Entry[i].LspID  == LspID )
                    return(i);
        }
        return(-1);
    }
       
    for (i=0; i<MSGT_.NB; i++) {
        if ( (MSGT_.Entry[i].FEC   == FEC  ) &&
             (MSGT_.Entry[i].LspID == LspID) &&
             (MSGT_.Entry[i].Src   == Src  ) )
            
            return(i);
    }

    return(-1);
}

void LDPAgent::MSGTlookup(int entrynb, int &MsgID, int &FEC, int &LspID, 
              int &Src, int &PMsgID, int &LabelOp)
{
    if ( (entrynb > -1) && (entrynb < MSGT_.NB) ) {  
        MsgID    = MSGT_.Entry[entrynb].MsgID;
        FEC      = MSGT_.Entry[entrynb].FEC;
        LspID    = MSGT_.Entry[entrynb].LspID;
        Src      = MSGT_.Entry[entrynb].Src;
        PMsgID   = MSGT_.Entry[entrynb].PMsgID;
        LabelOp= MSGT_.Entry[entrynb].LabelOp;
    } else {  
        MsgID = FEC = LspID = Src = PMsgID = LabelOp = -1;
    }
}

void LDPAgent::MSGTdump()
{
    for (int i = 0; i < MSGT_.NB; i++) {
        cerr << "  # MsgID =" << MSGT_.Entry[i].MsgID << "  ";
        cerr << "  # FEC   =" << MSGT_.Entry[i].FEC   << "  ";
        cerr << "  # LspID =" << MSGT_.Entry[i].LspID << "  ";
        cerr << "  # Src   =" << MSGT_.Entry[i].Src   << "  ";
        cerr << "  # PMsgID=" << MSGT_.Entry[i].PMsgID<< "  ";
        cerr << "  # LabelOp=" << MSGT_.Entry[i].LabelOp << "\n";
    }
}

void LDPAgent::trace(ns_addr_t src, hdr_ldp *hdrldp)
{
    // XXX will be changed later to directly write to a output channel
    // instead of sending stuff to otcl
    if (trace_ldp_ == 1) { 
        const char *msgtype = parse_msgtype(hdrldp->msgtype,
                            hdrldp->lspid);
        const char *status = (hdrldp->msgtype == 0x0001) ? 
            parse_status(hdrldp->status) : "*";
        Tcl::instance().evalf("%s trace-ldp-packet %d %d %s %d %d %d "
                      "%s %d %s %d %d %s %7f",
                      name(),
                      src.addr_,
                      src.port_,
                      msgtype, 
                      hdrldp->msgid, 
                      hdrldp->fec, 
                      hdrldp->label, 
                      hdrldp->pathvec, 
                      hdrldp->lspid, 
                      hdrldp->er, 
                      hdrldp->rc, 
                      hdrldp->reqmsgid,
                      status,
                      Scheduler::instance().clock());  
    }   
}

char* LDPAgent::parse_msgtype(int msgtype, int lspid)
{

    switch (msgtype) {
    case LDP_NotificationMSG:    /* Notification   */
        return("Notification");

    case LDP_MappingMSG:    /* Label Mapping  */
        if (lspid >= 0)          /* CR-LDP */
            return("CR-Mapping");
        else
            return("Mapping");
        
    case LDP_RequestMSG:    /* Label Request  */
        if (lspid >= 0)
            return("CR-Request");
        else
            return("Request");
        
    case LDP_WithdrawMSG:    /* Label Withdraw */
        return("Withdraw");
        
    case LDP_ReleaseMSG:    /* Label Release */
        return("Release");
    }

    return ("Error");
}

char* LDPAgent::parse_status(int status)
{
    switch (status) {
    case LDP_LoopDetected:
        return "LoopDetected";
        
    case LDP_NoRoute:
        return "NoRoute";
        
    default:
        return "Unknown";
    }
}

---