ldp_pdu_setup.c

Linux平台下

/*
 *  Copyright (C) James R. Leu 2000
 *  [e-mail]
 *
 *  This software is covered under the LGPL, for more
 *  info check out http://www.gnu.org/copyleft/lgpl.html
 */  
  
#include "ldp_struct.h"
#include "ldp_pdu_setup.h"

void setBaseMsgId(mplsLdpMsg_t * baseMsg, unsigned int msgId)
{
  baseMsg->msgId = msgId;
}

void setupBaseMsg(mplsLdpMsg_t * baseMsg, unsigned int type, int uBit,
  unsigned int msgId)
{
  baseMsg->flags.flags.msgType = type;
  baseMsg->flags.flags.uBit = uBit;
  baseMsg->msgLength = MPLS_MSGIDFIXLEN;
  setBaseMsgId(baseMsg, msgId);
}

int setupChpTlv(mplsLdpChpTlv_t * chpTlv, int target, int request, int res,
  int holdTime)
{
  chpTlv->baseTlv.flags.flags.tBit = MPLS_CHP_TLVTYPE;
  chpTlv->baseTlv.flags.flags.uBit = 0;
  chpTlv->baseTlv.flags.flags.fBit = 0;
  chpTlv->baseTlv.length = MPLS_CHPFIXLEN;
  chpTlv->flags.flags.target = target;
  chpTlv->flags.flags.request = request;
  chpTlv->flags.flags.res = res;
  chpTlv->holdTime = holdTime;
  return MPLS_TLVFIXLEN + MPLS_CHPFIXLEN;
}

int setupPinningTlv(mplsLdpPinningTlv_t * pinningTlv, int pBit, int res)
{
  pinningTlv->baseTlv.flags.flags.tBit = MPLS_PINNING_TLVTYPE;
  pinningTlv->baseTlv.flags.flags.uBit = 0;
  pinningTlv->baseTlv.flags.flags.fBit = 0;
  pinningTlv->baseTlv.length = 4;
  pinningTlv->flags.flags.pBit = pBit;
  pinningTlv->flags.flags.res = res;
  return 4 + MPLS_TLVFIXLEN;
}

int setupResClassTlv(mplsLdpResClsTlv_t * resClsTlv, unsigned int rsCls)
{
  resClsTlv->baseTlv.flags.flags.tBit = MPLS_RESCLASS_TLVTYPE;
  resClsTlv->baseTlv.flags.flags.uBit = 0;
  resClsTlv->baseTlv.flags.flags.fBit = 0;
  resClsTlv->baseTlv.length = 4;
  resClsTlv->rsCls = rsCls;
  return 4 + MPLS_TLVFIXLEN;
}

int setupPreemptTlv(mplsLdpPreemptTlv_t * preemptTlv, unsigned char setPrio,
  unsigned char holdPrio, unsigned short res)
{
  preemptTlv->baseTlv.flags.flags.tBit = MPLS_PREEMPT_TLVTYPE;
  preemptTlv->baseTlv.flags.flags.uBit = 0;
  preemptTlv->baseTlv.flags.flags.fBit = 0;
  preemptTlv->baseTlv.length = MPLS_PREEMPTTLV_FIXLEN;
  preemptTlv->setPrio = setPrio;
  preemptTlv->holdPrio = holdPrio;
  preemptTlv->res = res;
  return MPLS_PREEMPTTLV_FIXLEN + MPLS_TLVFIXLEN;
}

int addErHop2ErHopTvl(mplsLdpErTlv_t * erHopTlv, mplsLdpErHop_t * erHop,
  unsigned short type)
{
  int num = erHopTlv->numberErHops;
  int result = 0;

  memcpy(&(erHopTlv->erHopArray[num]), erHop, sizeof(mplsLdpErHop_t));
  erHopTlv->erHopTypes[num] = type;
  erHopTlv->numberErHops++;
  switch (type) {
    case MPLS_ERHOP_IPV4_TLVTYPE:
      result = MPLS_ERHOP_IPV4_FIXLEN;
      break;
    case MPLS_ERHOP_IPV6_TLVTYPE:
      result = MPLS_ERHOP_IPV6_FIXLEN;
      break;
    case MPLS_ERHOP_AS_TLVTYPE:
      result = MPLS_ERHOP_AS_FIXLEN;
      break;
    case MPLS_ERHOP_LSPID_TLVTYPE:
      result = MPLS_ERHOP_LSPID_FIXLEN;
      break;
  }
  return result + MPLS_TLVFIXLEN;
}

