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