ldp_pdu_setup.c

Linux平台下

  memcpy(&(fecTlv->fecElArray[num]), elem, sizeof(mplsFecElement_t));
  fecTlv->fecElemTypes[num] = elem->addressEl.type;
  fecTlv->numberFecElements++;
  return size;
}


#if 0
void copyLabelType2MapLabelTlv(struct mpls_label *label,
  mplsLdpLblMapMsg_t * lblMap)
{
  switch (label->ml_type) {
    case MPLS_LABEL_ATM:
      lblMap->baseMsg.msgLength +=
        setupAtmLblTlv(&(lblMap->atmLblTlv), 0, 0, label->u.ml_atm.mla_vpi,
        label->u.ml_atm.mla_vci); lblMap->atmLblTlvExists = 1;
      lblMap->genLblTlvExists = 0;
      lblMap->frLblTlvExists = 0;
      break;
    case MPLS_LABEL_GEN:
      lblMap->baseMsg.msgLength +=
        setupGenLblTlv(&(lblMap->genLblTlv), label->u.ml_gen);
      lblMap->atmLblTlvExists = 0;
      lblMap->genLblTlvExists = 1;
      lblMap->frLblTlvExists = 0;
      break;
    case MPLS_LABEL_FR:
      lblMap->baseMsg.msgLength +=
        setupFrLblTlv(&(lblMap->frLblTlv), 0, 0, label->u.ml_fr);
      lblMap->atmLblTlvExists = 0;
      lblMap->genLblTlvExists = 0;
      lblMap->frLblTlvExists = 1;
      break;
    default:
      LDP_PRINT(g->user_data, "invalid label type\n");
      break;
  }
}
void copyAtmLblTlv2MplsLabel(mplsLdpAtmLblTlv_t * atmLblTlv,
  struct mpls_label *label)
{
  label->ml_type = MPLS_LABEL_ATM;
  label->u.ml_atm.mla_vpi = atmLblTlv->flags.flags.vpi;
  label->u.ml_atm.mla_vci = atmLblTlv->vci;
}


#endif /*  */

int setupAtmLblTlv(mplsLdpAtmLblTlv_t * atmLblTlv, int res, int v,
  unsigned int vpi, unsigned int vci)
{
  atmLblTlv->baseTlv.flags.flags.tBit = MPLS_ATMLBL_TLVTYPE;
  atmLblTlv->baseTlv.flags.flags.uBit = 0;
  atmLblTlv->baseTlv.flags.flags.fBit = 0;
  atmLblTlv->baseTlv.length = MPLS_LBLFIXLEN;
  atmLblTlv->flags.flags.res = res;
  atmLblTlv->flags.flags.v = v;
  atmLblTlv->flags.flags.vpi = vpi;
  atmLblTlv->vci = vci;
  return MPLS_LBLFIXLEN + MPLS_TLVFIXLEN;
}


#if 0
void copyFrLblTlv2MplsLabel(mplsLdpFrLblTlv_t * frLblTlv,
  struct mpls_label *label)
{
  label->ml_type = MPLS_LABEL_FR;
  label->u.ml_fr = frLblTlv->flags.flags.dlci;
}


#endif /*  */

int setupFrLblTlv(mplsLdpFrLblTlv_t * frLblTlv, int res, int len,
  unsigned int dlci)
{
  frLblTlv->baseTlv.flags.flags.tBit = MPLS_FRLBL_TLVTYPE;
  frLblTlv->baseTlv.flags.flags.uBit = 0;
  frLblTlv->baseTlv.flags.flags.fBit = 0;
  frLblTlv->baseTlv.length = MPLS_LBLFIXLEN;
  frLblTlv->flags.flags.res = res;
  frLblTlv->flags.flags.len = len;
  frLblTlv->flags.flags.dlci = dlci;
  return MPLS_LBLFIXLEN + MPLS_TLVFIXLEN;
}


#if 0
void copyGenLblTlv2MplsLabel(mplsLdpGenLblTlv_t * genLblTlv,
  struct mpls_label *label)
{
  label->ml_type = MPLS_LABEL_GEN;
  label->u.ml_gen = genLblTlv->label;
}


#endif /*  */

