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 * Copyright (c) 2009 Mojatatu Networks, Inc 14 * 15 */ 16 17/* \summary: Forwarding and Control Element Separation (ForCES) Protocol printer */ 18 19/* specification: RFC 5810 */ 20 21#ifdef HAVE_CONFIG_H 22#include <config.h> 23#endif 24 25#include "netdissect-stdinc.h" 26 27#include "netdissect.h" 28#include "extract.h" 29 30 31#define ForCES_VERS 1 32#define ForCES_HDRL 24 33#define ForCES_ALNL 4U 34#define TLV_HDRL 4 35#define ILV_HDRL 8 36 37#define TOM_RSVD 0x0 38#define TOM_ASSNSETUP 0x1 39#define TOM_ASSNTEARD 0x2 40#define TOM_CONFIG 0x3 41#define TOM_QUERY 0x4 42#define TOM_EVENTNOT 0x5 43#define TOM_PKTREDIR 0x6 44#define TOM_HEARTBT 0x0F 45#define TOM_ASSNSETREP 0x11 46#define TOM_CONFIGREP 0x13 47#define TOM_QUERYREP 0x14 48 49/* 50 * tom_h Flags: resv1(8b):maxtlvs(4b):resv2(2b):mintlv(2b) 51*/ 52#define ZERO_TTLV 0x01 53#define ZERO_MORE_TTLV 0x02 54#define ONE_MORE_TTLV 0x04 55#define ZERO_TLV 0x00 56#define ONE_TLV 0x10 57#define TWO_TLV 0x20 58#define MAX_TLV 0xF0 59 60#define TTLV_T1 (ONE_MORE_TTLV|ONE_TLV) 61#define TTLV_T2 (ONE_MORE_TTLV|MAX_TLV) 62 63struct tom_h { 64 uint32_t v; 65 uint16_t flags; 66 uint16_t op_msk; 67 const char *s; 68 int (*print) (netdissect_options *ndo, const u_char * pptr, u_int len, 69 uint16_t op_msk, int indent); 70}; 71 72enum { 73 TOM_RSV_I, 74 TOM_ASS_I, 75 TOM_AST_I, 76 TOM_CFG_I, 77 TOM_QRY_I, 78 TOM_EVN_I, 79 TOM_RED_I, 80 TOM_HBT_I, 81 TOM_ASR_I, 82 TOM_CNR_I, 83 TOM_QRR_I, 84 _TOM_RSV_MAX 85}; 86#define TOM_MAX_IND (_TOM_RSV_MAX - 1) 87 88static int 89tom_valid(uint8_t tom) 90{ 91 if (tom > 0) { 92 if (tom >= 0x7 && tom <= 0xe) 93 return 0; 94 if (tom == 0x10) 95 return 0; 96 if (tom > 0x14) 97 return 0; 98 return 1; 99 } else 100 return 0; 101} 102 103static const char * 104ForCES_node(uint32_t node) 105{ 106 if (node <= 0x3FFFFFFF) 107 return "FE"; 108 if (node >= 0x40000000 && node <= 0x7FFFFFFF) 109 return "CE"; 110 if (node >= 0xC0000000 && node <= 0xFFFFFFEF) 111 return "AllMulticast"; 112 if (node == 0xFFFFFFFD) 113 return "AllCEsBroadcast"; 114 if (node == 0xFFFFFFFE) 115 return "AllFEsBroadcast"; 116 if (node == 0xFFFFFFFF) 117 return "AllBroadcast"; 118 119 return "ForCESreserved"; 120 121} 122 123static const struct tok ForCES_ACKs[] = { 124 {0x0, "NoACK"}, 125 {0x1, "SuccessACK"}, 126 {0x2, "FailureACK"}, 127 {0x3, "AlwaysACK"}, 128 {0, NULL} 129}; 130 131static const struct tok ForCES_EMs[] = { 132 {0x0, "EMReserved"}, 133 {0x1, "execute-all-or-none"}, 134 {0x2, "execute-until-failure"}, 135 {0x3, "continue-execute-on-failure"}, 136 {0, NULL} 137}; 138 139static const struct tok ForCES_ATs[] = { 140 {0x0, "Standalone"}, 141 {0x1, "2PCtransaction"}, 142 {0, NULL} 143}; 144 145static const struct tok ForCES_TPs[] = { 146 {0x0, "StartofTransaction"}, 147 {0x1, "MiddleofTransaction"}, 148 {0x2, "EndofTransaction"}, 149 {0x3, "abort"}, 150 {0, NULL} 151}; 152 153/* 154 * Structure of forces header, naked of TLVs. 155 */ 156struct forcesh { 157 nd_uint8_t fm_vrsvd; /* version and reserved */ 158#define ForCES_V(forcesh) (GET_U_1((forcesh)->fm_vrsvd) >> 4) 159 nd_uint8_t fm_tom; /* type of message */ 160 nd_uint16_t fm_len; /* total length * 4 bytes */ 161#define ForCES_BLN(forcesh) ((uint32_t)(GET_BE_U_2((forcesh)->fm_len) << 2)) 162 nd_uint32_t fm_sid; /* Source ID */ 163#define ForCES_SID(forcesh) GET_BE_U_4((forcesh)->fm_sid) 164 nd_uint32_t fm_did; /* Destination ID */ 165#define ForCES_DID(forcesh) GET_BE_U_4((forcesh)->fm_did) 166 nd_uint8_t fm_cor[8]; /* correlator */ 167 nd_uint32_t fm_flags; /* flags */ 168#define ForCES_ACK(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0xC0000000) >> 30) 169#define ForCES_PRI(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0x38000000) >> 27) 170#define ForCES_RS1(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0x07000000) >> 24) 171#define ForCES_EM(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0x00C00000) >> 22) 172#define ForCES_AT(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0x00200000) >> 21) 173#define ForCES_TP(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0x00180000) >> 19) 174#define ForCES_RS2(forcesh) ((GET_BE_U_4((forcesh)->fm_flags)&0x0007FFFF) >> 0) 175}; 176 177#define ForCES_HLN_VALID(fhl,tlen) ((tlen) >= ForCES_HDRL && \ 178 (fhl) >= ForCES_HDRL && \ 179 (fhl) == (tlen)) 180 181#define F_LFB_RSVD 0x0 182#define F_LFB_FEO 0x1 183#define F_LFB_FEPO 0x2 184static const struct tok ForCES_LFBs[] = { 185 {F_LFB_RSVD, "Invalid TLV"}, 186 {F_LFB_FEO, "FEObj LFB"}, 187 {F_LFB_FEPO, "FEProtoObj LFB"}, 188 {0, NULL} 189}; 190 191/* this is defined in RFC5810 section A.2 */ 192/* https://www.iana.org/assignments/forces/forces.xhtml#oper-tlv-types */ 193enum { 194 F_OP_RSV = 0, 195 F_OP_SET = 1, 196 F_OP_SETPROP = 2, 197 F_OP_SETRESP = 3, 198 F_OP_SETPRESP = 4, 199 F_OP_DEL = 5, 200 F_OP_DELRESP = 6, 201 F_OP_GET = 7, 202 F_OP_GETPROP = 8, 203 F_OP_GETRESP = 9, 204 F_OP_GETPRESP = 10, 205 F_OP_REPORT = 11, 206 F_OP_COMMIT = 12, 207 F_OP_RCOMMIT = 13, 208 F_OP_RTRCOMP = 14, 209 _F_OP_MAX 210}; 211#define F_OP_MAX (_F_OP_MAX - 1) 212 213enum { 214 B_OP_SET = 1 << (F_OP_SET - 1), 215 B_OP_SETPROP = 1 << (F_OP_SETPROP - 1), 216 B_OP_SETRESP = 1 << (F_OP_SETRESP - 1), 217 B_OP_SETPRESP = 1 << (F_OP_SETPRESP - 1), 218 B_OP_DEL = 1 << (F_OP_DEL - 1), 219 B_OP_DELRESP = 1 << (F_OP_DELRESP - 1), 220 B_OP_GET = 1 << (F_OP_GET - 1), 221 B_OP_GETPROP = 1 << (F_OP_GETPROP - 1), 222 B_OP_GETRESP = 1 << (F_OP_GETRESP - 1), 223 B_OP_GETPRESP = 1 << (F_OP_GETPRESP - 1), 224 B_OP_REPORT = 1 << (F_OP_REPORT - 1), 225 B_OP_COMMIT = 1 << (F_OP_COMMIT - 1), 226 B_OP_RCOMMIT = 1 << (F_OP_RCOMMIT - 1), 227 B_OP_RTRCOMP = 1 << (F_OP_RTRCOMP - 1) 228}; 229 230struct optlv_h { 231 uint16_t flags; 232 uint16_t op_msk; 233 const char *s; 234 int (*print) (netdissect_options *ndo, const u_char * pptr, u_int len, 235 uint16_t op_msk, int indent); 236}; 237 238static int genoptlv_print(netdissect_options *, const u_char * pptr, u_int len, 239 uint16_t op_msk, int indent); 240static int recpdoptlv_print(netdissect_options *, const u_char * pptr, u_int len, 241 uint16_t op_msk, int indent); 242static int invoptlv_print(netdissect_options *, const u_char * pptr, u_int len, 243 uint16_t op_msk, int indent); 244 245#define OP_MIN_SIZ 8 246struct pathdata_h { 247 nd_uint16_t pflags; 248 nd_uint16_t pIDcnt; 249}; 250 251#define B_FULLD 0x1 252#define B_SPARD 0x2 253#define B_RESTV 0x4 254#define B_KEYIN 0x8 255#define B_APPND 0x10 256#define B_TRNG 0x20 257 258static const struct optlv_h OPTLV_msg[F_OP_MAX + 1] = { 259 /* F_OP_RSV */ {ZERO_TTLV, 0, "Invalid OPTLV", invoptlv_print}, 260 /* F_OP_SET */ {TTLV_T2, B_FULLD | B_SPARD, " Set", recpdoptlv_print}, 261 /* F_OP_SETPROP */ 262 {TTLV_T2, B_FULLD | B_SPARD, " SetProp", recpdoptlv_print}, 263 /* F_OP_SETRESP */ {TTLV_T2, B_RESTV, " SetResp", recpdoptlv_print}, 264 /* F_OP_SETPRESP */ {TTLV_T2, B_RESTV, " SetPropResp", recpdoptlv_print}, 265 /* F_OP_DEL */ {ZERO_TTLV, 0, " Del", recpdoptlv_print}, 266 /* F_OP_DELRESP */ {TTLV_T2, B_RESTV, " DelResp", recpdoptlv_print}, 267 /* F_OP_GET */ {ZERO_TTLV, 0, " Get", recpdoptlv_print}, 268 /* F_OP_GETPROP */ {ZERO_TTLV, 0, " GetProp", recpdoptlv_print}, 269 /* F_OP_GETRESP */ 270 {TTLV_T2, B_FULLD | B_SPARD | B_RESTV, " GetResp", recpdoptlv_print}, 271 /* F_OP_GETPRESP */ 272 {TTLV_T2, B_FULLD | B_RESTV, " GetPropResp", recpdoptlv_print}, 273 /* F_OP_REPORT */ 274 {TTLV_T2, B_FULLD | B_SPARD, " Report", recpdoptlv_print}, 275 /* F_OP_COMMIT */ {ZERO_TTLV, 0, " Commit", NULL}, 276 /* F_OP_RCOMMIT */ {TTLV_T1, B_RESTV, " RCommit", genoptlv_print}, 277 /* F_OP_RTRCOMP */ {ZERO_TTLV, 0, " RTRCOMP", NULL}, 278}; 279 280static const struct optlv_h * 281get_forces_optlv_h(uint16_t opt) 282{ 283 if (opt > F_OP_MAX || opt == F_OP_RSV) 284 return &OPTLV_msg[F_OP_RSV]; 285 286 return &OPTLV_msg[opt]; 287} 288 289#define IND_SIZE 256 290#define IND_CHR ' ' 291#define IND_PREF '\n' 292#define IND_SUF 0x0 293static char ind_buf[IND_SIZE]; 294 295static char * 296indent_pr(int indent, int nlpref) 297{ 298 int i = 0; 299 char *r = ind_buf; 300 301 if (indent > (IND_SIZE - 1)) 302 indent = IND_SIZE - 1; 303 304 if (nlpref) { 305 r[i] = IND_PREF; 306 i++; 307 indent--; 308 } 309 310 while (--indent >= 0) 311 r[i++] = IND_CHR; 312 313 r[i] = IND_SUF; 314 return r; 315} 316 317static int 318op_valid(uint16_t op, uint16_t mask) 319{ 320 if (op == 0) 321 return 0; 322 if (op <= F_OP_MAX) 323 return (1 << (op - 1)) & mask; /* works only for 0x0001 through 0x0010 */ 324 /* I guess we should allow vendor operations? */ 325 if (op >= 0x8000) 326 return 1; 327 return 0; 328} 329 330#define F_TLV_RSVD 0x0000 331#define F_TLV_REDR 0x0001 332#define F_TLV_ASRS 0x0010 333#define F_TLV_ASRT 0x0011 334#define F_TLV_LFBS 0x1000 335#define F_TLV_PDAT 0x0110 336#define F_TLV_KEYI 0x0111 337#define F_TLV_FULD 0x0112 338#define F_TLV_SPAD 0x0113 339#define F_TLV_REST 0x0114 340#define F_TLV_METD 0x0115 341#define F_TLV_REDD 0x0116 342#define F_TLV_TRNG 0x0117 343 344 345#define F_TLV_VNST 0x8000 346 347static const struct tok ForCES_TLV[] = { 348 {F_TLV_RSVD, "Invalid TLV"}, 349 {F_TLV_REDR, "REDIRECT TLV"}, 350 {F_TLV_ASRS, "ASResult TLV"}, 351 {F_TLV_ASRT, "ASTreason TLV"}, 352 {F_TLV_LFBS, "LFBselect TLV"}, 353 {F_TLV_PDAT, "PATH-DATA TLV"}, 354 {F_TLV_KEYI, "KEYINFO TLV"}, 355 {F_TLV_FULD, "FULLDATA TLV"}, 356 {F_TLV_SPAD, "SPARSEDATA TLV"}, 357 {F_TLV_REST, "RESULT TLV"}, 358 {F_TLV_METD, "METADATA TLV"}, 359 {F_TLV_REDD, "REDIRECTDATA TLV"}, 360 {0, NULL} 361}; 362 363#define TLV_HLN 4 364static int 365ttlv_valid(uint16_t ttlv) 366{ 367 if (ttlv > 0) { 368 if (ttlv == 1 || ttlv == 0x1000) 369 return 1; 370 if (ttlv >= 0x10 && ttlv <= 0x11) 371 return 1; 372 if (ttlv >= 0x110 && ttlv <= 0x116) 373 return 1; 374 if (ttlv >= 0x8000) 375 return 0; /* XXX: */ 376 } 377 378 return 0; 379} 380 381struct forces_ilv { 382 nd_uint32_t type; 383 nd_uint32_t length; 384}; 385 386struct forces_tlv { 387 nd_uint16_t type; 388 nd_uint16_t length; 389}; 390 391#define F_ALN_LEN(len) roundup2(len, ForCES_ALNL) 392#define GET_TOP_TLV(fhdr) ((const struct forces_tlv *)((fhdr) + sizeof (struct forcesh))) 393#define TLV_SET_LEN(len) (F_ALN_LEN(TLV_HDRL) + (len)) 394#define TLV_DATA(tlvp) ((const void*)(((const char*)(tlvp)) + TLV_SET_LEN(0))) 395#define GO_NXT_TLV(tlv,rlen) ((rlen) -= F_ALN_LEN(GET_BE_U_2((tlv)->length)), \ 396 (const struct forces_tlv*)(((const char*)(tlv)) \ 397 + F_ALN_LEN(GET_BE_U_2((tlv)->length)))) 398#define ILV_SET_LEN(len) (F_ALN_LEN(ILV_HDRL) + (len)) 399#define ILV_DATA(ilvp) ((const void*)(((const char*)(ilvp)) + ILV_SET_LEN(0))) 400#define GO_NXT_ILV(ilv,rlen) ((rlen) -= F_ALN_LEN(GET_BE_U_4((ilv)->length)), \ 401 (const struct forces_ilv *)(((const char*)(ilv)) \ 402 + F_ALN_LEN(GET_BE_U_4((ilv)->length)))) 403#define INVALID_RLEN 1 404#define INVALID_STLN 2 405#define INVALID_LTLN 3 406#define INVALID_ALEN 4 407 408static const struct tok ForCES_TLV_err[] = { 409 {INVALID_RLEN, "Invalid total length"}, 410 {INVALID_STLN, "xLV too short"}, 411 {INVALID_LTLN, "xLV too long"}, 412 {INVALID_ALEN, "data padding missing"}, 413 {0, NULL} 414}; 415 416static u_int 417tlv_valid(u_int tlvl, u_int rlen) 418{ 419 if (rlen < TLV_HDRL) 420 return INVALID_RLEN; 421 if (tlvl < TLV_HDRL) 422 return INVALID_STLN; 423 if (tlvl > rlen) 424 return INVALID_LTLN; 425 if (rlen < F_ALN_LEN(tlvl)) 426 return INVALID_ALEN; 427 428 return 0; 429} 430 431static int 432ilv_valid(netdissect_options *ndo, const struct forces_ilv *ilv, u_int rlen) 433{ 434 if (rlen < ILV_HDRL) 435 return INVALID_RLEN; 436 if (GET_BE_U_4(ilv->length) < ILV_HDRL) 437 return INVALID_STLN; 438 if (GET_BE_U_4(ilv->length) > rlen) 439 return INVALID_LTLN; 440 if (rlen < F_ALN_LEN(GET_BE_U_4(ilv->length))) 441 return INVALID_ALEN; 442 443 return 0; 444} 445 446static int lfbselect_print(netdissect_options *, const u_char * pptr, u_int len, 447 uint16_t op_msk, int indent); 448static int redirect_print(netdissect_options *, const u_char * pptr, u_int len, 449 uint16_t op_msk, int indent); 450static int asrtlv_print(netdissect_options *, const u_char * pptr, u_int len, 451 uint16_t op_msk, int indent); 452static int asttlv_print(netdissect_options *, const u_char * pptr, u_int len, 453 uint16_t op_msk, int indent); 454 455struct forces_lfbsh { 456 nd_uint32_t class; 457 nd_uint32_t instance; 458}; 459 460#define ASSNS_OPS (B_OP_REPORT) 461#define CFG_OPS (B_OP_SET|B_OP_SETPROP|B_OP_DEL|B_OP_COMMIT|B_OP_RTRCOMP) 462#define CFG_ROPS (B_OP_SETRESP|B_OP_SETPRESP|B_OP_DELRESP|B_OP_RCOMMIT) 463#define CFG_QY (B_OP_GET|B_OP_GETPROP) 464#define CFG_QYR (B_OP_GETRESP|B_OP_GETPRESP) 465#define CFG_EVN (B_OP_REPORT) 466 467static const struct tom_h ForCES_msg[TOM_MAX_IND + 1] = { 468 /* TOM_RSV_I */ {TOM_RSVD, ZERO_TTLV, 0, "Invalid message", NULL}, 469 /* TOM_ASS_I */ {TOM_ASSNSETUP, ZERO_MORE_TTLV | TWO_TLV, ASSNS_OPS, 470 "Association Setup", lfbselect_print}, 471 /* TOM_AST_I */ 472 {TOM_ASSNTEARD, TTLV_T1, 0, "Association TearDown", asttlv_print}, 473 /* TOM_CFG_I */ {TOM_CONFIG, TTLV_T2, CFG_OPS, "Config", lfbselect_print}, 474 /* TOM_QRY_I */ {TOM_QUERY, TTLV_T2, CFG_QY, "Query", lfbselect_print}, 475 /* TOM_EVN_I */ {TOM_EVENTNOT, TTLV_T1, CFG_EVN, "Event Notification", 476 lfbselect_print}, 477 /* TOM_RED_I */ 478 {TOM_PKTREDIR, TTLV_T2, 0, "Packet Redirect", redirect_print}, 479 /* TOM_HBT_I */ {TOM_HEARTBT, ZERO_TTLV, 0, "HeartBeat", NULL}, 480 /* TOM_ASR_I */ 481 {TOM_ASSNSETREP, TTLV_T1, 0, "Association Response", asrtlv_print}, 482 /* TOM_CNR_I */ {TOM_CONFIGREP, TTLV_T2, CFG_ROPS, "Config Response", 483 lfbselect_print}, 484 /* TOM_QRR_I */ 485 {TOM_QUERYREP, TTLV_T2, CFG_QYR, "Query Response", lfbselect_print}, 486}; 487 488static const struct tom_h * 489get_forces_tom(uint8_t tom) 490{ 491 int i; 492 for (i = TOM_RSV_I; i <= TOM_MAX_IND; i++) { 493 const struct tom_h *th = &ForCES_msg[i]; 494 if (th->v == tom) 495 return th; 496 } 497 return &ForCES_msg[TOM_RSV_I]; 498} 499 500struct pdata_ops { 501 uint32_t v; 502 uint16_t flags; 503 uint16_t op_msk; 504 const char *s; 505 int (*print) (netdissect_options *, const u_char * pptr, u_int len, 506 uint16_t op_msk, int indent); 507}; 508 509enum { 510 PD_RSV_I, 511 PD_SEL_I, 512 PD_FDT_I, 513 PD_SDT_I, 514 PD_RES_I, 515 PD_PDT_I, 516 _PD_RSV_MAX 517}; 518#define PD_MAX_IND (_TOM_RSV_MAX - 1) 519 520static int 521pd_valid(uint16_t pd) 522{ 523 if (pd >= F_TLV_PDAT && pd <= F_TLV_REST) 524 return 1; 525 return 0; 526} 527 528static void 529chk_op_type(netdissect_options *ndo, 530 uint16_t type, uint16_t msk, uint16_t omsk) 531{ 532 if (type != F_TLV_PDAT) { 533 if (msk & B_KEYIN) { 534 if (type != F_TLV_KEYI) { 535 ND_PRINT("Based on flags expected KEYINFO TLV!\n"); 536 } 537 } else { 538 if (!(msk & omsk)) { 539 ND_PRINT("Illegal DATA encoding for type 0x%x programmed %x got %x\n", 540 type, omsk, msk); 541 } 542 } 543 } 544 545} 546 547#define F_SELKEY 1 548#define F_SELTABRANGE 2 549#define F_TABAPPEND 4 550 551struct res_val { 552 nd_uint8_t result; 553 nd_uint8_t resv1; 554 nd_uint16_t resv2; 555}; 556 557static int prestlv_print(netdissect_options *, const u_char * pptr, u_int len, 558 uint16_t op_msk, int indent); 559static int pkeyitlv_print(netdissect_options *, const u_char * pptr, u_int len, 560 uint16_t op_msk, int indent); 561static int fdatatlv_print(netdissect_options *, const u_char * pptr, u_int len, 562 uint16_t op_msk, int indent); 563static int sdatatlv_print(netdissect_options *, const u_char * pptr, u_int len, 564 uint16_t op_msk, int indent); 565 566static const struct pdata_ops ForCES_pdata[PD_MAX_IND + 1] = { 567 /* PD_RSV_I */ {0, 0, 0, "Invalid message", NULL}, 568 /* PD_SEL_I */ {F_TLV_KEYI, 0, 0, "KEYINFO TLV", pkeyitlv_print}, 569 /* PD_FDT_I */ {F_TLV_FULD, 0, B_FULLD, "FULLDATA TLV", fdatatlv_print}, 570 /* PD_SDT_I */ {F_TLV_SPAD, 0, B_SPARD, "SPARSEDATA TLV", sdatatlv_print}, 571 /* PD_RES_I */ {F_TLV_REST, 0, B_RESTV, "RESULT TLV", prestlv_print}, 572 /* PD_PDT_I */ 573 {F_TLV_PDAT, 0, 0, "Inner PATH-DATA TLV", recpdoptlv_print}, 574}; 575 576static const struct pdata_ops * 577get_forces_pd(uint16_t pd) 578{ 579 int i; 580 for (i = PD_RSV_I + 1; i <= PD_MAX_IND; i++) { 581 const struct pdata_ops *pdo = &ForCES_pdata[i]; 582 if (pdo->v == pd) 583 return pdo; 584 } 585 return &ForCES_pdata[TOM_RSV_I]; 586} 587 588enum { 589 E_SUCCESS, 590 E_INVALID_HEADER, 591 E_LENGTH_MISMATCH, 592 E_VERSION_MISMATCH, 593 E_INVALID_DESTINATION_PID, 594 E_LFB_UNKNOWN, 595 E_LFB_NOT_FOUND, 596 E_LFB_INSTANCE_ID_NOT_FOUND, 597 E_INVALID_PATH, 598 E_COMPONENT_DOES_NOT_EXIST, 599 E_EXISTS, 600 E_NOT_FOUND, 601 E_READ_ONLY, 602 E_INVALID_ARRAY_CREATION, 603 E_VALUE_OUT_OF_RANGE, 604 E_CONTENTS_TOO_LONG, 605 E_INVALID_PARAMETERS, 606 E_INVALID_MESSAGE_TYPE, 607 E_INVALID_FLAGS, 608 E_INVALID_TLV, 609 E_EVENT_ERROR, 610 E_NOT_SUPPORTED, 611 E_MEMORY_ERROR, 612 E_INTERNAL_ERROR, 613 /* 0x18-0xFE are reserved .. */ 614 E_UNSPECIFIED_ERROR = 0XFF 615}; 616 617static const struct tok ForCES_errs[] = { 618 {E_SUCCESS, "SUCCESS"}, 619 {E_INVALID_HEADER, "INVALID HEADER"}, 620 {E_LENGTH_MISMATCH, "LENGTH MISMATCH"}, 621 {E_VERSION_MISMATCH, "VERSION MISMATCH"}, 622 {E_INVALID_DESTINATION_PID, "INVALID DESTINATION PID"}, 623 {E_LFB_UNKNOWN, "LFB UNKNOWN"}, 624 {E_LFB_NOT_FOUND, "LFB NOT FOUND"}, 625 {E_LFB_INSTANCE_ID_NOT_FOUND, "LFB INSTANCE ID NOT FOUND"}, 626 {E_INVALID_PATH, "INVALID PATH"}, 627 {E_COMPONENT_DOES_NOT_EXIST, "COMPONENT DOES NOT EXIST"}, 628 {E_EXISTS, "EXISTS ALREADY"}, 629 {E_NOT_FOUND, "NOT FOUND"}, 630 {E_READ_ONLY, "READ ONLY"}, 631 {E_INVALID_ARRAY_CREATION, "INVALID ARRAY CREATION"}, 632 {E_VALUE_OUT_OF_RANGE, "VALUE OUT OF RANGE"}, 633 {E_CONTENTS_TOO_LONG, "CONTENTS TOO LONG"}, 634 {E_INVALID_PARAMETERS, "INVALID PARAMETERS"}, 635 {E_INVALID_MESSAGE_TYPE, "INVALID MESSAGE TYPE"}, 636 {E_INVALID_FLAGS, "INVALID FLAGS"}, 637 {E_INVALID_TLV, "INVALID TLV"}, 638 {E_EVENT_ERROR, "EVENT ERROR"}, 639 {E_NOT_SUPPORTED, "NOT SUPPORTED"}, 640 {E_MEMORY_ERROR, "MEMORY ERROR"}, 641 {E_INTERNAL_ERROR, "INTERNAL ERROR"}, 642 {E_UNSPECIFIED_ERROR, "UNSPECIFIED ERROR"}, 643 {0, NULL} 644}; 645 646#define RESLEN 4 647 648static int 649prestlv_print(netdissect_options *ndo, 650 const u_char * pptr, u_int len, 651 uint16_t op_msk _U_, int indent) 652{ 653 const struct forces_tlv *tlv = (const struct forces_tlv *)pptr; 654 const u_char *tdp = (const u_char *) TLV_DATA(tlv); 655 const struct res_val *r = (const struct res_val *)tdp; 656 u_int dlen; 657 uint8_t result; 658 659 /* 660 * pdatacnt_print() has ensured that len (the TLV length) 661 * >= TLV_HDRL. 662 */ 663 dlen = len - TLV_HDRL; 664 if (dlen != RESLEN) { 665 ND_PRINT("illegal RESULT-TLV: %u bytes!\n", dlen); 666 return -1; 667 } 668 669 ND_TCHECK_SIZE(r); 670 result = GET_U_1(r->result); 671 if (result >= 0x18 && result <= 0xFE) { 672 ND_PRINT("illegal reserved result code: 0x%x!\n", result); 673 return -1; 674 } 675 676 if (ndo->ndo_vflag >= 3) { 677 char *ib = indent_pr(indent, 0); 678 ND_PRINT("%s Result: %s (code 0x%x)\n", ib, 679 tok2str(ForCES_errs, NULL, result), result); 680 } 681 return 0; 682 683trunc: 684 nd_print_trunc(ndo); 685 return -1; 686} 687 688static int 689fdatatlv_print(netdissect_options *ndo, 690 const u_char * pptr, u_int len, 691 uint16_t op_msk _U_, int indent) 692{ 693 const struct forces_tlv *tlv = (const struct forces_tlv *)pptr; 694 u_int rlen; 695 const u_char *tdp = (const u_char *) TLV_DATA(tlv); 696 uint16_t type; 697 698 /* 699 * pdatacnt_print() or pkeyitlv_print() has ensured that len 700 * (the TLV length) >= TLV_HDRL. 701 */ 702 rlen = len - TLV_HDRL; 703 ND_TCHECK_SIZE(tlv); 704 type = GET_BE_U_2(tlv->type); 705 if (type != F_TLV_FULD) { 706 ND_PRINT("Error: expecting FULLDATA!\n"); 707 return -1; 708 } 709 710 if (ndo->ndo_vflag >= 3) { 711 char *ib = indent_pr(indent + 2, 1); 712 ND_PRINT("%s[", ib + 1); 713 hex_print(ndo, ib, tdp, rlen); 714 ND_PRINT("\n%s]", ib + 1); 715 } 716 return 0; 717 718trunc: 719 nd_print_trunc(ndo); 720 return -1; 721} 722 723static int 724sdatailv_print(netdissect_options *ndo, 725 const u_char * pptr, u_int len, 726 uint16_t op_msk _U_, int indent) 727{ 728 u_int rlen; 729 const struct forces_ilv *ilv = (const struct forces_ilv *)pptr; 730 int invilv; 731 732 if (len < ILV_HDRL) { 733 ND_PRINT("Error: BAD SPARSEDATA-TLV!\n"); 734 return -1; 735 } 736 rlen = len; 737 indent += 1; 738 while (rlen != 0) { 739#if 0 740 ND_PRINT("Jamal - outstanding length <%u>\n", rlen); 741#endif 742 char *ib = indent_pr(indent, 1); 743 const u_char *tdp = (const u_char *) ILV_DATA(ilv); 744 invilv = ilv_valid(ndo, ilv, rlen); 745 if (invilv) { 746 ND_PRINT("Error: %s, rlen %u\n", 747 tok2str(ForCES_TLV_err, NULL, invilv), rlen); 748 return -1; 749 } 750 if (ndo->ndo_vflag >= 3) { 751 u_int ilvl = GET_BE_U_4(ilv->length); 752 ND_PRINT("\n%s ILV: type %x length %u\n", ib + 1, 753 GET_BE_U_4(ilv->type), ilvl); 754 hex_print(ndo, "\t\t[", tdp, ilvl-ILV_HDRL); 755 } 756 757 ilv = GO_NXT_ILV(ilv, rlen); 758 } 759 760 return 0; 761} 762 763static int 764sdatatlv_print(netdissect_options *ndo, 765 const u_char * pptr, u_int len, 766 uint16_t op_msk, int indent) 767{ 768 const struct forces_tlv *tlv = (const struct forces_tlv *)pptr; 769 u_int rlen; 770 const u_char *tdp = (const u_char *) TLV_DATA(tlv); 771 uint16_t type; 772 773 /* 774 * pdatacnt_print() has ensured that len (the TLV length) 775 * >= TLV_HDRL. 776 */ 777 rlen = len - TLV_HDRL; 778 ND_TCHECK_SIZE(tlv); 779 type = GET_BE_U_2(tlv->type); 780 if (type != F_TLV_SPAD) { 781 ND_PRINT("Error: expecting SPARSEDATA!\n"); 782 return -1; 783 } 784 785 return sdatailv_print(ndo, tdp, rlen, op_msk, indent); 786 787trunc: 788 nd_print_trunc(ndo); 789 return -1; 790} 791 792static int 793pkeyitlv_print(netdissect_options *ndo, 794 const u_char * pptr, u_int len, 795 uint16_t op_msk, int indent) 796{ 797 const struct forces_tlv *tlv = (const struct forces_tlv *)pptr; 798 const u_char *tdp = (const u_char *) TLV_DATA(tlv); 799 const u_char *dp = tdp + 4; 800 const struct forces_tlv *kdtlv = (const struct forces_tlv *)dp; 801 uint32_t id; 802 char *ib = indent_pr(indent, 0); 803 uint16_t type, tll; 804 u_int invtlv; 805 806 id = GET_BE_U_4(tdp); 807 ND_PRINT("%sKeyinfo: Key 0x%x\n", ib, id); 808 type = GET_BE_U_2(kdtlv->type); 809 tll = GET_BE_U_2(kdtlv->length); 810 invtlv = tlv_valid(tll, len); 811 812 if (invtlv) { 813 ND_PRINT("%s TLV type 0x%x len %u\n", 814 tok2str(ForCES_TLV_err, NULL, invtlv), type, 815 tll); 816 return -1; 817 } 818 /* 819 * At this point, tlv_valid() has ensured that the TLV 820 * length is large enough but not too large (it doesn't 821 * go past the end of the containing TLV). 822 */ 823 tll = GET_BE_U_2(kdtlv->length); 824 dp = (const u_char *) TLV_DATA(kdtlv); 825 return fdatatlv_print(ndo, dp, tll, op_msk, indent); 826} 827 828#define PTH_DESC_SIZE 12 829 830static int 831pdatacnt_print(netdissect_options *ndo, 832 const u_char * pptr, u_int len, 833 uint16_t IDcnt, uint16_t op_msk, int indent) 834{ 835 u_int i; 836 uint32_t id; 837 char *ib = indent_pr(indent, 0); 838 839 if ((op_msk & B_APPND) && ndo->ndo_vflag >= 3) { 840 ND_PRINT("%sTABLE APPEND\n", ib); 841 } 842 for (i = 0; i < IDcnt; i++) { 843 ND_TCHECK_4(pptr); 844 if (len < 4) 845 goto trunc; 846 id = GET_BE_U_4(pptr); 847 if (ndo->ndo_vflag >= 3) 848 ND_PRINT("%sID#%02u: %u\n", ib, i + 1, id); 849 len -= 4; 850 pptr += 4; 851 } 852 853 if ((op_msk & B_TRNG) || (op_msk & B_KEYIN)) { 854 if (op_msk & B_TRNG) { 855 uint32_t starti, endi; 856 857 if (len < PTH_DESC_SIZE) { 858 ND_PRINT("pathlength %u with key/range too short %u\n", 859 len, PTH_DESC_SIZE); 860 return -1; 861 } 862 863 pptr += sizeof(struct forces_tlv); 864 len -= sizeof(struct forces_tlv); 865 866 starti = GET_BE_U_4(pptr); 867 pptr += 4; 868 len -= 4; 869 870 endi = GET_BE_U_4(pptr); 871 pptr += 4; 872 len -= 4; 873 874 if (ndo->ndo_vflag >= 3) 875 ND_PRINT("%sTable range: [%u,%u]\n", ib, starti, endi); 876 } 877 878 if (op_msk & B_KEYIN) { 879 const struct forces_tlv *keytlv; 880 uint16_t tll; 881 882 if (len < PTH_DESC_SIZE) { 883 ND_PRINT("pathlength %u with key/range too short %u\n", 884 len, PTH_DESC_SIZE); 885 return -1; 886 } 887 888 /* skip keyid */ 889 pptr += 4; 890 len -= 4; 891 keytlv = (const struct forces_tlv *)pptr; 892 /* skip header */ 893 pptr += sizeof(struct forces_tlv); 894 len -= sizeof(struct forces_tlv); 895 /* skip key content */ 896 tll = GET_BE_U_2(keytlv->length); 897 if (tll < TLV_HDRL) { 898 ND_PRINT("key content length %u < %u\n", 899 tll, TLV_HDRL); 900 return -1; 901 } 902 tll -= TLV_HDRL; 903 if (len < tll) { 904 ND_PRINT("key content too short\n"); 905 return -1; 906 } 907 pptr += tll; 908 len -= tll; 909 } 910 911 } 912 913 if (len) { 914 const struct forces_tlv *pdtlv = (const struct forces_tlv *)pptr; 915 uint16_t type; 916 uint16_t tlvl, tll; 917 u_int pad = 0; 918 u_int aln; 919 u_int invtlv; 920 921 type = GET_BE_U_2(pdtlv->type); 922 tlvl = GET_BE_U_2(pdtlv->length); 923 invtlv = tlv_valid(tlvl, len); 924 if (invtlv) { 925 ND_PRINT("%s Outstanding bytes %u for TLV type 0x%x TLV len %u\n", 926 tok2str(ForCES_TLV_err, NULL, invtlv), len, type, 927 tlvl); 928 goto pd_err; 929 } 930 /* 931 * At this point, tlv_valid() has ensured that the TLV 932 * length is large enough but not too large (it doesn't 933 * go past the end of the containing TLV). 934 */ 935 tll = tlvl - TLV_HDRL; 936 aln = F_ALN_LEN(tlvl); 937 if (aln > tlvl) { 938 if (aln > len) { 939 ND_PRINT("Invalid padded pathdata TLV type 0x%x len %u missing %u pad bytes\n", 940 type, tlvl, aln - len); 941 } else { 942 pad = aln - tlvl; 943 } 944 } 945 if (pd_valid(type)) { 946 const struct pdata_ops *ops = get_forces_pd(type); 947 948 if (ndo->ndo_vflag >= 3 && ops->v != F_TLV_PDAT) { 949 if (pad) 950 ND_PRINT("%s %s (Length %u DataLen %u pad %u Bytes)\n", 951 ib, ops->s, tlvl, tll, pad); 952 else 953 ND_PRINT("%s %s (Length %u DataLen %u Bytes)\n", 954 ib, ops->s, tlvl, tll); 955 } 956 957 chk_op_type(ndo, type, op_msk, ops->op_msk); 958 959 if (ops->print(ndo, (const u_char *)pdtlv, 960 tll + pad + TLV_HDRL, op_msk, 961 indent + 2) == -1) 962 return -1; 963 len -= (TLV_HDRL + pad + tll); 964 } else { 965 ND_PRINT("Invalid path data content type 0x%x len %u\n", 966 type, tlvl); 967pd_err: 968 if (tlvl) { 969 hex_print(ndo, "Bad Data val\n\t [", 970 pptr, len); 971 ND_PRINT("]\n"); 972 973 return -1; 974 } 975 } 976 } 977 return len; 978 979trunc: 980 nd_print_trunc(ndo); 981 return -1; 982} 983 984static int 985pdata_print(netdissect_options *ndo, 986 const u_char * pptr, u_int len, 987 uint16_t op_msk, int indent) 988{ 989 const struct pathdata_h *pdh = (const struct pathdata_h *)pptr; 990 char *ib = indent_pr(indent, 0); 991 u_int minsize = 0; 992 int more_pd = 0; 993 uint16_t idcnt = 0; 994 995 ND_TCHECK_SIZE(pdh); 996 if (len < sizeof(struct pathdata_h)) 997 goto trunc; 998 if (ndo->ndo_vflag >= 3) { 999 ND_PRINT("\n%sPathdata: Flags 0x%x ID count %u\n", 1000 ib, GET_BE_U_2(pdh->pflags), 1001 GET_BE_U_2(pdh->pIDcnt)); 1002 } 1003 1004 if (GET_BE_U_2(pdh->pflags) & F_SELKEY) { 1005 op_msk |= B_KEYIN; 1006 } 1007 1008 /* Table GET Range operation */ 1009 if (GET_BE_U_2(pdh->pflags) & F_SELTABRANGE) { 1010 op_msk |= B_TRNG; 1011 } 1012 /* Table SET append operation */ 1013 if (GET_BE_U_2(pdh->pflags) & F_TABAPPEND) { 1014 op_msk |= B_APPND; 1015 } 1016 1017 pptr += sizeof(struct pathdata_h); 1018 len -= sizeof(struct pathdata_h); 1019 idcnt = GET_BE_U_2(pdh->pIDcnt); 1020 minsize = idcnt * 4; 1021 if (len < minsize) { 1022 ND_PRINT("\t\t\ttruncated IDs expected %uB got %uB\n", minsize, 1023 len); 1024 hex_print(ndo, "\t\t\tID Data[", pptr, len); 1025 ND_PRINT("]\n"); 1026 return -1; 1027 } 1028 1029 if ((op_msk & B_TRNG) && (op_msk & B_KEYIN)) { 1030 ND_PRINT("\t\t\tIllegal to have both Table ranges and keys\n"); 1031 return -1; 1032 } 1033 1034 more_pd = pdatacnt_print(ndo, pptr, len, idcnt, op_msk, indent); 1035 if (more_pd > 0) { 1036 int consumed = len - more_pd; 1037 pptr += consumed; 1038 len = more_pd; 1039 /* XXX: Argh, recurse some more */ 1040 return recpdoptlv_print(ndo, pptr, len, op_msk, indent+1); 1041 } else 1042 return 0; 1043 1044trunc: 1045 nd_print_trunc(ndo); 1046 return -1; 1047} 1048 1049static int 1050genoptlv_print(netdissect_options *ndo, 1051 const u_char * pptr, u_int len, 1052 uint16_t op_msk, int indent) 1053{ 1054 const struct forces_tlv *pdtlv = (const struct forces_tlv *)pptr; 1055 uint16_t type; 1056 u_int tlvl; 1057 u_int invtlv; 1058 char *ib = indent_pr(indent, 0); 1059 1060 type = GET_BE_U_2(pdtlv->type); 1061 tlvl = GET_BE_U_2(pdtlv->length); 1062 invtlv = tlv_valid(tlvl, len); 1063 ND_PRINT("genoptlvprint - %s TLV type 0x%x len %u\n", 1064 tok2str(ForCES_TLV, NULL, type), type, tlvl); 1065 if (!invtlv) { 1066 /* 1067 * At this point, tlv_valid() has ensured that the TLV 1068 * length is large enough but not too large (it doesn't 1069 * go past the end of the containing TLV). 1070 */ 1071 const u_char *dp = (const u_char *) TLV_DATA(pdtlv); 1072 1073 if (!ttlv_valid(type)) { 1074 ND_PRINT("%s TLV type 0x%x len %u\n", 1075 tok2str(ForCES_TLV_err, NULL, invtlv), type, 1076 tlvl); 1077 return -1; 1078 } 1079 if (ndo->ndo_vflag >= 3) 1080 ND_PRINT("%s%s, length %u (data length %u Bytes)", 1081 ib, tok2str(ForCES_TLV, NULL, type), 1082 tlvl, tlvl - TLV_HDRL); 1083 1084 return pdata_print(ndo, dp, tlvl - TLV_HDRL, op_msk, indent + 1); 1085 } else { 1086 ND_PRINT("\t\t\tInvalid ForCES TLV type=%x", type); 1087 return -1; 1088 } 1089} 1090 1091static int 1092recpdoptlv_print(netdissect_options *ndo, 1093 const u_char * pptr, u_int len, 1094 uint16_t op_msk, int indent) 1095{ 1096 const struct forces_tlv *pdtlv = (const struct forces_tlv *)pptr; 1097 1098 while (len != 0) { 1099 uint16_t type, tlvl; 1100 u_int invtlv; 1101 char *ib; 1102 const u_char *dp; 1103 1104 tlvl = GET_BE_U_2(pdtlv->length); 1105 invtlv = tlv_valid(tlvl, len); 1106 if (invtlv) { 1107 break; 1108 } 1109 1110 /* 1111 * At this point, tlv_valid() has ensured that the TLV 1112 * length is large enough but not too large (it doesn't 1113 * go past the end of the containing TLV). 1114 */ 1115 ib = indent_pr(indent, 0); 1116 type = GET_BE_U_2(pdtlv->type); 1117 dp = (const u_char *) TLV_DATA(pdtlv); 1118 1119 if (ndo->ndo_vflag >= 3) 1120 ND_PRINT("%s%s, length %u (data encapsulated %u Bytes)", 1121 ib, tok2str(ForCES_TLV, NULL, type), 1122 tlvl, 1123 tlvl - TLV_HDRL); 1124 1125 if (pdata_print(ndo, dp, tlvl - TLV_HDRL, op_msk, indent + 1) == -1) 1126 return -1; 1127 pdtlv = GO_NXT_TLV(pdtlv, len); 1128 } 1129 1130 if (len) { 1131 ND_PRINT("\n\t\tMessy PATHDATA TLV header, type (0x%x)\n\t\texcess of %u Bytes ", 1132 GET_BE_U_2(pdtlv->type), 1133 len - GET_BE_U_2(pdtlv->length)); 1134 return -1; 1135 } 1136 1137 return 0; 1138} 1139 1140static int 1141invoptlv_print(netdissect_options *ndo, 1142 const u_char * pptr, u_int len, 1143 uint16_t op_msk _U_, int indent) 1144{ 1145 char *ib = indent_pr(indent, 1); 1146 1147 if (ndo->ndo_vflag >= 3) { 1148 ND_PRINT("%sData[", ib + 1); 1149 hex_print(ndo, ib, pptr, len); 1150 ND_PRINT("%s]\n", ib); 1151 } 1152 return -1; 1153} 1154 1155static int 1156otlv_print(netdissect_options *ndo, 1157 const struct forces_tlv *otlv, uint16_t op_msk _U_, int indent) 1158{ 1159 int rc = 0; 1160 const u_char *dp = (const u_char *) TLV_DATA(otlv); 1161 uint16_t type; 1162 u_int tll; 1163 char *ib = indent_pr(indent, 0); 1164 const struct optlv_h *ops; 1165 1166 /* 1167 * lfbselect_print() has ensured that GET_BE_U_2(otlv->length) 1168 * >= TLV_HDRL. 1169 */ 1170 type = GET_BE_U_2(otlv->type); 1171 tll = GET_BE_U_2(otlv->length) - TLV_HDRL; 1172 ops = get_forces_optlv_h(type); 1173 if (ndo->ndo_vflag >= 3) { 1174 ND_PRINT("%sOper TLV %s(0x%x) length %u\n", ib, ops->s, type, 1175 GET_BE_U_2(otlv->length)); 1176 } 1177 /* rest of ops must at least have 12B {pathinfo} */ 1178 if (tll < OP_MIN_SIZ) { 1179 ND_PRINT("\t\tOper TLV %s(0x%x) length %u\n", ops->s, type, 1180 GET_BE_U_2(otlv->length)); 1181 ND_PRINT("\t\tTruncated data size %u minimum required %u\n", tll, 1182 OP_MIN_SIZ); 1183 return invoptlv_print(ndo, dp, tll, ops->op_msk, indent); 1184 1185 } 1186 1187 /* XXX - do anything with ops->flags? */ 1188 if(ops->print) { 1189 rc = ops->print(ndo, dp, tll, ops->op_msk, indent + 1); 1190 } 1191 return rc; 1192} 1193 1194#define ASTDLN 4 1195#define ASTMCD 255 1196static int 1197asttlv_print(netdissect_options *ndo, 1198 const u_char * pptr, u_int len, 1199 uint16_t op_msk _U_, int indent) 1200{ 1201 uint32_t rescode; 1202 u_int dlen; 1203 char *ib = indent_pr(indent, 0); 1204 1205 /* 1206 * forces_type_print() has ensured that len (the TLV length) 1207 * >= TLV_HDRL. 1208 */ 1209 dlen = len - TLV_HDRL; 1210 if (dlen != ASTDLN) { 1211 ND_PRINT("illegal ASTresult-TLV: %u bytes!\n", dlen); 1212 return -1; 1213 } 1214 rescode = GET_BE_U_4(pptr); 1215 if (rescode > ASTMCD) { 1216 ND_PRINT("illegal ASTresult result code: %u!\n", rescode); 1217 return -1; 1218 } 1219 1220 if (ndo->ndo_vflag >= 3) { 1221 ND_PRINT("Teardown reason:\n%s", ib); 1222 switch (rescode) { 1223 case 0: 1224 ND_PRINT("Normal Teardown"); 1225 break; 1226 case 1: 1227 ND_PRINT("Loss of Heartbeats"); 1228 break; 1229 case 2: 1230 ND_PRINT("Out of bandwidth"); 1231 break; 1232 case 3: 1233 ND_PRINT("Out of Memory"); 1234 break; 1235 case 4: 1236 ND_PRINT("Application Crash"); 1237 break; 1238 default: 1239 ND_PRINT("Unknown Teardown reason"); 1240 break; 1241 } 1242 ND_PRINT("(%x)\n%s", rescode, ib); 1243 } 1244 return 0; 1245} 1246 1247#define ASRDLN 4 1248#define ASRMCD 3 1249static int 1250asrtlv_print(netdissect_options *ndo, 1251 const u_char * pptr, u_int len, 1252 uint16_t op_msk _U_, int indent) 1253{ 1254 uint32_t rescode; 1255 u_int dlen; 1256 char *ib = indent_pr(indent, 0); 1257 1258 /* 1259 * forces_type_print() has ensured that len (the TLV length) 1260 * >= TLV_HDRL. 1261 */ 1262 dlen = len - TLV_HDRL; 1263 if (dlen != ASRDLN) { /* id, instance, oper tlv */ 1264 ND_PRINT("illegal ASRresult-TLV: %u bytes!\n", dlen); 1265 return -1; 1266 } 1267 rescode = GET_BE_U_4(pptr); 1268 1269 if (rescode > ASRMCD) { 1270 ND_PRINT("illegal ASRresult result code: %u!\n", rescode); 1271 return -1; 1272 } 1273 1274 if (ndo->ndo_vflag >= 3) { 1275 ND_PRINT("\n%s", ib); 1276 switch (rescode) { 1277 case 0: 1278 ND_PRINT("Success "); 1279 break; 1280 case 1: 1281 ND_PRINT("FE ID invalid "); 1282 break; 1283 case 2: 1284 ND_PRINT("permission denied "); 1285 break; 1286 default: 1287 ND_PRINT("Unknown "); 1288 break; 1289 } 1290 ND_PRINT("(%x)\n%s", rescode, ib); 1291 } 1292 return 0; 1293} 1294 1295#if 0 1296/* 1297 * XXX - not used. 1298 */ 1299static int 1300gentltlv_print(netdissect_options *ndo, 1301 const u_char * pptr _U_, u_int len, 1302 uint16_t op_msk _U_, int indent _U_) 1303{ 1304 u_int dlen = len - TLV_HDRL; 1305 1306 if (dlen < 4) { /* at least 32 bits must exist */ 1307 ND_PRINT("truncated TLV: %u bytes missing! ", 4 - dlen); 1308 return -1; 1309 } 1310 return 0; 1311} 1312#endif 1313 1314#define RD_MIN 8 1315 1316static int 1317print_metailv(netdissect_options *ndo, 1318 const u_char * pptr, uint16_t op_msk _U_, int indent) 1319{ 1320 u_int rlen; 1321 char *ib = indent_pr(indent, 0); 1322 /* XXX: check header length */ 1323 const struct forces_ilv *ilv = (const struct forces_ilv *)pptr; 1324 1325 /* 1326 * print_metatlv() has ensured that len (what remains in the 1327 * ILV) >= ILV_HDRL. 1328 */ 1329 rlen = GET_BE_U_4(ilv->length) - ILV_HDRL; 1330 ND_PRINT("%sMetaID 0x%x length %u\n", ib, GET_BE_U_4(ilv->type), 1331 GET_BE_U_4(ilv->length)); 1332 if (ndo->ndo_vflag >= 3) { 1333 hex_print(ndo, "\t\t[", ILV_DATA(ilv), rlen); 1334 ND_PRINT(" ]\n"); 1335 } 1336 return 0; 1337} 1338 1339static int 1340print_metatlv(netdissect_options *ndo, 1341 const u_char * pptr, u_int len, 1342 uint16_t op_msk _U_, int indent) 1343{ 1344 u_int dlen; 1345 char *ib = indent_pr(indent, 0); 1346 u_int rlen; 1347 const struct forces_ilv *ilv = (const struct forces_ilv *)pptr; 1348 int invilv; 1349 1350 /* 1351 * redirect_print() has ensured that len (what remains in the 1352 * TLV) >= TLV_HDRL. 1353 */ 1354 dlen = len - TLV_HDRL; 1355 rlen = dlen; 1356 ND_PRINT("\n%s METADATA length %u\n", ib, rlen); 1357 while (rlen != 0) { 1358 invilv = ilv_valid(ndo, ilv, rlen); 1359 if (invilv) { 1360 break; 1361 } 1362 1363 /* 1364 * At this point, ilv_valid() has ensured that the ILV 1365 * length is large enough but not too large (it doesn't 1366 * go past the end of the containing TLV). 1367 */ 1368 print_metailv(ndo, (const u_char *) ilv, 0, indent + 1); 1369 ilv = GO_NXT_ILV(ilv, rlen); 1370 } 1371 1372 return 0; 1373} 1374 1375 1376static int 1377print_reddata(netdissect_options *ndo, 1378 const u_char * pptr, u_int len, 1379 uint16_t op_msk _U_, int indent) 1380{ 1381 u_int dlen; 1382 char *ib = indent_pr(indent, 0); 1383 u_int rlen; 1384 1385 dlen = len - TLV_HDRL; 1386 rlen = dlen; 1387 ND_PRINT("\n%s Redirect Data length %u\n", ib, rlen); 1388 1389 if (ndo->ndo_vflag >= 3) { 1390 ND_PRINT("\t\t["); 1391 hex_print(ndo, "\n\t\t", pptr, rlen); 1392 ND_PRINT("\n\t\t]"); 1393 } 1394 1395 return 0; 1396} 1397 1398static int 1399redirect_print(netdissect_options *ndo, 1400 const u_char * pptr, u_int len, 1401 uint16_t op_msk _U_, int indent) 1402{ 1403 const struct forces_tlv *tlv = (const struct forces_tlv *)pptr; 1404 u_int dlen; 1405 u_int rlen; 1406 u_int invtlv; 1407 1408 /* 1409 * forces_type_print() has ensured that len (the TLV length) 1410 * >= TLV_HDRL. 1411 */ 1412 dlen = len - TLV_HDRL; 1413 if (dlen <= RD_MIN) { 1414 ND_PRINT("\n\t\ttruncated Redirect TLV: %u bytes missing! ", 1415 RD_MIN - dlen); 1416 return -1; 1417 } 1418 1419 rlen = dlen; 1420 indent += 1; 1421 while (rlen != 0) { 1422 uint16_t type, tlvl; 1423 1424 type = GET_BE_U_2(tlv->type); 1425 tlvl = GET_BE_U_2(tlv->length); 1426 invtlv = tlv_valid(tlvl, rlen); 1427 if (invtlv) { 1428 ND_PRINT("Bad Redirect data\n"); 1429 break; 1430 } 1431 1432 /* 1433 * At this point, tlv_valid() has ensured that the TLV 1434 * length is large enough but not too large (it doesn't 1435 * go past the end of the containing TLV). 1436 */ 1437 if (type == F_TLV_METD) { 1438 print_metatlv(ndo, (const u_char *) TLV_DATA(tlv), 1439 tlvl, 0, 1440 indent); 1441 } else if (type == F_TLV_REDD) { 1442 print_reddata(ndo, (const u_char *) TLV_DATA(tlv), 1443 tlvl, 0, 1444 indent); 1445 } else { 1446 ND_PRINT("Unknown REDIRECT TLV 0x%x len %u\n", 1447 type, 1448 tlvl); 1449 } 1450 1451 tlv = GO_NXT_TLV(tlv, rlen); 1452 } 1453 1454 if (rlen) { 1455 ND_PRINT("\n\t\tMessy Redirect TLV header, type (0x%x)\n\t\texcess of %u Bytes ", 1456 GET_BE_U_2(tlv->type), 1457 rlen - GET_BE_U_2(tlv->length)); 1458 return -1; 1459 } 1460 1461 return 0; 1462} 1463 1464#define OP_OFF 8 1465#define OP_MIN 12 1466 1467static int 1468lfbselect_print(netdissect_options *ndo, 1469 const u_char * pptr, u_int len, 1470 uint16_t op_msk, int indent) 1471{ 1472 const struct forces_lfbsh *lfbs; 1473 const struct forces_tlv *otlv; 1474 char *ib = indent_pr(indent, 0); 1475 u_int dlen; 1476 u_int rlen; 1477 u_int invtlv; 1478 1479 /* 1480 * forces_type_print() has ensured that len (the TLV length) 1481 * >= TLV_HDRL. 1482 */ 1483 dlen = len - TLV_HDRL; 1484 if (dlen <= OP_MIN) { /* id, instance, oper tlv header .. */ 1485 ND_PRINT("\n\t\ttruncated lfb selector: %u bytes missing! ", 1486 OP_MIN - dlen); 1487 return -1; 1488 } 1489 1490 /* 1491 * At this point, we know that dlen > OP_MIN; OP_OFF < OP_MIN, so 1492 * we also know that it's > OP_OFF. 1493 */ 1494 rlen = dlen - OP_OFF; 1495 1496 lfbs = (const struct forces_lfbsh *)pptr; 1497 ND_TCHECK_SIZE(lfbs); 1498 if (ndo->ndo_vflag >= 3) { 1499 ND_PRINT("\n%s%s(Classid %x) instance %x\n", 1500 ib, 1501 tok2str(ForCES_LFBs, NULL, GET_BE_U_4(lfbs->class)), 1502 GET_BE_U_4(lfbs->class), 1503 GET_BE_U_4(lfbs->instance)); 1504 } 1505 1506 otlv = (const struct forces_tlv *)(lfbs + 1); 1507 1508 indent += 1; 1509 while (rlen != 0) { 1510 uint16_t type, tlvl; 1511 1512 type = GET_BE_U_2(otlv->type); 1513 tlvl = GET_BE_U_2(otlv->length); 1514 invtlv = tlv_valid(tlvl, rlen); 1515 if (invtlv) 1516 break; 1517 1518 /* 1519 * At this point, tlv_valid() has ensured that the TLV 1520 * length is large enough but not too large (it doesn't 1521 * go past the end of the containing TLV). 1522 */ 1523 if (op_valid(type, op_msk)) { 1524 otlv_print(ndo, otlv, 0, indent); 1525 } else { 1526 if (ndo->ndo_vflag < 3) 1527 ND_PRINT("\n"); 1528 ND_PRINT("\t\tINValid oper-TLV type 0x%x length %u for this ForCES message\n", 1529 type, tlvl); 1530 invoptlv_print(ndo, (const u_char *)otlv, rlen, 0, indent); 1531 } 1532 otlv = GO_NXT_TLV(otlv, rlen); 1533 } 1534 1535 if (rlen) { 1536 ND_PRINT("\n\t\tMessy oper TLV header, type (0x%x)\n\t\texcess of %u Bytes ", 1537 GET_BE_U_2(otlv->type), 1538 rlen - GET_BE_U_2(otlv->length)); 1539 return -1; 1540 } 1541 1542 return 0; 1543 1544trunc: 1545 nd_print_trunc(ndo); 1546 return -1; 1547} 1548 1549static int 1550forces_type_print(netdissect_options *ndo, 1551 const u_char * pptr, const struct forcesh *fhdr _U_, 1552 u_int mlen, const struct tom_h *tops) 1553{ 1554 const struct forces_tlv *tltlv; 1555 u_int rlen; 1556 u_int invtlv; 1557 int rc = 0; 1558 u_int ttlv = 0; 1559 1560 /* 1561 * forces_print() has already checked that mlen >= ForCES_HDRL 1562 * by calling ForCES_HLN_VALID(). 1563 */ 1564 rlen = mlen - ForCES_HDRL; 1565 1566 if (rlen > TLV_HLN) { 1567 if (tops->flags & ZERO_TTLV) { 1568 ND_PRINT("<0x%x>Illegal Top level TLV!\n", tops->flags); 1569 return -1; 1570 } 1571 } else { 1572 if (tops->flags & ZERO_MORE_TTLV) 1573 return 0; 1574 if (tops->flags & ONE_MORE_TTLV) { 1575 ND_PRINT("\tTop level TLV Data missing!\n"); 1576 return -1; 1577 } 1578 } 1579 1580 if (tops->flags & ZERO_TTLV) { 1581 return 0; 1582 } 1583 1584 ttlv = tops->flags >> 4; 1585 tltlv = GET_TOP_TLV(pptr); 1586 1587 /*XXX: 15 top level tlvs will probably be fine 1588 You are nuts if you send more ;-> */ 1589 while (rlen != 0) { 1590 uint16_t type, tlvl; 1591 1592 type = GET_BE_U_2(tltlv->type); 1593 tlvl = GET_BE_U_2(tltlv->length); 1594 invtlv = tlv_valid(tlvl, rlen); 1595 if (invtlv) 1596 break; 1597 1598 /* 1599 * At this point, tlv_valid() has ensured that the TLV 1600 * length is large enough but not too large (it doesn't 1601 * go past the end of the packet). 1602 */ 1603 if (!ttlv_valid(type)) { 1604 ND_PRINT("\n\tInvalid ForCES Top TLV type=0x%x", 1605 type); 1606 return -1; 1607 } 1608 1609 if (ndo->ndo_vflag >= 3) 1610 ND_PRINT("\t%s, length %u (data length %u Bytes)", 1611 tok2str(ForCES_TLV, NULL, type), 1612 tlvl, 1613 tlvl - TLV_HDRL); 1614 1615 rc = tops->print(ndo, (const u_char *) TLV_DATA(tltlv), 1616 tlvl, 1617 tops->op_msk, 9); 1618 if (rc < 0) { 1619 return -1; 1620 } 1621 tltlv = GO_NXT_TLV(tltlv, rlen); 1622 ttlv--; 1623 if (ttlv <= 0) 1624 break; 1625 } 1626 /* 1627 * XXX - if ttlv != 0, does that mean that the packet was too 1628 * short, and didn't have *enough* TLVs in it? 1629 */ 1630 if (rlen) { 1631 ND_PRINT("\tMess TopTLV header: min %u, total %u advertised %u ", 1632 TLV_HDRL, rlen, GET_BE_U_2(tltlv->length)); 1633 return -1; 1634 } 1635 1636 return 0; 1637} 1638 1639void 1640forces_print(netdissect_options *ndo, 1641 const u_char * pptr, u_int len) 1642{ 1643 const struct forcesh *fhdr; 1644 u_int mlen; 1645 uint32_t flg_raw; 1646 uint8_t tom; 1647 const struct tom_h *tops; 1648 int rc = 0; 1649 1650 ndo->ndo_protocol = "forces"; 1651 fhdr = (const struct forcesh *)pptr; 1652 ND_TCHECK_SIZE(fhdr); 1653 tom = GET_U_1(fhdr->fm_tom); 1654 if (!tom_valid(tom)) { 1655 ND_PRINT("Invalid ForCES message type %u\n", tom); 1656 goto error; 1657 } 1658 1659 mlen = ForCES_BLN(fhdr); 1660 1661 tops = get_forces_tom(tom); 1662 if (tops->v == TOM_RSVD) { 1663 ND_PRINT("\n\tUnknown ForCES message type=0x%x", tom); 1664 goto error; 1665 } 1666 1667 ND_PRINT("\n\tForCES %s ", tops->s); 1668 if (!ForCES_HLN_VALID(mlen, len)) { 1669 ND_PRINT("Illegal ForCES pkt len - min %u, total recvd %u, advertised %u ", 1670 ForCES_HDRL, len, ForCES_BLN(fhdr)); 1671 goto error; 1672 } 1673 1674 flg_raw = GET_BE_U_4(pptr + 20); 1675 if (ndo->ndo_vflag >= 1) { 1676 ND_PRINT("\n\tForCES Version %u len %uB flags 0x%08x ", 1677 ForCES_V(fhdr), mlen, flg_raw); 1678 ND_PRINT("\n\tSrcID 0x%x(%s) DstID 0x%x(%s) Correlator 0x%" PRIx64, 1679 ForCES_SID(fhdr), ForCES_node(ForCES_SID(fhdr)), 1680 ForCES_DID(fhdr), ForCES_node(ForCES_DID(fhdr)), 1681 GET_BE_U_8(fhdr->fm_cor)); 1682 1683 } 1684 if (ndo->ndo_vflag >= 2) { 1685 ND_PRINT("\n\tForCES flags:\n\t %s(0x%x), prio=%u, %s(0x%x),\n\t %s(0x%x), %s(0x%x)\n", 1686 tok2str(ForCES_ACKs, "ACKUnknown", ForCES_ACK(fhdr)), 1687 ForCES_ACK(fhdr), 1688 ForCES_PRI(fhdr), 1689 tok2str(ForCES_EMs, "EMUnknown", ForCES_EM(fhdr)), 1690 ForCES_EM(fhdr), 1691 tok2str(ForCES_ATs, "ATUnknown", ForCES_AT(fhdr)), 1692 ForCES_AT(fhdr), 1693 tok2str(ForCES_TPs, "TPUnknown", ForCES_TP(fhdr)), 1694 ForCES_TP(fhdr)); 1695 ND_PRINT("\t Extra flags: rsv(b5-7) 0x%x rsv(b13-31) 0x%x\n", 1696 ForCES_RS1(fhdr), ForCES_RS2(fhdr)); 1697 } 1698 rc = forces_type_print(ndo, pptr, fhdr, mlen, tops); 1699 if (rc < 0) { 1700error: 1701 hex_print(ndo, "\n\t[", pptr, len); 1702 ND_PRINT("\n\t]"); 1703 return; 1704 } 1705 1706 if (ndo->ndo_vflag >= 4) { 1707 ND_PRINT("\n\t Raw ForCES message\n\t ["); 1708 hex_print(ndo, "\n\t ", pptr, len); 1709 ND_PRINT("\n\t ]"); 1710 } 1711 return; 1712 1713trunc: 1714 nd_print_trunc(ndo); 1715} 1716