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