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