]> The Tcpdump Group git mirrors - tcpdump/blob - print-lmp.c
projects / tcpdump / blob


22a2664371d26eeecfc4a59130dc472ceaf9a392
[tcpdump] / print-lmp.c
1 /*
2 * Redistribution and use in source and binary forms, with or without
3 * modification, are permitted provided that: (1) source code
4 * distributions retain the above copyright notice and this paragraph
5 * in its entirety, and (2) distributions including binary code include
6 * the above copyright notice and this paragraph in its entirety in
7 * the documentation or other materials provided with the distribution.
8 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
9 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
10 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
11 * FOR A PARTICULAR PURPOSE.
12 *
13 * Support for the Link Management Protocol as per rfc 4204.
14 *
15 * Original code by Hannes Gredler (hannes@juniper.net)
16 * Support for LMP service discovery extensions (defined by UNI 1.0) added
17 * by Manu Pathak (mapathak@cisco.com), May 2005
18 */
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <tcpdump-stdinc.h>
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "interface.h"
31 #include "extract.h"
32 #include "addrtoname.h"
33 #include "gmpls.h"
34
35 /*
36 * LMP common header
37 *
38 * 0 1 2 3
39 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
40 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
41 * | Vers | (Reserved) | Flags | Msg Type |
42 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
43 * | LMP Length | (Reserved) |
44 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
45 */
46
47 struct lmp_common_header {
48 u_int8_t version_res[2];
49 u_int8_t flags;
50 u_int8_t msg_type;
51 u_int8_t length[2];
52 u_int8_t reserved[2];
53 };
54
55 #define LMP_VERSION 1
56 #define LMP_EXTRACT_VERSION(x) (((x)&0xf0)>>4)
57
58 static const struct tok lmp_header_flag_values[] = {
59 { 0x01, "Control Channel Down"},
60 { 0x02, "LMP restart"},
61 { 0, NULL}
62 };
63
64 static const struct tok lmp_obj_te_link_flag_values[] = {
65 { 0x01, "Fault Management Supported"},
66 { 0x02, "Link Verification Supported"},
67 { 0, NULL}
68 };
69
70 static const struct tok lmp_obj_data_link_flag_values[] = {
71 { 0x01, "Data Link Port"},
72 { 0x02, "Allocated for user traffic"},
73 { 0x04, "Failed link"},
74 { 0, NULL}
75 };
76
77 static const struct tok lmp_obj_channel_status_values[] = {
78 { 1, "Signal Okay"},
79 { 2, "Signal Degraded"},
80 { 3, "Signal Fail"},
81 { 0, NULL}
82 };
83
84 static const struct tok lmp_obj_begin_verify_flag_values[] = {
85 { 0x0001, "Verify all links"},
86 { 0x0002, "Data link type"},
87 { 0, NULL}
88 };
89
90 static const struct tok lmp_obj_begin_verify_error_values[] = {
91 { 0x01, "Link Verification Procedure Not supported"},
92 { 0x02, "Unwilling to verify"},
93 { 0x04, "Unsupported verification transport mechanism"},
94 { 0x08, "Link-Id configuration error"},
95 { 0x10, "Unknown object c-type"},
96 { 0, NULL}
97 };
98
99 static const struct tok lmp_obj_link_summary_error_values[] = {
100 { 0x01, "Unacceptable non-negotiable LINK-SUMMARY parameters"},
101 { 0x02, "Renegotiate LINK-SUMMARY parameters"},
102 { 0x04, "Invalid TE-LINK Object"},
103 { 0x08, "Invalid DATA-LINK Object"},
104 { 0x10, "Unknown TE-LINK Object c-type"},
105 { 0x20, "Unknown DATA-LINK Object c-type"},
106 { 0, NULL}
107 };
108
109 /* Service Config Supported Protocols Flags */
110 static const struct tok lmp_obj_service_config_sp_flag_values[] = {
111 { 0x01, "RSVP Supported"},
112 { 0x02, "LDP Supported"},
113 { 0, NULL}
114 };
115
116 /* Service Config Client Port Service Attribute Transparency Flags */
117 static const struct tok lmp_obj_service_config_cpsa_tp_flag_values[] = {
118 { 0x01, "Path/VC Overhead Transparency Supported"},
119 { 0x02, "Line/MS Overhead Transparency Supported"},
120 { 0x04, "Section/RS Overhead Transparency Supported"},
121 { 0, NULL}
122 };
123
124 /* Service Config Client Port Service Attribute Contiguous Concatenation Types Flags */
125 static const struct tok lmp_obj_service_config_cpsa_cct_flag_values[] = {
126 { 0x01, "Contiguous Concatenation Types Supported"},
127 { 0, NULL}
128 };
129
130 /* Service Config Network Service Attributes Transparency Flags */
131 static const struct tok lmp_obj_service_config_nsa_transparency_flag_values[] = {
132 { 0x01, "Standard SOH/RSOH Transparency Supported"},
133 { 0x02, "Standard LOH/MSOH Transparency Supported"},
134 { 0, NULL}
135 };
136
137 /* Service Config Network Service Attributes TCM Monitoring Flags */
138 static const struct tok lmp_obj_service_config_nsa_tcm_flag_values[] = {
139 { 0x01, "Transparent Tandem Connection Monitoring Supported"},
140 { 0, NULL}
141 };
142
143 /* Network Service Attributes Network Diversity Flags */
144 static const struct tok lmp_obj_service_config_nsa_network_diversity_flag_values[] = {
145 { 0x01, "Node Diversity Supported"},
146 { 0x02, "Link Diversity Supported"},
147 { 0x04, "SRLG Diversity Supported"},
148 { 0, NULL}
149 };
150
151 #define LMP_MSGTYPE_CONFIG 1
152 #define LMP_MSGTYPE_CONFIG_ACK 2
153 #define LMP_MSGTYPE_CONFIG_NACK 3
154 #define LMP_MSGTYPE_HELLO 4
155 #define LMP_MSGTYPE_VERIFY_BEGIN 5
156 #define LMP_MSGTYPE_VERIFY_BEGIN_ACK 6
157 #define LMP_MSGTYPE_VERIFY_BEGIN_NACK 7
158 #define LMP_MSGTYPE_VERIFY_END 8
159 #define LMP_MSGTYPE_VERIFY_END_ACK 9
160 #define LMP_MSGTYPE_TEST 10
161 #define LMP_MSGTYPE_TEST_STATUS_SUCCESS 11
162 #define LMP_MSGTYPE_TEST_STATUS_FAILURE 12
163 #define LMP_MSGTYPE_TEST_STATUS_ACK 13
164 #define LMP_MSGTYPE_LINK_SUMMARY 14
165 #define LMP_MSGTYPE_LINK_SUMMARY_ACK 15
166 #define LMP_MSGTYPE_LINK_SUMMARY_NACK 16
167 #define LMP_MSGTYPE_CHANNEL_STATUS 17
168 #define LMP_MSGTYPE_CHANNEL_STATUS_ACK 18
169 #define LMP_MSGTYPE_CHANNEL_STATUS_REQ 19
170 #define LMP_MSGTYPE_CHANNEL_STATUS_RESP 20
171 /* LMP Service Discovery message types defined by UNI 1.0 */
172 #define LMP_MSGTYPE_SERVICE_CONFIG 50
173 #define LMP_MSGTYPE_SERVICE_CONFIG_ACK 51
174 #define LMP_MSGTYPE_SERVICE_CONFIG_NACK 52
175
176 static const struct tok lmp_msg_type_values[] = {
177 { LMP_MSGTYPE_CONFIG, "Config"},
178 { LMP_MSGTYPE_CONFIG_ACK, "Config ACK"},
179 { LMP_MSGTYPE_CONFIG_NACK, "Config NACK"},
180 { LMP_MSGTYPE_HELLO, "Hello"},
181 { LMP_MSGTYPE_VERIFY_BEGIN, "Begin Verify"},
182 { LMP_MSGTYPE_VERIFY_BEGIN_ACK, "Begin Verify ACK"},
183 { LMP_MSGTYPE_VERIFY_BEGIN_NACK, "Begin Verify NACK"},
184 { LMP_MSGTYPE_VERIFY_END, "End Verify"},
185 { LMP_MSGTYPE_VERIFY_END_ACK, "End Verify ACK"},
186 { LMP_MSGTYPE_TEST, "Test"},
187 { LMP_MSGTYPE_TEST_STATUS_SUCCESS, "Test Status Success"},
188 { LMP_MSGTYPE_TEST_STATUS_FAILURE, "Test Status Failure"},
189 { LMP_MSGTYPE_TEST_STATUS_ACK, "Test Status ACK"},
190 { LMP_MSGTYPE_LINK_SUMMARY, "Link Summary"},
191 { LMP_MSGTYPE_LINK_SUMMARY_ACK, "Link Summary ACK"},
192 { LMP_MSGTYPE_LINK_SUMMARY_NACK, "Link Summary NACK"},
193 { LMP_MSGTYPE_CHANNEL_STATUS, "Channel Status"},
194 { LMP_MSGTYPE_CHANNEL_STATUS_ACK, "Channel Status ACK"},
195 { LMP_MSGTYPE_CHANNEL_STATUS_REQ, "Channel Status Request"},
196 { LMP_MSGTYPE_CHANNEL_STATUS_RESP, "Channel Status Response"},
197 { LMP_MSGTYPE_SERVICE_CONFIG, "Service Config"},
198 { LMP_MSGTYPE_SERVICE_CONFIG_ACK, "Service Config ACK"},
199 { LMP_MSGTYPE_SERVICE_CONFIG_NACK, "Service Config NACK"},
200 { 0, NULL}
201 };
202
203 /*
204 * LMP object header
205 *
206 * 0 1 2 3
207 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
208 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
209 * |N| C-Type | Class | Length |
210 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
211 * | |
212 * // (object contents) //
213 * | |
214 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
215 */
216
217 struct lmp_object_header {
218 u_int8_t ctype;
219 u_int8_t class_num;
220 u_int8_t length[2];
221 };
222
223 #define LMP_OBJ_CC_ID 1
224 #define LMP_OBJ_NODE_ID 2
225 #define LMP_OBJ_LINK_ID 3
226 #define LMP_OBJ_INTERFACE_ID 4
227 #define LMP_OBJ_MESSAGE_ID 5
228 #define LMP_OBJ_CONFIG 6
229 #define LMP_OBJ_HELLO 7
230 #define LMP_OBJ_VERIFY_BEGIN 8
231 #define LMP_OBJ_VERIFY_BEGIN_ACK 9
232 #define LMP_OBJ_VERIFY_ID 10
233 #define LMP_OBJ_TE_LINK 11
234 #define LMP_OBJ_DATA_LINK 12
235 #define LMP_OBJ_CHANNEL_STATUS 13
236 #define LMP_OBJ_CHANNEL_STATUS_REQ 14
237 #define LMP_OBJ_ERROR_CODE 20
238
239 #define LMP_OBJ_SERVICE_CONFIG 51 /* defined in UNI 1.0 */
240
241 static const struct tok lmp_obj_values[] = {
242 { LMP_OBJ_CC_ID, "Control Channel ID" },
243 { LMP_OBJ_NODE_ID, "Node ID" },
244 { LMP_OBJ_LINK_ID, "Link ID" },
245 { LMP_OBJ_INTERFACE_ID, "Interface ID" },
246 { LMP_OBJ_MESSAGE_ID, "Message ID" },
247 { LMP_OBJ_CONFIG, "Configuration" },
248 { LMP_OBJ_HELLO, "Hello" },
249 { LMP_OBJ_VERIFY_BEGIN, "Verify Begin" },
250 { LMP_OBJ_VERIFY_BEGIN_ACK, "Verify Begin ACK" },
251 { LMP_OBJ_VERIFY_ID, "Verify ID" },
252 { LMP_OBJ_TE_LINK, "TE Link" },
253 { LMP_OBJ_DATA_LINK, "Data Link" },
254 { LMP_OBJ_CHANNEL_STATUS, "Channel Status" },
255 { LMP_OBJ_CHANNEL_STATUS_REQ, "Channel Status Request" },
256 { LMP_OBJ_ERROR_CODE, "Error Code" },
257 { LMP_OBJ_SERVICE_CONFIG, "Service Config" },
258
259 { 0, NULL}
260 };
261
262 #define INT_SWITCHING_TYPE_SUBOBJ 1
263 #define WAVELENGTH_SUBOBJ 2
264
265 static const struct tok lmp_data_link_subobj[] = {
266 { INT_SWITCHING_TYPE_SUBOBJ, "Interface Switching Type" },
267 { WAVELENGTH_SUBOBJ , "Wavelength" },
268 { 0, NULL}
269 };
270
271 #define LMP_CTYPE_IPV4 1
272 #define LMP_CTYPE_IPV6 2
273
274 #define LMP_CTYPE_LOC 1
275 #define LMP_CTYPE_RMT 2
276 #define LMP_CTYPE_UNMD 3
277
278 #define LMP_CTYPE_IPV4_LOC 1
279 #define LMP_CTYPE_IPV4_RMT 2
280 #define LMP_CTYPE_IPV6_LOC 3
281 #define LMP_CTYPE_IPV6_RMT 4
282 #define LMP_CTYPE_UNMD_LOC 5
283 #define LMP_CTYPE_UNMD_RMT 6
284
285 #define LMP_CTYPE_1 1
286 #define LMP_CTYPE_2 2
287
288 #define LMP_CTYPE_HELLO_CONFIG 1
289 #define LMP_CTYPE_HELLO 1
290
291 #define LMP_CTYPE_BEGIN_VERIFY_ERROR 1
292 #define LMP_CTYPE_LINK_SUMMARY_ERROR 2
293
294 /* C-Types for Service Config Object */
295 #define LMP_CTYPE_SERVICE_CONFIG_SP 1
296 #define LMP_CTYPE_SERVICE_CONFIG_CPSA 2
297 #define LMP_CTYPE_SERVICE_CONFIG_TRANSPARENCY_TCM 3
298 #define LMP_CTYPE_SERVICE_CONFIG_NETWORK_DIVERSITY 4
299
300 /*
301 * Different link types allowed in the Client Port Service Attributes
302 * subobject defined for LMP Service Discovery in the UNI 1.0 spec
303 */
304 #define LMP_SD_SERVICE_CONFIG_CPSA_LINK_TYPE_SDH 5 /* UNI 1.0 Sec 9.4.2 */
305 #define LMP_SD_SERVICE_CONFIG_CPSA_LINK_TYPE_SONET 6 /* UNI 1.0 Sec 9.4.2 */
306
307 /*
308 * the ctypes are not globally unique so for
309 * translating it to strings we build a table based
310 * on objects offsetted by the ctype
311 */
312
313 static const struct tok lmp_ctype_values[] = {
314 { 256*LMP_OBJ_CC_ID+LMP_CTYPE_LOC, "Local" },
315 { 256*LMP_OBJ_CC_ID+LMP_CTYPE_RMT, "Remote" },
316 { 256*LMP_OBJ_NODE_ID+LMP_CTYPE_LOC, "Local" },
317 { 256*LMP_OBJ_NODE_ID+LMP_CTYPE_RMT, "Remote" },
318 { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV4_LOC, "IPv4 Local" },
319 { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV4_RMT, "IPv4 Remote" },
320 { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV6_LOC, "IPv6 Local" },
321 { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV6_RMT, "IPv6 Remote" },
322 { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_UNMD_LOC, "Unnumbered Local" },
323 { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_UNMD_RMT, "Unnumbered Remote" },
324 { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV4_LOC, "IPv4 Local" },
325 { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV4_RMT, "IPv4 Remote" },
326 { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV6_LOC, "IPv6 Local" },
327 { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV6_RMT, "IPv6 Remote" },
328 { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_UNMD_LOC, "Unnumbered Local" },
329 { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_UNMD_RMT, "Unnumbered Remote" },
330 { 256*LMP_OBJ_MESSAGE_ID+LMP_CTYPE_1, "1" },
331 { 256*LMP_OBJ_MESSAGE_ID+LMP_CTYPE_2, "2" },
332 { 256*LMP_OBJ_CONFIG+LMP_CTYPE_1, "1" },
333 { 256*LMP_OBJ_HELLO+LMP_CTYPE_1, "1" },
334 { 256*LMP_OBJ_VERIFY_BEGIN+LMP_CTYPE_1, "1" },
335 { 256*LMP_OBJ_VERIFY_BEGIN_ACK+LMP_CTYPE_1, "1" },
336 { 256*LMP_OBJ_VERIFY_ID+LMP_CTYPE_1, "1" },
337 { 256*LMP_OBJ_TE_LINK+LMP_CTYPE_IPV4, "IPv4" },
338 { 256*LMP_OBJ_TE_LINK+LMP_CTYPE_IPV6, "IPv6" },
339 { 256*LMP_OBJ_TE_LINK+LMP_CTYPE_UNMD, "Unnumbered" },
340 { 256*LMP_OBJ_DATA_LINK+LMP_CTYPE_IPV4, "IPv4" },
341 { 256*LMP_OBJ_DATA_LINK+LMP_CTYPE_IPV6, "IPv6" },
342 { 256*LMP_OBJ_DATA_LINK+LMP_CTYPE_UNMD, "Unnumbered" },
343 { 256*LMP_OBJ_CHANNEL_STATUS+LMP_CTYPE_IPV4, "IPv4" },
344 { 256*LMP_OBJ_CHANNEL_STATUS+LMP_CTYPE_IPV6, "IPv6" },
345 { 256*LMP_OBJ_CHANNEL_STATUS+LMP_CTYPE_UNMD, "Unnumbered" },
346 { 256*LMP_OBJ_CHANNEL_STATUS_REQ+LMP_CTYPE_IPV4, "IPv4" },
347 { 256*LMP_OBJ_CHANNEL_STATUS_REQ+LMP_CTYPE_IPV6, "IPv6" },
348 { 256*LMP_OBJ_CHANNEL_STATUS_REQ+LMP_CTYPE_UNMD, "Unnumbered" },
349 { 256*LMP_OBJ_ERROR_CODE+LMP_CTYPE_1, "1" },
350 { 256*LMP_OBJ_ERROR_CODE+LMP_CTYPE_2, "2" },
351 { 256*LMP_OBJ_SERVICE_CONFIG+LMP_CTYPE_SERVICE_CONFIG_SP, "1" },
352 { 256*LMP_OBJ_SERVICE_CONFIG+LMP_CTYPE_SERVICE_CONFIG_CPSA, "2" },
353 { 256*LMP_OBJ_SERVICE_CONFIG+LMP_CTYPE_SERVICE_CONFIG_TRANSPARENCY_TCM, "3" },
354 { 256*LMP_OBJ_SERVICE_CONFIG+LMP_CTYPE_SERVICE_CONFIG_NETWORK_DIVERSITY, "4" },
355 { 0, NULL}
356 };
357
358 void
359 lmp_print(register const u_char *pptr, register u_int len) {
360
361 const struct lmp_common_header *lmp_com_header;
362 const struct lmp_object_header *lmp_obj_header;
363 const u_char *tptr,*obj_tptr;
364 int tlen,lmp_obj_len,lmp_obj_ctype,obj_tlen;
365 int hexdump;
366 int offset,subobj_type,subobj_len,total_subobj_len;
367 int link_type;
368
369 union { /* int to float conversion buffer */
370 float f;
371 u_int32_t i;
372 } bw;
373
374 tptr=pptr;
375 lmp_com_header = (const struct lmp_common_header *)pptr;
376 TCHECK(*lmp_com_header);
377
378 /*
379 * Sanity checking of the header.
380 */
381 if (LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]) != LMP_VERSION) {
382 printf("LMP version %u packet not supported",
383 LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]));
384 return;
385 }
386
387 /* in non-verbose mode just lets print the basic Message Type*/
388 if (vflag < 1) {
389 printf("LMPv%u %s Message, length: %u",
390 LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]),
391 tok2str(lmp_msg_type_values, "unknown (%u)",lmp_com_header->msg_type),
392 len);
393 return;
394 }
395
396 /* ok they seem to want to know everything - lets fully decode it */
397
398 tlen=EXTRACT_16BITS(lmp_com_header->length);
399
400 printf("\n\tLMPv%u, msg-type: %s, Flags: [%s], length: %u",
401 LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]),
402 tok2str(lmp_msg_type_values, "unknown, type: %u",lmp_com_header->msg_type),
403 bittok2str(lmp_header_flag_values,"none",lmp_com_header->flags),
404 tlen);
405
406 tptr+=sizeof(const struct lmp_common_header);
407 tlen-=sizeof(const struct lmp_common_header);
408
409 while(tlen>0) {
410 /* did we capture enough for fully decoding the object header ? */
411 if (!TTEST2(*tptr, sizeof(struct lmp_object_header)))
412 goto trunc;
413
414 lmp_obj_header = (const struct lmp_object_header *)tptr;
415 lmp_obj_len=EXTRACT_16BITS(lmp_obj_header->length);
416 lmp_obj_ctype=(lmp_obj_header->ctype)&0x7f;
417
418 if(lmp_obj_len % 4 || lmp_obj_len < 4)
419 return;
420
421 printf("\n\t %s Object (%u), Class-Type: %s (%u) Flags: [%snegotiable], length: %u",
422 tok2str(lmp_obj_values,
423 "Unknown",
424 lmp_obj_header->class_num),
425 lmp_obj_header->class_num,
426 tok2str(lmp_ctype_values,
427 "Unknown",
428 ((lmp_obj_header->class_num)<<8)+lmp_obj_ctype),
429 lmp_obj_ctype,
430 (lmp_obj_header->ctype)&0x80 ? "" : "non-",
431 lmp_obj_len);
432
433 obj_tptr=tptr+sizeof(struct lmp_object_header);
434 obj_tlen=lmp_obj_len-sizeof(struct lmp_object_header);
435
436 /* did we capture enough for fully decoding the object ? */
437 if (!TTEST2(*tptr, lmp_obj_len))
438 goto trunc;
439 hexdump=FALSE;
440
441 switch(lmp_obj_header->class_num) {
442
443 case LMP_OBJ_CC_ID:
444 switch(lmp_obj_ctype) {
445 case LMP_CTYPE_LOC:
446 case LMP_CTYPE_RMT:
447 printf("\n\t Control Channel ID: %u (0x%08x)",
448 EXTRACT_32BITS(obj_tptr),
449 EXTRACT_32BITS(obj_tptr));
450 break;
451
452 default:
453 hexdump=TRUE;
454 }
455 break;
456
457 case LMP_OBJ_LINK_ID:
458 case LMP_OBJ_INTERFACE_ID:
459 switch(lmp_obj_ctype) {
460 case LMP_CTYPE_IPV4_LOC:
461 case LMP_CTYPE_IPV4_RMT:
462 printf("\n\t IPv4 Link ID: %s (0x%08x)",
463 ipaddr_string(obj_tptr),
464 EXTRACT_32BITS(obj_tptr));
465 break;
466 #ifdef INET6
467 case LMP_CTYPE_IPV6_LOC:
468 case LMP_CTYPE_IPV6_RMT:
469 printf("\n\t IPv6 Link ID: %s (0x%08x)",
470 ip6addr_string(obj_tptr),
471 EXTRACT_32BITS(obj_tptr));
472 break;
473 #endif
474 case LMP_CTYPE_UNMD_LOC:
475 case LMP_CTYPE_UNMD_RMT:
476 printf("\n\t Link ID: %u (0x%08x)",
477 EXTRACT_32BITS(obj_tptr),
478 EXTRACT_32BITS(obj_tptr));
479 break;
480 default:
481 hexdump=TRUE;
482 }
483 break;
484
485 case LMP_OBJ_MESSAGE_ID:
486 switch(lmp_obj_ctype) {
487 case LMP_CTYPE_1:
488 printf("\n\t Message ID: %u (0x%08x)",
489 EXTRACT_32BITS(obj_tptr),
490 EXTRACT_32BITS(obj_tptr));
491 break;
492 case LMP_CTYPE_2:
493 printf("\n\t Message ID Ack: %u (0x%08x)",
494 EXTRACT_32BITS(obj_tptr),
495 EXTRACT_32BITS(obj_tptr));
496 break;
497 default:
498 hexdump=TRUE;
499 }
500 break;
501
502 case LMP_OBJ_NODE_ID:
503 switch(lmp_obj_ctype) {
504 case LMP_CTYPE_LOC:
505 case LMP_CTYPE_RMT:
506 printf("\n\t Node ID: %s (0x%08x)",
507 ipaddr_string(obj_tptr),
508 EXTRACT_32BITS(obj_tptr));
509 break;
510
511 default:
512 hexdump=TRUE;
513 }
514 break;
515
516 case LMP_OBJ_CONFIG:
517 switch(lmp_obj_ctype) {
518 case LMP_CTYPE_HELLO_CONFIG:
519 printf("\n\t Hello Interval: %u\n\t Hello Dead Interval: %u",
520 EXTRACT_16BITS(obj_tptr),
521 EXTRACT_16BITS(obj_tptr+2));
522 break;
523
524 default:
525 hexdump=TRUE;
526 }
527 break;
528
529 case LMP_OBJ_HELLO:
530 switch(lmp_obj_ctype) {
531 case LMP_CTYPE_HELLO:
532 printf("\n\t Tx Seq: %u, Rx Seq: %u",
533 EXTRACT_32BITS(obj_tptr),
534 EXTRACT_32BITS(obj_tptr+4));
535 break;
536
537 default:
538 hexdump=TRUE;
539 }
540 break;
541
542 case LMP_OBJ_TE_LINK:
543 printf("\n\t Flags: [%s]",
544 bittok2str(lmp_obj_te_link_flag_values,
545 "none",
546 EXTRACT_16BITS(obj_tptr)>>8));
547
548 switch(lmp_obj_ctype) {
549 case LMP_CTYPE_IPV4:
550 printf("\n\t Local Link-ID: %s (0x%08x)"
551 "\n\t Remote Link-ID: %s (0x%08x)",
552 ipaddr_string(obj_tptr+4),
553 EXTRACT_32BITS(obj_tptr+4),
554 ipaddr_string(obj_tptr+8),
555 EXTRACT_32BITS(obj_tptr+8));
556 break;
557
558 #ifdef INET6
559 case LMP_CTYPE_IPV6:
560 #endif
561 case LMP_CTYPE_UNMD:
562 default:
563 hexdump=TRUE;
564 }
565 break;
566
567 case LMP_OBJ_DATA_LINK:
568 printf("\n\t Flags: [%s]",
569 bittok2str(lmp_obj_data_link_flag_values,
570 "none",
571 EXTRACT_16BITS(obj_tptr)>>8));
572
573 switch(lmp_obj_ctype) {
574 case LMP_CTYPE_IPV4:
575 case LMP_CTYPE_UNMD:
576 printf("\n\t Local Interface ID: %s (0x%08x)"
577 "\n\t Remote Interface ID: %s (0x%08x)",
578 ipaddr_string(obj_tptr+4),
579 EXTRACT_32BITS(obj_tptr+4),
580 ipaddr_string(obj_tptr+8),
581 EXTRACT_32BITS(obj_tptr+8));
582
583 total_subobj_len = lmp_obj_len - 16;
584 offset = 12;
585 while (total_subobj_len > 0 && hexdump == FALSE ) {
586 subobj_type = EXTRACT_16BITS(obj_tptr+offset)>>8;
587 subobj_len = EXTRACT_16BITS(obj_tptr+offset)&0x00FF;
588 printf("\n\t Subobject, Type: %s (%u), Length: %u",
589 tok2str(lmp_data_link_subobj,
590 "Unknown",
591 subobj_type),
592 subobj_type,
593 subobj_len);
594 switch(subobj_type) {
595 case INT_SWITCHING_TYPE_SUBOBJ:
596 printf("\n\t Switching Type: %s (%u)",
597 tok2str(gmpls_switch_cap_values,
598 "Unknown",
599 EXTRACT_16BITS(obj_tptr+offset+2)>>8),
600 EXTRACT_16BITS(obj_tptr+offset+2)>>8);
601 printf("\n\t Encoding Type: %s (%u)",
602 tok2str(gmpls_encoding_values,
603 "Unknown",
604 EXTRACT_16BITS(obj_tptr+offset+2)&0x00FF),
605 EXTRACT_16BITS(obj_tptr+offset+2)&0x00FF);
606 bw.i = EXTRACT_32BITS(obj_tptr+offset+4);
607 printf("\n\t Min Reservable Bandwidth: %.3f Mbps",
608 bw.f*8/1000000);
609 bw.i = EXTRACT_32BITS(obj_tptr+offset+8);
610 printf("\n\t Max Reservable Bandwidth: %.3f Mbps",
611 bw.f*8/1000000);
612 break;
613 case WAVELENGTH_SUBOBJ:
614 printf("\n\t Wavelength: %u",
615 EXTRACT_32BITS(obj_tptr+offset+4));
616 break;
617 default:
618 /* Any Unknown Subobject ==> Exit loop */
619 hexdump=TRUE;
620 break;
621 }
622 total_subobj_len-=subobj_len;
623 offset+=subobj_len;
624 }
625
626 break;
627 #ifdef INET6
628 case LMP_CTYPE_IPV6:
629 #endif
630 default:
631 hexdump=TRUE;
632 }
633 break;
634
635 case LMP_OBJ_VERIFY_BEGIN:
636 switch(lmp_obj_ctype) {
637 case LMP_CTYPE_1:
638 printf("\n\t Flags: %s",
639 bittok2str(lmp_obj_begin_verify_flag_values,
640 "none",
641 EXTRACT_16BITS(obj_tptr)));
642 printf("\n\t Verify Interval: %u",
643 EXTRACT_16BITS(obj_tptr+2));
644 printf("\n\t Data links: %u",
645 EXTRACT_32BITS(obj_tptr+4));
646 printf("\n\t Encoding type: %s",
647 tok2str(gmpls_encoding_values, "Unknown", *(obj_tptr+8)));
648 printf("\n\t Verify Transport Mechanism: %u (0x%x)%s",
649 EXTRACT_16BITS(obj_tptr+10),
650 EXTRACT_16BITS(obj_tptr+10),
651 EXTRACT_16BITS(obj_tptr+10)&8000 ? " (Payload test messages capable)" : "");
652 bw.i = EXTRACT_32BITS(obj_tptr+12);
653 printf("\n\t Transmission Rate: %.3f Mbps",bw.f*8/1000000);
654 printf("\n\t Wavelength: %u",
655 EXTRACT_32BITS(obj_tptr+16));
656 break;
657
658 default:
659 hexdump=TRUE;
660 }
661 break;
662
663 case LMP_OBJ_VERIFY_BEGIN_ACK:
664 switch(lmp_obj_ctype) {
665 case LMP_CTYPE_1:
666 printf("\n\t Verify Dead Interval: %u"
667 "\n\t Verify Transport Response: %u",
668 EXTRACT_16BITS(obj_tptr),
669 EXTRACT_16BITS(obj_tptr+2));
670 break;
671
672 default:
673 hexdump=TRUE;
674 }
675 break;
676
677 case LMP_OBJ_VERIFY_ID:
678 switch(lmp_obj_ctype) {
679 case LMP_CTYPE_1:
680 printf("\n\t Verify ID: %u",
681 EXTRACT_32BITS(obj_tptr));
682 break;
683
684 default:
685 hexdump=TRUE;
686 }
687 break;
688
689 case LMP_OBJ_CHANNEL_STATUS:
690 switch(lmp_obj_ctype) {
691 case LMP_CTYPE_IPV4:
692 case LMP_CTYPE_UNMD:
693 offset = 0;
694 /* Decode pairs: <Interface_ID (4 bytes), Channel_status (4 bytes)> */
695 while (offset < (lmp_obj_len-(int)sizeof(struct lmp_object_header)) ) {
696 printf("\n\t Interface ID: %s (0x%08x)",
697 ipaddr_string(obj_tptr+offset),
698 EXTRACT_32BITS(obj_tptr+offset));
699
700 printf("\n\t\t Active: %s (%u)", (EXTRACT_32BITS(obj_tptr+offset+4)>>31) ?
701 "Allocated" : "Non-allocated",
702 (EXTRACT_32BITS(obj_tptr+offset+4)>>31));
703
704 printf("\n\t\t Direction: %s (%u)", (EXTRACT_32BITS(obj_tptr+offset+4)>>30)&0x1 ?
705 "Transmit" : "Receive",
706 (EXTRACT_32BITS(obj_tptr+offset+4)>>30)&0x1);
707
708 printf("\n\t\t Channel Status: %s (%u)",
709 tok2str(lmp_obj_channel_status_values,
710 "Unknown",
711 EXTRACT_32BITS(obj_tptr+offset+4)&0x3FFFFFF),
712 EXTRACT_32BITS(obj_tptr+offset+4)&0x3FFFFFF);
713 offset+=8;
714 }
715 break;
716 #ifdef INET6
717 case LMP_CTYPE_IPV6:
718 #endif
719 default:
720 hexdump=TRUE;
721 }
722 break;
723
724 case LMP_OBJ_CHANNEL_STATUS_REQ:
725 switch(lmp_obj_ctype) {
726 case LMP_CTYPE_IPV4:
727 case LMP_CTYPE_UNMD:
728 offset = 0;
729 while (offset < (lmp_obj_len-(int)sizeof(struct lmp_object_header)) ) {
730 printf("\n\t Interface ID: %s (0x%08x)",
731 ipaddr_string(obj_tptr+offset),
732 EXTRACT_32BITS(obj_tptr+offset));
733 offset+=4;
734 }
735 break;
736 #ifdef INET6
737 case LMP_CTYPE_IPV6:
738 #endif
739 default:
740 hexdump=TRUE;
741 }
742 break;
743
744 case LMP_OBJ_ERROR_CODE:
745 switch(lmp_obj_ctype) {
746 case LMP_CTYPE_BEGIN_VERIFY_ERROR:
747 printf("\n\t Error Code: %s",
748 bittok2str(lmp_obj_begin_verify_error_values,
749 "none",
750 EXTRACT_32BITS(obj_tptr)));
751 break;
752
753 case LMP_CTYPE_LINK_SUMMARY_ERROR:
754 printf("\n\t Error Code: %s",
755 bittok2str(lmp_obj_link_summary_error_values,
756 "none",
757 EXTRACT_32BITS(obj_tptr)));
758 break;
759 default:
760 hexdump=TRUE;
761 }
762 break;
763
764 case LMP_OBJ_SERVICE_CONFIG:
765 switch (lmp_obj_ctype) {
766 case LMP_CTYPE_SERVICE_CONFIG_SP:
767
768 printf("\n\t Flags: %s",
769 bittok2str(lmp_obj_service_config_sp_flag_values,
770 "none",
771 EXTRACT_16BITS(obj_tptr)>>8));
772
773 printf("\n\t UNI Version: %u",
774 EXTRACT_16BITS(obj_tptr) & 0x00FF);
775
776 break;
777
778 case LMP_CTYPE_SERVICE_CONFIG_CPSA:
779
780 link_type = EXTRACT_16BITS(obj_tptr)>>8;
781
782 printf("\n\t Link Type: %s (%u)",
783 tok2str(lmp_sd_service_config_cpsa_link_type_values,
784 "Unknown", link_type),
785 link_type);
786
787 if (link_type == LMP_SD_SERVICE_CONFIG_CPSA_LINK_TYPE_SDH) {
788 printf("\n\t Signal Type: %s (%u)",
789 tok2str(lmp_sd_service_config_cpsa_signal_type_sdh_values,
790 "Unknown",
791 EXTRACT_16BITS(obj_tptr) & 0x00FF),
792 EXTRACT_16BITS(obj_tptr) & 0x00FF);
793 }
794
795 if (link_type == LMP_SD_SERVICE_CONFIG_CPSA_LINK_TYPE_SONET) {
796 printf("\n\t Signal Type: %s (%u)",
797 tok2str(lmp_sd_service_config_cpsa_signal_type_sonet_values,
798 "Unknown",
799 EXTRACT_16BITS(obj_tptr) & 0x00FF),
800 EXTRACT_16BITS(obj_tptr) & 0x00FF);
801 }
802
803 printf("\n\t Transparency: %s",
804 bittok2str(lmp_obj_service_config_cpsa_tp_flag_values,
805 "none",
806 EXTRACT_16BITS(obj_tptr+2)>>8));
807
808 printf("\n\t Contiguous Concatenation Types: %s",
809 bittok2str(lmp_obj_service_config_cpsa_cct_flag_values,
810 "none",
811 EXTRACT_16BITS(obj_tptr+2)>>8 & 0x00FF));
812
813 printf("\n\t Minimum NCC: %u",
814 EXTRACT_16BITS(obj_tptr+4));
815
816 printf("\n\t Maximum NCC: %u",
817 EXTRACT_16BITS(obj_tptr+6));
818
819 printf("\n\t Minimum NVC:%u",
820 EXTRACT_16BITS(obj_tptr+8));
821
822 printf("\n\t Maximum NVC:%u",
823 EXTRACT_16BITS(obj_tptr+10));
824
825 printf("\n\t Local Interface ID: %s (0x%08x)",
826 ipaddr_string(obj_tptr+12),
827 EXTRACT_32BITS(obj_tptr+12));
828
829 break;
830
831 case LMP_CTYPE_SERVICE_CONFIG_TRANSPARENCY_TCM:
832
833 printf("\n\t Transparency Flags: %s",
834 bittok2str(
835 lmp_obj_service_config_nsa_transparency_flag_values,
836 "none",
837 EXTRACT_32BITS(obj_tptr)));
838
839 printf("\n\t TCM Monitoring Flags: %s",
840 bittok2str(
841 lmp_obj_service_config_nsa_tcm_flag_values,
842 "none",
843 EXTRACT_16BITS(obj_tptr+6) & 0x00FF));
844
845 break;
846
847 case LMP_CTYPE_SERVICE_CONFIG_NETWORK_DIVERSITY:
848
849 printf("\n\t Diversity: Flags: %s",
850 bittok2str(
851 lmp_obj_service_config_nsa_network_diversity_flag_values,
852 "none",
853 EXTRACT_16BITS(obj_tptr+2) & 0x00FF));
854 break;
855
856 default:
857 hexdump = TRUE;
858 };
859
860 break;
861
862 default:
863 if (vflag <= 1)
864 print_unknown_data(gndo,obj_tptr,"\n\t ",obj_tlen);
865 break;
866 }
867 /* do we want to see an additionally hexdump ? */
868 if (vflag > 1 || hexdump==TRUE)
869 print_unknown_data(gndo,tptr+sizeof(struct lmp_object_header),"\n\t ",
870 lmp_obj_len-sizeof(struct lmp_object_header));
871
872 tptr+=lmp_obj_len;
873 tlen-=lmp_obj_len;
874 }
875 return;
876 trunc:
877 printf("\n\t\t packet exceeded snapshot");
878 }
879 /*
880 * Local Variables:
881 * c-style: whitesmith
882 * c-basic-offset: 8
883 * End:
884 */
[mirror] the TCPdump network dissector