int setupGenLblTlv(mplsLdpGenLblTlv_t * genLblTlv, int label)
{
  genLblTlv->baseTlv.flags.flags.tBit = MPLS_GENLBL_TLVTYPE;
  genLblTlv->baseTlv.flags.flags.uBit = 0;
  genLblTlv->baseTlv.flags.flags.fBit = 0;
  genLblTlv->baseTlv.length = MPLS_LBLFIXLEN;
  genLblTlv->label = label;
  return MPLS_LBLFIXLEN + MPLS_TLVFIXLEN;
}

int setupHopCountTlv(mplsLdpHopTlv_t * hopCountTlv, unsigned int hopCount)
{
  hopCountTlv->baseTlv.flags.flags.tBit = MPLS_HOPCOUNT_TLVTYPE;
  hopCountTlv->baseTlv.flags.flags.uBit = 0;
  hopCountTlv->baseTlv.flags.flags.fBit = 0;
  hopCountTlv->baseTlv.length = MPLS_HOPCOUNTFIXLEN;
  hopCountTlv->hcValue = hopCount;
  return MPLS_HOPCOUNTFIXLEN + MPLS_TLVFIXLEN;
}

int setupPathTlv(mplsLdpPathTlv_t * pathTlv)
{
  pathTlv->baseTlv.flags.flags.tBit = MPLS_PATH_TLVTYPE;
  pathTlv->baseTlv.flags.flags.uBit = 0;
  pathTlv->baseTlv.flags.flags.fBit = 0;
  pathTlv->baseTlv.length = 0;
  return MPLS_TLVFIXLEN;
}

int addLsrId2PathTlv(mplsLdpPathTlv_t * pathTlv, unsigned int lsrId)
{
  int num = pathTlv->baseTlv.length / sizeof(unsigned int);
  pathTlv->baseTlv.length += sizeof(unsigned int);

  pathTlv->lsrId[num] = lsrId;
  return sizeof(unsigned int);
}

int setupAddrTlv(mplsLdpAdrTlv_t * addrTlv)
{
  addrTlv->baseTlv.flags.flags.tBit = MPLS_ADDRLIST_TLVTYPE;
  addrTlv->baseTlv.flags.flags.uBit = 0;
  addrTlv->baseTlv.flags.flags.fBit = 0;
  addrTlv->baseTlv.length = MPLS_ADDFAMFIXLEN;
  addrTlv->addrFamily = 1;
  return MPLS_TLVFIXLEN + MPLS_ADDFAMFIXLEN;
}

int addAddrElem2AddrTlv(mplsLdpAdrTlv_t * addrTlv, unsigned int addr)
{
  int num = (addrTlv->baseTlv.length - MPLS_ADDFAMFIXLEN) / MPLS_IPv4LEN;

  addrTlv->address[num] = addr;
  addrTlv->baseTlv.length += MPLS_IPv4LEN;
  return MPLS_IPv4LEN;
}

int setupStatusTlv(mplsLdpStatusTlv_t * statTlv, int fatal, int forward,
  int status, unsigned int msgId, int msgType)
{
  statTlv->baseTlv.flags.flags.tBit = MPLS_NOT_ST_TLVTYPE;
  statTlv->baseTlv.flags.flags.uBit = 0;
  statTlv->baseTlv.flags.flags.fBit = 0;
  statTlv->baseTlv.length = MPLS_STATUSFIXLEN;
  statTlv->flags.flags.error = fatal;
  statTlv->flags.flags.forward = forward;
  statTlv->flags.flags.status = status;
  statTlv->msgId = msgId;
  statTlv->msgType = msgType;
  return MPLS_STATUSFIXLEN + MPLS_TLVFIXLEN;
}

int setupExStatusTlv(mplsLdpExStatusTlv_t * exStatus, unsigned int value)
{
  exStatus->baseTlv.flags.flags.tBit = MPLS_NOT_ES_TLVTYPE;
  exStatus->baseTlv.flags.flags.uBit = 0;
  exStatus->baseTlv.flags.flags.fBit = 0;
  exStatus->baseTlv.length = MPLS_EXSTATUSLEN;
  exStatus->value = value;
  return MPLS_EXSTATUSLEN + MPLS_TLVFIXLEN;
}

