pceplib/test/pcep_msg_tools_test.c

   1 /*
   2  * This file is part of the PCEPlib, a PCEP protocol library.
   3  *
   4  * Copyright (C) 2020 Volta Networks https://voltanet.io/
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  18  *
  19  * Author : Brady Johnson <brady@voltanet.io>
  20  *
  21  */
  22
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <assert.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34
  35
  36 #include <CUnit/CUnit.h>
  37
  38 #include <zebra.h>
  39
  40 #include "pcep_msg_encoding.h"
  41 #include "pcep_msg_messages.h"
  42 #include "pcep_msg_tools.h"
  43 #include "pcep_msg_tools_test.h"
  44 #include "pcep_utils_double_linked_list.h"
  45 #include "pcep_utils_logging.h"
  46 #include "pcep_utils_memory.h"
  47
  48 const uint8_t any_obj_class = 255;
  49
  50 uint16_t pcep_open_hexbyte_strs_length = 28;
  51 const char *pcep_open_odl_hexbyte_strs[] = {
  52         "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e",
  53         "78", "55", "00", "10", "00", "04", "00", "00", "00", "3f",
  54         "00", "1a", "00", "04", "00", "00", "00", "00"};
  55
  56 /* PCEP INITIATE str received from ODL with 4 objects: [SRP, LSP, Endpoints,
  57  * ERO] The LSP has a SYMBOLIC_PATH_NAME TLV. The ERO has 2 IPV4 Endpoints. */
  58 uint16_t pcep_initiate_hexbyte_strs_length = 68;
  59 const char *pcep_initiate_hexbyte_strs[] = {
  60         "20", "0c", "00", "44", "21", "12", "00", "0c", "00", "00", "00", "00",
  61         "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
  62         "00", "11", "00", "08", "66", "61", "39", "33", "33", "39", "32", "39",
  63         "04", "10", "00", "0c", "7f", "00", "00", "01", "28", "28", "28", "28",
  64         "07", "10", "00", "14", "01", "08", "0a", "00", "01", "01", "18", "00",
  65         "01", "08", "0a", "00", "07", "04", "18", "00"};
  66
  67 uint16_t pcep_initiate2_hexbyte_strs_length = 72;
  68 const char *pcep_initiate2_hexbyte_strs[] = {
  69         "20", "0c", "00", "48", "21", "12", "00", "14", "00", "00", "00", "00",
  70         "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
  71         "20", "10", "00", "14", "00", "00", "00", "09", "00", "11", "00", "08",
  72         "36", "65", "31", "31", "38", "39", "32", "31", "04", "10", "00", "0c",
  73         "c0", "a8", "14", "05", "01", "01", "01", "01", "07", "10", "00", "10",
  74         "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
  75
  76 uint16_t pcep_update_hexbyte_strs_length = 48;
  77 const char *pcep_update_hexbyte_strs[] = {
  78         "20", "0b", "00", "30", "21", "12", "00", "14", "00", "00", "00", "00",
  79         "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
  80         "20", "10", "00", "08", "00", "02", "a0", "09", "07", "10", "00", "10",
  81         "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
  82
  83 /* Test that pcep_msg_read() can read multiple messages in 1 call */
  84 uint16_t pcep_open_initiate_hexbyte_strs_length = 100;
  85 const char *pcep_open_initiate_odl_hexbyte_strs[] = {
  86         "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e", "78", "55",
  87         "00", "10", "00", "04", "00", "00", "00", "3f", "00", "1a", "00", "04",
  88         "00", "00", "00", "00", "20", "0c", "00", "48", "21", "12", "00", "14",
  89         "00", "00", "00", "00", "00", "00", "00", "01", "00", "1c", "00", "04",
  90         "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
  91         "00", "11", "00", "08", "36", "65", "31", "31", "38", "39", "32", "31",
  92         "04", "10", "00", "0c", "c0", "a8", "14", "05", "01", "01", "01", "01",
  93         "07", "10", "00", "10", "05", "0c", "10", "01", "03", "e8", "a0", "00",
  94         "01", "01", "01", "01"};
  95
  96 uint16_t pcep_open_cisco_pce_hexbyte_strs_length = 28;
  97 const char *pcep_open_cisco_pce_hexbyte_strs[] = {
  98         "20", "01", "00", "1c", "01", "10", "00", "18", "20", "3c",
  99         "78", "00", "00", "10", "00", "04", "00", "00", "00", "05",
 100         "00", "1a", "00", "04", "00", "00", "00", "0a"};
 101
 102 uint16_t pcep_update_cisco_pce_hexbyte_strs_length = 100;
 103 const char *pcep_update_cisco_pce_hexbyte_strs[] = {
 104         "20", "0b", "00", "64", "21", "10", "00", "14", "00", "00", "00", "00",
 105         "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
 106         "20", "10", "00", "18", "80", "00", "f0", "89", "00", "07", "00", "0c",
 107         "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
 108         "07", "10", "00", "28", "24", "0c", "10", "01", "04", "65", "50", "00",
 109         "0a", "0a", "0a", "05", "24", "0c", "10", "01", "04", "65", "20", "00",
 110         "0a", "0a", "0a", "02", "24", "0c", "10", "01", "04", "65", "10", "00",
 111         "0a", "0a", "0a", "01", "06", "10", "00", "0c", "00", "00", "00", "02",
 112         "41", "f0", "00", "00"};
 113
 114 uint16_t pcep_report_cisco_pcc_hexbyte_strs_length = 148;
 115 const char *pcep_report_cisco_pcc_hexbyte_strs[] = {
 116         "20", "0a", "00", "94", "21", "10", "00", "14", "00", "00", "00", "00",
 117         "00", "00", "00", "00", "00", "1c", "00", "04", "00", "00", "00", "01",
 118         "20", "10", "00", "3c", "80", "00", "f0", "09", "00", "12", "00", "10",
 119         "0a", "0a", "0a", "06", "00", "02", "00", "0f", "0a", "0a", "0a", "06",
 120         "0a", "0a", "0a", "01", "00", "11", "00", "0d", "63", "66", "67", "5f",
 121         "52", "36", "2d", "74", "6f", "2d", "52", "31", "00", "00", "00", "00",
 122         "ff", "e1", "00", "06", "00", "00", "05", "dd", "70", "00", "00", "00",
 123         "07", "10", "00", "04", "09", "10", "00", "14", "00", "00", "00", "00",
 124         "00", "00", "00", "00", "00", "00", "00", "00", "07", "07", "01", "00",
 125         "05", "12", "00", "08", "00", "00", "00", "00", "05", "52", "00", "08",
 126         "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "00", "02",
 127         "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "01", "04",
 128         "41", "80", "00", "00"};
 129
 130 /* Cisco PcInitiate with the following objects:
 131  *   SRP, LSP, Endpoint, Inter-layer, Switch-layer, ERO
 132  */
 133 uint16_t pcep_initiate_cisco_pcc_hexbyte_strs_length = 104;
 134 const char *pcep_initiate_cisco_pcc_hexbyte_strs[] = {
 135         "20", "0c", "00", "68", "21", "10", "00", "14", "00", "00", "00", "00",
 136         "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
 137         "20", "10", "00", "30", "00", "00", "00", "89", "00", "11", "00", "13",
 138         "50", "4f", "4c", "31", "5f", "50", "43", "49", "4e", "49", "54", "41",
 139         "54", "45", "5f", "54", "45", "53", "54", "00", "00", "07", "00", "0c",
 140         "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
 141         "04", "10", "00", "0c", "0a", "0a", "0a", "0a", "0a", "0a", "0a", "04",
 142         "24", "10", "00", "08", "00", "00", "01", "4d", "25", "10", "00", "08",
 143         "00", "00", "00", "64", "07", "10", "00", "04"};
 144
 145 struct pcep_message *create_message(uint8_t msg_type, uint8_t obj1_class,
 146                                     uint8_t obj2_class, uint8_t obj3_class,
 147                                     uint8_t obj4_class);
 148 int convert_hexstrs_to_binary(char *filename, const char *hexbyte_strs[],
 149                               uint16_t hexbyte_strs_length);
 150
 151 int pcep_tools_test_suite_setup(void)
 152 {
 153         pceplib_memory_reset();
 154         return 0;
 155 }
 156
 157 int pcep_tools_test_suite_teardown(void)
 158 {
 159         printf("\n");
 160         pceplib_memory_dump();
 161         return 0;
 162 }
 163
 164 void pcep_tools_test_setup(void)
 165 {
 166 }
 167
 168 void pcep_tools_test_teardown(void)
 169 {
 170 }
 171
 172 static const char BASE_TMPFILE[] = "/tmp/pceplib_XXXXXX";
 173 static int BASE_TMPFILE_SIZE = sizeof(BASE_TMPFILE);
 174
 175 /* Reads an array of hexbyte strs, and writes them to a temporary file.
 176  * The caller should close the returned file. */
 177 int convert_hexstrs_to_binary(char *filename,
 178                               const char *hexbyte_strs[],
 179                               uint16_t hexbyte_strs_length)
 180 {
 181         mode_t oldumask;
 182         oldumask = umask(S_IXUSR|S_IXGRP|S_IWOTH|S_IROTH|S_IXOTH);
 183         /* Set umask before anything for security */
 184         umask(0027);
 185
 186         strlcpy(filename, BASE_TMPFILE, BASE_TMPFILE_SIZE);
 187         int fd = mkstemp(filename);
 188         umask(oldumask);
 189
 190         if (fd == -1)
 191                 return -1;
 192
 193         int i = 0;
 194         for (; i < hexbyte_strs_length; i++) {
 195                 uint8_t byte = (uint8_t)strtol(hexbyte_strs[i], 0, 16);
 196                 if (write(fd, (char *)&byte, 1) < 0) {
 197                         return -1;
 198                 }
 199         }
 200
 201         /* Go back to the beginning of the file */
 202         lseek(fd, 0, SEEK_SET);
 203         return fd;
 204 }
 205
 206 static bool pcep_obj_has_tlv(struct pcep_object_header *obj_hdr)
 207 {
 208         if (obj_hdr->tlv_list == NULL) {
 209                 return false;
 210         }
 211
 212         return (obj_hdr->tlv_list->num_entries > 0);
 213 }
 214
 215 void test_pcep_msg_read_pcep_initiate()
 216 {
 217         char filename[BASE_TMPFILE_SIZE];
 218
 219         int fd = convert_hexstrs_to_binary(filename,
 220                                            pcep_initiate_hexbyte_strs,
 221                                            pcep_initiate_hexbyte_strs_length);
 222         if(fd == -1){
 223                 CU_ASSERT_TRUE(fd>=0);
 224                 return;
 225         }
 226         double_linked_list *msg_list = pcep_msg_read(fd);
 227         CU_ASSERT_PTR_NOT_NULL(msg_list);
 228         assert(msg_list != NULL);
 229         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 230
 231         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 232         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 4);
 233         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_INITIATE);
 234         CU_ASSERT_EQUAL(msg->encoded_message_length,
 235                         pcep_initiate_hexbyte_strs_length);
 236
 237         /* Verify each of the object types */
 238
 239         /* SRP object */
 240         double_linked_list_node *node = msg->obj_list->head;
 241         struct pcep_object_header *obj_hdr =
 242                 (struct pcep_object_header *)node->data;
 243         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_SRP);
 244         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_SRP);
 245         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length,
 246                         pcep_object_get_length_by_hdr(obj_hdr));
 247         CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr));
 248
 249         /* LSP object and its TLV*/
 250         node = node->next_node;
 251         obj_hdr = (struct pcep_object_header *)node->data;
 252         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_LSP);
 253         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_LSP);
 254         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 20);
 255         CU_ASSERT_EQUAL(((struct pcep_object_lsp *)obj_hdr)->plsp_id, 0);
 256         CU_ASSERT_TRUE(((struct pcep_object_lsp *)obj_hdr)->flag_d);
 257         CU_ASSERT_TRUE(((struct pcep_object_lsp *)obj_hdr)->flag_a);
 258         CU_ASSERT_FALSE(((struct pcep_object_lsp *)obj_hdr)->flag_s);
 259         CU_ASSERT_FALSE(((struct pcep_object_lsp *)obj_hdr)->flag_r);
 260         CU_ASSERT_FALSE(((struct pcep_object_lsp *)obj_hdr)->flag_c);
 261
 262         /* LSP TLV */
 263         CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr));
 264         CU_ASSERT_EQUAL(obj_hdr->tlv_list->num_entries, 1);
 265         struct pcep_object_tlv_header *tlv =
 266                 (struct pcep_object_tlv_header *)obj_hdr->tlv_list->head->data;
 267         CU_ASSERT_EQUAL(tlv->type, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME);
 268         CU_ASSERT_EQUAL(tlv->encoded_tlv_length, 8);
 269
 270         /* Endpoints object */
 271         node = node->next_node;
 272         obj_hdr = (struct pcep_object_header *)node->data;
 273         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_ENDPOINTS);
 274         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_ENDPOINT_IPV4);
 275         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length,
 276                         pcep_object_get_length_by_hdr(obj_hdr));
 277         CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr));
 278
 279         /* ERO object */
 280         node = node->next_node;
 281         obj_hdr = (struct pcep_object_header *)node->data;
 282         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_ERO);
 283         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_ERO);
 284         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 20);
 285
 286         /* ERO Subobjects */
 287         double_linked_list *ero_subobj_list =
 288                 ((struct pcep_object_ro *)obj_hdr)->sub_objects;
 289         CU_ASSERT_PTR_NOT_NULL(ero_subobj_list);
 290         assert(ero_subobj_list != NULL);
 291         CU_ASSERT_EQUAL(ero_subobj_list->num_entries, 2);
 292         double_linked_list_node *subobj_node = ero_subobj_list->head;
 293         struct pcep_object_ro_subobj *subobj_hdr =
 294                 (struct pcep_object_ro_subobj *)subobj_node->data;
 295         CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_IPV4);
 296         struct in_addr ero_subobj_ip;
 297         inet_pton(AF_INET, "10.0.1.1", &ero_subobj_ip);
 298         CU_ASSERT_EQUAL(
 299                 ((struct pcep_ro_subobj_ipv4 *)subobj_hdr)->ip_addr.s_addr,
 300                 ero_subobj_ip.s_addr);
 301         CU_ASSERT_EQUAL(
 302                 ((struct pcep_ro_subobj_ipv4 *)subobj_hdr)->prefix_length, 24);
 303
 304         subobj_hdr =
 305                 (struct pcep_object_ro_subobj *)subobj_node->next_node->data;
 306         CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_IPV4);
 307         inet_pton(AF_INET, "10.0.7.4", &ero_subobj_ip);
 308         CU_ASSERT_EQUAL(
 309                 ((struct pcep_ro_subobj_ipv4 *)subobj_hdr)->ip_addr.s_addr,
 310                 ero_subobj_ip.s_addr);
 311         CU_ASSERT_EQUAL(
 312                 ((struct pcep_ro_subobj_ipv4 *)subobj_hdr)->prefix_length, 24);
 313
 314         pcep_msg_free_message_list(msg_list);
 315         close(fd);
 316         unlink(filename);
 317 }
 318
 319
 320 void test_pcep_msg_read_pcep_initiate2()
 321 {
 322         char filename[BASE_TMPFILE_SIZE];
 323
 324         int fd = convert_hexstrs_to_binary(filename,
 325                                            pcep_initiate2_hexbyte_strs,
 326                                            pcep_initiate2_hexbyte_strs_length);
 327         if(fd == -1){
 328                 CU_ASSERT_TRUE(fd>=0);
 329                 return;
 330         }
 331         double_linked_list *msg_list = pcep_msg_read(fd);
 332         CU_ASSERT_PTR_NOT_NULL(msg_list);
 333         assert(msg_list != NULL);
 334         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 335
 336         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 337         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 4);
 338         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_INITIATE);
 339         CU_ASSERT_EQUAL(msg->encoded_message_length,
 340                         pcep_initiate2_hexbyte_strs_length);
 341
 342         /* Verify each of the object types */
 343
 344         /* SRP object */
 345         double_linked_list_node *node = msg->obj_list->head;
 346         struct pcep_object_header *obj_hdr =
 347                 (struct pcep_object_header *)node->data;
 348         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_SRP);
 349         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_SRP);
 350         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 20);
 351         CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr));
 352         /* TODO test the TLVs */
 353
 354         /* LSP object and its TLV*/
 355         node = node->next_node;
 356         obj_hdr = (struct pcep_object_header *)node->data;
 357         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_LSP);
 358         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_LSP);
 359         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 20);
 360
 361         /* LSP TLV */
 362         CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr));
 363         CU_ASSERT_EQUAL(obj_hdr->tlv_list->num_entries, 1);
 364         struct pcep_object_tlv_header *tlv =
 365                 (struct pcep_object_tlv_header *)obj_hdr->tlv_list->head->data;
 366         CU_ASSERT_EQUAL(tlv->type, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME);
 367         CU_ASSERT_EQUAL(tlv->encoded_tlv_length, 8);
 368
 369         /* Endpoints object */
 370         node = node->next_node;
 371         obj_hdr = (struct pcep_object_header *)node->data;
 372         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_ENDPOINTS);
 373         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_ENDPOINT_IPV4);
 374         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length,
 375                         pcep_object_get_length_by_hdr(obj_hdr));
 376         CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr));
 377
 378         /* ERO object */
 379         node = node->next_node;
 380         obj_hdr = (struct pcep_object_header *)node->data;
 381         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_ERO);
 382         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_ERO);
 383         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 16);
 384
 385         /* ERO Subobjects */
 386         double_linked_list *ero_subobj_list =
 387                 ((struct pcep_object_ro *)obj_hdr)->sub_objects;
 388         CU_ASSERT_PTR_NOT_NULL(ero_subobj_list);
 389         assert(ero_subobj_list != NULL);
 390         CU_ASSERT_EQUAL(ero_subobj_list->num_entries, 0);
 391         double_linked_list_node *subobj_node = ero_subobj_list->head;
 392         CU_ASSERT_PTR_NULL(subobj_node);
 393         /* We no longer support draft07 SR sub-object type=5, and only support
 394         type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
 395         pcep_object_ro_subobj *) subobj_node->data;
 396         CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
 397         struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
 398         subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
 399         PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
 400         CU_ASSERT_FALSE(subobj_sr->flag_c);
 401         CU_ASSERT_FALSE(subobj_sr->flag_s);
 402         CU_ASSERT_FALSE(subobj_sr->flag_f);
 403         CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
 404         CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
 405         0x01010101);
 406         */
 407
 408         pcep_msg_free_message_list(msg_list);
 409         close(fd);
 410         unlink(filename);
 411 }
 412
 413 void test_pcep_msg_read_pcep_open()
 414 {
 415         char filename[BASE_TMPFILE_SIZE];
 416
 417         int fd = convert_hexstrs_to_binary(filename,
 418                                            pcep_open_odl_hexbyte_strs,
 419                                            pcep_open_hexbyte_strs_length);
 420         if(fd == -1){
 421                 CU_ASSERT_TRUE(fd>=0);
 422                 return;
 423         }
 424         double_linked_list *msg_list = pcep_msg_read(fd);
 425         CU_ASSERT_PTR_NOT_NULL(msg_list);
 426         assert(msg_list != NULL);
 427         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 428
 429         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 430         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 1);
 431         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_OPEN);
 432         CU_ASSERT_EQUAL(msg->encoded_message_length,
 433                         pcep_open_hexbyte_strs_length);
 434
 435         /* Verify the Open message */
 436         struct pcep_object_header *obj_hdr =
 437                 (struct pcep_object_header *)msg->obj_list->head->data;
 438         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_OPEN);
 439         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_OPEN);
 440         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 24);
 441         CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr));
 442
 443         /* Open TLV: Stateful PCE Capability */
 444         CU_ASSERT_EQUAL(obj_hdr->tlv_list->num_entries, 2);
 445         double_linked_list_node *tlv_node = obj_hdr->tlv_list->head;
 446         struct pcep_object_tlv_header *tlv =
 447                 (struct pcep_object_tlv_header *)tlv_node->data;
 448         CU_ASSERT_EQUAL(tlv->type, PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY);
 449         CU_ASSERT_EQUAL(tlv->encoded_tlv_length, 4);
 450
 451         /* Open TLV: SR PCE Capability */
 452         tlv_node = tlv_node->next_node;
 453         tlv = (struct pcep_object_tlv_header *)tlv_node->data;
 454         CU_ASSERT_EQUAL(tlv->type, PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY);
 455         CU_ASSERT_EQUAL(tlv->encoded_tlv_length, 4);
 456
 457         pcep_msg_free_message_list(msg_list);
 458         close(fd);
 459         unlink(filename);
 460 }
 461
 462 void test_pcep_msg_read_pcep_update()
 463 {
 464         char filename[BASE_TMPFILE_SIZE];
 465
 466         int fd = convert_hexstrs_to_binary(filename,
 467                                            pcep_update_hexbyte_strs,
 468                                            pcep_update_hexbyte_strs_length);
 469         if(fd == -1){
 470                 CU_ASSERT_TRUE(fd>=0);
 471                 return;
 472         }
 473         double_linked_list *msg_list = pcep_msg_read(fd);
 474         CU_ASSERT_PTR_NOT_NULL(msg_list);
 475         assert(msg_list != NULL);
 476         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 477
 478         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 479         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 3);
 480
 481         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_UPDATE);
 482         CU_ASSERT_EQUAL(msg->encoded_message_length,
 483                         pcep_update_hexbyte_strs_length);
 484
 485         /* Verify each of the object types */
 486
 487         double_linked_list_node *node = msg->obj_list->head;
 488
 489         /* SRP object */
 490         struct pcep_object_header *obj_hdr =
 491                 (struct pcep_object_header *)node->data;
 492         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_SRP);
 493         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_SRP);
 494         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 20);
 495         CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr));
 496
 497         /* SRP TLV */
 498         CU_ASSERT_EQUAL(obj_hdr->tlv_list->num_entries, 1);
 499         struct pcep_object_tlv_header *tlv =
 500                 (struct pcep_object_tlv_header *)obj_hdr->tlv_list->head->data;
 501         CU_ASSERT_EQUAL(tlv->type, PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE);
 502         CU_ASSERT_EQUAL(tlv->encoded_tlv_length, 4);
 503         /* TODO verify the path setup type */
 504
 505         /* LSP object */
 506         node = node->next_node;
 507         obj_hdr = (struct pcep_object_header *)node->data;
 508         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_LSP);
 509         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_LSP);
 510         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length,
 511                         pcep_object_get_length_by_hdr(obj_hdr));
 512         CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr));
 513
 514         /* ERO object */
 515         node = node->next_node;
 516         obj_hdr = (struct pcep_object_header *)node->data;
 517         CU_ASSERT_EQUAL(obj_hdr->object_class, PCEP_OBJ_CLASS_ERO);
 518         CU_ASSERT_EQUAL(obj_hdr->object_type, PCEP_OBJ_TYPE_ERO);
 519         CU_ASSERT_EQUAL(obj_hdr->encoded_object_length, 16);
 520
 521         /* ERO Subobjects */
 522         double_linked_list *ero_subobj_list =
 523                 ((struct pcep_object_ro *)obj_hdr)->sub_objects;
 524         CU_ASSERT_PTR_NOT_NULL(ero_subobj_list);
 525         assert(ero_subobj_list != NULL);
 526         CU_ASSERT_EQUAL(ero_subobj_list->num_entries, 0);
 527         double_linked_list_node *subobj_node = ero_subobj_list->head;
 528         CU_ASSERT_PTR_NULL(subobj_node);
 529         /* We no longer support draft07 SR sub-object type=5, and only support
 530         type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
 531         pcep_object_ro_subobj *) subobj_node->data;
 532         CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
 533         struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
 534         subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
 535         PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
 536         CU_ASSERT_FALSE(subobj_sr->flag_c);
 537         CU_ASSERT_FALSE(subobj_sr->flag_s);
 538         CU_ASSERT_FALSE(subobj_sr->flag_f);
 539         CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
 540         CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
 541         0x01010101);
 542         */
 543
 544         pcep_msg_free_message_list(msg_list);
 545         close(fd);
 546         unlink(filename);
 547 }
 548
 549 void test_pcep_msg_read_pcep_open_initiate()
 550 {
 551         char filename[BASE_TMPFILE_SIZE];
 552
 553         int fd = convert_hexstrs_to_binary(
 554                 filename, pcep_open_initiate_odl_hexbyte_strs,
 555                 pcep_open_initiate_hexbyte_strs_length);
 556         if(fd == -1){
 557                 CU_ASSERT_TRUE(fd>=0);
 558                 return;
 559         }
 560         double_linked_list *msg_list = pcep_msg_read(fd);
 561         CU_ASSERT_PTR_NOT_NULL(msg_list);
 562         assert(msg_list != NULL);
 563         CU_ASSERT_EQUAL(msg_list->num_entries, 2);
 564
 565         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 566         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 1);
 567         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_OPEN);
 568         CU_ASSERT_EQUAL(msg->encoded_message_length,
 569                         pcep_open_hexbyte_strs_length);
 570
 571         msg = (struct pcep_message *)msg_list->head->next_node->data;
 572         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 4);
 573         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_INITIATE);
 574         CU_ASSERT_EQUAL(msg->encoded_message_length,
 575                         pcep_initiate2_hexbyte_strs_length);
 576
 577         pcep_msg_free_message_list(msg_list);
 578         close(fd);
 579         unlink(filename);
 580 }
 581
 582 void test_pcep_msg_read_pcep_open_cisco_pce()
 583 {
 584         char filename[BASE_TMPFILE_SIZE];
 585
 586         int fd = convert_hexstrs_to_binary(
 587                 filename, pcep_open_cisco_pce_hexbyte_strs,
 588                 pcep_open_cisco_pce_hexbyte_strs_length);
 589         if(fd == -1){
 590                 CU_ASSERT_TRUE(fd>=0);
 591                 return;
 592         }
 593         double_linked_list *msg_list = pcep_msg_read(fd);
 594         CU_ASSERT_PTR_NOT_NULL(msg_list);
 595         assert(msg_list != NULL);
 596         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 597
 598         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 599         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_OPEN);
 600         CU_ASSERT_EQUAL(msg->encoded_message_length,
 601                         pcep_open_hexbyte_strs_length);
 602         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 1);
 603
 604         /* Open object */
 605         struct pcep_object_open *open =
 606                 (struct pcep_object_open *)msg->obj_list->head->data;
 607         CU_ASSERT_EQUAL(open->header.object_class, PCEP_OBJ_CLASS_OPEN);
 608         CU_ASSERT_EQUAL(open->header.object_type, PCEP_OBJ_TYPE_OPEN);
 609         CU_ASSERT_EQUAL(open->header.encoded_object_length, 24);
 610         CU_ASSERT_EQUAL(open->open_deadtimer, 120);
 611         CU_ASSERT_EQUAL(open->open_keepalive, 60);
 612         CU_ASSERT_EQUAL(open->open_sid, 0);
 613         CU_ASSERT_EQUAL(open->open_version, 1);
 614         CU_ASSERT_PTR_NOT_NULL(open->header.tlv_list);
 615         assert(open->header.tlv_list != NULL);
 616         CU_ASSERT_EQUAL(open->header.tlv_list->num_entries, 2);
 617
 618         /* Stateful PCE Capability TLV */
 619         double_linked_list_node *tlv_node = open->header.tlv_list->head;
 620         struct pcep_object_tlv_stateful_pce_capability *pce_cap_tlv =
 621                 (struct pcep_object_tlv_stateful_pce_capability *)
 622                         tlv_node->data;
 623         CU_ASSERT_EQUAL(pce_cap_tlv->header.type,
 624                         PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY);
 625         CU_ASSERT_EQUAL(pce_cap_tlv->header.encoded_tlv_length, 4);
 626         CU_ASSERT_TRUE(pce_cap_tlv->flag_u_lsp_update_capability);
 627         CU_ASSERT_TRUE(pce_cap_tlv->flag_i_lsp_instantiation_capability);
 628         CU_ASSERT_FALSE(pce_cap_tlv->flag_s_include_db_version);
 629         CU_ASSERT_FALSE(pce_cap_tlv->flag_t_triggered_resync);
 630         CU_ASSERT_FALSE(pce_cap_tlv->flag_d_delta_lsp_sync);
 631         CU_ASSERT_FALSE(pce_cap_tlv->flag_f_triggered_initial_sync);
 632
 633         /* SR PCE Capability TLV */
 634         tlv_node = tlv_node->next_node;
 635         struct pcep_object_tlv_sr_pce_capability *sr_pce_cap_tlv =
 636                 (struct pcep_object_tlv_sr_pce_capability *)tlv_node->data;
 637         CU_ASSERT_EQUAL(sr_pce_cap_tlv->header.type,
 638                         PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY);
 639         CU_ASSERT_EQUAL(sr_pce_cap_tlv->header.encoded_tlv_length, 4);
 640         CU_ASSERT_FALSE(sr_pce_cap_tlv->flag_n);
 641         CU_ASSERT_FALSE(sr_pce_cap_tlv->flag_x);
 642         CU_ASSERT_EQUAL(sr_pce_cap_tlv->max_sid_depth, 10);
 643
 644         pcep_msg_free_message_list(msg_list);
 645         close(fd);
 646         unlink(filename);
 647 }
 648
 649 void test_pcep_msg_read_pcep_update_cisco_pce()
 650 {
 651         char filename[BASE_TMPFILE_SIZE];
 652
 653         int fd = convert_hexstrs_to_binary(
 654                 filename, pcep_update_cisco_pce_hexbyte_strs,
 655                 pcep_update_cisco_pce_hexbyte_strs_length);
 656         if(fd == -1){
 657                 CU_ASSERT_TRUE(fd>=0);
 658                 return;
 659         }
 660         double_linked_list *msg_list = pcep_msg_read(fd);
 661         CU_ASSERT_PTR_NOT_NULL(msg_list);
 662         assert(msg_list != NULL);
 663         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 664
 665         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 666         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_UPDATE);
 667         CU_ASSERT_EQUAL(msg->encoded_message_length,
 668                         pcep_update_cisco_pce_hexbyte_strs_length);
 669         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 4);
 670
 671         /* SRP object */
 672         double_linked_list_node *obj_node = msg->obj_list->head;
 673         struct pcep_object_srp *srp = (struct pcep_object_srp *)obj_node->data;
 674         CU_ASSERT_EQUAL(srp->header.object_class, PCEP_OBJ_CLASS_SRP);
 675         CU_ASSERT_EQUAL(srp->header.object_type, PCEP_OBJ_TYPE_SRP);
 676         CU_ASSERT_EQUAL(srp->header.encoded_object_length, 20);
 677         CU_ASSERT_PTR_NOT_NULL(srp->header.tlv_list);
 678         assert(srp->header.tlv_list != NULL);
 679         CU_ASSERT_EQUAL(srp->header.tlv_list->num_entries, 1);
 680         CU_ASSERT_EQUAL(srp->srp_id_number, 1);
 681         CU_ASSERT_FALSE(srp->flag_lsp_remove);
 682
 683         /* SRP Path Setup Type TLV */
 684         double_linked_list_node *tlv_node = srp->header.tlv_list->head;
 685         struct pcep_object_tlv_path_setup_type *pst_tlv =
 686                 (struct pcep_object_tlv_path_setup_type *)tlv_node->data;
 687         CU_ASSERT_EQUAL(pst_tlv->header.type,
 688                         PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE);
 689         CU_ASSERT_EQUAL(pst_tlv->header.encoded_tlv_length, 4);
 690         CU_ASSERT_EQUAL(pst_tlv->path_setup_type, 1);
 691
 692         /* LSP object */
 693         obj_node = obj_node->next_node;
 694         struct pcep_object_lsp *lsp = (struct pcep_object_lsp *)obj_node->data;
 695         CU_ASSERT_EQUAL(lsp->header.object_class, PCEP_OBJ_CLASS_LSP);
 696         CU_ASSERT_EQUAL(lsp->header.object_type, PCEP_OBJ_TYPE_LSP);
 697         CU_ASSERT_EQUAL(lsp->header.encoded_object_length, 24);
 698         CU_ASSERT_PTR_NOT_NULL(lsp->header.tlv_list);
 699         assert(lsp->header.tlv_list != NULL);
 700         CU_ASSERT_EQUAL(lsp->header.tlv_list->num_entries, 1);
 701         CU_ASSERT_EQUAL(lsp->plsp_id, 524303);
 702         CU_ASSERT_EQUAL(lsp->operational_status, PCEP_LSP_OPERATIONAL_DOWN);
 703         CU_ASSERT_TRUE(lsp->flag_a);
 704         CU_ASSERT_TRUE(lsp->flag_c);
 705         CU_ASSERT_TRUE(lsp->flag_d);
 706         CU_ASSERT_FALSE(lsp->flag_r);
 707         CU_ASSERT_FALSE(lsp->flag_s);
 708
 709         /* LSP Vendor Info TLV */
 710         tlv_node = lsp->header.tlv_list->head;
 711         struct pcep_object_tlv_vendor_info *vendor_tlv =
 712                 (struct pcep_object_tlv_vendor_info *)tlv_node->data;
 713         CU_ASSERT_EQUAL(vendor_tlv->header.type, PCEP_OBJ_TLV_TYPE_VENDOR_INFO);
 714         CU_ASSERT_EQUAL(vendor_tlv->header.encoded_tlv_length, 12);
 715         CU_ASSERT_EQUAL(vendor_tlv->enterprise_number, 9);
 716         CU_ASSERT_EQUAL(vendor_tlv->enterprise_specific_info, 0x00030004);
 717
 718         /* ERO object */
 719         obj_node = obj_node->next_node;
 720         struct pcep_object_ro *ero = (struct pcep_object_ro *)obj_node->data;
 721         CU_ASSERT_EQUAL(ero->header.object_class, PCEP_OBJ_CLASS_ERO);
 722         CU_ASSERT_EQUAL(ero->header.object_type, PCEP_OBJ_TYPE_ERO);
 723         CU_ASSERT_EQUAL(ero->header.encoded_object_length, 40);
 724         CU_ASSERT_PTR_NULL(ero->header.tlv_list);
 725         CU_ASSERT_PTR_NOT_NULL(ero->sub_objects);
 726         assert(ero->sub_objects != NULL);
 727         CU_ASSERT_EQUAL(ero->sub_objects->num_entries, 3);
 728
 729         /* ERO Subobjects */
 730         double_linked_list_node *ero_subobj_node = ero->sub_objects->head;
 731         struct pcep_ro_subobj_sr *sr_subobj_ipv4_node =
 732                 (struct pcep_ro_subobj_sr *)ero_subobj_node->data;
 733         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->ro_subobj.ro_subobj_type,
 734                         RO_SUBOBJ_TYPE_SR);
 735         CU_ASSERT_FALSE(sr_subobj_ipv4_node->ro_subobj.flag_subobj_loose_hop);
 736         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->nai_type,
 737                         PCEP_SR_SUBOBJ_NAI_IPV4_NODE);
 738         CU_ASSERT_TRUE(sr_subobj_ipv4_node->flag_m);
 739         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_c);
 740         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_f);
 741         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_s);
 742         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->sid, 73748480);
 743         CU_ASSERT_EQUAL(
 744                 *((uint32_t *)sr_subobj_ipv4_node->nai_list->head->data),
 745                 htonl(0x0a0a0a05));
 746
 747         ero_subobj_node = ero_subobj_node->next_node;
 748         sr_subobj_ipv4_node = (struct pcep_ro_subobj_sr *)ero_subobj_node->data;
 749         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->ro_subobj.ro_subobj_type,
 750                         RO_SUBOBJ_TYPE_SR);
 751         CU_ASSERT_FALSE(sr_subobj_ipv4_node->ro_subobj.flag_subobj_loose_hop);
 752         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->nai_type,
 753                         PCEP_SR_SUBOBJ_NAI_IPV4_NODE);
 754         CU_ASSERT_TRUE(sr_subobj_ipv4_node->flag_m);
 755         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_c);
 756         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_f);
 757         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_s);
 758         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->sid, 73736192);
 759         CU_ASSERT_EQUAL(
 760                 *((uint32_t *)sr_subobj_ipv4_node->nai_list->head->data),
 761                 htonl(0x0a0a0a02));
 762
 763         ero_subobj_node = ero_subobj_node->next_node;
 764         sr_subobj_ipv4_node = (struct pcep_ro_subobj_sr *)ero_subobj_node->data;
 765         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->ro_subobj.ro_subobj_type,
 766                         RO_SUBOBJ_TYPE_SR);
 767         CU_ASSERT_FALSE(sr_subobj_ipv4_node->ro_subobj.flag_subobj_loose_hop);
 768         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->nai_type,
 769                         PCEP_SR_SUBOBJ_NAI_IPV4_NODE);
 770         CU_ASSERT_TRUE(sr_subobj_ipv4_node->flag_m);
 771         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_c);
 772         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_f);
 773         CU_ASSERT_FALSE(sr_subobj_ipv4_node->flag_s);
 774         CU_ASSERT_EQUAL(sr_subobj_ipv4_node->sid, 73732096);
 775         CU_ASSERT_EQUAL(
 776                 *((uint32_t *)sr_subobj_ipv4_node->nai_list->head->data),
 777                 htonl(0x0a0a0a01));
 778
 779         /* Metric object */
 780         obj_node = obj_node->next_node;
 781         struct pcep_object_metric *metric =
 782                 (struct pcep_object_metric *)obj_node->data;
 783         CU_ASSERT_EQUAL(metric->header.object_class, PCEP_OBJ_CLASS_METRIC);
 784         CU_ASSERT_EQUAL(metric->header.object_type, PCEP_OBJ_TYPE_METRIC);
 785         CU_ASSERT_EQUAL(metric->header.encoded_object_length, 12);
 786         CU_ASSERT_PTR_NULL(metric->header.tlv_list);
 787         CU_ASSERT_FALSE(metric->flag_b);
 788         CU_ASSERT_FALSE(metric->flag_c);
 789         CU_ASSERT_EQUAL(metric->type, PCEP_METRIC_TE);
 790         CU_ASSERT_EQUAL(metric->value, 30.0);
 791
 792         pcep_msg_free_message_list(msg_list);
 793         close(fd);
 794         unlink(filename);
 795 }
 796
 797 void test_pcep_msg_read_pcep_report_cisco_pcc()
 798 {
 799         char filename[BASE_TMPFILE_SIZE];
 800
 801         int fd = convert_hexstrs_to_binary(
 802                 filename, pcep_report_cisco_pcc_hexbyte_strs,
 803                 pcep_report_cisco_pcc_hexbyte_strs_length);
 804         if(fd == -1){
 805                 CU_ASSERT_TRUE(fd>=0);
 806                 return;
 807         }
 808         double_linked_list *msg_list = pcep_msg_read(fd);
 809         CU_ASSERT_PTR_NOT_NULL(msg_list);
 810         assert(msg_list != NULL);
 811         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 812
 813         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 814         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_REPORT);
 815         CU_ASSERT_EQUAL(msg->encoded_message_length,
 816                         pcep_report_cisco_pcc_hexbyte_strs_length);
 817         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 8);
 818
 819         /* SRP object */
 820         double_linked_list_node *obj_node = msg->obj_list->head;
 821         struct pcep_object_srp *srp = (struct pcep_object_srp *)obj_node->data;
 822         CU_ASSERT_EQUAL(srp->header.object_class, PCEP_OBJ_CLASS_SRP);
 823         CU_ASSERT_EQUAL(srp->header.object_type, PCEP_OBJ_TYPE_SRP);
 824         CU_ASSERT_EQUAL(srp->header.encoded_object_length, 20);
 825         CU_ASSERT_PTR_NOT_NULL(srp->header.tlv_list);
 826         assert(srp->header.tlv_list != NULL);
 827         CU_ASSERT_EQUAL(srp->header.tlv_list->num_entries, 1);
 828         CU_ASSERT_EQUAL(srp->srp_id_number, 0);
 829         CU_ASSERT_FALSE(srp->flag_lsp_remove);
 830
 831         /* SRP Path Setup Type TLV */
 832         double_linked_list_node *tlv_node = srp->header.tlv_list->head;
 833         struct pcep_object_tlv_path_setup_type *pst_tlv =
 834                 (struct pcep_object_tlv_path_setup_type *)tlv_node->data;
 835         CU_ASSERT_EQUAL(pst_tlv->header.type,
 836                         PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE);
 837         CU_ASSERT_EQUAL(pst_tlv->header.encoded_tlv_length, 4);
 838         CU_ASSERT_EQUAL(pst_tlv->path_setup_type, 1);
 839
 840         /* LSP object */
 841         obj_node = obj_node->next_node;
 842         struct pcep_object_lsp *lsp = (struct pcep_object_lsp *)obj_node->data;
 843         CU_ASSERT_EQUAL(lsp->header.object_class, PCEP_OBJ_CLASS_LSP);
 844         CU_ASSERT_EQUAL(lsp->header.object_type, PCEP_OBJ_TYPE_LSP);
 845         CU_ASSERT_EQUAL(lsp->header.encoded_object_length, 60);
 846         CU_ASSERT_PTR_NOT_NULL(lsp->header.tlv_list);
 847         /* The TLV with ID 65505 is now recognized, and its in the list */
 848         CU_ASSERT_EQUAL(lsp->header.tlv_list->num_entries, 3);
 849         CU_ASSERT_EQUAL(lsp->plsp_id, 524303);
 850         CU_ASSERT_EQUAL(lsp->operational_status, PCEP_LSP_OPERATIONAL_DOWN);
 851         CU_ASSERT_TRUE(lsp->flag_a);
 852         CU_ASSERT_TRUE(lsp->flag_d);
 853         CU_ASSERT_FALSE(lsp->flag_c);
 854         CU_ASSERT_FALSE(lsp->flag_r);
 855         CU_ASSERT_FALSE(lsp->flag_s);
 856
 857         /* LSP IPv4 LSP Identifier TLV */
 858         tlv_node = lsp->header.tlv_list->head;
 859         struct pcep_object_tlv_ipv4_lsp_identifier *ipv4_lsp_id =
 860                 (struct pcep_object_tlv_ipv4_lsp_identifier *)tlv_node->data;
 861         CU_ASSERT_EQUAL(ipv4_lsp_id->header.type,
 862                         PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS);
 863         CU_ASSERT_EQUAL(ipv4_lsp_id->header.encoded_tlv_length, 16);
 864         CU_ASSERT_EQUAL(ipv4_lsp_id->ipv4_tunnel_sender.s_addr,
 865                         htonl(0x0a0a0a06));
 866         CU_ASSERT_EQUAL(ipv4_lsp_id->ipv4_tunnel_endpoint.s_addr,
 867                         htonl(0x0a0a0a01));
 868         CU_ASSERT_EQUAL(ipv4_lsp_id->extended_tunnel_id.s_addr,
 869                         htonl(0x0a0a0a06));
 870         CU_ASSERT_EQUAL(ipv4_lsp_id->tunnel_id, 15);
 871         CU_ASSERT_EQUAL(ipv4_lsp_id->lsp_id, 2);
 872
 873         /* LSP Symbolic Path Name TLV */
 874         tlv_node = tlv_node->next_node;
 875         struct pcep_object_tlv_symbolic_path_name *sym_path_name =
 876                 (struct pcep_object_tlv_symbolic_path_name *)tlv_node->data;
 877         CU_ASSERT_EQUAL(sym_path_name->header.type,
 878                         PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME);
 879         CU_ASSERT_EQUAL(sym_path_name->header.encoded_tlv_length, 13);
 880         CU_ASSERT_EQUAL(sym_path_name->symbolic_path_name_length, 13);
 881         CU_ASSERT_EQUAL(
 882                 strncmp(sym_path_name->symbolic_path_name, "cfg_R6-to-R1", 13),
 883                 0);
 884
 885         /* ERO object */
 886         obj_node = obj_node->next_node;
 887         struct pcep_object_ro *ero = (struct pcep_object_ro *)obj_node->data;
 888         CU_ASSERT_EQUAL(ero->header.object_class, PCEP_OBJ_CLASS_ERO);
 889         CU_ASSERT_EQUAL(ero->header.object_type, PCEP_OBJ_TYPE_ERO);
 890         CU_ASSERT_EQUAL(ero->header.encoded_object_length, 4);
 891         CU_ASSERT_PTR_NULL(ero->header.tlv_list);
 892         CU_ASSERT_PTR_NOT_NULL(ero->sub_objects);
 893         assert(ero->sub_objects != NULL);
 894         CU_ASSERT_EQUAL(ero->sub_objects->num_entries, 0);
 895
 896         /* LSPA object */
 897         obj_node = obj_node->next_node;
 898         struct pcep_object_lspa *lspa =
 899                 (struct pcep_object_lspa *)obj_node->data;
 900         CU_ASSERT_EQUAL(lspa->header.object_class, PCEP_OBJ_CLASS_LSPA);
 901         CU_ASSERT_EQUAL(lspa->header.object_type, PCEP_OBJ_TYPE_LSPA);
 902         CU_ASSERT_EQUAL(lspa->header.encoded_object_length, 20);
 903         CU_ASSERT_PTR_NULL(lspa->header.tlv_list);
 904         CU_ASSERT_TRUE(lspa->flag_local_protection);
 905         CU_ASSERT_EQUAL(lspa->holding_priority, 7);
 906         CU_ASSERT_EQUAL(lspa->setup_priority, 7);
 907         CU_ASSERT_EQUAL(lspa->lspa_include_all, 0);
 908         CU_ASSERT_EQUAL(lspa->lspa_include_any, 0);
 909         CU_ASSERT_EQUAL(lspa->lspa_exclude_any, 0);
 910
 911         /* Bandwidth object 1 */
 912         obj_node = obj_node->next_node;
 913         struct pcep_object_bandwidth *bandwidth =
 914                 (struct pcep_object_bandwidth *)obj_node->data;
 915         CU_ASSERT_EQUAL(bandwidth->header.object_class,
 916                         PCEP_OBJ_CLASS_BANDWIDTH);
 917         CU_ASSERT_EQUAL(bandwidth->header.object_type,
 918                         PCEP_OBJ_TYPE_BANDWIDTH_REQ);
 919         CU_ASSERT_EQUAL(bandwidth->header.encoded_object_length, 8);
 920         CU_ASSERT_EQUAL(bandwidth->bandwidth, 0);
 921
 922         /* Bandwidth object 2 */
 923         obj_node = obj_node->next_node;
 924         bandwidth = (struct pcep_object_bandwidth *)obj_node->data;
 925         CU_ASSERT_EQUAL(bandwidth->header.object_class,
 926                         PCEP_OBJ_CLASS_BANDWIDTH);
 927         CU_ASSERT_EQUAL(bandwidth->header.object_type,
 928                         PCEP_OBJ_TYPE_BANDWIDTH_CISCO);
 929         CU_ASSERT_EQUAL(bandwidth->header.encoded_object_length, 8);
 930         CU_ASSERT_EQUAL(bandwidth->bandwidth, 0);
 931
 932         /* Metric object 1 */
 933         obj_node = obj_node->next_node;
 934         struct pcep_object_metric *metric =
 935                 (struct pcep_object_metric *)obj_node->data;
 936         CU_ASSERT_EQUAL(metric->header.object_class, PCEP_OBJ_CLASS_METRIC);
 937         CU_ASSERT_EQUAL(metric->header.object_type, PCEP_OBJ_TYPE_METRIC);
 938         CU_ASSERT_EQUAL(metric->header.encoded_object_length, 12);
 939         CU_ASSERT_PTR_NULL(metric->header.tlv_list);
 940         CU_ASSERT_FALSE(metric->flag_b);
 941         CU_ASSERT_FALSE(metric->flag_c);
 942         CU_ASSERT_EQUAL(metric->type, PCEP_METRIC_TE);
 943         CU_ASSERT_EQUAL(metric->value, 0);
 944
 945         /* Metric object 2 */
 946         obj_node = obj_node->next_node;
 947         metric = (struct pcep_object_metric *)obj_node->data;
 948         CU_ASSERT_EQUAL(metric->header.object_class, PCEP_OBJ_CLASS_METRIC);
 949         CU_ASSERT_EQUAL(metric->header.object_type, PCEP_OBJ_TYPE_METRIC);
 950         CU_ASSERT_EQUAL(metric->header.encoded_object_length, 12);
 951         CU_ASSERT_PTR_NULL(metric->header.tlv_list);
 952         CU_ASSERT_TRUE(metric->flag_b);
 953         CU_ASSERT_FALSE(metric->flag_c);
 954         CU_ASSERT_EQUAL(metric->type, PCEP_METRIC_AGGREGATE_BW);
 955         CU_ASSERT_EQUAL(metric->value, 16.0);
 956
 957         pcep_msg_free_message_list(msg_list);
 958         close(fd);
 959         unlink(filename);
 960 }
 961
 962 void test_pcep_msg_read_pcep_initiate_cisco_pcc()
 963 {
 964         char filename[BASE_TMPFILE_SIZE];
 965
 966         int fd = convert_hexstrs_to_binary(
 967                 filename, pcep_initiate_cisco_pcc_hexbyte_strs,
 968                 pcep_initiate_cisco_pcc_hexbyte_strs_length);
 969         if(fd == -1){
 970                 CU_ASSERT_TRUE(fd>=0);
 971                 return;
 972         }
 973         double_linked_list *msg_list = pcep_msg_read(fd);
 974         CU_ASSERT_PTR_NOT_NULL(msg_list);
 975         assert(msg_list != NULL);
 976         CU_ASSERT_EQUAL(msg_list->num_entries, 1);
 977
 978         struct pcep_message *msg = (struct pcep_message *)msg_list->head->data;
 979         CU_ASSERT_EQUAL(msg->msg_header->type, PCEP_TYPE_INITIATE);
 980         CU_ASSERT_EQUAL(msg->encoded_message_length,
 981                         pcep_initiate_cisco_pcc_hexbyte_strs_length);
 982         CU_ASSERT_EQUAL(msg->obj_list->num_entries, 6);
 983
 984         /* SRP object */
 985         double_linked_list_node *obj_node = msg->obj_list->head;
 986         struct pcep_object_srp *srp = (struct pcep_object_srp *)obj_node->data;
 987         CU_ASSERT_EQUAL(srp->header.object_class, PCEP_OBJ_CLASS_SRP);
 988         CU_ASSERT_EQUAL(srp->header.object_type, PCEP_OBJ_TYPE_SRP);
 989         CU_ASSERT_EQUAL(srp->header.encoded_object_length, 20);
 990         CU_ASSERT_PTR_NOT_NULL(srp->header.tlv_list);
 991         assert(srp->header.tlv_list != NULL);
 992         CU_ASSERT_EQUAL(srp->header.tlv_list->num_entries, 1);
 993         CU_ASSERT_EQUAL(srp->srp_id_number, 1);
 994         CU_ASSERT_FALSE(srp->flag_lsp_remove);
 995
 996         /* LSP object */
 997         obj_node = obj_node->next_node;
 998         struct pcep_object_lsp *lsp = (struct pcep_object_lsp *)obj_node->data;
 999         CU_ASSERT_EQUAL(lsp->header.object_class, PCEP_OBJ_CLASS_LSP);
1000         CU_ASSERT_EQUAL(lsp->header.object_type, PCEP_OBJ_TYPE_LSP);
1001         CU_ASSERT_EQUAL(lsp->header.encoded_object_length, 48);
1002         CU_ASSERT_PTR_NOT_NULL(lsp->header.tlv_list);
1003         assert(lsp->header.tlv_list != NULL);
1004         CU_ASSERT_EQUAL(lsp->header.tlv_list->num_entries, 2);
1005         CU_ASSERT_EQUAL(lsp->plsp_id, 0);
1006         CU_ASSERT_EQUAL(lsp->operational_status, PCEP_LSP_OPERATIONAL_DOWN);
1007         CU_ASSERT_TRUE(lsp->flag_a);
1008         CU_ASSERT_TRUE(lsp->flag_d);
1009         CU_ASSERT_TRUE(lsp->flag_c);
1010         CU_ASSERT_FALSE(lsp->flag_r);
1011         CU_ASSERT_FALSE(lsp->flag_s);
1012
1013         /* Endpoint object */
1014         obj_node = obj_node->next_node;
1015         struct pcep_object_endpoints_ipv4 *endpoint =
1016                 (struct pcep_object_endpoints_ipv4 *)obj_node->data;
1017         CU_ASSERT_EQUAL(endpoint->header.object_class,
1018                         PCEP_OBJ_CLASS_ENDPOINTS);
1019         CU_ASSERT_EQUAL(endpoint->header.object_type,
1020                         PCEP_OBJ_TYPE_ENDPOINT_IPV4);
1021         CU_ASSERT_EQUAL(endpoint->header.encoded_object_length, 12);
1022         CU_ASSERT_PTR_NULL(endpoint->header.tlv_list);
1023         CU_ASSERT_EQUAL(endpoint->src_ipv4.s_addr, htonl(0x0a0a0a0a));
1024         CU_ASSERT_EQUAL(endpoint->dst_ipv4.s_addr, htonl(0x0a0a0a04));
1025
1026         /* Inter-Layer object */
1027         obj_node = obj_node->next_node;
1028         struct pcep_object_inter_layer *inter_layer =
1029                 (struct pcep_object_inter_layer *)obj_node->data;
1030         CU_ASSERT_EQUAL(inter_layer->header.object_class,
1031                         PCEP_OBJ_CLASS_INTER_LAYER);
1032         CU_ASSERT_EQUAL(inter_layer->header.object_type,
1033                         PCEP_OBJ_TYPE_INTER_LAYER);
1034         CU_ASSERT_EQUAL(inter_layer->header.encoded_object_length, 8);
1035         CU_ASSERT_PTR_NULL(inter_layer->header.tlv_list);
1036         CU_ASSERT_TRUE(inter_layer->flag_i);
1037         CU_ASSERT_FALSE(inter_layer->flag_m);
1038         CU_ASSERT_TRUE(inter_layer->flag_t);
1039
1040         /* Switch-Layer object */
1041         obj_node = obj_node->next_node;
1042         struct pcep_object_switch_layer *switch_layer =
1043                 (struct pcep_object_switch_layer *)obj_node->data;
1044         CU_ASSERT_EQUAL(switch_layer->header.object_class,
1045                         PCEP_OBJ_CLASS_SWITCH_LAYER);
1046         CU_ASSERT_EQUAL(switch_layer->header.object_type,
1047                         PCEP_OBJ_TYPE_SWITCH_LAYER);
1048         CU_ASSERT_EQUAL(switch_layer->header.encoded_object_length, 8);
1049         CU_ASSERT_PTR_NULL(switch_layer->header.tlv_list);
1050         assert(switch_layer->header.tlv_list == NULL);
1051         CU_ASSERT_PTR_NOT_NULL(switch_layer->switch_layer_rows);
1052         assert(switch_layer->switch_layer_rows != NULL);
1053         CU_ASSERT_EQUAL(switch_layer->switch_layer_rows->num_entries, 1);
1054         struct pcep_object_switch_layer_row *switch_layer_row =
1055                 (struct pcep_object_switch_layer_row *)
1056                         switch_layer->switch_layer_rows->head->data;
1057         CU_ASSERT_EQUAL(switch_layer_row->lsp_encoding_type, 0);
1058         CU_ASSERT_EQUAL(switch_layer_row->switching_type, 0);
1059         CU_ASSERT_FALSE(switch_layer_row->flag_i);
1060
1061         /* ERO object */
1062         obj_node = obj_node->next_node;
1063         struct pcep_object_ro *ero = (struct pcep_object_ro *)obj_node->data;
1064         CU_ASSERT_EQUAL(ero->header.object_class, PCEP_OBJ_CLASS_ERO);
1065         CU_ASSERT_EQUAL(ero->header.object_type, PCEP_OBJ_TYPE_ERO);
1066         CU_ASSERT_EQUAL(ero->header.encoded_object_length, 4);
1067         CU_ASSERT_PTR_NULL(ero->header.tlv_list);
1068
1069         pcep_msg_free_message_list(msg_list);
1070         close(fd);
1071         unlink(filename);
1072 }
1073
1074 void test_validate_message_header()
1075 {
1076         uint8_t pcep_message_invalid_version[] = {0x40, 0x01, 0x04, 0x00};
1077         uint8_t pcep_message_invalid_flags[] = {0x22, 0x01, 0x04, 0x00};
1078         uint8_t pcep_message_invalid_length[] = {0x20, 0x01, 0x00, 0x00};
1079         uint8_t pcep_message_invalid_type[] = {0x20, 0xff, 0x04, 0x00};
1080         uint8_t pcep_message_valid[] = {0x20, 0x01, 0x00, 0x04};
1081
1082         /* Verify invalid message header version */
1083         CU_ASSERT_TRUE(
1084                 pcep_decode_validate_msg_header(pcep_message_invalid_version)
1085                 < 0);
1086
1087         /* Verify invalid message header flags */
1088         CU_ASSERT_TRUE(
1089                 pcep_decode_validate_msg_header(pcep_message_invalid_flags)
1090                 < 0);
1091
1092         /* Verify invalid message header lengths */
1093         CU_ASSERT_TRUE(
1094                 pcep_decode_validate_msg_header(pcep_message_invalid_length)
1095                 < 0);
1096         pcep_message_invalid_length[3] = 0x05;
1097         CU_ASSERT_TRUE(
1098                 pcep_decode_validate_msg_header(pcep_message_invalid_length)
1099                 < 0);
1100
1101         /* Verify invalid message header types */
1102         CU_ASSERT_TRUE(
1103                 pcep_decode_validate_msg_header(pcep_message_invalid_type) < 0);
1104         pcep_message_invalid_type[1] = 0x00;
1105         CU_ASSERT_TRUE(
1106                 pcep_decode_validate_msg_header(pcep_message_invalid_type) < 0);
1107
1108         /* Verify a valid message header */
1109         CU_ASSERT_EQUAL(pcep_decode_validate_msg_header(pcep_message_valid), 4);
1110 }
1111
1112 /* Internal util function */
1113 struct pcep_message *create_message(uint8_t msg_type, uint8_t obj1_class,
1114                                     uint8_t obj2_class, uint8_t obj3_class,
1115                                     uint8_t obj4_class)
1116 {
1117         struct pcep_message *msg =
1118                 pceplib_malloc(PCEPLIB_MESSAGES, sizeof(struct pcep_message));
1119         msg->obj_list = dll_initialize();
1120         msg->msg_header = pceplib_malloc(PCEPLIB_MESSAGES,
1121                                          sizeof(struct pcep_message_header));
1122         msg->msg_header->type = msg_type;
1123         msg->encoded_message = NULL;
1124
1125         if (obj1_class > 0) {
1126                 struct pcep_object_header *obj_hdr = pceplib_malloc(
1127                         PCEPLIB_MESSAGES, sizeof(struct pcep_object_header));
1128                 obj_hdr->object_class = obj1_class;
1129                 obj_hdr->tlv_list = NULL;
1130                 dll_append(msg->obj_list, obj_hdr);
1131         }
1132
1133         if (obj2_class > 0) {
1134                 struct pcep_object_header *obj_hdr = pceplib_malloc(
1135                         PCEPLIB_MESSAGES, sizeof(struct pcep_object_header));
1136                 obj_hdr->object_class = obj2_class;
1137                 obj_hdr->tlv_list = NULL;
1138                 dll_append(msg->obj_list, obj_hdr);
1139         }
1140
1141         if (obj3_class > 0) {
1142                 struct pcep_object_header *obj_hdr = pceplib_malloc(
1143                         PCEPLIB_MESSAGES, sizeof(struct pcep_object_header));
1144                 obj_hdr->object_class = obj3_class;
1145                 obj_hdr->tlv_list = NULL;
1146                 dll_append(msg->obj_list, obj_hdr);
1147         }
1148
1149         if (obj4_class > 0) {
1150                 struct pcep_object_header *obj_hdr = pceplib_malloc(
1151                         PCEPLIB_MESSAGES, sizeof(struct pcep_object_header));
1152                 obj_hdr->object_class = obj4_class;
1153                 obj_hdr->tlv_list = NULL;
1154                 dll_append(msg->obj_list, obj_hdr);
1155         }
1156
1157         return msg;
1158 }
1159
1160 void test_validate_message_objects()
1161 {
1162         /* Valid Open message */
1163         struct pcep_message *msg =
1164                 create_message(PCEP_TYPE_OPEN, PCEP_OBJ_CLASS_OPEN, 0, 0, 0);
1165         CU_ASSERT_TRUE(validate_message_objects(msg));
1166         pcep_msg_free_message(msg);
1167
1168         /* Valid KeepAlive message */
1169         msg = create_message(PCEP_TYPE_KEEPALIVE, 0, 0, 0, 0);
1170         CU_ASSERT_TRUE(validate_message_objects(msg));
1171         pcep_msg_free_message(msg);
1172
1173         /* Valid PcReq message */
1174         /* Using object_class=255 to verify it can take any object */
1175         msg = create_message(PCEP_TYPE_PCREQ, PCEP_OBJ_CLASS_RP,
1176                              PCEP_OBJ_CLASS_ENDPOINTS, any_obj_class, 0);
1177         CU_ASSERT_TRUE(validate_message_objects(msg));
1178         pcep_msg_free_message(msg);
1179
1180         /* Valid PcRep message */
1181         msg = create_message(PCEP_TYPE_PCREP, PCEP_OBJ_CLASS_RP, any_obj_class,
1182                              0, 0);
1183         CU_ASSERT_TRUE(validate_message_objects(msg));
1184         pcep_msg_free_message(msg);
1185
1186         /* Valid Notify message */
1187         msg = create_message(PCEP_TYPE_PCNOTF, PCEP_OBJ_CLASS_NOTF,
1188                              any_obj_class, 0, 0);
1189         CU_ASSERT_TRUE(validate_message_objects(msg));
1190         pcep_msg_free_message(msg);
1191
1192         /* Valid Error message */
1193         msg = create_message(PCEP_TYPE_ERROR, PCEP_OBJ_CLASS_ERROR,
1194                              any_obj_class, 0, 0);
1195         CU_ASSERT_TRUE(validate_message_objects(msg));
1196         pcep_msg_free_message(msg);
1197
1198         /* Valid Close message */
1199         msg = create_message(PCEP_TYPE_CLOSE, PCEP_OBJ_CLASS_CLOSE, 0, 0, 0);
1200         CU_ASSERT_TRUE(validate_message_objects(msg));
1201         pcep_msg_free_message(msg);
1202
1203         /* Valid Report message */
1204         msg = create_message(PCEP_TYPE_REPORT, PCEP_OBJ_CLASS_SRP,
1205                              PCEP_OBJ_CLASS_LSP, any_obj_class, any_obj_class);
1206         CU_ASSERT_TRUE(validate_message_objects(msg));
1207         pcep_msg_free_message(msg);
1208
1209         /* Valid Update message */
1210         msg = create_message(PCEP_TYPE_UPDATE, PCEP_OBJ_CLASS_SRP,
1211                              PCEP_OBJ_CLASS_LSP, any_obj_class, any_obj_class);
1212         CU_ASSERT_TRUE(validate_message_objects(msg));
1213         pcep_msg_free_message(msg);
1214
1215         /* Valid Initiate message */
1216         msg = create_message(PCEP_TYPE_INITIATE, PCEP_OBJ_CLASS_SRP,
1217                              PCEP_OBJ_CLASS_LSP, any_obj_class, any_obj_class);
1218         CU_ASSERT_TRUE(validate_message_objects(msg));
1219         pcep_msg_free_message(msg);
1220 }
1221
1222 void test_validate_message_objects_invalid()
1223 {
1224         /* unsupported message ID = 0
1225          * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1226         struct pcep_message *msg = create_message(0, any_obj_class, 0, 0, 0);
1227         CU_ASSERT_FALSE(validate_message_objects(msg));
1228         pcep_msg_free_message(msg);
1229
1230         /* Open message
1231          * {PCEP_OBJ_CLASS_OPEN, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1232         msg = create_message(PCEP_TYPE_OPEN, 0, 0, 0, 0);
1233         CU_ASSERT_FALSE(validate_message_objects(msg));
1234         pcep_msg_free_message(msg);
1235
1236         msg = create_message(PCEP_TYPE_OPEN, any_obj_class, 0, 0, 0);
1237         CU_ASSERT_FALSE(validate_message_objects(msg));
1238         pcep_msg_free_message(msg);
1239
1240         msg = create_message(PCEP_TYPE_OPEN, PCEP_OBJ_CLASS_OPEN, any_obj_class,
1241                              0, 0);
1242         CU_ASSERT_FALSE(validate_message_objects(msg));
1243         pcep_msg_free_message(msg);
1244
1245         /* KeepAlive message
1246          * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1247         msg = create_message(PCEP_TYPE_KEEPALIVE, any_obj_class, 0, 0, 0);
1248         CU_ASSERT_FALSE(validate_message_objects(msg));
1249         pcep_msg_free_message(msg);
1250
1251         /* PcReq message
1252          * {PCEP_OBJ_CLASS_RP, PCEP_OBJ_CLASS_ENDPOINTS, ANY_OBJECT, ANY_OBJECT}
1253          */
1254         msg = create_message(PCEP_TYPE_PCREQ, 0, 0, 0, 0);
1255         CU_ASSERT_FALSE(validate_message_objects(msg));
1256         pcep_msg_free_message(msg);
1257
1258         msg = create_message(PCEP_TYPE_PCREQ, PCEP_OBJ_CLASS_RP, any_obj_class,
1259                              0, 0);
1260         CU_ASSERT_FALSE(validate_message_objects(msg));
1261         pcep_msg_free_message(msg);
1262
1263         /* PcRep message
1264          * {PCEP_OBJ_CLASS_RP, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1265         msg = create_message(PCEP_TYPE_PCREP, 0, 0, 0, 0);
1266         CU_ASSERT_FALSE(validate_message_objects(msg));
1267         pcep_msg_free_message(msg);
1268
1269         msg = create_message(PCEP_TYPE_PCREP, any_obj_class, 0, 0, 0);
1270         CU_ASSERT_FALSE(validate_message_objects(msg));
1271         pcep_msg_free_message(msg);
1272
1273         /* Notify message
1274          * {PCEP_OBJ_CLASS_NOTF, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1275         msg = create_message(PCEP_TYPE_PCNOTF, 0, 0, 0, 0);
1276         CU_ASSERT_FALSE(validate_message_objects(msg));
1277         pcep_msg_free_message(msg);
1278
1279         msg = create_message(PCEP_TYPE_PCNOTF, any_obj_class, 0, 0, 0);
1280         CU_ASSERT_FALSE(validate_message_objects(msg));
1281         pcep_msg_free_message(msg);
1282
1283         /* Error message
1284          * {PCEP_OBJ_CLASS_ERROR, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1285         msg = create_message(PCEP_TYPE_ERROR, 0, 0, 0, 0);
1286         CU_ASSERT_FALSE(validate_message_objects(msg));
1287         pcep_msg_free_message(msg);
1288
1289         msg = create_message(PCEP_TYPE_ERROR, any_obj_class, 0, 0, 0);
1290         CU_ASSERT_FALSE(validate_message_objects(msg));
1291         pcep_msg_free_message(msg);
1292
1293         /* Close message
1294          * {PCEP_OBJ_CLASS_CLOSE, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1295         msg = create_message(PCEP_TYPE_CLOSE, 0, 0, 0, 0);
1296         CU_ASSERT_FALSE(validate_message_objects(msg));
1297         pcep_msg_free_message(msg);
1298
1299         msg = create_message(PCEP_TYPE_CLOSE, any_obj_class, 0, 0, 0);
1300         CU_ASSERT_FALSE(validate_message_objects(msg));
1301         pcep_msg_free_message(msg);
1302
1303         /* unsupported message ID = 8
1304          * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1305         msg = create_message(8, any_obj_class, 0, 0, 0);
1306         CU_ASSERT_FALSE(validate_message_objects(msg));
1307         pcep_msg_free_message(msg);
1308
1309         /* unsupported message ID = 9
1310          * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1311         msg = create_message(9, any_obj_class, 0, 0, 0);
1312         CU_ASSERT_FALSE(validate_message_objects(msg));
1313         pcep_msg_free_message(msg);
1314
1315         /* Report message
1316          * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1317         msg = create_message(PCEP_TYPE_REPORT, 0, 0, 0, 0);
1318         CU_ASSERT_FALSE(validate_message_objects(msg));
1319         pcep_msg_free_message(msg);
1320
1321         msg = create_message(PCEP_TYPE_REPORT, any_obj_class, 0, 0, 0);
1322         CU_ASSERT_FALSE(validate_message_objects(msg));
1323         pcep_msg_free_message(msg);
1324
1325         msg = create_message(PCEP_TYPE_REPORT, PCEP_OBJ_CLASS_SRP, 0, 0, 0);
1326         CU_ASSERT_FALSE(validate_message_objects(msg));
1327         pcep_msg_free_message(msg);
1328
1329         msg = create_message(PCEP_TYPE_REPORT, PCEP_OBJ_CLASS_SRP,
1330                              any_obj_class, 0, 0);
1331         CU_ASSERT_FALSE(validate_message_objects(msg));
1332         pcep_msg_free_message(msg);
1333
1334         /* Update message
1335          * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1336         msg = create_message(PCEP_TYPE_UPDATE, 0, 0, 0, 0);
1337         CU_ASSERT_FALSE(validate_message_objects(msg));
1338         pcep_msg_free_message(msg);
1339
1340         msg = create_message(PCEP_TYPE_UPDATE, any_obj_class, 0, 0, 0);
1341         CU_ASSERT_FALSE(validate_message_objects(msg));
1342         pcep_msg_free_message(msg);
1343
1344         msg = create_message(PCEP_TYPE_UPDATE, PCEP_OBJ_CLASS_SRP, 0, 0, 0);
1345         CU_ASSERT_FALSE(validate_message_objects(msg));
1346         pcep_msg_free_message(msg);
1347
1348         msg = create_message(PCEP_TYPE_UPDATE, PCEP_OBJ_CLASS_SRP,
1349                              any_obj_class, 0, 0);
1350         CU_ASSERT_FALSE(validate_message_objects(msg));
1351         pcep_msg_free_message(msg);
1352
1353         /* Initiate message
1354          * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1355         msg = create_message(PCEP_TYPE_INITIATE, 0, 0, 0, 0);
1356         CU_ASSERT_FALSE(validate_message_objects(msg));
1357         pcep_msg_free_message(msg);
1358
1359         msg = create_message(PCEP_TYPE_INITIATE, any_obj_class, 0, 0, 0);
1360         CU_ASSERT_FALSE(validate_message_objects(msg));
1361         pcep_msg_free_message(msg);
1362
1363         msg = create_message(PCEP_TYPE_INITIATE, PCEP_OBJ_CLASS_SRP, 0, 0, 0);
1364         CU_ASSERT_FALSE(validate_message_objects(msg));
1365         pcep_msg_free_message(msg);
1366
1367         msg = create_message(PCEP_TYPE_INITIATE, PCEP_OBJ_CLASS_SRP,
1368                              any_obj_class, 0, 0);
1369         CU_ASSERT_FALSE(validate_message_objects(msg));
1370         pcep_msg_free_message(msg);
1371 }