int setupErHopTlv(mplsLdpErTlv_t * erHopTlv)
{
  erHopTlv->baseTlv.flags.flags.tBit = MPLS_ERHOP_IPV4_TLVTYPE;
  erHopTlv->baseTlv.flags.flags.uBit = 0;
  erHopTlv->baseTlv.flags.flags.fBit = 0;
  erHopTlv->baseTlv.length = 0;
  return MPLS_TLVFIXLEN;
}

int setupTrAddrTlv(mplsLdpTrAdrTlv_t * trAddrTlv, unsigned int trAddr)
{
  trAddrTlv->baseTlv.flags.flags.tBit = MPLS_TRADR_TLVTYPE;
  trAddrTlv->baseTlv.flags.flags.uBit = 0;
  trAddrTlv->baseTlv.flags.flags.fBit = 0;
  trAddrTlv->baseTlv.length = MPLS_TRADRFIXLEN;
  trAddrTlv->address = trAddr;
  return MPLS_TRADRFIXLEN + MPLS_TLVFIXLEN;
}

int setupCsnTlv(mplsLdpCsnTlv_t * csnTlv, unsigned int confSeqNum)
{
  csnTlv->baseTlv.flags.flags.tBit = MPLS_CSN_TLVTYPE;
  csnTlv->baseTlv.flags.flags.uBit = 0;
  csnTlv->baseTlv.flags.flags.fBit = 0;
  csnTlv->baseTlv.length = MPLS_CSNFIXLEN;
  csnTlv->seqNumber = confSeqNum;
  return MPLS_CSNFIXLEN + MPLS_TLVFIXLEN;
}

int setupCspTlv(mplsLdpCspTlv_t * cspTlv, uint16_t keepalive,
  uint8_t adv_discp, uint8_t loop, uint8_t pvl, uint16_t mtu,
  uint32_t remote_lsraddr, uint16_t remote_labelspace, uint32_t res)
{
  cspTlv->baseTlv.flags.flags.tBit = MPLS_CSP_TLVTYPE;
  cspTlv->baseTlv.flags.flags.uBit = 0;
  cspTlv->baseTlv.flags.flags.fBit = 0;
  cspTlv->baseTlv.length = MPLS_CSPFIXLEN;
  cspTlv->protocolVersion = 1;
  cspTlv->holdTime = keepalive;
  cspTlv->flags.flags.lad = adv_discp;
  cspTlv->flags.flags.ld = loop;
  cspTlv->flags.flags.res = res;
  cspTlv->flags.flags.pvl = pvl;
  cspTlv->maxPduLen = mtu;
  cspTlv->rcvLsrAddress = remote_lsraddr;
  cspTlv->rcvLsId = remote_labelspace;
  return MPLS_CSPFIXLEN + MPLS_TLVFIXLEN;
}

int addLblRng2AspTlv(mplsLdpAspTlv_t * aspTlv, unsigned int minvpi,
  unsigned int minvci, unsigned int maxvpi, unsigned int maxvci)
{
  int num = aspTlv->baseTlv.length / MPLS_ASPFIXLEN;

  aspTlv->baseTlv.length += MPLS_ASPFIXLEN;
  aspTlv->lblRngList[num].flags.flags.res1 = 0;
  aspTlv->lblRngList[num].flags.flags.minVpi = minvpi;
  aspTlv->lblRngList[num].flags.flags.minVci = minvci;
  aspTlv->lblRngList[num].flags.flags.res2 = 0;
  aspTlv->lblRngList[num].flags.flags.maxVpi = maxvpi;
  aspTlv->lblRngList[num].flags.flags.maxVci = maxvci;
  return MPLS_ASPFIXLEN;
}

