rsvpte_packet.c

Linux平台下

int rsvpteEncodeExplicitRoute6(rsvpExplicitRoute6_t * er, u_char * buf, int bufSize) {
    rsvpExplicitRoute6_t erCopy;

    if (RSVP_ER6_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }
    erCopy = *er;

    erCopy.flags.mark = htons(er->flags.mark);

    memcpy(buf, &erCopy, RSVP_ER6_SIZE);

    return RSVP_ER6_SIZE;
}

int rsvpteDecodeExplicitRoute6(rsvpExplicitRoute6_t * er, u_char * buf, int bufSize) {
    if (RSVP_ER6_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(er, buf, RSVP_ER6_SIZE);
    er->flags.mark = ntohs(er->flags.mark);

    return RSVP_ER6_SIZE;
}

int rsvpteEncodeExplicitRouteAsn(rsvpExplicitRouteAsn_t * er, u_char * buf, int bufSize) {
    rsvpExplicitRouteAsn_t erCopy;

    if (RSVP_ERASN_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }
    erCopy = *er;

    erCopy.flags.mark = htons(er->flags.mark);

    memcpy(buf, &erCopy, RSVP_ER6_SIZE);

    return RSVP_ERASN_SIZE;
}

int rsvpteDecodeExplicitRouteAsn(rsvpExplicitRouteAsn_t * er, u_char * buf, int bufSize) {
    if (RSVP_ERASN_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(er, buf, RSVP_ERASN_SIZE);
    er->flags.mark = ntohs(er->flags.mark);

    return RSVP_ERASN_SIZE;
}

int rsvpteEncodeExplicitRouteObject(rsvpExplicitRouteObject_t * er, u_char * buf, int bufSize) {

    int encodedSize = 0;
    char *bufHdr = buf;
    int size;

    if (RSVP_OBJECT_HDRSIZE > bufSize) {
        return MPLS_ENC_BUFFTOOSMALL;
    }

    size = RSVP_OBJECT_HDRSIZE;
    encodeSize += size;
    bufSize -= size;
    buf += size;

    for (i = 0;i < er->eroLength;i++) {

	switch(er->eroType[i]) {
	    case RSVP_ERO_TYPE_IPV4:
		size = rsvpteEncodeExplicitRoute4(&er->ero[i], buf, bufSize);
		break;
	    case RSVP_ERO_TYPE_IPV6:
		size = rsvpteEncodeExplicitRoute6(&er->ero[i], buf, bufSize);
		break;
	    case RSVP_ERO_TYPE_ASN:
		size = rsvpteEncodeExplicitRouteAsn(&er->ero[i], buf, bufSize);
		break;
  	    default:
		return RSVP_ENC_OBJECTERROR;
	}

	if (size < 0) {
	    return size;
	}

	encodeSize += size;
	bufSize -= size;
	buf += size;
    }

    session->hdr.length = encodeSize;
    session->hdr.class = RSVP_EXPLICIT_ROUTE_CLASS;
    session->hdr.cType = RSVP_EXPLICIT_ROUTE_CTYPE;
    size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
        return size;
    }

    return encodeSize;
}

int rsvpteDecodeExplicitRouteSubObjectHdr(rsvpExplicitRouteFlag_t * hdr, u_char * buf, int bufSize) {
    u_short temp;
    if (sizeof(u_short) > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(&temp, buf, sizeof(u_short));
    temp = ntohs(temp);
    memcpy(hdr, &temp, sizeof(u_short));

    return sizeof(u_short);
}

int rsvpteDecodeExplicitRouteObject(rsvpExplicitRouteObject_t * er, u_char * buf, int bufSize) {
    rsvpExplicitRouteFlag_t erFlag;

    int decodedSize = 0;
    int size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);

    if (size < 0) {
        return size;
    }
    decodeSize += size;
    bufSize -= size;
    buf += size;

    if (session->hdr.length > bufSize) {
        return MPLS_DEC_BUFFTOOSMALL;
    }

    if (session->hdr.class != RSVP_EXPLICIT_ROUTE_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }

    while (decodeSize < session->hdr.length) {
	result = rsvpteDecodeExplicitRouteSubObjectHdr(&erFlag, buf, bufSize);

	switch(erFlag.type) {
	    case RSVP_ERO_TYPE_IPV4:
		size = rsvpteDecodeExplicitRoute4(&er->ero[i], buf, bufSize);
		break;
	    case RSVP_ERO_TYPE_IPV6:
		size = rsvpteDecodeExplicitRoute6(&er->ero[i], buf, bufSize);
		break;
	    case RSVP_ERO_TYPE_ASN:
		size = rsvpteDecodeExplicitRouteAsn(&er->ero[i], buf, bufSize);
		break;
	    default:
		return RSVP_DEC_OBJECTERROR;
	}
	er->eroType[i] = erFlag.type;

	if (size < 0) {
	    return size;
	}

	decodeSize += size;
	bufSize -= size;
	buf += size;
	i++;
    }
    er->erLength = i;

    return decodeSize;
}

/* Label Request Object */

int rsvpteEncodeLabelReqGeneric(rsvpLabelReqGeneric_t * gen, u_char * buf, int bufSize) {
    rsvpLabelReqGeneric_t genCopy;
    if (RSVP_LABELREQ_GENERIC_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }
    genCopy.reserved = htons(gen->reserved);
    genCopy.l3pid = htons(gen->l3pid);

    memcpy(buf, &genCopy, RSVP_LABELREQ_GENERIC_SIZE);

    return RSVP_LABELREQ_GENERIC_SIZE;
}

int rsvpteDecodeLabelReqGeneric(rsvpLabelReqGeneric_t * gen, u_char * buf, int bufSize) {
    if (RSVP_LABELREQ_GENERIC_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(er, buf, RSVP_LABELREQ_GENERIC_SIZE);
    gen->genCopy.reserved = ntohs(gen->genCopy.reserved);
    gen->genCopy.l3pid = ntohs(gen->genCopy.l3pid);

    return RSVP_LABELREQ_GENERIC_SIZE;
}

int rsvpteEncodeLabelReqAtm(rsvpLabelReqAtm_t * atm, u_char * buf, int bufSize) {
    rsvpLabelReqAtm_t atmCopy;
    if (RSVP_LABELREQ_ATM_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }
    atmCopy.reserved = htons(atm->reserved);
    atmCopy.l3pid = htons(atm->l3pid);

    atmCopy.minFlags.mark = htons(atm->minFlags.mark);
    atmCopy.minVci = htons(atm->minVci);

    atmCopy.maxFlags.mark = htons(atm->maxFlags.mark);
    atmCopy.maxVci = htons(atm->maxVci);

    memcpy(buf, &atmCopy, RSVP_LABELREQ_ATM_SIZE);

    return RSVP_LABELREQ_ATM_SIZE;
}

int rsvpteDecodeLabelReqAtm(rsvpLabelReqAtm_t * atm, u_char * buf, int bufSize) {
    if (RSVP_LABELREQ_ATM_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(atm, buf, RSVP_LABELREQ_ATM_SIZE);

    atm->reserved = htons(atm->reserved);
    atm->l3pid = htons(atm->l3pid);

    atm->minFlags.mark = htons(atm->minFlags.mark);
    atm->minVci = htons(atm->minVci);

    atm->maxFlags.mark = htons(atm->maxFlags.mark);
    atm->maxVci = htons(atm->maxVci);

    return RSVP_LABELREQ_ATM_SIZE;
}

int rsvpteEncodeLabelReqFr(rsvpLabelReqFr_t * fr, u_char * buf, int bufSize) {
    rsvpLabelReqFr_t frCopy;
    if (RSVP_LABELREQ_FR_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }
    frCopy.reserved = htons(fr->reserved);
    frCopy.l3pid = htons(fr->l3pid);

    frCopy.minFlags.mark = htons(fr->minFlags.mark);
    frCopy.maxFlags.mark = htons(fr->maxFlags.mark);

    memcpy(buf, &frCopy, RSVP_LABELREQ_FR_SIZE);

    return RSVP_LABELREQ_FR_SIZE;
}

int rsvpteDecodeLabelReqFr(rsvpLabelReqFr_t * fr, u_char * buf, int bufSize) {
    if (RSVP_LABELREQ_FR_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(fr, buf, RSVP_LABELREQ_FR_SIZE);

    fr->reserved = htons(fr->reserved);
    fr->l3pid = htons(fr->l3pid);

    fr->minFlags.mark = htons(fr->minFlags.mark);
    fr->maxFlags.mark = htons(fr->maxFlags.mark);

    return RSVP_LABELREQ_FR_SIZE;
}

int rsvpteEncodeLabelRequestObject(rsvpLabelRequestObject_t * req, u_char * buf, int bufSize) {
    int encodedSize = 0;
    char *bufHdr = buf;
    int size;

    if (RSVP_OBJECT_HDRSIZE > bufSize) {
        return MPLS_ENC_BUFFTOOSMALL;
    }

    size = RSVP_OBJECT_HDRSIZE;
    encodeSize += size;
    bufSize -= size;
    buf += size;

    switch(req->hdr.cType) {
	case RSVP_LABEL_REQUEST_CTYPE_GENERIC:
	    size = rsvpteEncodeLabelReqGeneric(&req->u.generic, buf, bufSize);
	    break;
	case RSVP_LABEL_REQUEST_CTYPE_ATM:
	    size = rsvpteEncodeLabelReqAtm(&req->u.atm, buf, bufSize);
	    break;
	case RSVP_LABEL_REQUEST_CTYPE_FR:
	    size = rsvpteEncodeLabelReqFr(&req->u.fr, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }
    if (size < 0) {
        return size;
    }

    encodeSize += size;

    req->hdr.length = encodeSize;
    req->hdr.class = RSVP_LABEL_REQUEST_CLASS;
    size = rsvpteEncodeObjectHeader(&req->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
        return size;
    }

    return encodeSize;
}

int rsvpteDecodeLabelRequestObject(rsvpLabelRequestObject_t * req, u_char * buf, int bufSize) {
    int decodedSize = 0;
    int size = rsvpteDecodeObjectHeader(&req->hdr, buf, bufSize);

    if (size < 0) {
        return size;
    }
    decodeSize += size;
    bufSize -= size;
    buf += size;

    if (req->hdr.length > bufSize) {
        return MPLS_DEC_BUFFTOOSMALL;
    }

    if (req->hdr.class != RSVP_LABEL_REQUEST_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }

    switch(req->hdr.cType) {
	case RSVP_LABEL_REQUEST_CTYPE_GENERIC:
	    size = rsvpteDecodeLabelReqGeneric(&req->u.generic, buf, bufSize);
	    break;
	case RSVP_LABEL_REQUEST_CTYPE_ATM:
	    size = rsvpteDecodeLabelReqAtm(&req->u.atm, buf, bufSize);
	    break;
	case RSVP_LABEL_REQUEST_CTYPE_FR:
	    size = rsvpteDecodeLabelReqFr(&req->u.fr, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }

    if (size < 0) {
	return size;
    }

    return decodeSize + size;
}

/* Session Attribute Object */

int rsvpteEncodeSessionAttribLspTunnel(rsvpSessionAttribLspTunnel_t * lsp, u_char * buf, int bufSize) {
    int size = RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE + lsp->nameLen;

    if (size > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    memcpy(buf, lsp, size);

    return size;
}

int rsvpteDecodeSessionAttribLspTunnel(rsvpSessionAttribLspTunnel_t * lsp, u_char * buf, int bufSize) {
    if (RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(lsp, buf, RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE);
    if (lsp->nameLen > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(lsp->name, buf, lsp->nameLen);

    return RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE + lsp->nameLen;
}

int rsvpteEncodeSessionAttribLspTunnelRa(rsvpSessionAttribLspTunnelRa_t * lsp, u_char * buf, int bufSize) {
    rsvpSessionAttribLspTunnelRa_t lspCopy;
    int size = RSVP_SESSION_ATTRIB_LSP_TUNNEL_RA_BASE_SIZE + lsp->nameLen;

    if (size > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    lspCopy = *lsp;
    lspCopy.excludeAny = htonl(lspCopy.excludeAny);
    lspCopy.includeAny = htonl(lspCopy.includeAny);
    lspCopy.includeAll = htonl(lspCopy.includeAll);
    memcpy(buf, &lspCopy, size);

    return size;
}

int rsvpteDecodeSessionAttribLspTunnelRa(rsvpSessionAttribLspTunnelRa_t * lsp, u_char * buf, int bufSize) {
    if (RSVP_SESSION_ATTRIB_LSP_TUNNEL_RA_BASE_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }
    memcpy(lsp, buf, RSVP_SESSION_ATTRIB_LSP_TUNNEL_RA_BASE_SIZE);

    if (lsp->nameLen > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }
    memcpy(lsp->name, buf, lsp->nameLen);

    lsp->excludeAny = ntohl(lsp->excludeAny);
    lsp->includeAny = ntohl(lsp->includeAny);
    lsp->includeAll = ntohl(lsp->includeAll);

    return RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE + lsp->nameLen;
}

int rsvpteEncodeSessionAttribObject(rsvpSessionAttibObject_t * session, u_char * buf, int bufSize) {

    int encodedSize = 0;
    char *bufHdr = buf;
    int size;

    if (RSVP_OBJECT_HDRSIZE > bufSize) {
        return MPLS_ENC_BUFFTOOSMALL;
    }

    size = RSVP_OBJECT_HDRSIZE;
    encodeSize += size;
    bufSize -= size;
    buf += size;

    switch(session->hdr.cType) {
	case RSVP_SESSION_ATTRIB_CTYPE_LSP_TUNNEL:
	    size = rsvpteEncodeSessionAttribLspTunnel(&session->u.tunnel, buf, bufSize);
	    break;
	case RSVP_SESSION_ATTRIB_CLASS_LSP_TUNNEL_RA:
	    size = rsvpteEncodeSessionAttribLspTunnelRa(&session->u.tunnelRa, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }

    if (size < 0) {
        return size;
    }

    encodeSize += size;

    session->hdr.length = encodeSize;
    session->hdr.class = RSVP_SESSION_ATTRIB_CLASS;
    size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
        return size;
    }

    return encodeSize;
}

int rsvpteDecodeSessionAttribObject(rsvpSessionAttibObject_t * session, u_char * buf, int bufSize) {
    int decodedSize = 0;
    int size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);

    if (size < 0) {
        return size;
    }
    decodeSize += size;
    bufSize -= size;
    buf += size;

    if (session->hdr.length > bufSize) {
        return MPLS_DEC_BUFFTOOSMALL;
    }

    if (session->hdr.class != RSVP_SESSION_ATTRIB_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }

    switch(session->hdr.cType) {
	case RSVP_SESSION_ATTRIB_CTYPE_LSP_TUNNEL:
	    size = rsvpteDecodeSessionAttribLspTunnel(&session->u.tunnel, buf, bufSize);
	    break;
	case RSVP_SESSION_ATTRIB_CLASS_LSP_TUNNEL_RA:
	    size = rsvpteDecodeSessionAttribLspTunnelRa(&session->u.tunnelRa, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }
    if (size < 0) {
        return size;
    }

    return decodeSize + size;
}

/* Filter Spec Object */

int rsvpteEncodeFilterSpec4(rsvpFilterSpec4_t * filter, u_char * buf, int bufSize) {
    rsvpFilterSpec4_t filterCopy;

    if (RSVP_FILTER_SPEC4_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    filterCopy.sourceAddr = htonl(filter->sourceAddr);
    filterCopy.sourcePort = htons(filter->sourcePort);
    filterCopy.reserved = filter->reserved = 0;

    memcpy(buf, &filterCopy, RSVP_FILTER_SPEC4_SIZE);

    return RSVP_FILTER_SPEC4_SIZE;
}

int rsvpteDecodeFilterSpec4(rsvpFilterSpec4_t * filter, u_char * buf, int bufSize) {
    if (RSVP_FILTER_SPEC4_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(filter, buf, RSVP_FILTER_SPEC4_SIZE);
    filter->sourceAddr = ntohl(filter->sourceAddr);
    filter->sourcePort = ntohs(filter->sourcePort);
    filter->reserved = 0;

    return RSVP_FILTER_SPEC4_SIZE;
}

int rsvpteEncodeFilterSpec6(rsvpFilterSpec6_t * filter, u_char * buf, int bufSize) {
    rsvpFilterSpec6_t filterCopy;

    if (RSVP_FILTER_SPEC6_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }