rsvpte_packet.c

Linux平台下

    memcpy(filterCopy.sourceAddr, filter->sourceAddr, RSVP_IPV6_ADDR_LEN);
    filterCopy.sourcePort = htons(filter->sourcePort);
    filterCopy.reserved = filter->reserved = 0;

    memcpy(buf, &filterCopy, RSVP_FILTER_SPEC6_SIZE);

    return RSVP_FILTER_SPEC6_SIZE;
}

int rsvpteDecodeFilterSpec6(rsvpFilterSpec6_t * filter, u_char * buf, int bufSize) {
    if (RSVP_FILTER_SPEC6_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(filter, buf, RSVP_FILTER_SPEC6_SIZE);
    filter->sourcePort = ntohs(filter->sourcePort);
    filter->reserved = 0;

    return RSVP_FILTER_SPEC6_SIZE;
}

int rsvpteEncodeFilterSpecFlow(rsvpFilterSpecFlow_t * filter, u_char * buf, int bufSize) {
    rsvpFilterSpecFlow_t filterCopy;

    if (RSVP_FILTER_SPEC_FLOW_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    memcpy(filterCopy.sourceAddr, filter->sourceAddr, RSVP_IPV6_ADDR_LEN);
    filterCopy.flag.mark = htonl(filter->flag.mark);

    memcpy(buf, &filterCopy, RSVP_FILTER_SPEC_FLOW_SIZE);

    return RSVP_FILTER_SPEC_FLOW_SIZE;
}

int rsvpteDecodeFilterSpecFlow(rsvpFilterSpecFlow_t * filter, u_char * buf, int bufSize) {
    if (RSVP_FILTER_SPEC_FLOW_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(filter, buf, RSVP_FILTER_SPEC_FLOW_SIZE);
    filter->flag.mark = ntohl(filter->flag.mark);

    return RSVP_FILTER_SPEC_FLOW_SIZE;
}

int rsvpteEncodeFilterSpecObject(rsvpFilterSpec_t * filter, 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(filter->hdr.cType) {
	case RSVP_FILTER_SPEC_CTYPE_IPV4:
	    size = rsvpteEncodeFilterSpec4(&filter->u.ipv4, buf, bufSize);
	    break;
	case RSVP_FILTER_SPEC_CTYPE_IPV6:
	    size = rsvpteEncodeFilterSpec6(&filter->u.ipv6, buf, bufSize);
	    break;
	case RSVP_FILTER_SPEC_CTYPE_FLOW:
	    size = rsvpteEncodeFilterSpecFlow(&filter->u.flow, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }
    if (size < 0) {
        return size;
    }

    encodeSize += size;

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

    return encodeSize;
}

int rsvpteDecodeFilterSpecObject(rsvpFilterSpec_t * filter, u_char * buf, int bufSize) {
    int decodedSize = 0;
    int size = rsvpteDecodeObjectHeader(&filter->hdr, buf, bufSize);

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

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

    if (filter->hdr.class != RSVP_FILTER_SPEC_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }

    switch(filter->hdr.cType) {
	case RSVP_FILTER_SPEC_CTYPE_IPV4:
	    size = rsvpteDecodeFilterSpec4(&filter->u.ipv4, buf, bufSize);
	    break;
	case RSVP_FILTER_SPEC_CTYPE_IPV6:
	    size = rsvpteDecodeFilterSpec6(&filter->u.ipv6, buf, bufSize);
	    break;
	case RSVP_FILTER_SPEC_CTYPE_FLOW:
	    size = rsvpteDecodeFilterSpecFlow(&filter->u.flow, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }
    if (size < 0) {
        return size;
    }

    return decodeSize + size;
}

/* Sender Template Object */

int rsvpteEncodeSenderTemplateTunnel4(rsvpSenderTemplateTunnel4_t * sender, u_char * buf, int bufSize) {
    rsvpSenderTemplateTunnel4_t senderCopy;

    if (RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    senderCopy.sender = htonl(sender->sender);
    senderCopy.reserved = 0;
    senderCopy.lspId = htons(sender->lspId);

    memcpy(buf, &senderCopy, RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE);

    return RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE;
}

int rsvpteDecodeSenderTemplateTunnel4(rsvpSenderTemplateTunnel4_t * sender, u_char * buf, int bufSize) {
    if (RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(sender, buf, RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE);
    sender->sender = ntohl(sender->sender);
    sender->reserved = 0;
    sender->lspId = ntohs(sender->lspId);

    return RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE;
}

int rsvpteEncodeSenderTemplateTunnel6(rsvpSenderTemplateTunnel4 * sender, u_char * buf, int bufSize) {
    rsvpSenderTemplateTunnel6_t senderCopy;

    if (RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    memcpy(senderCopy.sender, sender->sender, RSVP_IPV6_ADDR_LEN);
    senderCopy.reserved = 0;
    senderCopy.lspId = htons(sender->lspId);

    memcpy(buf, &senderCopy, RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE);

    return RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE;
}

int rsvpteDecodeSenderTemplateTunnel6(rsvpFilterSpecFlow_t * sender, u_char * buf, int bufSize) {
    if (RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(sender, buf, RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE);
    sender->lspId = ntohs(sender->lspId);

    return RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE;
}

int rsvpteEncodeSenderTemplateObject(rsvpSenderTemplate_t * sender, 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(sender->hdr.cType) {
	case RSVP_SENDER_TEMPLATE_CTYPE_IPV4:
	    size = rsvpteEncodeSenderTemplate4(&sender->u.ipv4, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_IPV6:
	    size = rsvpteEncodeSenderTemplate6(&sender->u.ipv6, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_FLOW:
	    size = rsvpteEncodeSenderTemplateFlow(&sender->u.flow, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL4:
	    size = rsvpteEncodeSenderTemplateTunnel4(&sender->u.tunnel4, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL6:
	    size = rsvpteEncodeSenderTemplateTunnel6(&sender->u.tunnel6, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }
    if (size < 0) {
        return size;
    }

    encodeSize += size;

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

    return encodeSize;
}

int rsvpteDecodeSenderTemplateObject(rsvpSenderTemplate_t * sender, u_char * buf, int bufSize) {
    int decodedSize = 0;
    int size = rsvpteDecodeObjectHeader(&sender->hdr, buf, bufSize);

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

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

    if (sender->hdr.class != RSVP_SENDER_TEMPLATE_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }

    switch(sender->hdr.cType) {
	case RSVP_SENDER_TEMPLATE_CTYPE_IPV4:
	    size = rsvpteDecodeSenderTemplate4(&sender->u.ipv4, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_IPV6:
	    size = rsvpteDecodeSenderTemplate6(&sender->u.ipv6, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_FLOW:
	    size = rsvpteDecodeSenderTemplateFlow(&sender->u.flow, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL4:
	    size = rsvpteDecodeSenderTemplateTunnel4(&sender->u.tunnel4, buf, bufSize);
	    break;
	case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL6:
	    size = rsvpteDecodeSenderTemplateTunnel6(&sender->u.tunnel6, buf, bufSize);
	    break;
  	default:
	    return RSVP_DEC_OBJECTERROR;
    }
    if (size < 0) {
        return size;
    }

    return decodeSize + size;
}

/* Record Route Object */

int rsvpteEncodeRecordRoute4(rsvpRecordRoute4_t * rr, u_char * buf, int bufSize) {
    rsvpRecordRoute4_t rrCopy;

    if (RSVP_RECORD_ROUTE4_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    rrCopy = *rr;
    rrCopy.type = RSVP_RECORD_ROUTE_TYPE_IPV4;
    rrCopy.length = RSVP_RECORD_ROUTE4_SIZE;
    htonl_nba(&rrCopy.addressMsb, NULL);

    memcpy(buf, &rrCopy, RSVP_RECORD_ROUTE4_SIZE);

    return RSVP_RECORD_ROUTE4_SIZE;
}

int rsvpteDecodeRecordRoute4(rsvpRecordRoute4_t * sender, u_char * buf, int bufSize) {
    if (RSVP_RECORD_ROUTE4_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(rr, buf, RSVP_RECORD_ROUTE4_SIZE);
    ntohl_nba(rr->addressMsb, NULL);

    return RSVP_RECORD_ROUTE4_SIZE;
}

int rsvpteEncodeRecordRoute6(rsvpRecordRoute6_t * rr, u_char * buf, int bufSize) {
    rsvpRecordRoute6_t rrCopy;

    if (RSVP_RECORD_ROUTE6_SIZE > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    rrCopy = *rr;
    rrCopy.type = RSVP_RECORD_ROUTE_TYPE_IPV6;
    rrCopy.length = RSVP_RECORD_ROUTE6_SIZE;

    memcpy(buf, &rrCopy, RSVP_RECORD_ROUTE6_SIZE);

    return RSVP_RECORD_ROUTE6_SIZE;
}

int rsvpteDecodeRecordRoute6(rsvpRecordRoute6_t * sender, u_char * buf, int bufSize) {
    if (RSVP_RECORD_ROUTE6_SIZE > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(rr, buf, RSVP_RECORD_ROUTE6_SIZE);

    return RSVP_RECORD_ROUTE6_SIZE;
}

int rsvpteEncodeRecordRouteLabel(rsvpRecordRouteLabel_t * rr, u_char * buf, int bufSize) {
    rsvpRecordRouteLabel_t rrCopy;
    int size;

    if (4 > bufSize) {
	return MPLS_ENC_BUFFTOOSMALL;
    }

    if ((size = rsvpteEncodeLabelObject(&rr->label, buf + 4, bufSize - 4)) < 0) {
	return size;
    }

    rrCopy = *rr;
    rrCopy.type = RSVP_RECORD_ROUTE_TYPE_LABEL;
    rrCopy.length = 4 + size;
    rrCopy.cType = rr->label.hdr.cType;

    memcpy(buf, &rrCopy, 4);

    return 4 + size;
}

int rsvpteDecodeRecordRouteLabel(rsvpRecordRouteLabel_t * sender, u_char * buf, int bufSize) {
    int size;
    if (4 > bufSize) {
	return MPLS_DEC_BUFFTOOSMALL;
    }

    memcpy(rr, buf, 4);
    size = rsvpteDecodeLabelObject(&rr->label, buf + 4, bufSize - 4;

    return 4 + size;
}

int rsvpteEncodeRecordRouteObject(rsvpRecordRouteObject_t * rr, char * bug, int bufSize) {
    int encodedSize = 0;
    char *bufHdr = buf;
    int size;
    in i;

    if (RSVP_OBJECT_HDRSIZE > bufSize) {
        return MPLS_ENC_BUFFTOOSMALL;
    }

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

    for (i = 0, i < = rr->rrLen, i++) {
	switch(rr->rrType[i]) {
	    case RSVP_RECORD_ROUTE_TYPE_IPV4:
		size = rsvpteEncodeRecordRoute4(&rr->rr[i].ipv4, buf, bufSize);
		break;
	    case RSVP_RECORD_ROUTE_TYPE_IPV6:
		size = rsvpteEncodeRecordRoute6(&rr->rr[i].ipv6, buf, bufSize);
		break;
	    case RSVP_RECORD_ROUTE_TYPE_LABEL:
		size = rsvpteEncodeRecordRouteLabel(&rr->rr[i].label, buf, bufSize);
		break;
	    default:
		return RSVP_ENC_OBJECTERROR;
	}
	if (size < 0) {
	    return size;
	}
	encodeSize += size;
	bufSize -= size;
	buf += size;
    }

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

    return encodeSize;
}

int rsvpteDecodeRecordRouteObject(rsvpRecordRouteObject_t * rr, char * bug, int bufSize) {
    int decodedSize = 0;
    int size = rsvpteDecodeObjectHeader(&rr->hdr, buf, bufSize);
    int i;

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

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

    if (rr->hdr.class != RSVP_RECORD_ROUTE_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }

    while (decodeSize < rr->hdr.length) {
	switch(buf[0]) {
	    case RSVP_RECORD_ROUTE_TYPE_IPV4:
		size = rsvpteDecodeRecordRoute4(&rr->rr[i].ipv4, buf, bufSize);
		break;
	    case RSVP_RECORD_ROUTE_TYPE_IPV6:
		size = rsvpteDecodeRecordRoute6(&rr->rr[i].ipv6, buf, bufSize);
		break;
	    case RSVP_RECORD_ROUTE_TYPE_LABEL:
		size = rsvpteDecodeRecordRouteLabel(&rr->rr[i].label, buf, bufSize);
		break;
	    default:
		return RSVP_DEC_OBJECTERROR;
	}

	if (size < 0) {
	    return RSVP_DEC_OBJECTERROR;
	}

	decodeSize += size;
	bufSize -= size;
	buf += size;
	i++;
    }
    rr->rrLen = i;

    return decodeSize;
}

/* Sender TSpec Object */

int rsvpteEncodeSenderTSpectObject(rsvpSenderTSpecObject_t * sender, char * bug, 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;

    /* need TSpec Definition */

    if (size < 0) {
        return size;
    }

    encodeSize += size;

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

    return encodeSize;
}

int rsvpteDecodeSenderTSpecObject(rsvpSenderTSpecObject_t * req, char * bug, int bufSize) {

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

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

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

    if (sender->hdr.class != RSVP_SENDER_TSPEC_CLASS) {
        return RSVP_DEC_OBJECTERROR;
    }
    /* need TSpec definitiion */

    if (size < 0) {
        return size;
    }

    return decodeSize + size;
}