rsvpte/rsvpte_packet.c

   1 #include "rsvpte_struct.h"
   2
   3 inline void htonl_nba(u_char * buf, u_int * extra) {
   4     u_int temp;
   5     memcpy(&temp, buf, sizeof(u_int));
   6     temp = htonl(temp);
   7     memcpy(buf, &temp, sizeof(u_int));
   8     if (extra) {
   9         (*extra) = temp;
  10     }
  11 }
  12
  13 inline void ntohl_nba(u_char * buf, u_int * extra) {
  14     u_int temp;
  15     memcpy(&temp, buf, sizeof(u_int));
  16     temp = ntohl(temp);
  17     memcpy(buf, &temp, sizeof(u_int));
  18     if (extra) {
  19         (*extra) = temp;
  20     }
  21 }
  22
  23 inline void htons_nba(u_char * buf, u_short * extra) {
  24     u_short temp;
  25     memcpy(&temp, buf, sizeof(u_short));
  26     temp = htons(temp);
  27     memcpy(buf, &temp, sizeof(u_short));
  28     if (extra) {
  29         (*extra) = temp;
  30     }
  31 }
  32
  33 inline void ntohs_nba(u_char * buf, u_short * extra) {
  34     u_int temp;
  35     memcpy(&temp, buf, sizeof(u_short));
  36     temp = ntohs(temp);
  37     memcpy(buf, &temp, sizeof(u_short));
  38     if (extra) {
  39         (*extra) = temp;
  40     }
  41 }
  42
  43 /* Message Header */
  44
  45 int rsvpteEncodeMsgHeader(rsvpHeader_t * header, u_char * buf, int bufSize) {
  46     rsvpHeader_t headerCopy;
  47
  48     if (RSVP_HDRSIZE > bufSize) {
  49         return MPLS_ENC_BUFFTOOSMALL;
  50     }
  51
  52     headerCopy = *header;
  53     headerCopy.checksum = htons(header->checksum);
  54     headerCopy.length = htons(header->length);
  55
  56     memcpy(buf, &headerCopy, RSVP_HDRSIZE);
  57     return RSVP_HDRSIZE;
  58 }
  59
  60 int rsvpteDecodeMsgHeader(rsvpHeader_t * header, u_char * buf, int bufSize) {
  61     if (RSVP_HDRSIZE > bufSize) {
  62         return MPLS_DEC_BUFFTOOSMALL;
  63     }
  64
  65     memcpy((u_char*)header, buf, RSVP_HDRSIZE);
  66     header->checksum = ntohs(header->checksum);
  67     header->length = ntohs(header->length);
  68
  69     if (header->length > RSVP_PDUMAXLEN) {
  70         return MPLS_PDU_LENGTH_ERROR;
  71     }
  72     return RSVP_HDRSIZE;
  73 }
  74
  75 /* Object Header */
  76
  77 int rsvpteEncodeObjectHeader(rsvpObjectHeader_t * header, u_char * buf, int bufSize) {
  78     rsvpObjectHeader_t headerCopy;
  79
  80     if (RSVP_OBJECT_HDRSIZE > bufSize) {
  81         return MPLS_ENC_BUFFTOOSMALL;
  82     }
  83
  84     headerCopy = *header;
  85     headerCopy.length = htons(header->length);
  86
  87     memcpy(buf, &headerCopy, RSVP_OBJECT_HDRSIZE);
  88     return RSVP_OBJECT_HDRSIZE;
  89 }
  90
  91 int rsvpteDecodeObjectHeader(rsvpObjectHeader_t * header, u_char * buf, int bufSize) {
  92     if (RSVP_OBJECT_HDRSIZE > bufSize) {
  93         return MPLS_DEC_BUFFTOOSMALL;
  94     }
  95
  96     memcpy(header, buf, RSVP_OBJECT_HDRSIZE);
  97     header->length = ntohs(header->length);
  98     return RSVP_OBJECT_HDRSIZE;
  99 }
 100
 101 /* Session Object */
 102
 103 int rsvpteEncodeSession4(rsvpSession4_t * session, u_char * buf, int bufSize) {
 104     rsvpSession4_t sessionCopy;
 105
 106     if (RSVP_SESSION4_SIZE > bufSize) {
 107         return MPLS_ENC_BUFFTOOSMALL;
 108     }
 109     sessionCopy = *session;
 110
 111     sessionCopy.destAddr = htonl(session->destAddr);
 112     sessionCopy.destPort = htons(session->destPort);
 113
 114     memcpy(buf, &sessionCopy, RSVP_SESSION4_SIZE);
 115     return RSVP_SESSION4_SIZE;
 116 }
 117
 118 int rsvpteDecodeSession4(rsvpSession4_t * session, u_char * buf, int bufSize) {
 119     if (RSVP_SESSION4_SIZE > bufSize) {
 120         return MPLS_DEC_BUFFTOOSMALL;
 121     }
 122
 123     memcpy(session, buf, RSVP_SESSION4_SIZE);
 124     session->destAddr = nthol(session->destAddr);
 125     session->destPort = nthos(session->destPort);
 126
 127     return RSVP_SESSION4_SIZE;
 128 }
 129
 130 int rsvpteEncodeSession6(rsvpSession6_t * session, u_char * buf, int bufSize) {
 131     rsvpSession6_t sessionCopy;
 132     if (RSVP_SESSION6_SIZE > bufSize) {
 133         return MPLS_ENC_BUFFTOOSMALL;
 134     }
 135     sessionCopy = *session;
 136
 137     sessionCopy.destPort = htons(session->destPort);
 138
 139     memcpy(buf, &sessionCopy, RSVP_SESSION4_SIZE);
 140     return RSVP_SESSION4_SIZE;
 141 }
 142
 143 int rsvpteDecodeSession6(rsvpSession6_t * session, u_char * buf, int bufSize) {
 144     if (RSVP_SESSION6_SIZE > bufSize) {
 145         return MPLS_DEC_BUFFTOOSMALL;
 146     }
 147
 148     memcpy(session, buf, RSVP_SESSION4_SIZE);
 149     session->destPort = nthos(session->destPort);
 150
 151     return RSVP_SESSION4_SIZE;
 152 }
 153
 154 int rsvpteEncodeSessionTunnel4(rsvpSessionTunnel4_t * session, u_char * buf, int bufSize) {
 155     rsvpSessionTunnel4_t sessionCopy;
 156     if (RSVP_SESSION_TUNNEL4_SIZE > bufSize) {
 157         return MPLS_ENC_BUFFTOOSMALL;
 158     }
 159     sessionCopy = *session;
 160
 161     sessionCopy.endPointAddress = htonl(session->endPointAddress);
 162     sessionCopy.reserved = 0;
 163     sessionCopy.tunnelId = htons(session->tunnelId);
 164     sessionCopy.extentedTunnelId = htonl(session->destPort);
 165
 166     memcpy(buf, &sessionCopy, RSVP_SESSION_TUNNEL4_SIZE);
 167     return RSVP_SESSION_TUNNEL4_SIZE;
 168 }
 169
 170 int rsvpteDecodeSessionTunnel4(rsvpSessionTunnel4_t * session, u_char * buf, int bufSize) {
 171     if (RSVP_SESSION_TUNNEL4_SIZE > bufSize) {
 172         return MPLS_DEC_BUFFTOOSMALL;
 173     }
 174
 175     memcpy(session, buf, RSVP_SESSION_TUNNEL4_SIZE);
 176     session->endPointAddress = nthol(session->endPointAddress);
 177     session->reserved = nthos(session->reserved);
 178     session->tunnelId = nthos(session->tunnelId);
 179     session->extentedTunnelId = nthol(session->extentedTunnelId);
 180
 181     return RSVP_SESSION_TUNNEL4_SIZE;
 182 }
 183
 184 int rsvpteEncodeSessionTunnel6(rsvpSessionTunnel6_t * session, u_char * buf, int bufSize) {
 185     rsvpSessionTunnel6_t sessionCopy;
 186     if (RSVP_SESSION_TUNNEL6_SIZE > bufSize) {
 187         return MPLS_ENC_BUFFTOOSMALL;
 188     }
 189     sessionCopy = *session;
 190
 191     sessionCopy.reserved = 0;
 192     sessionCopy.tunnelId = htons(session->tunnelId);
 193
 194     memcpy(buf, &sessionCopy, RSVP_SESSION_TUNNEL6_SIZE);
 195     return RSVP_SESSION_TUNNEL6_SIZE;
 196 }
 197
 198 int rsvpteDecodeSessionTunnel6(rsvpSessionTunnel6_t * session, u_char * buf, int bufSize) {
 199     if (RSVP_SESSION_TUNNEL6_SIZE > bufSize) {
 200         return MPLS_DEC_BUFFTOOSMALL;
 201     }
 202
 203     memcpy(session, buf, RSVP_SESSION_TUNNEL6_SIZE);
 204     session->reserved = nthos(session->reserved);
 205     session->tunnelId = nthos(session->tunnelId);
 206
 207     return RSVP_SESSION_TUNNEL6_SIZE;
 208 }
 209
 210 int rsvpteEncodeSessionObject(rsvpSessionObject_t * session, u_char * buf, int bufSize) {
 211     int encodedSize = 0;
 212     char *bufHdr = buf;
 213     int size;
 214
 215     if (RSVP_OBJECT_HDRSIZE > bufSize) {
 216         return MPLS_ENC_BUFFTOOSMALL;
 217     }
 218
 219     size = RSVP_OBJECT_HDRSIZE;
 220     encodeSize += size;
 221     bufSize -= size;
 222     buf += size;
 223
 224     switch(session->hdr.cType) {
 225         case RSVP_SESSION_CTYPE_IPV4:
 226             size = rsvpteEncodeSession4(&session->u.ipv4, buf, bufSize);
 227             break;
 228         case RSVP_SESSION_CTYPE_IPV6:
 229             size = rsvpteEncodeSession6(&session->u.ipv6, buf, bufSize);
 230             break;
 231         case RSVP_SESSION_CTYPE_TUNNEL4:
 232             size = rsvpteEncodeSessionTunnel4(&session->u.tunnel4, buf, bufSize);
 233             break;
 234         case RSVP_SESSION_CTYPE_TUNNEL6:
 235             size = rsvpteEncodeSessionTunnel6(&session->u.tunnel6, buf, bufSize);
 236             break;
 237         default:
 238             return RSVP_ENC_OBJECTERROR;
 239     }
 240
 241     if (size < 0) {
 242         return size;
 243     }
 244
 245     encodeSize += size;
 246
 247     session->hdr.length = encodeSize;
 248     session->hdr.class = RSVP_SESSION_CLASS;
 249     size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);
 250     if (size < 0) {
 251         return size;
 252     }
 253
 254     return encodeSize;
 255 }
 256
 257 int rsvpteDecodeSessionObject(rsvpSessionObject_t * session, u_char * buf, int bufSize) {
 258     int decodedSize = 0;
 259
 260     size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);
 261     if (size < 0) {
 262         return size;
 263     }
 264     decodeSize += size;
 265     bufSize -= size;
 266     buf += size;
 267
 268     if (session->hdr.length > bufSize) {
 269         return MPLS_DEC_BUFFTOOSMALL;
 270     }
 271
 272     if (session->hdr.class != RSVP_SESSION_CLASS) {
 273         return RSVP_DEC_OBJECTERROR;
 274     }
 275
 276     switch(session->hdr.cType) {
 277         case RSVP_SESSION_CTYPE_IPV4:
 278             size = rsvpteDecodeSession4(&session->u.ipv4, buf, bufSize);
 279             break;
 280         case RSVP_SESSION_CTYPE_IPV6:
 281             size = rsvpteDecodeSession6(&session->u.ipv6, buf, bufSize);
 282             break;
 283         case RSVP_SESSION_CTYPE_TUNNEL4:
 284             size = rsvpteDecodeSessionTunnel4(&session->u.tunnel4, buf, bufSize);
 285             break;
 286         case RSVP_SESSION_CTYPE_TUNNEL6:
 287             size = rsvpteDecodeSessionTunnel6(&session->u.tunnel6, buf, bufSize);
 288             break;
 289         default:
 290             return RSVP_DEC_OBJECTERROR;
 291     }
 292
 293     if (size < 0) {
 294         return size;
 295     }
 296
 297     return decodeSize + size;
 298 }
 299
 300 int rsvpteEncodeHop4(rsvpHop4_t * hop, u_char * buf, int bufSize) {
 301     rsvpHop4_t hopCopy;
 302     if (RSVP_HOP4_SIZE > bufSize) {
 303         return MPLS_ENC_BUFFTOOSMALL;
 304     }
 305     hopCopy = *hop;
 306
 307     hopCopy.hopAddr = htonl(hop->hopAddr);
 308     hopCopy.logicalIfHandle = htonl(hop->logicalIfHandle);
 309     memcpy(buf, &hopCopy, RSVP_HOP4_SIZE);
 310
 311     return RSVP_HOP4_SIZE;
 312 }
 313
 314 int rsvpteDecodeHop4(rsvpHop4_t * hop, u_char * buf, int bufSize) {
 315     if (RSVP_HOP4_SIZE > bufSize) {
 316         return MPLS_DEC_BUFFTOOSMALL;
 317     }
 318
 319     memcpy(hop, buf, RSVP_HOP4_SIZE);
 320     hop->hopAddr = nthol(hop->hopAddr);
 321     hop->logicalIfHandle = nthol(hop->logicalIfHandle);
 322
 323     return RSVP_HOP4_SIZE;
 324 }
 325
 326 int rsvpteEncodeHop6(rsvpHop6_t * hop, u_char * buf, int bufSize) {
 327     rsvpHop6_t hopCopy;
 328     if (RSVP_HOP6_SIZE > bufSize) {
 329         return MPLS_ENC_BUFFTOOSMALL;
 330     }
 331     hopCopy = *hop;
 332
 333     hopCopy.logicalIfHandle = htonl(hop->logicalIfHandle);
 334     memcpy(buf, &hopCopy, RSVP_HOP6_SIZE);
 335
 336     return RSVP_HOP6_SIZE;
 337 }
 338
 339 int rsvpteDecodeHop6(rsvpHop6_t * hop, u_char * buf, int bufSize) {
 340     if (RSVP_HOP6_SIZE > bufSize) {
 341         return MPLS_DEC_BUFFTOOSMALL;
 342     }
 343
 344     memcpy(hop, buf, RSVP_HOP6_SIZE);
 345     hop->logicalIfHandle = nthol(hop->logicalIfHandle);
 346
 347     return RSVP_HOP6_SIZE;
 348 }
 349
 350 int rsvpteEncodeHopObject(rsvpHopObject_t * hop, u_char * buf, int bufSize) {
 351     int encodedSize = 0;
 352     char *bufHdr = buf;
 353     int size;
 354
 355     if (RSVP_OBJECT_HDRSIZE > bufSize) {
 356         return MPLS_ENC_BUFFTOOSMALL;
 357     }
 358
 359     size = RSVP_OBJECT_HDRSIZE;
 360     encodeSize += size;
 361     bufSize -= size;
 362     buf += size;
 363
 364     switch(hop->hdr.cType) {
 365         case RSVP_HOP_CTYPE_IPV4:
 366             size = rsvpteEncodeHop4(&hop->u.ipv4, buf, bufSize);
 367             break;
 368         case RSVP_HOP_CTYPE_IPV6:
 369             size = rsvpteEncodeHop6(&hop->u.ipv6, buf, bufSize);
 370             break;
 371         default:
 372             return RSVP_ENC_OBJECTERROR;
 373     }
 374
 375     if (size < 0) {
 376         return size;
 377     }
 378
 379     encodeSize += size;
 380
 381     session->hdr.length = encodeSize;
 382     session->hdr.class = RSVP_HOP_CLASS;
 383     size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
 384         return size;
 385     }
 386
 387     return encodeSize;
 388 }
 389
 390 int rsvpteDecodeHopObject(rsvpHopObject_t * hop, u_char * buf, int bufSize) {
 391     int decodedSize = 0;
 392     int size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);
 393
 394     if (size < 0) {
 395         return size;
 396     }
 397     decodeSize += size;
 398     bufSize -= size;
 399     buf += size;
 400
 401     if (session->hdr.length > bufSize) {
 402         return MPLS_DEC_BUFFTOOSMALL;
 403     }
 404
 405     if (session->hdr.class != RSVP_HOP_CLASS) {
 406         return RSVP_DEC_OBJECTERROR;
 407     }
 408
 409     switch(session->hdr.cType) {
 410         case RSVP_HOP_CTYPE_IPV4:
 411             size = rsvpteDecodeHop4(&hop->u.ipv4, buf, bufSize);
 412             break;
 413         case RSVP_HOP_CTYPE_IPV6:
 414             size = rsvpteDecodeHop4(&hop->u.ipv6, buf, bufSize);
 415             break;
 416         default:
 417             return RSVP_DEC_OBJECTERROR;
 418     }
 419
 420     if (size < 0) {
 421         return size;
 422     }
 423
 424     return decodeSize + size;
 425 }
 426
 427 /* Time Object */
 428
 429 int rsvpteEncodeTimeObject(rsvpTimeObject_t * time, u_char * buf, int bufSize) {
 430     int encodedSize = 0;
 431     char *bufHdr = buf;
 432     int size;
 433
 434     if (RSVP_OBJECT_HDRSIZE > bufSize) {
 435         return MPLS_ENC_BUFFTOOSMALL;
 436     }
 437
 438     size = RSVP_OBJECT_HDRSIZE;
 439     encodeSize += size;
 440     bufSize -= size;
 441     buf += size;
 442
 443     {
 444         u_int refresh = htonl(time->refresh);
 445         if (RSVP_TIME_SIZE > bufSize) {
 446             return MPLS_DEC_BUFFTOOSMALL;
 447         }
 448         memcpy(buf, &refresh, RSVP_TIME_SIZE);
 449         size = RSVP_TIME_SIZE;
 450     }
 451     encodeSize += size;
 452
 453     session->hdr.length = encodeSize;
 454     session->hdr.class = RSVP_TIME_CLASS;
 455     session->hdr.cType = RSVP_TIME_CTYPE;
 456
 457     size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
 458         return size;
 459     }
 460
 461     return encodeSize;
 462 }
 463
 464 int rsvpteDecodeTimeObject(rsvpTimeObject_t * time, u_char * buf, int bufSize) {
 465     int decodedSize = 0;
 466     int size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);
 467
 468     if (size < 0) {
 469         return size;
 470     }
 471     decodeSize += size;
 472     bufSize -= size;
 473     buf += size;
 474
 475     if (session->hdr.length > bufSize) {
 476         return MPLS_DEC_BUFFTOOSMALL;
 477     }
 478
 479     if (session->hdr.class != RSVP_TIME_CLASS) {
 480         return RSVP_DEC_OBJECTERROR;
 481     }
 482
 483     switch(time->hdr.cType) {
 484         case RSVP_TIME_CTYPE:
 485             if (RSVP_TIME_SIZE > bufSize) {
 486                 return MPLS_DEC_BUFFTOOSMALL;
 487             }
 488             memcpy(&time->refresh, buf, RSVP_TIME_SIZE);
 489             time->refresh = ntohl(time->refresh);
 490             size = RSVP_TIME_SIZE;
 491             break;
 492         default:
 493             return RSVP_DEC_OBJECTERROR;
 494     }
 495
 496     return decodeSize + size;
 497 }
 498
 499 /* Explicit Route Object */
 500
 501 int rsvpteEncodeExplicitRoute4(rsvpExplicitRoute4_t * er, u_char * buf, int bufSize) {
 502     rsvpExplicitRoute4_t erCopy;
 503
 504     if (RSVP_ER4_SIZE > bufSize) {
 505         return MPLS_ENC_BUFFTOOSMALL;
 506     }
 507     erCopy = *er;
 508
 509     erCopy.flags.mark = htons(er->flags.mark);
 510     htonl_nba(erCopy.address, &erCopy.uIntAddress);
 511
 512     memcpy(buf, &erCopy, RSVP_ER4_SIZE);
 513
 514     return RSVP_ER4_SIZE;
 515 }
 516
 517 int rsvpteDecodeExplicitRoute4(rsvpExplicitRoute4_t * er, u_char * buf, int bufSize) {
 518     if (RSVP_ER4_SIZE > bufSize) {
 519         return MPLS_DEC_BUFFTOOSMALL;
 520     }
 521
 522     memcpy(er, buf, RSVP_ER4_SIZE);
 523     er->flags.mark = ntohs(er->flags.mark);
 524     ntohl_nba(er->address, &er->uIntAddress);
 525
 526     return RSVP_ER4_SIZE;
 527 }
 528
 529 int rsvpteEncodeExplicitRoute6(rsvpExplicitRoute6_t * er, u_char * buf, int bufSize) {
 530     rsvpExplicitRoute6_t erCopy;
 531
 532     if (RSVP_ER6_SIZE > bufSize) {
 533         return MPLS_ENC_BUFFTOOSMALL;
 534     }
 535     erCopy = *er;
 536
 537     erCopy.flags.mark = htons(er->flags.mark);
 538
 539     memcpy(buf, &erCopy, RSVP_ER6_SIZE);
 540
 541     return RSVP_ER6_SIZE;
 542 }
 543
 544 int rsvpteDecodeExplicitRoute6(rsvpExplicitRoute6_t * er, u_char * buf, int bufSize) {
 545     if (RSVP_ER6_SIZE > bufSize) {
 546         return MPLS_DEC_BUFFTOOSMALL;
 547     }
 548
 549     memcpy(er, buf, RSVP_ER6_SIZE);
 550     er->flags.mark = ntohs(er->flags.mark);
 551
 552     return RSVP_ER6_SIZE;
 553 }
 554
 555 int rsvpteEncodeExplicitRouteAsn(rsvpExplicitRouteAsn_t * er, u_char * buf, int bufSize) {
 556     rsvpExplicitRouteAsn_t erCopy;
 557
 558     if (RSVP_ERASN_SIZE > bufSize) {
 559         return MPLS_ENC_BUFFTOOSMALL;
 560     }
 561     erCopy = *er;
 562
 563     erCopy.flags.mark = htons(er->flags.mark);
 564
 565     memcpy(buf, &erCopy, RSVP_ER6_SIZE);
 566
 567     return RSVP_ERASN_SIZE;
 568 }
 569
 570 int rsvpteDecodeExplicitRouteAsn(rsvpExplicitRouteAsn_t * er, u_char * buf, int bufSize) {
 571     if (RSVP_ERASN_SIZE > bufSize) {
 572         return MPLS_DEC_BUFFTOOSMALL;
 573     }
 574
 575     memcpy(er, buf, RSVP_ERASN_SIZE);
 576     er->flags.mark = ntohs(er->flags.mark);
 577
 578     return RSVP_ERASN_SIZE;
 579 }
 580
 581 int rsvpteEncodeExplicitRouteObject(rsvpExplicitRouteObject_t * er, u_char * buf, int bufSize) {
 582
 583     int encodedSize = 0;
 584     char *bufHdr = buf;
 585     int size;
 586
 587     if (RSVP_OBJECT_HDRSIZE > bufSize) {
 588         return MPLS_ENC_BUFFTOOSMALL;
 589     }
 590
 591     size = RSVP_OBJECT_HDRSIZE;
 592     encodeSize += size;
 593     bufSize -= size;
 594     buf += size;
 595
 596     for (i = 0;i < er->eroLength;i++) {
 597
 598         switch(er->eroType[i]) {
 599             case RSVP_ERO_TYPE_IPV4:
 600                 size = rsvpteEncodeExplicitRoute4(&er->ero[i], buf, bufSize);
 601                 break;
 602             case RSVP_ERO_TYPE_IPV6:
 603                 size = rsvpteEncodeExplicitRoute6(&er->ero[i], buf, bufSize);
 604                 break;
 605             case RSVP_ERO_TYPE_ASN:
 606                 size = rsvpteEncodeExplicitRouteAsn(&er->ero[i], buf, bufSize);
 607                 break;
 608             default:
 609                 return RSVP_ENC_OBJECTERROR;
 610         }
 611
 612         if (size < 0) {
 613             return size;
 614         }
 615
 616         encodeSize += size;
 617         bufSize -= size;
 618         buf += size;
 619     }
 620
 621     session->hdr.length = encodeSize;
 622     session->hdr.class = RSVP_EXPLICIT_ROUTE_CLASS;
 623     session->hdr.cType = RSVP_EXPLICIT_ROUTE_CTYPE;
 624     size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
 625         return size;
 626     }
 627
 628     return encodeSize;
 629 }
 630
 631 int rsvpteDecodeExplicitRouteSubObjectHdr(rsvpExplicitRouteFlag_t * hdr, u_char * buf, int bufSize) {
 632     u_short temp;
 633     if (sizeof(u_short) > bufSize) {
 634         return MPLS_DEC_BUFFTOOSMALL;
 635     }
 636
 637     memcpy(&temp, buf, sizeof(u_short));
 638     temp = ntohs(temp);
 639     memcpy(hdr, &temp, sizeof(u_short));
 640
 641     return sizeof(u_short);
 642 }
 643
 644 int rsvpteDecodeExplicitRouteObject(rsvpExplicitRouteObject_t * er, u_char * buf, int bufSize) {
 645     rsvpExplicitRouteFlag_t erFlag;
 646
 647     int decodedSize = 0;
 648     int size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);
 649
 650     if (size < 0) {
 651         return size;
 652     }
 653     decodeSize += size;
 654     bufSize -= size;
 655     buf += size;
 656
 657     if (session->hdr.length > bufSize) {
 658         return MPLS_DEC_BUFFTOOSMALL;
 659     }
 660
 661     if (session->hdr.class != RSVP_EXPLICIT_ROUTE_CLASS) {
 662         return RSVP_DEC_OBJECTERROR;
 663     }
 664
 665     while (decodeSize < session->hdr.length) {
 666         result = rsvpteDecodeExplicitRouteSubObjectHdr(&erFlag, buf, bufSize);
 667
 668         switch(erFlag.type) {
 669             case RSVP_ERO_TYPE_IPV4:
 670                 size = rsvpteDecodeExplicitRoute4(&er->ero[i], buf, bufSize);
 671                 break;
 672             case RSVP_ERO_TYPE_IPV6:
 673                 size = rsvpteDecodeExplicitRoute6(&er->ero[i], buf, bufSize);
 674                 break;
 675             case RSVP_ERO_TYPE_ASN:
 676                 size = rsvpteDecodeExplicitRouteAsn(&er->ero[i], buf, bufSize);
 677                 break;
 678             default:
 679                 return RSVP_DEC_OBJECTERROR;
 680         }
 681         er->eroType[i] = erFlag.type;
 682
 683         if (size < 0) {
 684             return size;
 685         }
 686
 687         decodeSize += size;
 688         bufSize -= size;
 689         buf += size;
 690         i++;
 691     }
 692     er->erLength = i;
 693
 694     return decodeSize;
 695 }
 696
 697 /* Label Request Object */
 698
 699 int rsvpteEncodeLabelReqGeneric(rsvpLabelReqGeneric_t * gen, u_char * buf, int bufSize) {
 700     rsvpLabelReqGeneric_t genCopy;
 701     if (RSVP_LABELREQ_GENERIC_SIZE > bufSize) {
 702         return MPLS_ENC_BUFFTOOSMALL;
 703     }
 704     genCopy.reserved = htons(gen->reserved);
 705     genCopy.l3pid = htons(gen->l3pid);
 706
 707     memcpy(buf, &genCopy, RSVP_LABELREQ_GENERIC_SIZE);
 708
 709     return RSVP_LABELREQ_GENERIC_SIZE;
 710 }
 711
 712 int rsvpteDecodeLabelReqGeneric(rsvpLabelReqGeneric_t * gen, u_char * buf, int bufSize) {
 713     if (RSVP_LABELREQ_GENERIC_SIZE > bufSize) {
 714         return MPLS_DEC_BUFFTOOSMALL;
 715     }
 716
 717     memcpy(er, buf, RSVP_LABELREQ_GENERIC_SIZE);
 718     gen->genCopy.reserved = ntohs(gen->genCopy.reserved);
 719     gen->genCopy.l3pid = ntohs(gen->genCopy.l3pid);
 720
 721     return RSVP_LABELREQ_GENERIC_SIZE;
 722 }
 723
 724 int rsvpteEncodeLabelReqAtm(rsvpLabelReqAtm_t * atm, u_char * buf, int bufSize) {
 725     rsvpLabelReqAtm_t atmCopy;
 726     if (RSVP_LABELREQ_ATM_SIZE > bufSize) {
 727         return MPLS_ENC_BUFFTOOSMALL;
 728     }
 729     atmCopy.reserved = htons(atm->reserved);
 730     atmCopy.l3pid = htons(atm->l3pid);
 731
 732     atmCopy.minFlags.mark = htons(atm->minFlags.mark);
 733     atmCopy.minVci = htons(atm->minVci);
 734
 735     atmCopy.maxFlags.mark = htons(atm->maxFlags.mark);
 736     atmCopy.maxVci = htons(atm->maxVci);
 737
 738     memcpy(buf, &atmCopy, RSVP_LABELREQ_ATM_SIZE);
 739
 740     return RSVP_LABELREQ_ATM_SIZE;
 741 }
 742
 743 int rsvpteDecodeLabelReqAtm(rsvpLabelReqAtm_t * atm, u_char * buf, int bufSize) {
 744     if (RSVP_LABELREQ_ATM_SIZE > bufSize) {
 745         return MPLS_DEC_BUFFTOOSMALL;
 746     }
 747
 748     memcpy(atm, buf, RSVP_LABELREQ_ATM_SIZE);
 749
 750     atm->reserved = htons(atm->reserved);
 751     atm->l3pid = htons(atm->l3pid);
 752
 753     atm->minFlags.mark = htons(atm->minFlags.mark);
 754     atm->minVci = htons(atm->minVci);
 755
 756     atm->maxFlags.mark = htons(atm->maxFlags.mark);
 757     atm->maxVci = htons(atm->maxVci);
 758
 759     return RSVP_LABELREQ_ATM_SIZE;
 760 }
 761
 762 int rsvpteEncodeLabelReqFr(rsvpLabelReqFr_t * fr, u_char * buf, int bufSize) {
 763     rsvpLabelReqFr_t frCopy;
 764     if (RSVP_LABELREQ_FR_SIZE > bufSize) {
 765         return MPLS_ENC_BUFFTOOSMALL;
 766     }
 767     frCopy.reserved = htons(fr->reserved);
 768     frCopy.l3pid = htons(fr->l3pid);
 769
 770     frCopy.minFlags.mark = htons(fr->minFlags.mark);
 771     frCopy.maxFlags.mark = htons(fr->maxFlags.mark);
 772
 773     memcpy(buf, &frCopy, RSVP_LABELREQ_FR_SIZE);
 774
 775     return RSVP_LABELREQ_FR_SIZE;
 776 }
 777
 778 int rsvpteDecodeLabelReqFr(rsvpLabelReqFr_t * fr, u_char * buf, int bufSize) {
 779     if (RSVP_LABELREQ_FR_SIZE > bufSize) {
 780         return MPLS_DEC_BUFFTOOSMALL;
 781     }
 782
 783     memcpy(fr, buf, RSVP_LABELREQ_FR_SIZE);
 784
 785     fr->reserved = htons(fr->reserved);
 786     fr->l3pid = htons(fr->l3pid);
 787
 788     fr->minFlags.mark = htons(fr->minFlags.mark);
 789     fr->maxFlags.mark = htons(fr->maxFlags.mark);
 790
 791     return RSVP_LABELREQ_FR_SIZE;
 792 }
 793
 794 int rsvpteEncodeLabelRequestObject(rsvpLabelRequestObject_t * req, u_char * buf, int bufSize) {
 795     int encodedSize = 0;
 796     char *bufHdr = buf;
 797     int size;
 798
 799     if (RSVP_OBJECT_HDRSIZE > bufSize) {
 800         return MPLS_ENC_BUFFTOOSMALL;
 801     }
 802
 803     size = RSVP_OBJECT_HDRSIZE;
 804     encodeSize += size;
 805     bufSize -= size;
 806     buf += size;
 807
 808     switch(req->hdr.cType) {
 809         case RSVP_LABEL_REQUEST_CTYPE_GENERIC:
 810             size = rsvpteEncodeLabelReqGeneric(&req->u.generic, buf, bufSize);
 811             break;
 812         case RSVP_LABEL_REQUEST_CTYPE_ATM:
 813             size = rsvpteEncodeLabelReqAtm(&req->u.atm, buf, bufSize);
 814             break;
 815         case RSVP_LABEL_REQUEST_CTYPE_FR:
 816             size = rsvpteEncodeLabelReqFr(&req->u.fr, buf, bufSize);
 817             break;
 818         default:
 819             return RSVP_DEC_OBJECTERROR;
 820     }
 821     if (size < 0) {
 822         return size;
 823     }
 824
 825     encodeSize += size;
 826
 827     req->hdr.length = encodeSize;
 828     req->hdr.class = RSVP_LABEL_REQUEST_CLASS;
 829     size = rsvpteEncodeObjectHeader(&req->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
 830         return size;
 831     }
 832
 833     return encodeSize;
 834 }
 835
 836 int rsvpteDecodeLabelRequestObject(rsvpLabelRequestObject_t * req, u_char * buf, int bufSize) {
 837     int decodedSize = 0;
 838     int size = rsvpteDecodeObjectHeader(&req->hdr, buf, bufSize);
 839
 840     if (size < 0) {
 841         return size;
 842     }
 843     decodeSize += size;
 844     bufSize -= size;
 845     buf += size;
 846
 847     if (req->hdr.length > bufSize) {
 848         return MPLS_DEC_BUFFTOOSMALL;
 849     }
 850
 851     if (req->hdr.class != RSVP_LABEL_REQUEST_CLASS) {
 852         return RSVP_DEC_OBJECTERROR;
 853     }
 854
 855     switch(req->hdr.cType) {
 856         case RSVP_LABEL_REQUEST_CTYPE_GENERIC:
 857             size = rsvpteDecodeLabelReqGeneric(&req->u.generic, buf, bufSize);
 858             break;
 859         case RSVP_LABEL_REQUEST_CTYPE_ATM:
 860             size = rsvpteDecodeLabelReqAtm(&req->u.atm, buf, bufSize);
 861             break;
 862         case RSVP_LABEL_REQUEST_CTYPE_FR:
 863             size = rsvpteDecodeLabelReqFr(&req->u.fr, buf, bufSize);
 864             break;
 865         default:
 866             return RSVP_DEC_OBJECTERROR;
 867     }
 868
 869     if (size < 0) {
 870         return size;
 871     }
 872
 873     return decodeSize + size;
 874 }
 875
 876 /* Session Attribute Object */
 877
 878 int rsvpteEncodeSessionAttribLspTunnel(rsvpSessionAttribLspTunnel_t * lsp, u_char * buf, int bufSize) {
 879     int size = RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE + lsp->nameLen;
 880
 881     if (size > bufSize) {
 882         return MPLS_ENC_BUFFTOOSMALL;
 883     }
 884
 885     memcpy(buf, lsp, size);
 886
 887     return size;
 888 }
 889
 890 int rsvpteDecodeSessionAttribLspTunnel(rsvpSessionAttribLspTunnel_t * lsp, u_char * buf, int bufSize) {
 891     if (RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE > bufSize) {
 892         return MPLS_DEC_BUFFTOOSMALL;
 893     }
 894
 895     memcpy(lsp, buf, RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE);
 896     if (lsp->nameLen > bufSize) {
 897         return MPLS_DEC_BUFFTOOSMALL;
 898     }
 899
 900     memcpy(lsp->name, buf, lsp->nameLen);
 901
 902     return RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE + lsp->nameLen;
 903 }
 904
 905 int rsvpteEncodeSessionAttribLspTunnelRa(rsvpSessionAttribLspTunnelRa_t * lsp, u_char * buf, int bufSize) {
 906     rsvpSessionAttribLspTunnelRa_t lspCopy;
 907     int size = RSVP_SESSION_ATTRIB_LSP_TUNNEL_RA_BASE_SIZE + lsp->nameLen;
 908
 909     if (size > bufSize) {
 910         return MPLS_ENC_BUFFTOOSMALL;
 911     }
 912
 913     lspCopy = *lsp;
 914     lspCopy.excludeAny = htonl(lspCopy.excludeAny);
 915     lspCopy.includeAny = htonl(lspCopy.includeAny);
 916     lspCopy.includeAll = htonl(lspCopy.includeAll);
 917     memcpy(buf, &lspCopy, size);
 918
 919     return size;
 920 }
 921
 922 int rsvpteDecodeSessionAttribLspTunnelRa(rsvpSessionAttribLspTunnelRa_t * lsp, u_char * buf, int bufSize) {
 923     if (RSVP_SESSION_ATTRIB_LSP_TUNNEL_RA_BASE_SIZE > bufSize) {
 924         return MPLS_DEC_BUFFTOOSMALL;
 925     }
 926     memcpy(lsp, buf, RSVP_SESSION_ATTRIB_LSP_TUNNEL_RA_BASE_SIZE);
 927
 928     if (lsp->nameLen > bufSize) {
 929         return MPLS_DEC_BUFFTOOSMALL;
 930     }
 931     memcpy(lsp->name, buf, lsp->nameLen);
 932
 933     lsp->excludeAny = ntohl(lsp->excludeAny);
 934     lsp->includeAny = ntohl(lsp->includeAny);
 935     lsp->includeAll = ntohl(lsp->includeAll);
 936
 937     return RSVP_SESSION_ATTRIB_LSP_TUNNEL_BASE_SIZE + lsp->nameLen;
 938 }
 939
 940 int rsvpteEncodeSessionAttribObject(rsvpSessionAttibObject_t * session, u_char * buf, int bufSize) {
 941
 942     int encodedSize = 0;
 943     char *bufHdr = buf;
 944     int size;
 945
 946     if (RSVP_OBJECT_HDRSIZE > bufSize) {
 947         return MPLS_ENC_BUFFTOOSMALL;
 948     }
 949
 950     size = RSVP_OBJECT_HDRSIZE;
 951     encodeSize += size;
 952     bufSize -= size;
 953     buf += size;
 954
 955     switch(session->hdr.cType) {
 956         case RSVP_SESSION_ATTRIB_CTYPE_LSP_TUNNEL:
 957             size = rsvpteEncodeSessionAttribLspTunnel(&session->u.tunnel, buf, bufSize);
 958             break;
 959         case RSVP_SESSION_ATTRIB_CLASS_LSP_TUNNEL_RA:
 960             size = rsvpteEncodeSessionAttribLspTunnelRa(&session->u.tunnelRa, buf, bufSize);
 961             break;
 962         default:
 963             return RSVP_DEC_OBJECTERROR;
 964     }
 965
 966     if (size < 0) {
 967         return size;
 968     }
 969
 970     encodeSize += size;
 971
 972     session->hdr.length = encodeSize;
 973     session->hdr.class = RSVP_SESSION_ATTRIB_CLASS;
 974     size = rsvpteEncodeObjectHeader(&session->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
 975         return size;
 976     }
 977
 978     return encodeSize;
 979 }
 980
 981 int rsvpteDecodeSessionAttribObject(rsvpSessionAttibObject_t * session, u_char * buf, int bufSize) {
 982     int decodedSize = 0;
 983     int size = rsvpteDecodeObjectHeader(&session->hdr, buf, bufSize);
 984
 985     if (size < 0) {
 986         return size;
 987     }
 988     decodeSize += size;
 989     bufSize -= size;
 990     buf += size;
 991
 992     if (session->hdr.length > bufSize) {
 993         return MPLS_DEC_BUFFTOOSMALL;
 994     }
 995
 996     if (session->hdr.class != RSVP_SESSION_ATTRIB_CLASS) {
 997         return RSVP_DEC_OBJECTERROR;
 998     }
 999
1000     switch(session->hdr.cType) {
1001         case RSVP_SESSION_ATTRIB_CTYPE_LSP_TUNNEL:
1002             size = rsvpteDecodeSessionAttribLspTunnel(&session->u.tunnel, buf, bufSize);
1003             break;
1004         case RSVP_SESSION_ATTRIB_CLASS_LSP_TUNNEL_RA:
1005             size = rsvpteDecodeSessionAttribLspTunnelRa(&session->u.tunnelRa, buf, bufSize);
1006             break;
1007         default:
1008             return RSVP_DEC_OBJECTERROR;
1009     }
1010     if (size < 0) {
1011         return size;
1012     }
1013
1014     return decodeSize + size;
1015 }
1016
1017 /* Filter Spec Object */
1018
1019 int rsvpteEncodeFilterSpec4(rsvpFilterSpec4_t * filter, u_char * buf, int bufSize) {
1020     rsvpFilterSpec4_t filterCopy;
1021
1022     if (RSVP_FILTER_SPEC4_SIZE > bufSize) {
1023         return MPLS_ENC_BUFFTOOSMALL;
1024     }
1025
1026     filterCopy.sourceAddr = htonl(filter->sourceAddr);
1027     filterCopy.sourcePort = htons(filter->sourcePort);
1028     filterCopy.reserved = filter->reserved = 0;
1029
1030     memcpy(buf, &filterCopy, RSVP_FILTER_SPEC4_SIZE);
1031
1032     return RSVP_FILTER_SPEC4_SIZE;
1033 }
1034
1035 int rsvpteDecodeFilterSpec4(rsvpFilterSpec4_t * filter, u_char * buf, int bufSize) {
1036     if (RSVP_FILTER_SPEC4_SIZE > bufSize) {
1037         return MPLS_DEC_BUFFTOOSMALL;
1038     }
1039
1040     memcpy(filter, buf, RSVP_FILTER_SPEC4_SIZE);
1041     filter->sourceAddr = ntohl(filter->sourceAddr);
1042     filter->sourcePort = ntohs(filter->sourcePort);
1043     filter->reserved = 0;
1044
1045     return RSVP_FILTER_SPEC4_SIZE;
1046 }
1047
1048 int rsvpteEncodeFilterSpec6(rsvpFilterSpec6_t * filter, u_char * buf, int bufSize) {
1049     rsvpFilterSpec6_t filterCopy;
1050
1051     if (RSVP_FILTER_SPEC6_SIZE > bufSize) {
1052         return MPLS_ENC_BUFFTOOSMALL;
1053     }
1054
1055     memcpy(filterCopy.sourceAddr, filter->sourceAddr, RSVP_IPV6_ADDR_LEN);
1056     filterCopy.sourcePort = htons(filter->sourcePort);
1057     filterCopy.reserved = filter->reserved = 0;
1058
1059     memcpy(buf, &filterCopy, RSVP_FILTER_SPEC6_SIZE);
1060
1061     return RSVP_FILTER_SPEC6_SIZE;
1062 }
1063
1064 int rsvpteDecodeFilterSpec6(rsvpFilterSpec6_t * filter, u_char * buf, int bufSize) {
1065     if (RSVP_FILTER_SPEC6_SIZE > bufSize) {
1066         return MPLS_DEC_BUFFTOOSMALL;
1067     }
1068
1069     memcpy(filter, buf, RSVP_FILTER_SPEC6_SIZE);
1070     filter->sourcePort = ntohs(filter->sourcePort);
1071     filter->reserved = 0;
1072
1073     return RSVP_FILTER_SPEC6_SIZE;
1074 }
1075
1076 int rsvpteEncodeFilterSpecFlow(rsvpFilterSpecFlow_t * filter, u_char * buf, int bufSize) {
1077     rsvpFilterSpecFlow_t filterCopy;
1078
1079     if (RSVP_FILTER_SPEC_FLOW_SIZE > bufSize) {
1080         return MPLS_ENC_BUFFTOOSMALL;
1081     }
1082
1083     memcpy(filterCopy.sourceAddr, filter->sourceAddr, RSVP_IPV6_ADDR_LEN);
1084     filterCopy.flag.mark = htonl(filter->flag.mark);
1085
1086     memcpy(buf, &filterCopy, RSVP_FILTER_SPEC_FLOW_SIZE);
1087
1088     return RSVP_FILTER_SPEC_FLOW_SIZE;
1089 }
1090
1091 int rsvpteDecodeFilterSpecFlow(rsvpFilterSpecFlow_t * filter, u_char * buf, int bufSize) {
1092     if (RSVP_FILTER_SPEC_FLOW_SIZE > bufSize) {
1093         return MPLS_DEC_BUFFTOOSMALL;
1094     }
1095
1096     memcpy(filter, buf, RSVP_FILTER_SPEC_FLOW_SIZE);
1097     filter->flag.mark = ntohl(filter->flag.mark);
1098
1099     return RSVP_FILTER_SPEC_FLOW_SIZE;
1100 }
1101
1102 int rsvpteEncodeFilterSpecObject(rsvpFilterSpec_t * filter, u_char * buf, int bufSize) {
1103
1104     int encodedSize = 0;
1105     char *bufHdr = buf;
1106     int size;
1107
1108     if (RSVP_OBJECT_HDRSIZE > bufSize) {
1109         return MPLS_ENC_BUFFTOOSMALL;
1110     }
1111
1112     size = RSVP_OBJECT_HDRSIZE;
1113     encodeSize += size;
1114     bufSize -= size;
1115     buf += size;
1116
1117     switch(filter->hdr.cType) {
1118         case RSVP_FILTER_SPEC_CTYPE_IPV4:
1119             size = rsvpteEncodeFilterSpec4(&filter->u.ipv4, buf, bufSize);
1120             break;
1121         case RSVP_FILTER_SPEC_CTYPE_IPV6:
1122             size = rsvpteEncodeFilterSpec6(&filter->u.ipv6, buf, bufSize);
1123             break;
1124         case RSVP_FILTER_SPEC_CTYPE_FLOW:
1125             size = rsvpteEncodeFilterSpecFlow(&filter->u.flow, buf, bufSize);
1126             break;
1127         default:
1128             return RSVP_DEC_OBJECTERROR;
1129     }
1130     if (size < 0) {
1131         return size;
1132     }
1133
1134     encodeSize += size;
1135
1136     filter->hdr.length = encodeSize;
1137     filter->hdr.class = RSVP_FILTER_SPEC_CLASS;
1138     size = rsvpteEncodeObjectHeader(&filter->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
1139         return size;
1140     }
1141
1142     return encodeSize;
1143 }
1144
1145 int rsvpteDecodeFilterSpecObject(rsvpFilterSpec_t * filter, u_char * buf, int bufSize) {
1146     int decodedSize = 0;
1147     int size = rsvpteDecodeObjectHeader(&filter->hdr, buf, bufSize);
1148
1149     if (size < 0) {
1150         return size;
1151     }
1152     decodeSize += size;
1153     bufSize -= size;
1154     buf += size;
1155
1156     if (filter->hdr.length > bufSize) {
1157         return MPLS_DEC_BUFFTOOSMALL;
1158     }
1159
1160     if (filter->hdr.class != RSVP_FILTER_SPEC_CLASS) {
1161         return RSVP_DEC_OBJECTERROR;
1162     }
1163
1164     switch(filter->hdr.cType) {
1165         case RSVP_FILTER_SPEC_CTYPE_IPV4:
1166             size = rsvpteDecodeFilterSpec4(&filter->u.ipv4, buf, bufSize);
1167             break;
1168         case RSVP_FILTER_SPEC_CTYPE_IPV6:
1169             size = rsvpteDecodeFilterSpec6(&filter->u.ipv6, buf, bufSize);
1170             break;
1171         case RSVP_FILTER_SPEC_CTYPE_FLOW:
1172             size = rsvpteDecodeFilterSpecFlow(&filter->u.flow, buf, bufSize);
1173             break;
1174         default:
1175             return RSVP_DEC_OBJECTERROR;
1176     }
1177     if (size < 0) {
1178         return size;
1179     }
1180
1181     return decodeSize + size;
1182 }
1183
1184 /* Sender Template Object */
1185
1186 int rsvpteEncodeSenderTemplateTunnel4(rsvpSenderTemplateTunnel4_t * sender, u_char * buf, int bufSize) {
1187     rsvpSenderTemplateTunnel4_t senderCopy;
1188
1189     if (RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE > bufSize) {
1190         return MPLS_ENC_BUFFTOOSMALL;
1191     }
1192
1193     senderCopy.sender = htonl(sender->sender);
1194     senderCopy.reserved = 0;
1195     senderCopy.lspId = htons(sender->lspId);
1196
1197     memcpy(buf, &senderCopy, RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE);
1198
1199     return RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE;
1200 }
1201
1202 int rsvpteDecodeSenderTemplateTunnel4(rsvpSenderTemplateTunnel4_t * sender, u_char * buf, int bufSize) {
1203     if (RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE > bufSize) {
1204         return MPLS_DEC_BUFFTOOSMALL;
1205     }
1206
1207     memcpy(sender, buf, RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE);
1208     sender->sender = ntohl(sender->sender);
1209     sender->reserved = 0;
1210     sender->lspId = ntohs(sender->lspId);
1211
1212     return RSVP_SENDER_TEMPLATE_TUNNEL4_SIZE;
1213 }
1214
1215 int rsvpteEncodeSenderTemplateTunnel6(rsvpSenderTemplateTunnel4 * sender, u_char * buf, int bufSize) {
1216     rsvpSenderTemplateTunnel6_t senderCopy;
1217
1218     if (RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE > bufSize) {
1219         return MPLS_ENC_BUFFTOOSMALL;
1220     }
1221
1222     memcpy(senderCopy.sender, sender->sender, RSVP_IPV6_ADDR_LEN);
1223     senderCopy.reserved = 0;
1224     senderCopy.lspId = htons(sender->lspId);
1225
1226     memcpy(buf, &senderCopy, RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE);
1227
1228     return RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE;
1229 }
1230
1231 int rsvpteDecodeSenderTemplateTunnel6(rsvpFilterSpecFlow_t * sender, u_char * buf, int bufSize) {
1232     if (RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE > bufSize) {
1233         return MPLS_DEC_BUFFTOOSMALL;
1234     }
1235
1236     memcpy(sender, buf, RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE);
1237     sender->lspId = ntohs(sender->lspId);
1238
1239     return RSVP_SENDER_TEMPLATE_TUNNEL6_SIZE;
1240 }
1241
1242 int rsvpteEncodeSenderTemplateObject(rsvpSenderTemplate_t * sender, u_char * buf, int bufSize) {
1243     int encodedSize = 0;
1244     char *bufHdr = buf;
1245     int size;
1246
1247     if (RSVP_OBJECT_HDRSIZE > bufSize) {
1248         return MPLS_ENC_BUFFTOOSMALL;
1249     }
1250
1251     size = RSVP_OBJECT_HDRSIZE;
1252     encodeSize += size;
1253     bufSize -= size;
1254     buf += size;
1255
1256     switch(sender->hdr.cType) {
1257         case RSVP_SENDER_TEMPLATE_CTYPE_IPV4:
1258             size = rsvpteEncodeSenderTemplate4(&sender->u.ipv4, buf, bufSize);
1259             break;
1260         case RSVP_SENDER_TEMPLATE_CTYPE_IPV6:
1261             size = rsvpteEncodeSenderTemplate6(&sender->u.ipv6, buf, bufSize);
1262             break;
1263         case RSVP_SENDER_TEMPLATE_CTYPE_FLOW:
1264             size = rsvpteEncodeSenderTemplateFlow(&sender->u.flow, buf, bufSize);
1265             break;
1266         case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL4:
1267             size = rsvpteEncodeSenderTemplateTunnel4(&sender->u.tunnel4, buf, bufSize);
1268             break;
1269         case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL6:
1270             size = rsvpteEncodeSenderTemplateTunnel6(&sender->u.tunnel6, buf, bufSize);
1271             break;
1272         default:
1273             return RSVP_DEC_OBJECTERROR;
1274     }
1275     if (size < 0) {
1276         return size;
1277     }
1278
1279     encodeSize += size;
1280
1281     sender->hdr.length = encodeSize;
1282     sender->hdr.class = RSVP_SENDER_TEMPLATE_CLASS;
1283     size = rsvpteEncodeObjectHeader(&sender->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
1284         return size;
1285     }
1286
1287     return encodeSize;
1288 }
1289
1290 int rsvpteDecodeSenderTemplateObject(rsvpSenderTemplate_t * sender, u_char * buf, int bufSize) {
1291     int decodedSize = 0;
1292     int size = rsvpteDecodeObjectHeader(&sender->hdr, buf, bufSize);
1293
1294     if (size < 0) {
1295         return size;
1296     }
1297     decodeSize += size;
1298     bufSize -= size;
1299     buf += size;
1300
1301     if (sender->hdr.length > bufSize) {
1302         return MPLS_DEC_BUFFTOOSMALL;
1303     }
1304
1305     if (sender->hdr.class != RSVP_SENDER_TEMPLATE_CLASS) {
1306         return RSVP_DEC_OBJECTERROR;
1307     }
1308
1309     switch(sender->hdr.cType) {
1310         case RSVP_SENDER_TEMPLATE_CTYPE_IPV4:
1311             size = rsvpteDecodeSenderTemplate4(&sender->u.ipv4, buf, bufSize);
1312             break;
1313         case RSVP_SENDER_TEMPLATE_CTYPE_IPV6:
1314             size = rsvpteDecodeSenderTemplate6(&sender->u.ipv6, buf, bufSize);
1315             break;
1316         case RSVP_SENDER_TEMPLATE_CTYPE_FLOW:
1317             size = rsvpteDecodeSenderTemplateFlow(&sender->u.flow, buf, bufSize);
1318             break;
1319         case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL4:
1320             size = rsvpteDecodeSenderTemplateTunnel4(&sender->u.tunnel4, buf, bufSize);
1321             break;
1322         case RSVP_SENDER_TEMPLATE_CTYPE_TUNNEL6:
1323             size = rsvpteDecodeSenderTemplateTunnel6(&sender->u.tunnel6, buf, bufSize);
1324             break;
1325         default:
1326             return RSVP_DEC_OBJECTERROR;
1327     }
1328     if (size < 0) {
1329         return size;
1330     }
1331
1332     return decodeSize + size;
1333 }
1334
1335 /* Record Route Object */
1336
1337 int rsvpteEncodeRecordRoute4(rsvpRecordRoute4_t * rr, u_char * buf, int bufSize) {
1338     rsvpRecordRoute4_t rrCopy;
1339
1340     if (RSVP_RECORD_ROUTE4_SIZE > bufSize) {
1341         return MPLS_ENC_BUFFTOOSMALL;
1342     }
1343
1344     rrCopy = *rr;
1345     rrCopy.type = RSVP_RECORD_ROUTE_TYPE_IPV4;
1346     rrCopy.length = RSVP_RECORD_ROUTE4_SIZE;
1347     htonl_nba(&rrCopy.addressMsb, NULL);
1348
1349     memcpy(buf, &rrCopy, RSVP_RECORD_ROUTE4_SIZE);
1350
1351     return RSVP_RECORD_ROUTE4_SIZE;
1352 }
1353
1354 int rsvpteDecodeRecordRoute4(rsvpRecordRoute4_t * sender, u_char * buf, int bufSize) {
1355     if (RSVP_RECORD_ROUTE4_SIZE > bufSize) {
1356         return MPLS_DEC_BUFFTOOSMALL;
1357     }
1358
1359     memcpy(rr, buf, RSVP_RECORD_ROUTE4_SIZE);
1360     ntohl_nba(rr->addressMsb, NULL);
1361
1362     return RSVP_RECORD_ROUTE4_SIZE;
1363 }
1364
1365 int rsvpteEncodeRecordRoute6(rsvpRecordRoute6_t * rr, u_char * buf, int bufSize) {
1366     rsvpRecordRoute6_t rrCopy;
1367
1368     if (RSVP_RECORD_ROUTE6_SIZE > bufSize) {
1369         return MPLS_ENC_BUFFTOOSMALL;
1370     }
1371
1372     rrCopy = *rr;
1373     rrCopy.type = RSVP_RECORD_ROUTE_TYPE_IPV6;
1374     rrCopy.length = RSVP_RECORD_ROUTE6_SIZE;
1375
1376     memcpy(buf, &rrCopy, RSVP_RECORD_ROUTE6_SIZE);
1377
1378     return RSVP_RECORD_ROUTE6_SIZE;
1379 }
1380
1381 int rsvpteDecodeRecordRoute6(rsvpRecordRoute6_t * sender, u_char * buf, int bufSize) {
1382     if (RSVP_RECORD_ROUTE6_SIZE > bufSize) {
1383         return MPLS_DEC_BUFFTOOSMALL;
1384     }
1385
1386     memcpy(rr, buf, RSVP_RECORD_ROUTE6_SIZE);
1387
1388     return RSVP_RECORD_ROUTE6_SIZE;
1389 }
1390
1391 int rsvpteEncodeRecordRouteLabel(rsvpRecordRouteLabel_t * rr, u_char * buf, int bufSize) {
1392     rsvpRecordRouteLabel_t rrCopy;
1393     int size;
1394
1395     if (4 > bufSize) {
1396         return MPLS_ENC_BUFFTOOSMALL;
1397     }
1398
1399     if ((size = rsvpteEncodeLabelObject(&rr->label, buf + 4, bufSize - 4)) < 0) {
1400         return size;
1401     }
1402
1403     rrCopy = *rr;
1404     rrCopy.type = RSVP_RECORD_ROUTE_TYPE_LABEL;
1405     rrCopy.length = 4 + size;
1406     rrCopy.cType = rr->label.hdr.cType;
1407
1408     memcpy(buf, &rrCopy, 4);
1409
1410     return 4 + size;
1411 }
1412
1413 int rsvpteDecodeRecordRouteLabel(rsvpRecordRouteLabel_t * sender, u_char * buf, int bufSize) {
1414     int size;
1415     if (4 > bufSize) {
1416         return MPLS_DEC_BUFFTOOSMALL;
1417     }
1418
1419     memcpy(rr, buf, 4);
1420     size = rsvpteDecodeLabelObject(&rr->label, buf + 4, bufSize - 4;
1421
1422     return 4 + size;
1423 }
1424
1425 int rsvpteEncodeRecordRouteObject(rsvpRecordRouteObject_t * rr, char * bug, int bufSize) {
1426     int encodedSize = 0;
1427     char *bufHdr = buf;
1428     int size;
1429     in i;
1430
1431     if (RSVP_OBJECT_HDRSIZE > bufSize) {
1432         return MPLS_ENC_BUFFTOOSMALL;
1433     }
1434
1435     size = RSVP_OBJECT_HDRSIZE;
1436     encodeSize += size;
1437     bufSize -= size;
1438     buf += size;
1439
1440     for (i = 0, i < = rr->rrLen, i++) {
1441         switch(rr->rrType[i]) {
1442             case RSVP_RECORD_ROUTE_TYPE_IPV4:
1443                 size = rsvpteEncodeRecordRoute4(&rr->rr[i].ipv4, buf, bufSize);
1444                 break;
1445             case RSVP_RECORD_ROUTE_TYPE_IPV6:
1446                 size = rsvpteEncodeRecordRoute6(&rr->rr[i].ipv6, buf, bufSize);
1447                 break;
1448             case RSVP_RECORD_ROUTE_TYPE_LABEL:
1449                 size = rsvpteEncodeRecordRouteLabel(&rr->rr[i].label, buf, bufSize);
1450                 break;
1451             default:
1452                 return RSVP_ENC_OBJECTERROR;
1453         }
1454         if (size < 0) {
1455             return size;
1456         }
1457         encodeSize += size;
1458         bufSize -= size;
1459         buf += size;
1460     }
1461
1462     rr->hdr.length = encodeSize;
1463     rr->hdr.class = RSVP_RECORD_ROUTE_CLASS;
1464     size = rsvpteEncodeObjectHeader(&rr->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
1465         return size;
1466     }
1467
1468     return encodeSize;
1469 }
1470
1471 int rsvpteDecodeRecordRouteObject(rsvpRecordRouteObject_t * rr, char * bug, int bufSize) {
1472     int decodedSize = 0;
1473     int size = rsvpteDecodeObjectHeader(&rr->hdr, buf, bufSize);
1474     int i;
1475
1476     if (size < 0) {
1477         return size;
1478     }
1479     decodeSize += size;
1480     bufSize -= size;
1481     buf += size;
1482
1483     if (rr->hdr.length > bufSize) {
1484         return MPLS_DEC_BUFFTOOSMALL;
1485     }
1486
1487     if (rr->hdr.class != RSVP_RECORD_ROUTE_CLASS) {
1488         return RSVP_DEC_OBJECTERROR;
1489     }
1490
1491     while (decodeSize < rr->hdr.length) {
1492         switch(buf[0]) {
1493             case RSVP_RECORD_ROUTE_TYPE_IPV4:
1494                 size = rsvpteDecodeRecordRoute4(&rr->rr[i].ipv4, buf, bufSize);
1495                 break;
1496             case RSVP_RECORD_ROUTE_TYPE_IPV6:
1497                 size = rsvpteDecodeRecordRoute6(&rr->rr[i].ipv6, buf, bufSize);
1498                 break;
1499             case RSVP_RECORD_ROUTE_TYPE_LABEL:
1500                 size = rsvpteDecodeRecordRouteLabel(&rr->rr[i].label, buf, bufSize);
1501                 break;
1502             default:
1503                 return RSVP_DEC_OBJECTERROR;
1504         }
1505
1506         if (size < 0) {
1507             return RSVP_DEC_OBJECTERROR;
1508         }
1509
1510         decodeSize += size;
1511         bufSize -= size;
1512         buf += size;
1513         i++;
1514     }
1515     rr->rrLen = i;
1516
1517     return decodeSize;
1518 }
1519
1520 /* Sender TSpec Object */
1521
1522 int rsvpteEncodeSenderTSpectObject(rsvpSenderTSpecObject_t * sender, char * bug, int bufSize) {
1523
1524     int encodedSize = 0;
1525     char *bufHdr = buf;
1526     int size;
1527
1528     if (RSVP_OBJECT_HDRSIZE > bufSize) {
1529         return MPLS_ENC_BUFFTOOSMALL;
1530     }
1531
1532     size = RSVP_OBJECT_HDRSIZE;
1533     encodeSize += size;
1534     bufSize -= size;
1535     buf += size;
1536
1537     /* need TSpec Definition */
1538
1539     if (size < 0) {
1540         return size;
1541     }
1542
1543     encodeSize += size;
1544
1545     sender->hdr.length = encodeSize;
1546     sender->hdr.class = RSVP_SENDER_TSPEC_CLASS;
1547     size = rsvpteEncodeObjectHeader(&sender->hdr, bufHdr, RSVP_OBJECT_HDRSIZE);    if (size < 0) {
1548         return size;
1549     }
1550
1551     return encodeSize;
1552 }
1553
1554 int rsvpteDecodeSenderTSpecObject(rsvpSenderTSpecObject_t * req, char * bug, int bufSize) {
1555
1556     int decodedSize = 0;
1557     int size = rsvpteDecodeObjectHeader(&sender->hdr, buf, bufSize);
1558
1559     if (size < 0) {
1560         return size;
1561     }
1562     decodeSize += size;
1563     bufSize -= size;
1564     buf += size;
1565
1566     if (sender->hdr.length > bufSize) {
1567         return MPLS_DEC_BUFFTOOSMALL;
1568     }
1569
1570     if (sender->hdr.class != RSVP_SENDER_TSPEC_CLASS) {
1571         return RSVP_DEC_OBJECTERROR;
1572     }
1573     /* need TSpec definitiion */
1574
1575     if (size < 0) {
1576         return size;
1577     }
1578
1579     return decodeSize + size;
1580 }