int setupRetPduTlv(mplsLdpRetPduTlv_t * retPduTvl, unsigned int len,
  mplsLdpHeader_t * hdr, void *data)
{
  retPduTvl->baseTlv.flags.flags.tBit = MPLS_NOT_RP_TLVTYPE;
  retPduTvl->baseTlv.flags.flags.uBit = 0;
  retPduTvl->baseTlv.flags.flags.fBit = 0;
  retPduTvl->baseTlv.length = MPLS_LDP_HDRSIZE + len;
  memcpy(&(retPduTvl->headerTlv), hdr, MPLS_LDP_HDRSIZE);
  memcpy(retPduTvl->data, data, len);
  return MPLS_LDP_HDRSIZE + len + MPLS_TLVFIXLEN;
}

int setupRetMsgTlv(mplsLdpRetMsgTlv_t * retMsgTlv, unsigned type,
  unsigned len, void *data)
{
  retMsgTlv->baseTlv.flags.flags.tBit = MPLS_NOT_RM_TLVTYPE;
  retMsgTlv->baseTlv.flags.flags.uBit = 0;
  retMsgTlv->baseTlv.flags.flags.fBit = 0;
  retMsgTlv->baseTlv.length = len;
  retMsgTlv->msgType = type;
  retMsgTlv->msgLength = 4 + len;
  memcpy(retMsgTlv->data, data, len);
  return 4 + len + MPLS_TLVFIXLEN;
}

int setupLspidTlv(mplsLdpLspIdTlv_t * lspidTlv, int res,
  unsigned int localCrlspId, unsigned int routerId)
{
  lspidTlv->baseTlv.flags.flags.tBit = MPLS_LSPID_TLVTYPE;
  lspidTlv->baseTlv.flags.flags.uBit = 0;
  lspidTlv->baseTlv.flags.flags.fBit = 0;
  lspidTlv->baseTlv.length = MPLS_LSPIDTLV_FIXLEN;
  lspidTlv->res = res;
  lspidTlv->localCrlspId = localCrlspId;
  lspidTlv->routerId = routerId;
  return MPLS_LSPIDTLV_FIXLEN + MPLS_TLVFIXLEN;
}

int setupTrafficTlv(mplsLdpTrafficTlv_t * trafficTlv, unsigned char freq,
  unsigned char res, unsigned char weight, float pdr, float pbs, float cdr,
  float cbs, float ebs)
{
  trafficTlv->baseTlv.flags.flags.tBit = MPLS_TRAFFIC_TLVTYPE;
  trafficTlv->baseTlv.flags.flags.uBit = 0;
  trafficTlv->baseTlv.flags.flags.fBit = 0;
  trafficTlv->baseTlv.length = 0;
  trafficTlv->flags.flags.res = 0;
  trafficTlv->flags.flags.f6Bit = 0;
  trafficTlv->flags.flags.f5Bit = 0;
  trafficTlv->flags.flags.f4Bit = 0;
  trafficTlv->flags.flags.f3Bit = 0;
  trafficTlv->flags.flags.f2Bit = 0;
  trafficTlv->flags.flags.f1Bit = 0;
  trafficTlv->freq = freq;
  trafficTlv->res = res;
  trafficTlv->weight = weight;
  trafficTlv->pdr.pdr = pdr;
  trafficTlv->pbs.pbs = pbs;
  trafficTlv->cdr.cdr = cdr;
  trafficTlv->cbs.cbs = cbs;
  trafficTlv->ebs.ebs = ebs;
  return MPLS_TLVFIXLEN;
}

int setupLblMsgIdTlv(mplsLdpLblMsgIdTlv_t * lblMsgIdTlv, unsigned int msgId)
{
  lblMsgIdTlv->baseTlv.flags.flags.tBit = MPLS_REQMSGID_TLVTYPE;
  lblMsgIdTlv->baseTlv.flags.flags.uBit = 0;
  lblMsgIdTlv->baseTlv.flags.flags.fBit = 0;
  lblMsgIdTlv->baseTlv.length = MPLS_MSGIDFIXLEN;
  lblMsgIdTlv->msgId = msgId;
  return MPLS_MSGIDFIXLEN + MPLS_TLVFIXLEN;
}