2 * This file is part of the PCEPlib, a PCEP protocol library.
4 * Copyright (C) 2020 Volta Networks https://voltanet.io/
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.
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.
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/>.
19 * Author : Brady Johnson <brady@voltanet.io>
32 #include <sys/types.h>
36 #include <CUnit/CUnit.h>
40 #include "pcep_msg_encoding.h"
41 #include "pcep_msg_messages.h"
42 #include "pcep_msg_tools.h"
43 #include "pcep_msg_tools_test.h"
44 #include "pcep_utils_double_linked_list.h"
45 #include "pcep_utils_logging.h"
46 #include "pcep_utils_memory.h"
48 const uint8_t any_obj_class
= 255;
50 uint16_t pcep_open_hexbyte_strs_length
= 28;
51 const char *pcep_open_odl_hexbyte_strs
[] = {
52 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e",
53 "78", "55", "00", "10", "00", "04", "00", "00", "00", "3f",
54 "00", "1a", "00", "04", "00", "00", "00", "00"};
56 /* PCEP INITIATE str received from ODL with 4 objects: [SRP, LSP, Endpoints,
57 * ERO] The LSP has a SYMBOLIC_PATH_NAME TLV. The ERO has 2 IPV4 Endpoints. */
58 uint16_t pcep_initiate_hexbyte_strs_length
= 68;
59 const char *pcep_initiate_hexbyte_strs
[] = {
60 "20", "0c", "00", "44", "21", "12", "00", "0c", "00", "00", "00", "00",
61 "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
62 "00", "11", "00", "08", "66", "61", "39", "33", "33", "39", "32", "39",
63 "04", "10", "00", "0c", "7f", "00", "00", "01", "28", "28", "28", "28",
64 "07", "10", "00", "14", "01", "08", "0a", "00", "01", "01", "18", "00",
65 "01", "08", "0a", "00", "07", "04", "18", "00"};
67 uint16_t pcep_initiate2_hexbyte_strs_length
= 72;
68 const char *pcep_initiate2_hexbyte_strs
[] = {
69 "20", "0c", "00", "48", "21", "12", "00", "14", "00", "00", "00", "00",
70 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
71 "20", "10", "00", "14", "00", "00", "00", "09", "00", "11", "00", "08",
72 "36", "65", "31", "31", "38", "39", "32", "31", "04", "10", "00", "0c",
73 "c0", "a8", "14", "05", "01", "01", "01", "01", "07", "10", "00", "10",
74 "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
76 uint16_t pcep_update_hexbyte_strs_length
= 48;
77 const char *pcep_update_hexbyte_strs
[] = {
78 "20", "0b", "00", "30", "21", "12", "00", "14", "00", "00", "00", "00",
79 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
80 "20", "10", "00", "08", "00", "02", "a0", "09", "07", "10", "00", "10",
81 "05", "0c", "10", "01", "03", "e8", "a0", "00", "01", "01", "01", "01"};
83 /* Test that pcep_msg_read() can read multiple messages in 1 call */
84 uint16_t pcep_open_initiate_hexbyte_strs_length
= 100;
85 const char *pcep_open_initiate_odl_hexbyte_strs
[] = {
86 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "1e", "78", "55",
87 "00", "10", "00", "04", "00", "00", "00", "3f", "00", "1a", "00", "04",
88 "00", "00", "00", "00", "20", "0c", "00", "48", "21", "12", "00", "14",
89 "00", "00", "00", "00", "00", "00", "00", "01", "00", "1c", "00", "04",
90 "00", "00", "00", "01", "20", "10", "00", "14", "00", "00", "00", "09",
91 "00", "11", "00", "08", "36", "65", "31", "31", "38", "39", "32", "31",
92 "04", "10", "00", "0c", "c0", "a8", "14", "05", "01", "01", "01", "01",
93 "07", "10", "00", "10", "05", "0c", "10", "01", "03", "e8", "a0", "00",
94 "01", "01", "01", "01"};
96 uint16_t pcep_open_cisco_pce_hexbyte_strs_length
= 28;
97 const char *pcep_open_cisco_pce_hexbyte_strs
[] = {
98 "20", "01", "00", "1c", "01", "10", "00", "18", "20", "3c",
99 "78", "00", "00", "10", "00", "04", "00", "00", "00", "05",
100 "00", "1a", "00", "04", "00", "00", "00", "0a"};
102 uint16_t pcep_update_cisco_pce_hexbyte_strs_length
= 100;
103 const char *pcep_update_cisco_pce_hexbyte_strs
[] = {
104 "20", "0b", "00", "64", "21", "10", "00", "14", "00", "00", "00", "00",
105 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
106 "20", "10", "00", "18", "80", "00", "f0", "89", "00", "07", "00", "0c",
107 "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
108 "07", "10", "00", "28", "24", "0c", "10", "01", "04", "65", "50", "00",
109 "0a", "0a", "0a", "05", "24", "0c", "10", "01", "04", "65", "20", "00",
110 "0a", "0a", "0a", "02", "24", "0c", "10", "01", "04", "65", "10", "00",
111 "0a", "0a", "0a", "01", "06", "10", "00", "0c", "00", "00", "00", "02",
112 "41", "f0", "00", "00"};
114 uint16_t pcep_report_cisco_pcc_hexbyte_strs_length
= 148;
115 const char *pcep_report_cisco_pcc_hexbyte_strs
[] = {
116 "20", "0a", "00", "94", "21", "10", "00", "14", "00", "00", "00", "00",
117 "00", "00", "00", "00", "00", "1c", "00", "04", "00", "00", "00", "01",
118 "20", "10", "00", "3c", "80", "00", "f0", "09", "00", "12", "00", "10",
119 "0a", "0a", "0a", "06", "00", "02", "00", "0f", "0a", "0a", "0a", "06",
120 "0a", "0a", "0a", "01", "00", "11", "00", "0d", "63", "66", "67", "5f",
121 "52", "36", "2d", "74", "6f", "2d", "52", "31", "00", "00", "00", "00",
122 "ff", "e1", "00", "06", "00", "00", "05", "dd", "70", "00", "00", "00",
123 "07", "10", "00", "04", "09", "10", "00", "14", "00", "00", "00", "00",
124 "00", "00", "00", "00", "00", "00", "00", "00", "07", "07", "01", "00",
125 "05", "12", "00", "08", "00", "00", "00", "00", "05", "52", "00", "08",
126 "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "00", "02",
127 "00", "00", "00", "00", "06", "10", "00", "0c", "00", "00", "01", "04",
128 "41", "80", "00", "00"};
130 /* Cisco PcInitiate with the following objects:
131 * SRP, LSP, Endpoint, Inter-layer, Switch-layer, ERO
133 uint16_t pcep_initiate_cisco_pcc_hexbyte_strs_length
= 104;
134 const char *pcep_initiate_cisco_pcc_hexbyte_strs
[] = {
135 "20", "0c", "00", "68", "21", "10", "00", "14", "00", "00", "00", "00",
136 "00", "00", "00", "01", "00", "1c", "00", "04", "00", "00", "00", "01",
137 "20", "10", "00", "30", "00", "00", "00", "89", "00", "11", "00", "13",
138 "50", "4f", "4c", "31", "5f", "50", "43", "49", "4e", "49", "54", "41",
139 "54", "45", "5f", "54", "45", "53", "54", "00", "00", "07", "00", "0c",
140 "00", "00", "00", "09", "00", "03", "00", "04", "00", "00", "00", "01",
141 "04", "10", "00", "0c", "0a", "0a", "0a", "0a", "0a", "0a", "0a", "04",
142 "24", "10", "00", "08", "00", "00", "01", "4d", "25", "10", "00", "08",
143 "00", "00", "00", "64", "07", "10", "00", "04"};
145 struct pcep_message
*create_message(uint8_t msg_type
, uint8_t obj1_class
,
146 uint8_t obj2_class
, uint8_t obj3_class
,
148 int convert_hexstrs_to_binary(char *filename
, const char *hexbyte_strs
[],
149 uint16_t hexbyte_strs_length
);
151 int pcep_tools_test_suite_setup(void)
153 pceplib_memory_reset();
157 int pcep_tools_test_suite_teardown(void)
160 pceplib_memory_dump();
164 void pcep_tools_test_setup(void)
168 void pcep_tools_test_teardown(void)
172 static const char BASE_TMPFILE
[] = "/tmp/pceplib_XXXXXX";
173 static int BASE_TMPFILE_SIZE
= sizeof(BASE_TMPFILE
);
175 /* Reads an array of hexbyte strs, and writes them to a temporary file.
176 * The caller should close the returned file. */
177 int convert_hexstrs_to_binary(char *filename
,
178 const char *hexbyte_strs
[],
179 uint16_t hexbyte_strs_length
)
182 oldumask
= umask(S_IXUSR
|S_IXGRP
|S_IWOTH
|S_IROTH
|S_IXOTH
);
183 /* Set umask before anything for security */
186 strlcpy(filename
, BASE_TMPFILE
, BASE_TMPFILE_SIZE
);
187 int fd
= mkstemp(filename
);
194 for (; i
< hexbyte_strs_length
; i
++) {
195 uint8_t byte
= (uint8_t)strtol(hexbyte_strs
[i
], 0, 16);
196 if (write(fd
, (char *)&byte
, 1) < 0) {
201 /* Go back to the beginning of the file */
202 lseek(fd
, 0, SEEK_SET
);
206 static bool pcep_obj_has_tlv(struct pcep_object_header
*obj_hdr
)
208 if (obj_hdr
->tlv_list
== NULL
) {
212 return (obj_hdr
->tlv_list
->num_entries
> 0);
215 void test_pcep_msg_read_pcep_initiate()
217 char filename
[BASE_TMPFILE_SIZE
];
219 int fd
= convert_hexstrs_to_binary(filename
,
220 pcep_initiate_hexbyte_strs
,
221 pcep_initiate_hexbyte_strs_length
);
223 CU_ASSERT_TRUE(fd
>=0);
226 double_linked_list
*msg_list
= pcep_msg_read(fd
);
227 CU_ASSERT_PTR_NOT_NULL(msg_list
);
228 assert(msg_list
!= NULL
);
229 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
231 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
232 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
233 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
234 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
235 pcep_initiate_hexbyte_strs_length
);
237 /* Verify each of the object types */
240 double_linked_list_node
*node
= msg
->obj_list
->head
;
241 struct pcep_object_header
*obj_hdr
=
242 (struct pcep_object_header
*)node
->data
;
243 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
244 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
245 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
246 pcep_object_get_length_by_hdr(obj_hdr
));
247 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
249 /* LSP object and its TLV*/
250 node
= node
->next_node
;
251 obj_hdr
= (struct pcep_object_header
*)node
->data
;
252 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
253 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
254 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
255 CU_ASSERT_EQUAL(((struct pcep_object_lsp
*)obj_hdr
)->plsp_id
, 0);
256 CU_ASSERT_TRUE(((struct pcep_object_lsp
*)obj_hdr
)->flag_d
);
257 CU_ASSERT_TRUE(((struct pcep_object_lsp
*)obj_hdr
)->flag_a
);
258 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_s
);
259 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_r
);
260 CU_ASSERT_FALSE(((struct pcep_object_lsp
*)obj_hdr
)->flag_c
);
263 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
264 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
265 struct pcep_object_tlv_header
*tlv
=
266 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
267 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
268 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 8);
270 /* Endpoints object */
271 node
= node
->next_node
;
272 obj_hdr
= (struct pcep_object_header
*)node
->data
;
273 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ENDPOINTS
);
274 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
275 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
276 pcep_object_get_length_by_hdr(obj_hdr
));
277 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
280 node
= node
->next_node
;
281 obj_hdr
= (struct pcep_object_header
*)node
->data
;
282 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
283 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
284 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
287 double_linked_list
*ero_subobj_list
=
288 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
289 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
290 assert(ero_subobj_list
!= NULL
);
291 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 2);
292 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
293 struct pcep_object_ro_subobj
*subobj_hdr
=
294 (struct pcep_object_ro_subobj
*)subobj_node
->data
;
295 CU_ASSERT_EQUAL(subobj_hdr
->ro_subobj_type
, RO_SUBOBJ_TYPE_IPV4
);
296 struct in_addr ero_subobj_ip
;
297 inet_pton(AF_INET
, "10.0.1.1", &ero_subobj_ip
);
299 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->ip_addr
.s_addr
,
300 ero_subobj_ip
.s_addr
);
302 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->prefix_length
, 24);
305 (struct pcep_object_ro_subobj
*)subobj_node
->next_node
->data
;
306 CU_ASSERT_EQUAL(subobj_hdr
->ro_subobj_type
, RO_SUBOBJ_TYPE_IPV4
);
307 inet_pton(AF_INET
, "10.0.7.4", &ero_subobj_ip
);
309 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->ip_addr
.s_addr
,
310 ero_subobj_ip
.s_addr
);
312 ((struct pcep_ro_subobj_ipv4
*)subobj_hdr
)->prefix_length
, 24);
314 pcep_msg_free_message_list(msg_list
);
320 void test_pcep_msg_read_pcep_initiate2()
322 char filename
[BASE_TMPFILE_SIZE
];
324 int fd
= convert_hexstrs_to_binary(filename
,
325 pcep_initiate2_hexbyte_strs
,
326 pcep_initiate2_hexbyte_strs_length
);
328 CU_ASSERT_TRUE(fd
>=0);
331 double_linked_list
*msg_list
= pcep_msg_read(fd
);
332 CU_ASSERT_PTR_NOT_NULL(msg_list
);
333 assert(msg_list
!= NULL
);
334 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
336 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
337 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
338 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
339 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
340 pcep_initiate2_hexbyte_strs_length
);
342 /* Verify each of the object types */
345 double_linked_list_node
*node
= msg
->obj_list
->head
;
346 struct pcep_object_header
*obj_hdr
=
347 (struct pcep_object_header
*)node
->data
;
348 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
349 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
350 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
351 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
352 /* TODO test the TLVs */
354 /* LSP object and its TLV*/
355 node
= node
->next_node
;
356 obj_hdr
= (struct pcep_object_header
*)node
->data
;
357 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
358 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
359 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
362 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
363 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
364 struct pcep_object_tlv_header
*tlv
=
365 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
366 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
367 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 8);
369 /* Endpoints object */
370 node
= node
->next_node
;
371 obj_hdr
= (struct pcep_object_header
*)node
->data
;
372 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ENDPOINTS
);
373 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
374 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
375 pcep_object_get_length_by_hdr(obj_hdr
));
376 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
379 node
= node
->next_node
;
380 obj_hdr
= (struct pcep_object_header
*)node
->data
;
381 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
382 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
383 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 16);
386 double_linked_list
*ero_subobj_list
=
387 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
388 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
389 assert(ero_subobj_list
!= NULL
);
390 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 0);
391 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
392 CU_ASSERT_PTR_NULL(subobj_node
);
393 /* We no longer support draft07 SR sub-object type=5, and only support
394 type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
395 pcep_object_ro_subobj *) subobj_node->data;
396 CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
397 struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
398 subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
399 PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
400 CU_ASSERT_FALSE(subobj_sr->flag_c);
401 CU_ASSERT_FALSE(subobj_sr->flag_s);
402 CU_ASSERT_FALSE(subobj_sr->flag_f);
403 CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
404 CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
408 pcep_msg_free_message_list(msg_list
);
413 void test_pcep_msg_read_pcep_open()
415 char filename
[BASE_TMPFILE_SIZE
];
417 int fd
= convert_hexstrs_to_binary(filename
,
418 pcep_open_odl_hexbyte_strs
,
419 pcep_open_hexbyte_strs_length
);
421 CU_ASSERT_TRUE(fd
>=0);
424 double_linked_list
*msg_list
= pcep_msg_read(fd
);
425 CU_ASSERT_PTR_NOT_NULL(msg_list
);
426 assert(msg_list
!= NULL
);
427 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
429 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
430 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
431 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
432 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
433 pcep_open_hexbyte_strs_length
);
435 /* Verify the Open message */
436 struct pcep_object_header
*obj_hdr
=
437 (struct pcep_object_header
*)msg
->obj_list
->head
->data
;
438 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_OPEN
);
439 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_OPEN
);
440 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 24);
441 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
443 /* Open TLV: Stateful PCE Capability */
444 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 2);
445 double_linked_list_node
*tlv_node
= obj_hdr
->tlv_list
->head
;
446 struct pcep_object_tlv_header
*tlv
=
447 (struct pcep_object_tlv_header
*)tlv_node
->data
;
448 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY
);
449 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
451 /* Open TLV: SR PCE Capability */
452 tlv_node
= tlv_node
->next_node
;
453 tlv
= (struct pcep_object_tlv_header
*)tlv_node
->data
;
454 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY
);
455 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
457 pcep_msg_free_message_list(msg_list
);
462 void test_pcep_msg_read_pcep_update()
464 char filename
[BASE_TMPFILE_SIZE
];
466 int fd
= convert_hexstrs_to_binary(filename
,
467 pcep_update_hexbyte_strs
,
468 pcep_update_hexbyte_strs_length
);
470 CU_ASSERT_TRUE(fd
>=0);
473 double_linked_list
*msg_list
= pcep_msg_read(fd
);
474 CU_ASSERT_PTR_NOT_NULL(msg_list
);
475 assert(msg_list
!= NULL
);
476 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
478 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
479 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 3);
481 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_UPDATE
);
482 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
483 pcep_update_hexbyte_strs_length
);
485 /* Verify each of the object types */
487 double_linked_list_node
*node
= msg
->obj_list
->head
;
490 struct pcep_object_header
*obj_hdr
=
491 (struct pcep_object_header
*)node
->data
;
492 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_SRP
);
493 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_SRP
);
494 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 20);
495 CU_ASSERT_TRUE(pcep_obj_has_tlv(obj_hdr
));
498 CU_ASSERT_EQUAL(obj_hdr
->tlv_list
->num_entries
, 1);
499 struct pcep_object_tlv_header
*tlv
=
500 (struct pcep_object_tlv_header
*)obj_hdr
->tlv_list
->head
->data
;
501 CU_ASSERT_EQUAL(tlv
->type
, PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
502 CU_ASSERT_EQUAL(tlv
->encoded_tlv_length
, 4);
503 /* TODO verify the path setup type */
506 node
= node
->next_node
;
507 obj_hdr
= (struct pcep_object_header
*)node
->data
;
508 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_LSP
);
509 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_LSP
);
510 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
,
511 pcep_object_get_length_by_hdr(obj_hdr
));
512 CU_ASSERT_FALSE(pcep_obj_has_tlv(obj_hdr
));
515 node
= node
->next_node
;
516 obj_hdr
= (struct pcep_object_header
*)node
->data
;
517 CU_ASSERT_EQUAL(obj_hdr
->object_class
, PCEP_OBJ_CLASS_ERO
);
518 CU_ASSERT_EQUAL(obj_hdr
->object_type
, PCEP_OBJ_TYPE_ERO
);
519 CU_ASSERT_EQUAL(obj_hdr
->encoded_object_length
, 16);
522 double_linked_list
*ero_subobj_list
=
523 ((struct pcep_object_ro
*)obj_hdr
)->sub_objects
;
524 CU_ASSERT_PTR_NOT_NULL(ero_subobj_list
);
525 assert(ero_subobj_list
!= NULL
);
526 CU_ASSERT_EQUAL(ero_subobj_list
->num_entries
, 0);
527 double_linked_list_node
*subobj_node
= ero_subobj_list
->head
;
528 CU_ASSERT_PTR_NULL(subobj_node
);
529 /* We no longer support draft07 SR sub-object type=5, and only support
530 type=36 struct pcep_object_ro_subobj *subobj_hdr = (struct
531 pcep_object_ro_subobj *) subobj_node->data;
532 CU_ASSERT_EQUAL(subobj_hdr->ro_subobj_type, RO_SUBOBJ_TYPE_SR);
533 struct pcep_ro_subobj_sr *subobj_sr = (struct pcep_ro_subobj_sr *)
534 subobj_hdr; CU_ASSERT_EQUAL(subobj_sr->nai_type,
535 PCEP_SR_SUBOBJ_NAI_IPV4_NODE); CU_ASSERT_TRUE(subobj_sr->flag_m);
536 CU_ASSERT_FALSE(subobj_sr->flag_c);
537 CU_ASSERT_FALSE(subobj_sr->flag_s);
538 CU_ASSERT_FALSE(subobj_sr->flag_f);
539 CU_ASSERT_EQUAL(subobj_sr->sid, 65576960);
540 CU_ASSERT_EQUAL(*((uint32_t *) subobj_sr->nai_list->head->data),
544 pcep_msg_free_message_list(msg_list
);
549 void test_pcep_msg_read_pcep_open_initiate()
551 char filename
[BASE_TMPFILE_SIZE
];
553 int fd
= convert_hexstrs_to_binary(
554 filename
, pcep_open_initiate_odl_hexbyte_strs
,
555 pcep_open_initiate_hexbyte_strs_length
);
557 CU_ASSERT_TRUE(fd
>=0);
560 double_linked_list
*msg_list
= pcep_msg_read(fd
);
561 CU_ASSERT_PTR_NOT_NULL(msg_list
);
562 assert(msg_list
!= NULL
);
563 CU_ASSERT_EQUAL(msg_list
->num_entries
, 2);
565 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
566 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
567 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
568 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
569 pcep_open_hexbyte_strs_length
);
571 msg
= (struct pcep_message
*)msg_list
->head
->next_node
->data
;
572 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
573 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
574 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
575 pcep_initiate2_hexbyte_strs_length
);
577 pcep_msg_free_message_list(msg_list
);
582 void test_pcep_msg_read_pcep_open_cisco_pce()
584 char filename
[BASE_TMPFILE_SIZE
];
586 int fd
= convert_hexstrs_to_binary(
587 filename
, pcep_open_cisco_pce_hexbyte_strs
,
588 pcep_open_cisco_pce_hexbyte_strs_length
);
590 CU_ASSERT_TRUE(fd
>=0);
593 double_linked_list
*msg_list
= pcep_msg_read(fd
);
594 CU_ASSERT_PTR_NOT_NULL(msg_list
);
595 assert(msg_list
!= NULL
);
596 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
598 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
599 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_OPEN
);
600 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
601 pcep_open_hexbyte_strs_length
);
602 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 1);
605 struct pcep_object_open
*open
=
606 (struct pcep_object_open
*)msg
->obj_list
->head
->data
;
607 CU_ASSERT_EQUAL(open
->header
.object_class
, PCEP_OBJ_CLASS_OPEN
);
608 CU_ASSERT_EQUAL(open
->header
.object_type
, PCEP_OBJ_TYPE_OPEN
);
609 CU_ASSERT_EQUAL(open
->header
.encoded_object_length
, 24);
610 CU_ASSERT_EQUAL(open
->open_deadtimer
, 120);
611 CU_ASSERT_EQUAL(open
->open_keepalive
, 60);
612 CU_ASSERT_EQUAL(open
->open_sid
, 0);
613 CU_ASSERT_EQUAL(open
->open_version
, 1);
614 CU_ASSERT_PTR_NOT_NULL(open
->header
.tlv_list
);
615 assert(open
->header
.tlv_list
!= NULL
);
616 CU_ASSERT_EQUAL(open
->header
.tlv_list
->num_entries
, 2);
618 /* Stateful PCE Capability TLV */
619 double_linked_list_node
*tlv_node
= open
->header
.tlv_list
->head
;
620 struct pcep_object_tlv_stateful_pce_capability
*pce_cap_tlv
=
621 (struct pcep_object_tlv_stateful_pce_capability
*)
623 CU_ASSERT_EQUAL(pce_cap_tlv
->header
.type
,
624 PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY
);
625 CU_ASSERT_EQUAL(pce_cap_tlv
->header
.encoded_tlv_length
, 4);
626 CU_ASSERT_TRUE(pce_cap_tlv
->flag_u_lsp_update_capability
);
627 CU_ASSERT_TRUE(pce_cap_tlv
->flag_i_lsp_instantiation_capability
);
628 CU_ASSERT_FALSE(pce_cap_tlv
->flag_s_include_db_version
);
629 CU_ASSERT_FALSE(pce_cap_tlv
->flag_t_triggered_resync
);
630 CU_ASSERT_FALSE(pce_cap_tlv
->flag_d_delta_lsp_sync
);
631 CU_ASSERT_FALSE(pce_cap_tlv
->flag_f_triggered_initial_sync
);
633 /* SR PCE Capability TLV */
634 tlv_node
= tlv_node
->next_node
;
635 struct pcep_object_tlv_sr_pce_capability
*sr_pce_cap_tlv
=
636 (struct pcep_object_tlv_sr_pce_capability
*)tlv_node
->data
;
637 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->header
.type
,
638 PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY
);
639 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->header
.encoded_tlv_length
, 4);
640 CU_ASSERT_FALSE(sr_pce_cap_tlv
->flag_n
);
641 CU_ASSERT_FALSE(sr_pce_cap_tlv
->flag_x
);
642 CU_ASSERT_EQUAL(sr_pce_cap_tlv
->max_sid_depth
, 10);
644 pcep_msg_free_message_list(msg_list
);
649 void test_pcep_msg_read_pcep_update_cisco_pce()
651 char filename
[BASE_TMPFILE_SIZE
];
653 int fd
= convert_hexstrs_to_binary(
654 filename
, pcep_update_cisco_pce_hexbyte_strs
,
655 pcep_update_cisco_pce_hexbyte_strs_length
);
657 CU_ASSERT_TRUE(fd
>=0);
660 double_linked_list
*msg_list
= pcep_msg_read(fd
);
661 CU_ASSERT_PTR_NOT_NULL(msg_list
);
662 assert(msg_list
!= NULL
);
663 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
665 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
666 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_UPDATE
);
667 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
668 pcep_update_cisco_pce_hexbyte_strs_length
);
669 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 4);
672 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
673 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
674 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
675 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
676 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
677 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
678 assert(srp
->header
.tlv_list
!= NULL
);
679 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
680 CU_ASSERT_EQUAL(srp
->srp_id_number
, 1);
681 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
683 /* SRP Path Setup Type TLV */
684 double_linked_list_node
*tlv_node
= srp
->header
.tlv_list
->head
;
685 struct pcep_object_tlv_path_setup_type
*pst_tlv
=
686 (struct pcep_object_tlv_path_setup_type
*)tlv_node
->data
;
687 CU_ASSERT_EQUAL(pst_tlv
->header
.type
,
688 PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
689 CU_ASSERT_EQUAL(pst_tlv
->header
.encoded_tlv_length
, 4);
690 CU_ASSERT_EQUAL(pst_tlv
->path_setup_type
, 1);
693 obj_node
= obj_node
->next_node
;
694 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
695 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
696 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
697 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 24);
698 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
699 assert(lsp
->header
.tlv_list
!= NULL
);
700 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 1);
701 CU_ASSERT_EQUAL(lsp
->plsp_id
, 524303);
702 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
703 CU_ASSERT_TRUE(lsp
->flag_a
);
704 CU_ASSERT_TRUE(lsp
->flag_c
);
705 CU_ASSERT_TRUE(lsp
->flag_d
);
706 CU_ASSERT_FALSE(lsp
->flag_r
);
707 CU_ASSERT_FALSE(lsp
->flag_s
);
709 /* LSP Vendor Info TLV */
710 tlv_node
= lsp
->header
.tlv_list
->head
;
711 struct pcep_object_tlv_vendor_info
*vendor_tlv
=
712 (struct pcep_object_tlv_vendor_info
*)tlv_node
->data
;
713 CU_ASSERT_EQUAL(vendor_tlv
->header
.type
, PCEP_OBJ_TLV_TYPE_VENDOR_INFO
);
714 CU_ASSERT_EQUAL(vendor_tlv
->header
.encoded_tlv_length
, 12);
715 CU_ASSERT_EQUAL(vendor_tlv
->enterprise_number
, 9);
716 CU_ASSERT_EQUAL(vendor_tlv
->enterprise_specific_info
, 0x00030004);
719 obj_node
= obj_node
->next_node
;
720 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
721 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
722 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
723 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 40);
724 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
725 CU_ASSERT_PTR_NOT_NULL(ero
->sub_objects
);
726 assert(ero
->sub_objects
!= NULL
);
727 CU_ASSERT_EQUAL(ero
->sub_objects
->num_entries
, 3);
730 double_linked_list_node
*ero_subobj_node
= ero
->sub_objects
->head
;
731 struct pcep_ro_subobj_sr
*sr_subobj_ipv4_node
=
732 (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
733 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
735 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
736 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
737 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
738 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
739 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
740 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
741 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
742 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73748480);
744 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
747 ero_subobj_node
= ero_subobj_node
->next_node
;
748 sr_subobj_ipv4_node
= (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
749 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
751 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
752 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
753 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
754 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
755 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
756 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
757 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
758 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73736192);
760 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
763 ero_subobj_node
= ero_subobj_node
->next_node
;
764 sr_subobj_ipv4_node
= (struct pcep_ro_subobj_sr
*)ero_subobj_node
->data
;
765 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->ro_subobj
.ro_subobj_type
,
767 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->ro_subobj
.flag_subobj_loose_hop
);
768 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->nai_type
,
769 PCEP_SR_SUBOBJ_NAI_IPV4_NODE
);
770 CU_ASSERT_TRUE(sr_subobj_ipv4_node
->flag_m
);
771 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_c
);
772 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_f
);
773 CU_ASSERT_FALSE(sr_subobj_ipv4_node
->flag_s
);
774 CU_ASSERT_EQUAL(sr_subobj_ipv4_node
->sid
, 73732096);
776 *((uint32_t *)sr_subobj_ipv4_node
->nai_list
->head
->data
),
780 obj_node
= obj_node
->next_node
;
781 struct pcep_object_metric
*metric
=
782 (struct pcep_object_metric
*)obj_node
->data
;
783 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
784 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
785 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
786 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
787 CU_ASSERT_FALSE(metric
->flag_b
);
788 CU_ASSERT_FALSE(metric
->flag_c
);
789 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_TE
);
790 CU_ASSERT_EQUAL(metric
->value
, 30.0);
792 pcep_msg_free_message_list(msg_list
);
797 void test_pcep_msg_read_pcep_report_cisco_pcc()
799 char filename
[BASE_TMPFILE_SIZE
];
801 int fd
= convert_hexstrs_to_binary(
802 filename
, pcep_report_cisco_pcc_hexbyte_strs
,
803 pcep_report_cisco_pcc_hexbyte_strs_length
);
805 CU_ASSERT_TRUE(fd
>=0);
808 double_linked_list
*msg_list
= pcep_msg_read(fd
);
809 CU_ASSERT_PTR_NOT_NULL(msg_list
);
810 assert(msg_list
!= NULL
);
811 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
813 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
814 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_REPORT
);
815 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
816 pcep_report_cisco_pcc_hexbyte_strs_length
);
817 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 8);
820 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
821 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
822 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
823 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
824 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
825 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
826 assert(srp
->header
.tlv_list
!= NULL
);
827 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
828 CU_ASSERT_EQUAL(srp
->srp_id_number
, 0);
829 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
831 /* SRP Path Setup Type TLV */
832 double_linked_list_node
*tlv_node
= srp
->header
.tlv_list
->head
;
833 struct pcep_object_tlv_path_setup_type
*pst_tlv
=
834 (struct pcep_object_tlv_path_setup_type
*)tlv_node
->data
;
835 CU_ASSERT_EQUAL(pst_tlv
->header
.type
,
836 PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE
);
837 CU_ASSERT_EQUAL(pst_tlv
->header
.encoded_tlv_length
, 4);
838 CU_ASSERT_EQUAL(pst_tlv
->path_setup_type
, 1);
841 obj_node
= obj_node
->next_node
;
842 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
843 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
844 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
845 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 60);
846 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
847 /* The TLV with ID 65505 is now recognized, and its in the list */
848 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 3);
849 CU_ASSERT_EQUAL(lsp
->plsp_id
, 524303);
850 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
851 CU_ASSERT_TRUE(lsp
->flag_a
);
852 CU_ASSERT_TRUE(lsp
->flag_d
);
853 CU_ASSERT_FALSE(lsp
->flag_c
);
854 CU_ASSERT_FALSE(lsp
->flag_r
);
855 CU_ASSERT_FALSE(lsp
->flag_s
);
857 /* LSP IPv4 LSP Identifier TLV */
858 tlv_node
= lsp
->header
.tlv_list
->head
;
859 struct pcep_object_tlv_ipv4_lsp_identifier
*ipv4_lsp_id
=
860 (struct pcep_object_tlv_ipv4_lsp_identifier
*)tlv_node
->data
;
861 CU_ASSERT_EQUAL(ipv4_lsp_id
->header
.type
,
862 PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS
);
863 CU_ASSERT_EQUAL(ipv4_lsp_id
->header
.encoded_tlv_length
, 16);
864 CU_ASSERT_EQUAL(ipv4_lsp_id
->ipv4_tunnel_sender
.s_addr
,
866 CU_ASSERT_EQUAL(ipv4_lsp_id
->ipv4_tunnel_endpoint
.s_addr
,
868 CU_ASSERT_EQUAL(ipv4_lsp_id
->extended_tunnel_id
.s_addr
,
870 CU_ASSERT_EQUAL(ipv4_lsp_id
->tunnel_id
, 15);
871 CU_ASSERT_EQUAL(ipv4_lsp_id
->lsp_id
, 2);
873 /* LSP Symbolic Path Name TLV */
874 tlv_node
= tlv_node
->next_node
;
875 struct pcep_object_tlv_symbolic_path_name
*sym_path_name
=
876 (struct pcep_object_tlv_symbolic_path_name
*)tlv_node
->data
;
877 CU_ASSERT_EQUAL(sym_path_name
->header
.type
,
878 PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME
);
879 CU_ASSERT_EQUAL(sym_path_name
->header
.encoded_tlv_length
, 13);
880 CU_ASSERT_EQUAL(sym_path_name
->symbolic_path_name_length
, 13);
882 strncmp(sym_path_name
->symbolic_path_name
, "cfg_R6-to-R1", 13),
886 obj_node
= obj_node
->next_node
;
887 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
888 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
889 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
890 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 4);
891 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
892 CU_ASSERT_PTR_NOT_NULL(ero
->sub_objects
);
893 assert(ero
->sub_objects
!= NULL
);
894 CU_ASSERT_EQUAL(ero
->sub_objects
->num_entries
, 0);
897 obj_node
= obj_node
->next_node
;
898 struct pcep_object_lspa
*lspa
=
899 (struct pcep_object_lspa
*)obj_node
->data
;
900 CU_ASSERT_EQUAL(lspa
->header
.object_class
, PCEP_OBJ_CLASS_LSPA
);
901 CU_ASSERT_EQUAL(lspa
->header
.object_type
, PCEP_OBJ_TYPE_LSPA
);
902 CU_ASSERT_EQUAL(lspa
->header
.encoded_object_length
, 20);
903 CU_ASSERT_PTR_NULL(lspa
->header
.tlv_list
);
904 CU_ASSERT_TRUE(lspa
->flag_local_protection
);
905 CU_ASSERT_EQUAL(lspa
->holding_priority
, 7);
906 CU_ASSERT_EQUAL(lspa
->setup_priority
, 7);
907 CU_ASSERT_EQUAL(lspa
->lspa_include_all
, 0);
908 CU_ASSERT_EQUAL(lspa
->lspa_include_any
, 0);
909 CU_ASSERT_EQUAL(lspa
->lspa_exclude_any
, 0);
911 /* Bandwidth object 1 */
912 obj_node
= obj_node
->next_node
;
913 struct pcep_object_bandwidth
*bandwidth
=
914 (struct pcep_object_bandwidth
*)obj_node
->data
;
915 CU_ASSERT_EQUAL(bandwidth
->header
.object_class
,
916 PCEP_OBJ_CLASS_BANDWIDTH
);
917 CU_ASSERT_EQUAL(bandwidth
->header
.object_type
,
918 PCEP_OBJ_TYPE_BANDWIDTH_REQ
);
919 CU_ASSERT_EQUAL(bandwidth
->header
.encoded_object_length
, 8);
920 CU_ASSERT_EQUAL(bandwidth
->bandwidth
, 0);
922 /* Bandwidth object 2 */
923 obj_node
= obj_node
->next_node
;
924 bandwidth
= (struct pcep_object_bandwidth
*)obj_node
->data
;
925 CU_ASSERT_EQUAL(bandwidth
->header
.object_class
,
926 PCEP_OBJ_CLASS_BANDWIDTH
);
927 CU_ASSERT_EQUAL(bandwidth
->header
.object_type
,
928 PCEP_OBJ_TYPE_BANDWIDTH_CISCO
);
929 CU_ASSERT_EQUAL(bandwidth
->header
.encoded_object_length
, 8);
930 CU_ASSERT_EQUAL(bandwidth
->bandwidth
, 0);
932 /* Metric object 1 */
933 obj_node
= obj_node
->next_node
;
934 struct pcep_object_metric
*metric
=
935 (struct pcep_object_metric
*)obj_node
->data
;
936 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
937 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
938 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
939 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
940 CU_ASSERT_FALSE(metric
->flag_b
);
941 CU_ASSERT_FALSE(metric
->flag_c
);
942 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_TE
);
943 CU_ASSERT_EQUAL(metric
->value
, 0);
945 /* Metric object 2 */
946 obj_node
= obj_node
->next_node
;
947 metric
= (struct pcep_object_metric
*)obj_node
->data
;
948 CU_ASSERT_EQUAL(metric
->header
.object_class
, PCEP_OBJ_CLASS_METRIC
);
949 CU_ASSERT_EQUAL(metric
->header
.object_type
, PCEP_OBJ_TYPE_METRIC
);
950 CU_ASSERT_EQUAL(metric
->header
.encoded_object_length
, 12);
951 CU_ASSERT_PTR_NULL(metric
->header
.tlv_list
);
952 CU_ASSERT_TRUE(metric
->flag_b
);
953 CU_ASSERT_FALSE(metric
->flag_c
);
954 CU_ASSERT_EQUAL(metric
->type
, PCEP_METRIC_AGGREGATE_BW
);
955 CU_ASSERT_EQUAL(metric
->value
, 16.0);
957 pcep_msg_free_message_list(msg_list
);
962 void test_pcep_msg_read_pcep_initiate_cisco_pcc()
964 char filename
[BASE_TMPFILE_SIZE
];
966 int fd
= convert_hexstrs_to_binary(
967 filename
, pcep_initiate_cisco_pcc_hexbyte_strs
,
968 pcep_initiate_cisco_pcc_hexbyte_strs_length
);
970 CU_ASSERT_TRUE(fd
>=0);
973 double_linked_list
*msg_list
= pcep_msg_read(fd
);
974 CU_ASSERT_PTR_NOT_NULL(msg_list
);
975 assert(msg_list
!= NULL
);
976 CU_ASSERT_EQUAL(msg_list
->num_entries
, 1);
978 struct pcep_message
*msg
= (struct pcep_message
*)msg_list
->head
->data
;
979 CU_ASSERT_EQUAL(msg
->msg_header
->type
, PCEP_TYPE_INITIATE
);
980 CU_ASSERT_EQUAL(msg
->encoded_message_length
,
981 pcep_initiate_cisco_pcc_hexbyte_strs_length
);
982 CU_ASSERT_EQUAL(msg
->obj_list
->num_entries
, 6);
985 double_linked_list_node
*obj_node
= msg
->obj_list
->head
;
986 struct pcep_object_srp
*srp
= (struct pcep_object_srp
*)obj_node
->data
;
987 CU_ASSERT_EQUAL(srp
->header
.object_class
, PCEP_OBJ_CLASS_SRP
);
988 CU_ASSERT_EQUAL(srp
->header
.object_type
, PCEP_OBJ_TYPE_SRP
);
989 CU_ASSERT_EQUAL(srp
->header
.encoded_object_length
, 20);
990 CU_ASSERT_PTR_NOT_NULL(srp
->header
.tlv_list
);
991 assert(srp
->header
.tlv_list
!= NULL
);
992 CU_ASSERT_EQUAL(srp
->header
.tlv_list
->num_entries
, 1);
993 CU_ASSERT_EQUAL(srp
->srp_id_number
, 1);
994 CU_ASSERT_FALSE(srp
->flag_lsp_remove
);
997 obj_node
= obj_node
->next_node
;
998 struct pcep_object_lsp
*lsp
= (struct pcep_object_lsp
*)obj_node
->data
;
999 CU_ASSERT_EQUAL(lsp
->header
.object_class
, PCEP_OBJ_CLASS_LSP
);
1000 CU_ASSERT_EQUAL(lsp
->header
.object_type
, PCEP_OBJ_TYPE_LSP
);
1001 CU_ASSERT_EQUAL(lsp
->header
.encoded_object_length
, 48);
1002 CU_ASSERT_PTR_NOT_NULL(lsp
->header
.tlv_list
);
1003 assert(lsp
->header
.tlv_list
!= NULL
);
1004 CU_ASSERT_EQUAL(lsp
->header
.tlv_list
->num_entries
, 2);
1005 CU_ASSERT_EQUAL(lsp
->plsp_id
, 0);
1006 CU_ASSERT_EQUAL(lsp
->operational_status
, PCEP_LSP_OPERATIONAL_DOWN
);
1007 CU_ASSERT_TRUE(lsp
->flag_a
);
1008 CU_ASSERT_TRUE(lsp
->flag_d
);
1009 CU_ASSERT_TRUE(lsp
->flag_c
);
1010 CU_ASSERT_FALSE(lsp
->flag_r
);
1011 CU_ASSERT_FALSE(lsp
->flag_s
);
1013 /* Endpoint object */
1014 obj_node
= obj_node
->next_node
;
1015 struct pcep_object_endpoints_ipv4
*endpoint
=
1016 (struct pcep_object_endpoints_ipv4
*)obj_node
->data
;
1017 CU_ASSERT_EQUAL(endpoint
->header
.object_class
,
1018 PCEP_OBJ_CLASS_ENDPOINTS
);
1019 CU_ASSERT_EQUAL(endpoint
->header
.object_type
,
1020 PCEP_OBJ_TYPE_ENDPOINT_IPV4
);
1021 CU_ASSERT_EQUAL(endpoint
->header
.encoded_object_length
, 12);
1022 CU_ASSERT_PTR_NULL(endpoint
->header
.tlv_list
);
1023 CU_ASSERT_EQUAL(endpoint
->src_ipv4
.s_addr
, htonl(0x0a0a0a0a));
1024 CU_ASSERT_EQUAL(endpoint
->dst_ipv4
.s_addr
, htonl(0x0a0a0a04));
1026 /* Inter-Layer object */
1027 obj_node
= obj_node
->next_node
;
1028 struct pcep_object_inter_layer
*inter_layer
=
1029 (struct pcep_object_inter_layer
*)obj_node
->data
;
1030 CU_ASSERT_EQUAL(inter_layer
->header
.object_class
,
1031 PCEP_OBJ_CLASS_INTER_LAYER
);
1032 CU_ASSERT_EQUAL(inter_layer
->header
.object_type
,
1033 PCEP_OBJ_TYPE_INTER_LAYER
);
1034 CU_ASSERT_EQUAL(inter_layer
->header
.encoded_object_length
, 8);
1035 CU_ASSERT_PTR_NULL(inter_layer
->header
.tlv_list
);
1036 CU_ASSERT_TRUE(inter_layer
->flag_i
);
1037 CU_ASSERT_FALSE(inter_layer
->flag_m
);
1038 CU_ASSERT_TRUE(inter_layer
->flag_t
);
1040 /* Switch-Layer object */
1041 obj_node
= obj_node
->next_node
;
1042 struct pcep_object_switch_layer
*switch_layer
=
1043 (struct pcep_object_switch_layer
*)obj_node
->data
;
1044 CU_ASSERT_EQUAL(switch_layer
->header
.object_class
,
1045 PCEP_OBJ_CLASS_SWITCH_LAYER
);
1046 CU_ASSERT_EQUAL(switch_layer
->header
.object_type
,
1047 PCEP_OBJ_TYPE_SWITCH_LAYER
);
1048 CU_ASSERT_EQUAL(switch_layer
->header
.encoded_object_length
, 8);
1049 CU_ASSERT_PTR_NULL(switch_layer
->header
.tlv_list
);
1050 assert(switch_layer
->header
.tlv_list
== NULL
);
1051 CU_ASSERT_PTR_NOT_NULL(switch_layer
->switch_layer_rows
);
1052 assert(switch_layer
->switch_layer_rows
!= NULL
);
1053 CU_ASSERT_EQUAL(switch_layer
->switch_layer_rows
->num_entries
, 1);
1054 struct pcep_object_switch_layer_row
*switch_layer_row
=
1055 (struct pcep_object_switch_layer_row
*)
1056 switch_layer
->switch_layer_rows
->head
->data
;
1057 CU_ASSERT_EQUAL(switch_layer_row
->lsp_encoding_type
, 0);
1058 CU_ASSERT_EQUAL(switch_layer_row
->switching_type
, 0);
1059 CU_ASSERT_FALSE(switch_layer_row
->flag_i
);
1062 obj_node
= obj_node
->next_node
;
1063 struct pcep_object_ro
*ero
= (struct pcep_object_ro
*)obj_node
->data
;
1064 CU_ASSERT_EQUAL(ero
->header
.object_class
, PCEP_OBJ_CLASS_ERO
);
1065 CU_ASSERT_EQUAL(ero
->header
.object_type
, PCEP_OBJ_TYPE_ERO
);
1066 CU_ASSERT_EQUAL(ero
->header
.encoded_object_length
, 4);
1067 CU_ASSERT_PTR_NULL(ero
->header
.tlv_list
);
1069 pcep_msg_free_message_list(msg_list
);
1074 void test_validate_message_header()
1076 uint8_t pcep_message_invalid_version
[] = {0x40, 0x01, 0x04, 0x00};
1077 uint8_t pcep_message_invalid_flags
[] = {0x22, 0x01, 0x04, 0x00};
1078 uint8_t pcep_message_invalid_length
[] = {0x20, 0x01, 0x00, 0x00};
1079 uint8_t pcep_message_invalid_type
[] = {0x20, 0xff, 0x04, 0x00};
1080 uint8_t pcep_message_valid
[] = {0x20, 0x01, 0x00, 0x04};
1082 /* Verify invalid message header version */
1084 pcep_decode_validate_msg_header(pcep_message_invalid_version
)
1087 /* Verify invalid message header flags */
1089 pcep_decode_validate_msg_header(pcep_message_invalid_flags
)
1092 /* Verify invalid message header lengths */
1094 pcep_decode_validate_msg_header(pcep_message_invalid_length
)
1096 pcep_message_invalid_length
[3] = 0x05;
1098 pcep_decode_validate_msg_header(pcep_message_invalid_length
)
1101 /* Verify invalid message header types */
1103 pcep_decode_validate_msg_header(pcep_message_invalid_type
) < 0);
1104 pcep_message_invalid_type
[1] = 0x00;
1106 pcep_decode_validate_msg_header(pcep_message_invalid_type
) < 0);
1108 /* Verify a valid message header */
1109 CU_ASSERT_EQUAL(pcep_decode_validate_msg_header(pcep_message_valid
), 4);
1112 /* Internal util function */
1113 struct pcep_message
*create_message(uint8_t msg_type
, uint8_t obj1_class
,
1114 uint8_t obj2_class
, uint8_t obj3_class
,
1117 struct pcep_message
*msg
=
1118 pceplib_malloc(PCEPLIB_MESSAGES
, sizeof(struct pcep_message
));
1119 msg
->obj_list
= dll_initialize();
1120 msg
->msg_header
= pceplib_malloc(PCEPLIB_MESSAGES
,
1121 sizeof(struct pcep_message_header
));
1122 msg
->msg_header
->type
= msg_type
;
1123 msg
->encoded_message
= NULL
;
1125 if (obj1_class
> 0) {
1126 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1127 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1128 obj_hdr
->object_class
= obj1_class
;
1129 obj_hdr
->tlv_list
= NULL
;
1130 dll_append(msg
->obj_list
, obj_hdr
);
1133 if (obj2_class
> 0) {
1134 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1135 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1136 obj_hdr
->object_class
= obj2_class
;
1137 obj_hdr
->tlv_list
= NULL
;
1138 dll_append(msg
->obj_list
, obj_hdr
);
1141 if (obj3_class
> 0) {
1142 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1143 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1144 obj_hdr
->object_class
= obj3_class
;
1145 obj_hdr
->tlv_list
= NULL
;
1146 dll_append(msg
->obj_list
, obj_hdr
);
1149 if (obj4_class
> 0) {
1150 struct pcep_object_header
*obj_hdr
= pceplib_malloc(
1151 PCEPLIB_MESSAGES
, sizeof(struct pcep_object_header
));
1152 obj_hdr
->object_class
= obj4_class
;
1153 obj_hdr
->tlv_list
= NULL
;
1154 dll_append(msg
->obj_list
, obj_hdr
);
1160 void test_validate_message_objects()
1162 /* Valid Open message */
1163 struct pcep_message
*msg
=
1164 create_message(PCEP_TYPE_OPEN
, PCEP_OBJ_CLASS_OPEN
, 0, 0, 0);
1165 CU_ASSERT_TRUE(validate_message_objects(msg
));
1166 pcep_msg_free_message(msg
);
1168 /* Valid KeepAlive message */
1169 msg
= create_message(PCEP_TYPE_KEEPALIVE
, 0, 0, 0, 0);
1170 CU_ASSERT_TRUE(validate_message_objects(msg
));
1171 pcep_msg_free_message(msg
);
1173 /* Valid PcReq message */
1174 /* Using object_class=255 to verify it can take any object */
1175 msg
= create_message(PCEP_TYPE_PCREQ
, PCEP_OBJ_CLASS_RP
,
1176 PCEP_OBJ_CLASS_ENDPOINTS
, any_obj_class
, 0);
1177 CU_ASSERT_TRUE(validate_message_objects(msg
));
1178 pcep_msg_free_message(msg
);
1180 /* Valid PcRep message */
1181 msg
= create_message(PCEP_TYPE_PCREP
, PCEP_OBJ_CLASS_RP
, any_obj_class
,
1183 CU_ASSERT_TRUE(validate_message_objects(msg
));
1184 pcep_msg_free_message(msg
);
1186 /* Valid Notify message */
1187 msg
= create_message(PCEP_TYPE_PCNOTF
, PCEP_OBJ_CLASS_NOTF
,
1188 any_obj_class
, 0, 0);
1189 CU_ASSERT_TRUE(validate_message_objects(msg
));
1190 pcep_msg_free_message(msg
);
1192 /* Valid Error message */
1193 msg
= create_message(PCEP_TYPE_ERROR
, PCEP_OBJ_CLASS_ERROR
,
1194 any_obj_class
, 0, 0);
1195 CU_ASSERT_TRUE(validate_message_objects(msg
));
1196 pcep_msg_free_message(msg
);
1198 /* Valid Close message */
1199 msg
= create_message(PCEP_TYPE_CLOSE
, PCEP_OBJ_CLASS_CLOSE
, 0, 0, 0);
1200 CU_ASSERT_TRUE(validate_message_objects(msg
));
1201 pcep_msg_free_message(msg
);
1203 /* Valid Report message */
1204 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
,
1205 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1206 CU_ASSERT_TRUE(validate_message_objects(msg
));
1207 pcep_msg_free_message(msg
);
1209 /* Valid Update message */
1210 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
,
1211 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1212 CU_ASSERT_TRUE(validate_message_objects(msg
));
1213 pcep_msg_free_message(msg
);
1215 /* Valid Initiate message */
1216 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
,
1217 PCEP_OBJ_CLASS_LSP
, any_obj_class
, any_obj_class
);
1218 CU_ASSERT_TRUE(validate_message_objects(msg
));
1219 pcep_msg_free_message(msg
);
1222 void test_validate_message_objects_invalid()
1224 /* unsupported message ID = 0
1225 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1226 struct pcep_message
*msg
= create_message(0, any_obj_class
, 0, 0, 0);
1227 CU_ASSERT_FALSE(validate_message_objects(msg
));
1228 pcep_msg_free_message(msg
);
1231 * {PCEP_OBJ_CLASS_OPEN, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1232 msg
= create_message(PCEP_TYPE_OPEN
, 0, 0, 0, 0);
1233 CU_ASSERT_FALSE(validate_message_objects(msg
));
1234 pcep_msg_free_message(msg
);
1236 msg
= create_message(PCEP_TYPE_OPEN
, any_obj_class
, 0, 0, 0);
1237 CU_ASSERT_FALSE(validate_message_objects(msg
));
1238 pcep_msg_free_message(msg
);
1240 msg
= create_message(PCEP_TYPE_OPEN
, PCEP_OBJ_CLASS_OPEN
, any_obj_class
,
1242 CU_ASSERT_FALSE(validate_message_objects(msg
));
1243 pcep_msg_free_message(msg
);
1245 /* KeepAlive message
1246 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1247 msg
= create_message(PCEP_TYPE_KEEPALIVE
, any_obj_class
, 0, 0, 0);
1248 CU_ASSERT_FALSE(validate_message_objects(msg
));
1249 pcep_msg_free_message(msg
);
1252 * {PCEP_OBJ_CLASS_RP, PCEP_OBJ_CLASS_ENDPOINTS, ANY_OBJECT, ANY_OBJECT}
1254 msg
= create_message(PCEP_TYPE_PCREQ
, 0, 0, 0, 0);
1255 CU_ASSERT_FALSE(validate_message_objects(msg
));
1256 pcep_msg_free_message(msg
);
1258 msg
= create_message(PCEP_TYPE_PCREQ
, PCEP_OBJ_CLASS_RP
, any_obj_class
,
1260 CU_ASSERT_FALSE(validate_message_objects(msg
));
1261 pcep_msg_free_message(msg
);
1264 * {PCEP_OBJ_CLASS_RP, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1265 msg
= create_message(PCEP_TYPE_PCREP
, 0, 0, 0, 0);
1266 CU_ASSERT_FALSE(validate_message_objects(msg
));
1267 pcep_msg_free_message(msg
);
1269 msg
= create_message(PCEP_TYPE_PCREP
, any_obj_class
, 0, 0, 0);
1270 CU_ASSERT_FALSE(validate_message_objects(msg
));
1271 pcep_msg_free_message(msg
);
1274 * {PCEP_OBJ_CLASS_NOTF, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1275 msg
= create_message(PCEP_TYPE_PCNOTF
, 0, 0, 0, 0);
1276 CU_ASSERT_FALSE(validate_message_objects(msg
));
1277 pcep_msg_free_message(msg
);
1279 msg
= create_message(PCEP_TYPE_PCNOTF
, any_obj_class
, 0, 0, 0);
1280 CU_ASSERT_FALSE(validate_message_objects(msg
));
1281 pcep_msg_free_message(msg
);
1284 * {PCEP_OBJ_CLASS_ERROR, ANY_OBJECT, ANY_OBJECT, ANY_OBJECT} */
1285 msg
= create_message(PCEP_TYPE_ERROR
, 0, 0, 0, 0);
1286 CU_ASSERT_FALSE(validate_message_objects(msg
));
1287 pcep_msg_free_message(msg
);
1289 msg
= create_message(PCEP_TYPE_ERROR
, any_obj_class
, 0, 0, 0);
1290 CU_ASSERT_FALSE(validate_message_objects(msg
));
1291 pcep_msg_free_message(msg
);
1294 * {PCEP_OBJ_CLASS_CLOSE, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1295 msg
= create_message(PCEP_TYPE_CLOSE
, 0, 0, 0, 0);
1296 CU_ASSERT_FALSE(validate_message_objects(msg
));
1297 pcep_msg_free_message(msg
);
1299 msg
= create_message(PCEP_TYPE_CLOSE
, any_obj_class
, 0, 0, 0);
1300 CU_ASSERT_FALSE(validate_message_objects(msg
));
1301 pcep_msg_free_message(msg
);
1303 /* unsupported message ID = 8
1304 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1305 msg
= create_message(8, any_obj_class
, 0, 0, 0);
1306 CU_ASSERT_FALSE(validate_message_objects(msg
));
1307 pcep_msg_free_message(msg
);
1309 /* unsupported message ID = 9
1310 * {NO_OBJECT, NO_OBJECT, NO_OBJECT, NO_OBJECT} */
1311 msg
= create_message(9, any_obj_class
, 0, 0, 0);
1312 CU_ASSERT_FALSE(validate_message_objects(msg
));
1313 pcep_msg_free_message(msg
);
1316 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1317 msg
= create_message(PCEP_TYPE_REPORT
, 0, 0, 0, 0);
1318 CU_ASSERT_FALSE(validate_message_objects(msg
));
1319 pcep_msg_free_message(msg
);
1321 msg
= create_message(PCEP_TYPE_REPORT
, any_obj_class
, 0, 0, 0);
1322 CU_ASSERT_FALSE(validate_message_objects(msg
));
1323 pcep_msg_free_message(msg
);
1325 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1326 CU_ASSERT_FALSE(validate_message_objects(msg
));
1327 pcep_msg_free_message(msg
);
1329 msg
= create_message(PCEP_TYPE_REPORT
, PCEP_OBJ_CLASS_SRP
,
1330 any_obj_class
, 0, 0);
1331 CU_ASSERT_FALSE(validate_message_objects(msg
));
1332 pcep_msg_free_message(msg
);
1335 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1336 msg
= create_message(PCEP_TYPE_UPDATE
, 0, 0, 0, 0);
1337 CU_ASSERT_FALSE(validate_message_objects(msg
));
1338 pcep_msg_free_message(msg
);
1340 msg
= create_message(PCEP_TYPE_UPDATE
, any_obj_class
, 0, 0, 0);
1341 CU_ASSERT_FALSE(validate_message_objects(msg
));
1342 pcep_msg_free_message(msg
);
1344 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1345 CU_ASSERT_FALSE(validate_message_objects(msg
));
1346 pcep_msg_free_message(msg
);
1348 msg
= create_message(PCEP_TYPE_UPDATE
, PCEP_OBJ_CLASS_SRP
,
1349 any_obj_class
, 0, 0);
1350 CU_ASSERT_FALSE(validate_message_objects(msg
));
1351 pcep_msg_free_message(msg
);
1354 * {PCEP_OBJ_CLASS_SRP, PCEP_OBJ_CLASS_LSP, ANY_OBJECT, ANY_OBJECT} */
1355 msg
= create_message(PCEP_TYPE_INITIATE
, 0, 0, 0, 0);
1356 CU_ASSERT_FALSE(validate_message_objects(msg
));
1357 pcep_msg_free_message(msg
);
1359 msg
= create_message(PCEP_TYPE_INITIATE
, any_obj_class
, 0, 0, 0);
1360 CU_ASSERT_FALSE(validate_message_objects(msg
));
1361 pcep_msg_free_message(msg
);
1363 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
, 0, 0, 0);
1364 CU_ASSERT_FALSE(validate_message_objects(msg
));
1365 pcep_msg_free_message(msg
);
1367 msg
= create_message(PCEP_TYPE_INITIATE
, PCEP_OBJ_CLASS_SRP
,
1368 any_obj_class
, 0, 0);
1369 CU_ASSERT_FALSE(validate_message_objects(msg
));
1370 pcep_msg_free_message(msg
);