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