int addLblRng2FspTlv(mplsLdpFspTlv_t * fspTlv, unsigned int resmin,
  unsigned int len, unsigned int mindlci, unsigned int resmax,
  unsigned int maxdlci)
{
  int num = fspTlv->baseTlv.length / MPLS_FSPFIXLEN;

  fspTlv->baseTlv.length += MPLS_FSPFIXLEN;
  fspTlv->lblRngList[num].flags.flags.res_min = resmin;
  fspTlv->lblRngList[num].flags.flags.len = len;
  fspTlv->lblRngList[num].flags.flags.minDlci = mindlci;
  fspTlv->lblRngList[num].flags.flags.res_max = resmax;
  fspTlv->lblRngList[num].flags.flags.maxDlci = maxdlci;
  return MPLS_FSPFIXLEN;
}

int setupAspTlv(mplsLdpAspTlv_t * aspTlv, uint8_t merge, uint8_t direction)
{
  aspTlv->baseTlv.flags.flags.tBit = MPLS_ASP_TLVTYPE;
  aspTlv->baseTlv.flags.flags.uBit = 0;
  aspTlv->baseTlv.flags.flags.fBit = 0;
  aspTlv->flags.flags.dir = direction;
  aspTlv->flags.flags.mergeType = merge;
  aspTlv->baseTlv.length = 0;
  return MPLS_TLVFIXLEN;
}

int setupFspTlv(mplsLdpFspTlv_t * fspTlv, uint8_t merge, uint8_t direction)
{
  fspTlv->baseTlv.flags.flags.tBit = MPLS_FSP_TLVTYPE;
  fspTlv->baseTlv.flags.flags.uBit = 0;
  fspTlv->baseTlv.flags.flags.fBit = 0;
  fspTlv->flags.flags.dir = direction;
  fspTlv->flags.flags.mergeType = merge;
  fspTlv->baseTlv.length = 0;
  return MPLS_TLVFIXLEN;
}

int setupFecTlv(mplsLdpFecTlv_t * fecTlv)
{
  fecTlv->baseTlv.flags.flags.tBit = MPLS_FEC_TLVTYPE;
  fecTlv->baseTlv.flags.flags.uBit = 0;
  fecTlv->baseTlv.flags.flags.fBit = 0;
  fecTlv->baseTlv.length = 0;
  fecTlv->wcElemExists = 0;
  fecTlv->numberFecElements = 0;
  return MPLS_TLVFIXLEN;
}


#if 0
  mplsFecElement_t * createFecElemFromFecType(struct mpls_fec * fec)
{
  mplsFecElement_t * fecElem =
    (mplsFecElement_t *) malloc(sizeof(mplsFecElement_t));
  fecElem->addressEl.type = MPLS_PREFIX_FEC;
  fecElem->addressEl.addressFam = 1;
  fecElem->addressEl.preLen = fec->len;
  fecElem->addressEl.address = fec->prefix;
  return fecElem;
}

mplsFecElement_t * createFecElemFromRoute(routeT * r)
{
  mplsFecElement_t * fecElem = 
    (mplsFecElement_t *) malloc(sizeof(mplsFecElement_t));
  memset(fecElem, 0, sizeof(mplsFecElement_t));
  fecElem->addressEl.type = MPLS_PREFIX_FEC;
  fecElem->addressEl.addressFam = 1;
  fecElem->addressEl.preLen = r->len;
  fecElem->addressEl.address = r->prefix;
  return fecElem;
}


#endif /*  */
int addFecElem2FecTlv(mplsLdpFecTlv_t * fecTlv, mplsFecElement_t * elem)
{
  int num = fecTlv->numberFecElements;
  int size = 0;

  switch (elem->addressEl.type) {
    case MPLS_PREFIX_FEC:
    case MPLS_HOSTADR_FEC:
      size = elem->addressEl.preLen / 8;
      if (elem->addressEl.preLen % 8)
        size++;
      size += 4;
      break;
    case MPLS_CRLSP_FEC:
      size = 4;
      break;
  }
  fecTlv->baseTlv.length += size;