(/home/sate/Testcases/c/cve/wireshark-1.2.0/epan/dissectors/packet-ncp2222.inc) |
| |
| 9328 | | | dissect_nds_request(tvbuff_t *tvb, packet_info *pinfo, |
| 9329 | | | guint32 nw_connection, guint8 sequence, |
| 9330 | | | guint16 type, proto_tree *ncp_tree) |
| 9331 | | | { |
| 9332 | | | guint8 func, subfunc = 0; |
| 9333 | | | ncp_req_hash_value *request_value = NULL; |
| 9334 | | | ncp_req_eid_hash_value *request_eid_value = NULL; |
| 9335 | | | const ncp_record *ncp_rec = NULL; |
| 9336 | | | conversation_t *conversation; |
| 9337 | | | ptvcursor_t *ptvc = NULL; |
| 9338 | | | proto_tree *temp_tree = NULL; |
| 9339 | | | gboolean run_req_cond = FALSE; |
| 9340 | | | gboolean run_info_str = FALSE; |
| 9341 | | | guint8 nds_verb = 0; |
| 9342 | | | const char *verb_string = ""; |
| 9343 | | | guint32 nds_frag = 0; |
| 9344 | | | gboolean added_arrow; |
| 9345 | | | nds_val pvalues[9], prot_flags[1]; |
| 9346 | | | guint8 nds_version = 0; |
| 9347 | | | guint32 foffset = 0; |
| 9348 | | | char global_object_name[256]; |
| 9349 | | | guint32 global_eid=0; |
| 9350 | | | gboolean resolve_eid=FALSE; |
| 9351 | | | guint32 global_flags=0, nds_prot_flags=0; |
| 9352 | | | int i; |
| 9353 | | | |
| 9354 | | | for (i = 0; i < 9; i++) { |
| 9355 | | | pvalues[i].vtype = 0; |
| 9356 | | | pvalues[i].vvalue = 0; |
| 9357 | | | pvalues[i].vlength = 0; |
| 9358 | | | pvalues[i].voffset = 0; |
| 9359 | | | pvalues[i].hfname = 0; |
| 9360 | | | pvalues[i].vdesc = ""; |
| 9361 | | | pvalues[i].vstring = NULL; |
| 9362 | | | pvalues[i].mvtype = 0; |
| 9363 | | | pvalues[i].vflags = 0; |
| 9364 | | | } |
| 9365 | | | |
| 9366 | | | global_object_name[0] = '\0'; |
| 9367 | | | |
| 9368 | | | func = tvb_get_guint8(tvb, 6); |
| 9369 | | | subfunc = tvb_get_guint8(tvb, 7); |
| 9370 | | | |
| 9371 | | | ncp_rec = ncp_record_find(func, subfunc); |
| 9372 | | | |
| 9373 | | | |
| 9374 | | | nds_frag = tvb_get_letohl(tvb, 8); |
| 9375 | | | |
| 9376 | | | |
| 9377 | | | if (nds_frag == 0xffffffff) { |
| 9378 | | | |
| 9379 | | | nds_verb = tvb_get_guint8(tvb, 24); |
| 9380 | | | if (nds_verb == 0xfe) |
| 9381 | | | { |
| 9382 | | | nds_version = nds_verb; |
| 9383 | | | nds_verb = tvb_get_guint8(tvb, 32); |
| 9384 | | | foffset = 36; |
| 9385 | | | } |
| 9386 | | | else |
| 9387 | | | { |
| 9388 | | | nds_version = 0; |
| 9389 | | | foffset = 28; |
| 9390 | | | } |
| 9391 | | | if (type == NCP_SERVICE_REQUEST) { |
| 9392 | | | proto_tree_add_item(ncp_tree, hf_nds_buffer_size, tvb, foffset, |
| 9393 | | | 4, TRUE); |
| 9394 | | | } |
| 9395 | | | foffset = foffset+4; |
| 9396 | | | verb_string = val_to_str(nds_verb, ncp_nds_verb_vals, |
| 9397 | | | "Continuation Fragment"); |
Ignored Return Value
The return value of val_to_str() is never checked in the highlighted execution scenario. - If the return value can indicate an error, the error will be ignored if the highlighted code executes.
- The return value of val_to_str() is checked 98% of the time in this project. CodeSonar is configured to enforce Ignored Return Value checks for any function whose return value is checked at least 96% of the time, unless the function is used fewer than 20 times. (To modify these thresholds, use configuration file parameters RETURN_CHECKER_SAMPLE_SIZE and RETURN_CHECKER_RATIO. To exempt val_to_str() from the Ignored Return Value check, use configuration file parameter RETURN_CHECKER_IGNORED_FUNCS).
Show: All events | Only primary events |
|
| 9398 | | | switch(nds_verb) { |
Event 2:
nds_verb evaluates to 5.
hide
|
|
| 9399 | | | |
| 9400 | | | case 0x01: |
| 9401 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 9402 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 9403 | | | pvalues[0].vdesc = "Version: %u"; |
| 9404 | | | pvalues[0].vlength = 4; |
| 9405 | | | pvalues[0].hfname = hf_nds_ver; |
| 9406 | | | pvalues[0].voffset = foffset; |
| 9407 | | | foffset = foffset+pvalues[0].vlength; |
| 9408 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9409 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 9410 | | | pvalues[1].vdesc = "Flags:"; |
| 9411 | | | pvalues[1].vlength = 2; |
| 9412 | | | pvalues[1].hfname= hf_nds_nflags; |
| 9413 | | | pvalues[1].voffset = foffset; |
| 9414 | | | pvalues[1].bit1 = "Entry ID"; |
| 9415 | | | pvalues[1].bit1hfname = hf_bit1nflags; |
| 9416 | | | pvalues[1].bit2 = "Readable"; |
| 9417 | | | pvalues[1].bit2hfname = hf_bit2nflags; |
| 9418 | | | pvalues[1].bit3 = "Writeable"; |
| 9419 | | | pvalues[1].bit3hfname = hf_bit3nflags; |
| 9420 | | | pvalues[1].bit4 = "Master"; |
| 9421 | | | pvalues[1].bit4hfname = hf_bit4nflags; |
| 9422 | | | pvalues[1].bit5 = "Create ID"; |
| 9423 | | | pvalues[1].bit5hfname = hf_bit5nflags; |
| 9424 | | | pvalues[1].bit6 = "Walk Tree"; |
| 9425 | | | pvalues[1].bit6hfname = hf_bit6nflags; |
| 9426 | | | pvalues[1].bit7 = "Dereference Alias"; |
| 9427 | | | pvalues[1].bit7hfname = hf_bit7nflags; |
| 9428 | | | pvalues[1].bit8 = "Not Defined"; |
| 9429 | | | pvalues[1].bit8hfname = hf_bit8nflags; |
| 9430 | | | pvalues[1].bit9 = "Not Defined"; |
| 9431 | | | pvalues[1].bit9hfname = hf_bit9nflags; |
| 9432 | | | pvalues[1].bit10 = "Not Defined"; |
| 9433 | | | pvalues[1].bit10hfname = hf_bit10nflags; |
| 9434 | | | pvalues[1].bit11= "Not Defined"; |
| 9435 | | | pvalues[1].bit11hfname = hf_bit11nflags; |
| 9436 | | | pvalues[1].bit12 = "Not Defined"; |
| 9437 | | | pvalues[1].bit12hfname = hf_bit12nflags; |
| 9438 | | | pvalues[1].bit13 = "Not Defined"; |
| 9439 | | | pvalues[1].bit13hfname = hf_bit13nflags; |
| 9440 | | | pvalues[1].bit14 = "Prefer Referrals"; |
| 9441 | | | pvalues[1].bit14hfname = hf_bit14nflags; |
| 9442 | | | pvalues[1].bit15 = "Prefer Only Referrals"; |
| 9443 | | | pvalues[1].bit15hfname = hf_bit15nflags; |
| 9444 | | | pvalues[1].bit16 = "Not Defined"; |
| 9445 | | | pvalues[1].bit16hfname = hf_bit16nflags; |
| 9446 | | | foffset = foffset+4; |
| 9447 | | | if (pvalues[0].vvalue == 0 || pvalues[0].vvalue == 1) |
| 9448 | | | { |
| 9449 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 9450 | | | pvalues[2].vdesc = "Scope: %u"; |
| 9451 | | | pvalues[2].vlength = 4; |
| 9452 | | | pvalues[2].voffset = foffset; |
| 9453 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 9454 | | | pvalues[2].hfname= hf_nds_scope; |
| 9455 | | | foffset = foffset+pvalues[2].vlength; |
| 9456 | | | pvalues[3].vtype = VTYPE_STRING; |
| 9457 | | | pvalues[3].vdesc = "Name: %s"; |
| 9458 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 9459 | | | pvalues[3].vvalue = 0; |
| 9460 | | | pvalues[3].vlength = 256; |
| 9461 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 9462 | | | if (pvalues[3].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 9463 | | | { |
| 9464 | | | pvalues[3].vtype = VTYPE_NONE; |
| 9465 | | | break; |
| 9466 | | | } |
| 9467 | | | pvalues[3].voffset = foffset+4; |
| 9468 | | | foffset = foffset + 4; |
| 9469 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 9470 | | | g_strlcpy(global_object_name, pvalues[3].vstring, 256); |
| 9471 | | | pvalues[3].hfname= hf_nds_name; |
| 9472 | | | foffset = foffset+pvalues[3].vlength; |
| 9473 | | | foffset += align_4(tvb, foffset); |
| 9474 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 9475 | | | pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9476 | | | pvalues[4].vdesc = "Communications Transports: %u"; |
| 9477 | | | pvalues[4].vlength = 4; |
| 9478 | | | pvalues[4].hfname= hf_nds_comm_trans; |
| 9479 | | | pvalues[4].voffset = foffset; |
| 9480 | | | pvalues[4].mvtype = MVTYPE_ADDR_REFERRAL_REQUEST; |
| 9481 | | | foffset = foffset + (pvalues[4].vvalue * 4) + 4; |
| 9482 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 9483 | | | pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9484 | | | pvalues[5].vdesc = "Tree Walker Transport Type: %u"; |
| 9485 | | | pvalues[5].vlength = 4; |
| 9486 | | | pvalues[5].mvtype = MVTYPE_ADDR_REFERRAL_REQUEST; |
| 9487 | | | pvalues[5].hfname= hf_nds_tree_trans; |
| 9488 | | | pvalues[5].voffset = foffset; |
| 9489 | | | } |
| 9490 | | | else |
| 9491 | | | { |
| 9492 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 9493 | | | pvalues[2].vdesc = "Minimum DS Version: %u"; |
| 9494 | | | pvalues[2].vlength = 4; |
| 9495 | | | pvalues[2].voffset = foffset; |
| 9496 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 9497 | | | pvalues[2].hfname= hf_min_nds_ver; |
| 9498 | | | foffset = foffset+pvalues[2].vlength; |
| 9499 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 9500 | | | pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9501 | | | pvalues[3].vdesc = "Number of Versions to Include: %u"; |
| 9502 | | | pvalues[3].vlength = 4; |
| 9503 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST2; |
| 9504 | | | pvalues[3].voffset = foffset; |
| 9505 | | | pvalues[3].hfname= hf_nds_ver_include; |
| 9506 | | | foffset += (pvalues[3].vvalue * 4) + 4; |
| 9507 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 9508 | | | pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9509 | | | pvalues[4].vdesc = "Number of Versions to Exclude: %u"; |
| 9510 | | | pvalues[4].vlength = 4; |
| 9511 | | | pvalues[4].mvtype = MVTYPE_ATTR_REQUEST2; |
| 9512 | | | pvalues[4].hfname= hf_nds_ver_exclude; |
| 9513 | | | pvalues[4].voffset = foffset; |
| 9514 | | | foffset += 4; |
| 9515 | | | pvalues[5].vtype = VTYPE_UINT32; |
| 9516 | | | pvalues[5].vdesc = "DN Output Type: %u"; |
| 9517 | | | pvalues[5].vlength = 4; |
| 9518 | | | pvalues[5].voffset = foffset; |
| 9519 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 9520 | | | pvalues[5].hfname= hf_nds_dn_output_type; |
| 9521 | | | foffset = foffset+pvalues[5].vlength; |
| 9522 | | | pvalues[6].vtype = VTYPE_UINT32; |
| 9523 | | | pvalues[6].vdesc = "Nested Output Type: %u"; |
| 9524 | | | pvalues[6].vlength = 4; |
| 9525 | | | pvalues[6].voffset = foffset; |
| 9526 | | | pvalues[6].vvalue = tvb_get_letohl(tvb, foffset); |
| 9527 | | | pvalues[6].hfname= hf_nds_nested_output_type; |
| 9528 | | | foffset = foffset+pvalues[6].vlength; |
| 9529 | | | pvalues[7].vtype = VTYPE_STRING; |
| 9530 | | | pvalues[7].vdesc = "Output Delimiter: %s"; |
| 9531 | | | pvalues[7].mvtype = MVTYPE_ATTR_REQUEST; |
| 9532 | | | pvalues[7].vvalue = 0; |
| 9533 | | | pvalues[7].vlength = 256; |
| 9534 | | | pvalues[7].vlength = tvb_get_letohl(tvb, foffset); |
| 9535 | | | pvalues[7].voffset = foffset+4; |
| 9536 | | | foffset = foffset + 4; |
| 9537 | | | pvalues[7].vstring = get_string(tvb, pvalues[7].voffset, pvalues[7].vlength); |
| 9538 | | | pvalues[7].hfname= hf_nds_output_delimiter; |
| 9539 | | | foffset = foffset+pvalues[7].vlength; |
| 9540 | | | foffset += align_4(tvb, foffset); |
| 9541 | | | pvalues[8].vvalue = tvb_get_letohl(tvb, foffset); |
| 9542 | | | pvalues[8].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9543 | | | pvalues[8].vdesc = "Size of Entry Specifier: %u"; |
| 9544 | | | pvalues[8].vlength = 4; |
| 9545 | | | pvalues[8].mvtype = MVTYPE_PROC_ENTRY_SPECIFIERS; |
| 9546 | | | pvalues[8].hfname= hf_nds_output_entry_specifier; |
| 9547 | | | pvalues[8].voffset = foffset; |
| 9548 | | | } |
| 9549 | | | break; |
| 9550 | | | case 0x02: |
| 9551 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 9552 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 9553 | | | pvalues[0].vdesc = "Version: %u"; |
| 9554 | | | pvalues[0].vlength = 4; |
| 9555 | | | pvalues[0].voffset = foffset; |
| 9556 | | | pvalues[0].hfname= hf_nds_ver; |
| 9557 | | | foffset = foffset+pvalues[0].vlength; |
| 9558 | | | switch(pvalues[0].vvalue) |
| 9559 | | | { |
| 9560 | | | case 0: |
| 9561 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9562 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 9563 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 9564 | | | pvalues[1].vlength = 4; |
| 9565 | | | resolve_eid = TRUE; |
| 9566 | | | global_eid = pvalues[1].vvalue; |
| 9567 | | | pvalues[1].voffset = foffset; |
| 9568 | | | pvalues[1].hfname = hf_nds_eid; |
| 9569 | | | foffset = foffset+pvalues[1].vlength; |
| 9570 | | | break; |
| 9571 | | | case 1: |
| 9572 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9573 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 9574 | | | pvalues[1].vdesc = "Request Flags:"; |
| 9575 | | | pvalues[1].vlength = 2; |
| 9576 | | | pvalues[1].hfname= hf_nds_rflags; |
| 9577 | | | pvalues[1].voffset = foffset; |
| 9578 | | | pvalues[1].bit1 = "Typeless"; |
| 9579 | | | pvalues[1].bit1hfname = hf_bit1rflags; |
| 9580 | | | pvalues[1].bit2 = "Slashed"; |
| 9581 | | | pvalues[1].bit2hfname = hf_bit2rflags; |
| 9582 | | | pvalues[1].bit3 = "Dotted"; |
| 9583 | | | pvalues[1].bit3hfname = hf_bit3rflags; |
| 9584 | | | pvalues[1].bit4 = "Tuned"; |
| 9585 | | | pvalues[1].bit4hfname = hf_bit4rflags; |
| 9586 | | | pvalues[1].bit5 = "Not Defined"; |
| 9587 | | | pvalues[1].bit5hfname = hf_bit5rflags; |
| 9588 | | | pvalues[1].bit6 = "Not Defined"; |
| 9589 | | | pvalues[1].bit6hfname = hf_bit6rflags; |
| 9590 | | | pvalues[1].bit7 = "Not Defined"; |
| 9591 | | | pvalues[1].bit7hfname = hf_bit7rflags; |
| 9592 | | | pvalues[1].bit8 = "Not Defined"; |
| 9593 | | | pvalues[1].bit8hfname = hf_bit8rflags; |
| 9594 | | | pvalues[1].bit9 = "Not Defined"; |
| 9595 | | | pvalues[1].bit9hfname = hf_bit9rflags; |
| 9596 | | | pvalues[1].bit10 = "Not Defined"; |
| 9597 | | | pvalues[1].bit10hfname = hf_bit10rflags; |
| 9598 | | | pvalues[1].bit11 = "Not Defined"; |
| 9599 | | | pvalues[1].bit11hfname = hf_bit11rflags; |
| 9600 | | | pvalues[1].bit12 = "Not Defined"; |
| 9601 | | | pvalues[1].bit12hfname = hf_bit12rflags; |
| 9602 | | | pvalues[1].bit13 = "Not Defined"; |
| 9603 | | | pvalues[1].bit13hfname = hf_bit13rflags; |
| 9604 | | | pvalues[1].bit14 = "Not Defined"; |
| 9605 | | | pvalues[1].bit14hfname = hf_bit14rflags; |
| 9606 | | | pvalues[1].bit15 = "Not Defined"; |
| 9607 | | | pvalues[1].bit15hfname = hf_bit15rflags; |
| 9608 | | | pvalues[1].bit16 = "Not Defined"; |
| 9609 | | | pvalues[1].bit16hfname = hf_bit16rflags; |
| 9610 | | | if((pvalues[1].vvalue&&0xf000) == 0xc000) |
| 9611 | | | { |
| 9612 | | | pvalues[2].vtype = VTYPE_STRING; |
| 9613 | | | pvalues[2].vdesc = "Name Type: %s"; |
| 9614 | | | pvalues[2].vstring = "Partial"; |
| 9615 | | | pvalues[2].mvtype = 0; |
| 9616 | | | pvalues[2].vvalue = 0; |
| 9617 | | | pvalues[2].vlength = 0; |
| 9618 | | | pvalues[2].voffset = 0; |
| 9619 | | | pvalues[2].hfname= hf_nds_name_type; |
| 9620 | | | } |
| 9621 | | | else |
| 9622 | | | { |
| 9623 | | | pvalues[2].vtype = VTYPE_STRING; |
| 9624 | | | pvalues[2].vdesc = "Name Type: %s"; |
| 9625 | | | pvalues[2].vstring = "Full"; |
| 9626 | | | pvalues[2].vvalue = 0; |
| 9627 | | | pvalues[2].mvtype = 0; |
| 9628 | | | pvalues[2].vlength = 0; |
| 9629 | | | pvalues[2].voffset = 0; |
| 9630 | | | pvalues[2].hfname= hf_nds_name_type; |
| 9631 | | | } |
| 9632 | | | foffset = foffset+4; |
| 9633 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 9634 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 9635 | | | pvalues[3].vdesc = "Entry ID: 0x%08x"; |
| 9636 | | | pvalues[3].vlength = 4; |
| 9637 | | | pvalues[3].voffset = foffset; |
| 9638 | | | resolve_eid = TRUE; |
| 9639 | | | global_eid = pvalues[3].vvalue; |
| 9640 | | | pvalues[3].hfname = hf_nds_eid; |
| 9641 | | | foffset = foffset+pvalues[3].vlength; |
| 9642 | | | break; |
| 9643 | | | case 2: |
| 9644 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9645 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 9646 | | | pvalues[1].vdesc = "Request Flags:"; |
| 9647 | | | pvalues[1].vlength = 2; |
| 9648 | | | pvalues[1].hfname= hf_nds_rflags; |
| 9649 | | | pvalues[1].voffset = foffset; |
| 9650 | | | pvalues[1].bit1 = "Typeless"; |
| 9651 | | | pvalues[1].bit1hfname = hf_bit1rflags; |
| 9652 | | | pvalues[1].bit2 = "Slashed"; |
| 9653 | | | pvalues[1].bit2hfname = hf_bit2rflags; |
| 9654 | | | pvalues[1].bit3 = "Dotted"; |
| 9655 | | | pvalues[1].bit3hfname = hf_bit3rflags; |
| 9656 | | | pvalues[1].bit4 = "Tuned"; |
| 9657 | | | pvalues[1].bit4hfname = hf_bit4rflags; |
| 9658 | | | pvalues[1].bit5 = "Not Defined"; |
| 9659 | | | pvalues[1].bit5hfname = hf_bit5rflags; |
| 9660 | | | pvalues[1].bit6 = "Not Defined"; |
| 9661 | | | pvalues[1].bit6hfname = hf_bit6rflags; |
| 9662 | | | pvalues[1].bit7 = "Not Defined"; |
| 9663 | | | pvalues[1].bit7hfname = hf_bit7rflags; |
| 9664 | | | pvalues[1].bit8 = "Not Defined"; |
| 9665 | | | pvalues[1].bit8hfname = hf_bit8rflags; |
| 9666 | | | pvalues[1].bit9 = "Not Defined"; |
| 9667 | | | pvalues[1].bit9hfname = hf_bit9rflags; |
| 9668 | | | pvalues[1].bit10 = "Not Defined"; |
| 9669 | | | pvalues[1].bit10hfname = hf_bit10rflags; |
| 9670 | | | pvalues[1].bit11 = "Not Defined"; |
| 9671 | | | pvalues[1].bit11hfname = hf_bit11rflags; |
| 9672 | | | pvalues[1].bit12 = "Not Defined"; |
| 9673 | | | pvalues[1].bit12hfname = hf_bit12rflags; |
| 9674 | | | pvalues[1].bit13 = "Not Defined"; |
| 9675 | | | pvalues[1].bit13hfname = hf_bit13rflags; |
| 9676 | | | pvalues[1].bit14 = "Not Defined"; |
| 9677 | | | pvalues[1].bit14hfname = hf_bit14rflags; |
| 9678 | | | pvalues[1].bit15 = "Not Defined"; |
| 9679 | | | pvalues[1].bit15hfname = hf_bit15rflags; |
| 9680 | | | pvalues[1].bit16 = "Not Defined"; |
| 9681 | | | pvalues[1].bit16hfname = hf_bit16rflags; |
| 9682 | | | if((pvalues[1].vvalue&&0xf000) == 0xc000) |
| 9683 | | | { |
| 9684 | | | pvalues[2].vtype = VTYPE_STRING; |
| 9685 | | | pvalues[2].vdesc = "Name Type: %s"; |
| 9686 | | | pvalues[2].vstring = "Return Partion Name"; |
| 9687 | | | pvalues[2].vvalue = 0; |
| 9688 | | | pvalues[2].vlength = 4; |
| 9689 | | | pvalues[2].voffset = pvalues[1].voffset; |
| 9690 | | | pvalues[2].mvtype = 0; |
| 9691 | | | pvalues[2].hfname= hf_nds_name_type; |
| 9692 | | | } |
| 9693 | | | else |
| 9694 | | | { |
| 9695 | | | pvalues[2].vtype = VTYPE_STRING; |
| 9696 | | | pvalues[2].vdesc = "Name Type: %s"; |
| 9697 | | | pvalues[2].vstring = "Return Full Name"; |
| 9698 | | | pvalues[2].vvalue = 0; |
| 9699 | | | pvalues[2].vlength = 4; |
| 9700 | | | pvalues[2].mvtype = 0; |
| 9701 | | | pvalues[2].voffset = pvalues[1].voffset; |
| 9702 | | | pvalues[2].hfname= hf_nds_name_type; |
| 9703 | | | } |
| 9704 | | | foffset = foffset+4; |
| 9705 | | | pvalues[3].vvalue = tvb_get_letohs(tvb, foffset); |
| 9706 | | | global_flags = tvb_get_letohl(tvb, foffset); |
| 9707 | | | pvalues[3].vtype = VTYPE_BITFIELD; |
| 9708 | | | pvalues[3].vdesc = "Information Flags (low) Byte:"; |
| 9709 | | | pvalues[3].vlength = 2; |
| 9710 | | | pvalues[3].hfname= hf_nds_rflags; |
| 9711 | | | pvalues[3].voffset = foffset; |
| 9712 | | | pvalues[3].bit1 = "Output Flags"; |
| 9713 | | | pvalues[3].bit1hfname = hf_bit1infoflagsl; |
| 9714 | | | pvalues[3].bit2 = "Entry ID"; |
| 9715 | | | pvalues[3].bit2hfname = hf_bit2infoflagsl; |
| 9716 | | | pvalues[3].bit3 = "Entry Flags"; |
| 9717 | | | pvalues[3].bit3hfname = hf_bit3infoflagsl; |
| 9718 | | | pvalues[3].bit4 = "Subordinate Count"; |
| 9719 | | | pvalues[3].bit4hfname = hf_bit4infoflagsl; |
| 9720 | | | pvalues[3].bit5 = "Modification Time"; |
| 9721 | | | pvalues[3].bit5hfname = hf_bit5infoflagsl; |
| 9722 | | | pvalues[3].bit6 = "Modification Timestamp"; |
| 9723 | | | pvalues[3].bit6hfname = hf_bit6infoflagsl; |
| 9724 | | | pvalues[3].bit7 = "Creation Timestamp"; |
| 9725 | | | pvalues[3].bit7hfname = hf_bit7infoflagsl; |
| 9726 | | | pvalues[3].bit8 = "Partition Root ID"; |
| 9727 | | | pvalues[3].bit8hfname = hf_bit8infoflagsl; |
| 9728 | | | pvalues[3].bit9 = "Parent ID"; |
| 9729 | | | pvalues[3].bit9hfname = hf_bit9infoflagsl; |
| 9730 | | | pvalues[3].bit10 = "Revision Count"; |
| 9731 | | | pvalues[3].bit10hfname = hf_bit10infoflagsl; |
| 9732 | | | pvalues[3].bit11 = "Replica Type"; |
| 9733 | | | pvalues[3].bit11hfname = hf_bit11infoflagsl; |
| 9734 | | | pvalues[3].bit12 = "Base Class"; |
| 9735 | | | pvalues[3].bit12hfname = hf_bit12infoflagsl; |
| 9736 | | | pvalues[3].bit13 = "Relative Distinguished Name"; |
| 9737 | | | pvalues[3].bit13hfname = hf_bit13infoflagsl; |
| 9738 | | | pvalues[3].bit14 = "Distinguished Name"; |
| 9739 | | | pvalues[3].bit14hfname = hf_bit14infoflagsl; |
| 9740 | | | pvalues[3].bit15 = "Root Distinguished Name"; |
| 9741 | | | pvalues[3].bit15hfname = hf_bit15infoflagsl; |
| 9742 | | | pvalues[3].bit16 = "Parent Distinguished Name"; |
| 9743 | | | pvalues[3].bit16hfname = hf_bit16infoflagsl; |
| 9744 | | | foffset = foffset+2; |
| 9745 | | | pvalues[4].vvalue = tvb_get_letohs(tvb, foffset); |
| 9746 | | | pvalues[4].vtype = VTYPE_BITFIELD; |
| 9747 | | | pvalues[4].vdesc = "Information Flags (high) Byte:"; |
| 9748 | | | pvalues[4].vlength = 2; |
| 9749 | | | pvalues[4].hfname= hf_nds_rflags; |
| 9750 | | | pvalues[4].voffset = foffset; |
| 9751 | | | pvalues[4].bit1 = "Purge Time"; |
| 9752 | | | pvalues[4].bit1hfname = hf_bit1infoflagsh; |
| 9753 | | | pvalues[4].bit2 = "Dereference Base Class"; |
| 9754 | | | pvalues[4].bit2hfname = hf_bit2infoflagsh; |
| 9755 | | | pvalues[4].bit3 = "Replica Number"; |
| 9756 | | | pvalues[4].bit3hfname = hf_bit3infoflagsh; |
| 9757 | | | pvalues[4].bit4 = "Replica State"; |
| 9758 | | | pvalues[4].bit4hfname = hf_bit4infoflagsh; |
| 9759 | | | pvalues[4].bit5 = "Federation Boundary"; |
| 9760 | | | pvalues[4].bit5hfname = hf_bit5infoflagsh; |
| 9761 | | | pvalues[4].bit6 = "Schema Boundary"; |
| 9762 | | | pvalues[4].bit6hfname = hf_bit6infoflagsh; |
| 9763 | | | pvalues[4].bit7 = "Federation Boundary ID"; |
| 9764 | | | pvalues[4].bit7hfname = hf_bit7infoflagsh; |
| 9765 | | | pvalues[4].bit8 = "Schema Boundary ID"; |
| 9766 | | | pvalues[4].bit8hfname = hf_bit8infoflagsh; |
| 9767 | | | pvalues[4].bit9 = "Current Subcount"; |
| 9768 | | | pvalues[4].bit9hfname = hf_bit9infoflagsh; |
| 9769 | | | pvalues[4].bit10 = "Local Entry Flags"; |
| 9770 | | | pvalues[4].bit10hfname = hf_bit10infoflagsh; |
| 9771 | | | pvalues[4].bit11 = "Not Defined"; |
| 9772 | | | pvalues[4].bit11hfname = hf_bit11infoflagsh; |
| 9773 | | | pvalues[4].bit12 = "Not Defined"; |
| 9774 | | | pvalues[4].bit12hfname = hf_bit12infoflagsh; |
| 9775 | | | pvalues[4].bit13 = "Not Defined"; |
| 9776 | | | pvalues[4].bit13hfname = hf_bit13infoflagsh; |
| 9777 | | | pvalues[4].bit14 = "Not Defined"; |
| 9778 | | | pvalues[4].bit14hfname = hf_bit14infoflagsh; |
| 9779 | | | pvalues[4].bit15 = "Not Defined"; |
| 9780 | | | pvalues[4].bit15hfname = hf_bit15infoflagsh; |
| 9781 | | | pvalues[4].bit16 = "Not Defined"; |
| 9782 | | | pvalues[4].bit16hfname = hf_bit16infoflagsh; |
| 9783 | | | foffset = foffset+2; |
| 9784 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 9785 | | | pvalues[5].vtype = VTYPE_UINT32; |
| 9786 | | | pvalues[5].vdesc = "Entry ID: 0x%08x"; |
| 9787 | | | pvalues[5].vlength = 4; |
| 9788 | | | pvalues[5].voffset = foffset; |
| 9789 | | | resolve_eid = TRUE; |
| 9790 | | | global_eid = pvalues[5].vvalue; |
| 9791 | | | pvalues[5].hfname = hf_nds_eid; |
| 9792 | | | foffset = foffset+pvalues[5].vlength; |
| 9793 | | | break; |
| 9794 | | | default: |
| 9795 | | | break; |
| 9796 | | | } |
| 9797 | | | |
| 9798 | | | break; |
| 9799 | | | case 0x03: |
| 9800 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 9801 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 9802 | | | pvalues[0].vdesc = "Version: %u"; |
| 9803 | | | pvalues[0].vlength = 4; |
| 9804 | | | pvalues[0].voffset = foffset; |
| 9805 | | | pvalues[0].hfname= hf_nds_ver; |
| 9806 | | | foffset = foffset+pvalues[0].vlength; |
| 9807 | | | if(pvalues[0].vvalue == 0) |
| 9808 | | | { |
| 9809 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9810 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 9811 | | | pvalues[1].vdesc = "Iteration Handle: 0x%08x"; |
| 9812 | | | pvalues[1].vlength = 4; |
| 9813 | | | pvalues[1].voffset = foffset; |
| 9814 | | | pvalues[1].hfname= hf_nds_iteration; |
| 9815 | | | foffset = foffset+pvalues[1].vlength; |
| 9816 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 9817 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 9818 | | | pvalues[2].vdesc = "Entry ID: 0x%08x"; |
| 9819 | | | pvalues[2].vlength = 4; |
| 9820 | | | resolve_eid = TRUE; |
| 9821 | | | global_eid = pvalues[2].vvalue; |
| 9822 | | | pvalues[2].voffset = foffset; |
| 9823 | | | pvalues[2].hfname= hf_nds_eid; |
| 9824 | | | foffset = foffset+pvalues[2].vlength; |
| 9825 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 9826 | | | pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, nds_info_type); |
| 9827 | | | global_flags = pvalues[3].vvalue; |
| 9828 | | | if(pvalues[3].vstring == NULL) |
| 9829 | | | { |
| 9830 | | | pvalues[3].vstring = "No Info Type Set"; |
| 9831 | | | } |
| 9832 | | | pvalues[3].vtype = VTYPE_STRING; |
| 9833 | | | pvalues[3].vdesc = "Info Type: %s"; |
| 9834 | | | pvalues[3].vlength = 4; |
| 9835 | | | pvalues[3].voffset = foffset; |
| 9836 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 9837 | | | pvalues[3].hfname= hf_nds_info_type; |
| 9838 | | | foffset = foffset + pvalues[3].vlength; |
| 9839 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 9840 | | | pvalues[4].vtype = VTYPE_UINT32; |
| 9841 | | | pvalues[4].vdesc = "All Attributes: %u"; |
| 9842 | | | pvalues[4].vlength = 4; |
| 9843 | | | pvalues[4].voffset = foffset; |
| 9844 | | | pvalues[4].hfname= hf_nds_all_attr; |
| 9845 | | | foffset = foffset+pvalues[4].vlength; |
| 9846 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 9847 | | | pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9848 | | | pvalues[5].vdesc = "Attributes: %u"; |
| 9849 | | | pvalues[5].vlength = 4; |
| 9850 | | | pvalues[5].voffset = foffset; |
| 9851 | | | pvalues[5].mvtype = MVTYPE_ATTR_REQUEST; |
| 9852 | | | pvalues[5].hfname= hf_nds_attr; |
| 9853 | | | } |
| 9854 | | | else |
| 9855 | | | { |
| 9856 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9857 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 9858 | | | pvalues[1].vdesc = "Request Flags: 0x%08x"; |
| 9859 | | | pvalues[1].vlength = 4; |
| 9860 | | | pvalues[1].voffset = foffset; |
| 9861 | | | pvalues[1].hfname= hf_nds_req_flags; |
| 9862 | | | foffset = foffset+pvalues[1].vlength; |
| 9863 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 9864 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 9865 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 9866 | | | pvalues[2].vlength = 4; |
| 9867 | | | pvalues[2].voffset = foffset; |
| 9868 | | | pvalues[2].hfname= hf_nds_iteration; |
| 9869 | | | foffset = foffset+pvalues[2].vlength; |
| 9870 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 9871 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 9872 | | | pvalues[3].vdesc = "Entry ID: 0x%08x"; |
| 9873 | | | pvalues[3].vlength = 4; |
| 9874 | | | resolve_eid = TRUE; |
| 9875 | | | global_eid = pvalues[3].vvalue; |
| 9876 | | | pvalues[3].voffset = foffset; |
| 9877 | | | pvalues[3].hfname= hf_nds_eid; |
| 9878 | | | foffset = foffset+pvalues[3].vlength; |
| 9879 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 9880 | | | pvalues[4].vstring = (char *)match_strval(pvalues[4].vvalue, nds_info_type); |
| 9881 | | | global_flags = pvalues[4].vvalue; |
| 9882 | | | if(pvalues[4].vstring == NULL) |
| 9883 | | | { |
| 9884 | | | pvalues[4].vstring = "No Info Type Set"; |
| 9885 | | | } |
| 9886 | | | pvalues[4].vtype = VTYPE_STRING; |
| 9887 | | | pvalues[4].vdesc = "Info Type: %s"; |
| 9888 | | | pvalues[4].vlength = 4; |
| 9889 | | | pvalues[4].voffset = foffset; |
| 9890 | | | pvalues[4].hfname= hf_nds_info_type; |
| 9891 | | | pvalues[4].mvtype = MVTYPE_ATTR_REQUEST; |
| 9892 | | | foffset = foffset+pvalues[4].vlength; |
| 9893 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 9894 | | | pvalues[5].vtype = VTYPE_UINT32; |
| 9895 | | | pvalues[5].vdesc = "All Attributes: %u"; |
| 9896 | | | pvalues[5].vlength = 4; |
| 9897 | | | pvalues[5].voffset = foffset; |
| 9898 | | | pvalues[5].hfname= hf_nds_all_attr; |
| 9899 | | | foffset = foffset+pvalues[5].vlength; |
| 9900 | | | pvalues[6].vvalue = tvb_get_letohl(tvb, foffset); |
| 9901 | | | pvalues[6].vtype = VTYPE_MULTIVALUE_UINT32; |
| 9902 | | | pvalues[6].vdesc = "Attributes: %u"; |
| 9903 | | | pvalues[6].vlength = 4; |
| 9904 | | | pvalues[6].voffset = foffset; |
| 9905 | | | pvalues[6].mvtype = MVTYPE_ATTR_REQUEST; |
| 9906 | | | pvalues[6].hfname= hf_nds_attr; |
| 9907 | | | } |
| 9908 | | | break; |
| 9909 | | | case 0x04: |
| 9910 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 9911 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 9912 | | | pvalues[0].vdesc = "Version: %u"; |
| 9913 | | | pvalues[0].vlength = 4; |
| 9914 | | | pvalues[0].voffset = foffset; |
| 9915 | | | pvalues[0].hfname= hf_nds_ver; |
| 9916 | | | foffset = foffset+pvalues[0].vlength; |
| 9917 | | | if (pvalues[0].vvalue == 1) { |
| 9918 | | | |
| 9919 | | | |
| 9920 | | | foffset += 4; |
| 9921 | | | } |
| 9922 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9923 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 9924 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 9925 | | | pvalues[1].vlength = 4; |
| 9926 | | | resolve_eid = TRUE; |
| 9927 | | | global_eid = pvalues[1].vvalue; |
| 9928 | | | pvalues[1].voffset = foffset; |
| 9929 | | | pvalues[1].hfname = hf_nds_eid; |
| 9930 | | | foffset = foffset+pvalues[1].vlength; |
| 9931 | | | foffset += 4; |
| 9932 | | | pvalues[2].vtype = VTYPE_STRING; |
| 9933 | | | pvalues[2].vdesc = "Attribute Name Being Compared: %s"; |
| 9934 | | | pvalues[2].mvtype = MVTYPE_ATTR_REQUEST; |
| 9935 | | | pvalues[2].vvalue = 0; |
| 9936 | | | pvalues[2].vlength = 256; |
| 9937 | | | pvalues[2].vlength = tvb_get_letohl(tvb, foffset); |
| 9938 | | | if (pvalues[2].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[2].vlength)) |
| 9939 | | | { |
| 9940 | | | pvalues[2].vtype = VTYPE_NONE; |
| 9941 | | | break; |
| 9942 | | | } |
| 9943 | | | pvalues[2].voffset = foffset+4; |
| 9944 | | | foffset = foffset + 4; |
| 9945 | | | pvalues[2].vstring = get_string(tvb, pvalues[2].voffset, pvalues[2].vlength); |
| 9946 | | | g_strlcpy(global_object_name, pvalues[2].vstring, 256); |
| 9947 | | | pvalues[2].hfname= hf_nds_name; |
| 9948 | | | foffset = foffset+pvalues[2].vlength; |
| 9949 | | | foffset += align_4(tvb, foffset); |
| 9950 | | | foffset += 4; |
| 9951 | | | pvalues[3].vtype = VTYPE_STRING; |
| 9952 | | | pvalues[3].vdesc = "Attribute Value: %s"; |
| 9953 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 9954 | | | pvalues[3].vvalue = 0; |
| 9955 | | | pvalues[3].vlength = 256; |
| 9956 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 9957 | | | pvalues[3].voffset = foffset+4; |
| 9958 | | | foffset = foffset + 4; |
| 9959 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 9960 | | | pvalues[3].hfname= hf_value_string; |
| 9961 | | | foffset = foffset+pvalues[3].vlength; |
| 9962 | | | break; |
| 9963 | | | case 0x05: |
| 9964 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 9965 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 9966 | | | pvalues[0].vdesc = "Version: %u"; |
| 9967 | | | pvalues[0].vlength = 4; |
| 9968 | | | pvalues[0].voffset = foffset; |
| 9969 | | | pvalues[0].hfname= hf_nds_ver; |
| 9970 | | | foffset = foffset+pvalues[0].vlength; |
| 9971 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 9972 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 9973 | | | pvalues[1].vdesc = "Request Flags:"; |
| 9974 | | | pvalues[1].vlength = 2; |
| 9975 | | | pvalues[1].hfname= hf_nds_rflags; |
| 9976 | | | pvalues[1].voffset = foffset; |
| 9977 | | | pvalues[1].bit1 = "List Typeless"; |
| 9978 | | | pvalues[1].bit1hfname = hf_bit1lflags; |
| 9979 | | | pvalues[1].bit2 = "List Containers"; |
| 9980 | | | pvalues[1].bit2hfname = hf_bit2lflags; |
| 9981 | | | pvalues[1].bit3 = "List Slashed"; |
| 9982 | | | pvalues[1].bit3hfname = hf_bit3lflags; |
| 9983 | | | pvalues[1].bit4 = "List Dotted"; |
| 9984 | | | pvalues[1].bit4hfname = hf_bit4lflags; |
| 9985 | | | pvalues[1].bit5 = "Dereference Alias"; |
| 9986 | | | pvalues[1].bit5hfname = hf_bit5lflags; |
| 9987 | | | pvalues[1].bit6 = "List All Containers"; |
| 9988 | | | pvalues[1].bit6hfname = hf_bit6lflags; |
| 9989 | | | pvalues[1].bit7 = "List Obsolete"; |
| 9990 | | | pvalues[1].bit7hfname = hf_bit7lflags; |
| 9991 | | | pvalues[1].bit8 = "List Tuned Output"; |
| 9992 | | | pvalues[1].bit8hfname = hf_bit8lflags; |
| 9993 | | | pvalues[1].bit9 = "List External Reference"; |
| 9994 | | | pvalues[1].bit9hfname = hf_bit9lflags; |
| 9995 | | | pvalues[1].bit10 = "Not Defined"; |
| 9996 | | | pvalues[1].bit10hfname = hf_bit10lflags; |
| 9997 | | | pvalues[1].bit11 = "Not Defined"; |
| 9998 | | | pvalues[1].bit11hfname = hf_bit11lflags; |
| 9999 | | | pvalues[1].bit12 = "Not Defined"; |
| 10000 | | | pvalues[1].bit12hfname = hf_bit12lflags; |
| 10001 | | | pvalues[1].bit13 = "Not Defined"; |
| 10002 | | | pvalues[1].bit13hfname = hf_bit13lflags; |
| 10003 | | | pvalues[1].bit14 = "Not Defined"; |
| 10004 | | | pvalues[1].bit14hfname = hf_bit14lflags; |
| 10005 | | | pvalues[1].bit15 = "Not Defined"; |
| 10006 | | | pvalues[1].bit15hfname = hf_bit15lflags; |
| 10007 | | | pvalues[1].bit16 = "Not Defined"; |
| 10008 | | | pvalues[1].bit16hfname = hf_bit16lflags; |
| 10009 | | | foffset = foffset+pvalues[1].vlength; |
| 10010 | | | foffset += 2; |
| 10011 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10012 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10013 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 10014 | | | pvalues[2].vlength = 4; |
| 10015 | | | pvalues[2].voffset = foffset; |
| 10016 | | | pvalues[2].hfname= hf_nds_iteration; |
| 10017 | | | foffset = foffset+pvalues[2].vlength; |
| 10018 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10019 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 10020 | | | pvalues[3].vdesc = "Parent ID: 0x%08x"; |
| 10021 | | | pvalues[3].vlength = 4; |
| 10022 | | | pvalues[3].voffset = foffset; |
| 10023 | | | pvalues[3].hfname= hf_nds_parent; |
| 10024 | | | foffset = foffset+pvalues[3].vlength; |
| 10025 | | | pvalues[4].vvalue = tvb_get_letohs(tvb, foffset); |
| 10026 | | | global_flags = tvb_get_letohl(tvb, foffset); |
| 10027 | | | pvalues[4].vtype = VTYPE_BITFIELD; |
| 10028 | | | pvalues[4].vdesc = "Information Flags (low) Byte:"; |
| 10029 | | | pvalues[4].vlength = 2; |
| 10030 | | | pvalues[4].hfname= hf_nds_rflags; |
| 10031 | | | pvalues[4].voffset = foffset; |
| 10032 | | | pvalues[4].bit1 = "Output Flags"; |
| 10033 | | | pvalues[4].bit1hfname = hf_bit1infoflagsl; |
| 10034 | | | pvalues[4].bit2 = "Entry ID"; |
| 10035 | | | pvalues[4].bit2hfname = hf_bit2infoflagsl; |
| 10036 | | | pvalues[4].bit3 = "Entry Flags"; |
| 10037 | | | pvalues[4].bit3hfname = hf_bit3infoflagsl; |
| 10038 | | | pvalues[4].bit4 = "Subordinate Count"; |
| 10039 | | | pvalues[4].bit4hfname = hf_bit4infoflagsl; |
| 10040 | | | pvalues[4].bit5 = "Modification Time"; |
| 10041 | | | pvalues[4].bit5hfname = hf_bit5infoflagsl; |
| 10042 | | | pvalues[4].bit6 = "Modification Timestamp"; |
| 10043 | | | pvalues[4].bit6hfname = hf_bit6infoflagsl; |
| 10044 | | | pvalues[4].bit7 = "Creation Timestamp"; |
| 10045 | | | pvalues[4].bit7hfname = hf_bit7infoflagsl; |
| 10046 | | | pvalues[4].bit8 = "Partition Root ID"; |
| 10047 | | | pvalues[4].bit8hfname = hf_bit8infoflagsl; |
| 10048 | | | pvalues[4].bit9 = "Parent ID"; |
| 10049 | | | pvalues[4].bit9hfname = hf_bit9infoflagsl; |
| 10050 | | | pvalues[4].bit10 = "Revision Count"; |
| 10051 | | | pvalues[4].bit10hfname = hf_bit10infoflagsl; |
| 10052 | | | pvalues[4].bit11 = "Replica Type"; |
| 10053 | | | pvalues[4].bit11hfname = hf_bit11infoflagsl; |
| 10054 | | | pvalues[4].bit12 = "Base Class"; |
| 10055 | | | pvalues[4].bit12hfname = hf_bit12infoflagsl; |
| 10056 | | | pvalues[4].bit13 = "Relative Distinguished Name"; |
| 10057 | | | pvalues[4].bit13hfname = hf_bit13infoflagsl; |
| 10058 | | | pvalues[4].bit14 = "Distinguished Name"; |
| 10059 | | | pvalues[4].bit14hfname = hf_bit14infoflagsl; |
| 10060 | | | pvalues[4].bit15 = "Root Distinguished Name"; |
| 10061 | | | pvalues[4].bit15hfname = hf_bit15infoflagsl; |
| 10062 | | | pvalues[4].bit16 = "Parent Distinguished Name"; |
| 10063 | | | pvalues[4].bit16hfname = hf_bit16infoflagsl; |
| 10064 | | | foffset = foffset+2; |
| 10065 | | | pvalues[5].vvalue = tvb_get_letohs(tvb, foffset); |
| 10066 | | | pvalues[5].vtype = VTYPE_BITFIELD; |
| 10067 | | | pvalues[5].vdesc = "Information Flags (high) Byte:"; |
| 10068 | | | pvalues[5].vlength = 2; |
| 10069 | | | pvalues[5].hfname= hf_nds_rflags; |
| 10070 | | | pvalues[5].voffset = foffset; |
| 10071 | | | pvalues[5].bit1 = "Purge Time"; |
| 10072 | | | pvalues[5].bit1hfname = hf_bit1infoflagsh; |
| 10073 | | | pvalues[5].bit2 = "Dereference Base Class"; |
| 10074 | | | pvalues[5].bit2hfname = hf_bit2infoflagsh; |
| 10075 | | | pvalues[5].bit3 = "Not Defined"; |
| 10076 | | | pvalues[5].bit3hfname = hf_bit3infoflagsh; |
| 10077 | | | pvalues[5].bit4 = "Not Defined"; |
| 10078 | | | pvalues[5].bit4hfname = hf_bit4infoflagsh; |
| 10079 | | | pvalues[5].bit5 = "Not Defined"; |
| 10080 | | | pvalues[5].bit5hfname = hf_bit5infoflagsh; |
| 10081 | | | pvalues[5].bit6 = "Not Defined"; |
| 10082 | | | pvalues[5].bit6hfname = hf_bit6infoflagsh; |
| 10083 | | | pvalues[5].bit7 = "Not Defined"; |
| 10084 | | | pvalues[5].bit7hfname = hf_bit7infoflagsh; |
| 10085 | | | pvalues[5].bit8 = "Not Defined"; |
| 10086 | | | pvalues[5].bit8hfname = hf_bit8infoflagsh; |
| 10087 | | | pvalues[5].bit9 = "Not Defined"; |
| 10088 | | | pvalues[5].bit9hfname = hf_bit9infoflagsh; |
| 10089 | | | pvalues[5].bit10 = "Not Defined"; |
| 10090 | | | pvalues[5].bit10hfname = hf_bit10infoflagsh; |
| 10091 | | | pvalues[5].bit11 = "Not Defined"; |
| 10092 | | | pvalues[5].bit11hfname = hf_bit11infoflagsh; |
| 10093 | | | pvalues[5].bit12 = "Not Defined"; |
| 10094 | | | pvalues[5].bit12hfname = hf_bit12infoflagsh; |
| 10095 | | | pvalues[5].bit13 = "Not Defined"; |
| 10096 | | | pvalues[5].bit13hfname = hf_bit13infoflagsh; |
| 10097 | | | pvalues[5].bit14 = "Not Defined"; |
| 10098 | | | pvalues[5].bit14hfname = hf_bit14infoflagsh; |
| 10099 | | | pvalues[5].bit15 = "Not Defined"; |
| 10100 | | | pvalues[5].bit15hfname = hf_bit15infoflagsh; |
| 10101 | | | pvalues[5].bit16 = "Not Defined"; |
| 10102 | | | pvalues[5].bit16hfname = hf_bit16infoflagsh; |
| 10103 | | | foffset = foffset+2; |
| 10104 | | | pvalues[6].vtype = VTYPE_STRING; |
| 10105 | | | pvalues[6].vdesc = "Name Filter: %s"; |
| 10106 | | | pvalues[6].mvtype = MVTYPE_ATTR_REQUEST; |
| 10107 | | | pvalues[6].vvalue = 0; |
| 10108 | | | pvalues[6].vlength = 256; |
| 10109 | | | pvalues[6].vlength = tvb_get_letohl(tvb, foffset); |
| 10110 | | | pvalues[6].voffset = foffset+4; |
| 10111 | | | foffset = foffset + 4; |
| 10112 | | | pvalues[6].vstring = get_string(tvb, pvalues[6].voffset, pvalues[6].vlength); |
| 10113 | | | pvalues[6].hfname= hf_nds_name_filter; |
| 10114 | | | foffset = foffset+pvalues[6].vlength; |
| 10115 | | | if(pvalues[0].vvalue == 0) |
Event 3:
Skipping " if". pvalues[0].vvalue == 0 evaluates to false.
hide
|
|
| 10116 | | | { |
| 10117 | | | break; |
| 10118 | | | } |
| 10119 | | | foffset += align_4(tvb, foffset); |
| 10120 | | | pvalues[7].vtype = VTYPE_STRING; |
| 10121 | | | pvalues[7].vdesc = "Class Filter: %s"; |
| 10122 | | | pvalues[7].mvtype = MVTYPE_ATTR_REQUEST; |
| 10123 | | | pvalues[7].vvalue = 0; |
| 10124 | | | pvalues[7].vlength = 256; |
| 10125 | | | pvalues[7].vlength = tvb_get_letohl(tvb, foffset); |
| 10126 | | | pvalues[7].voffset = foffset+4; |
| 10127 | | | foffset = foffset + 4; |
| 10128 | | | pvalues[7].vstring = get_string(tvb, pvalues[7].voffset, pvalues[7].vlength); |
| 10129 | | | pvalues[7].hfname= hf_nds_class_filter; |
| 10130 | | | foffset = foffset+pvalues[7].vlength; |
| 10131 | | | if(pvalues[0].vvalue == 1) |
Event 4:
Skipping " if". pvalues[0].vvalue == 1 evaluates to false.
hide
|
|
| 10132 | | | { |
| 10133 | | | break; |
| 10134 | | | } |
| 10135 | | | foffset += align_4(tvb, foffset); |
| 10136 | | | pvalues[8].vvalue = tvb_get_letohl(tvb, foffset); |
| 10137 | | | pvalues[8].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10138 | | | pvalues[8].vdesc = "Seconds: %u"; |
| 10139 | | | pvalues[8].vlength = 4; |
| 10140 | | | pvalues[8].mvtype = MVTYPE_PRINT_TIMESTAMP; |
| 10141 | | | pvalues[8].hfname= hf_nds_time_filter; |
| 10142 | | | pvalues[8].voffset = foffset; |
| 10143 | | | break; |
| 10144 | | | case 0x06: |
| 10145 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10146 | | | pvalues[0].vstring = ""; |
| 10147 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10148 | | | pvalues[0].vdesc = "Version: %u"; |
| 10149 | | | pvalues[0].vlength = 4; |
| 10150 | | | pvalues[0].voffset = foffset; |
| 10151 | | | pvalues[0].hfname= hf_nds_ver; |
| 10152 | | | foffset = foffset+pvalues[0].vlength; |
| 10153 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10154 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10155 | | | pvalues[1].vstring = ""; |
| 10156 | | | pvalues[1].vdesc = "Request Flags: 0x%08x"; |
| 10157 | | | pvalues[1].vlength = 4; |
| 10158 | | | pvalues[1].hfname= hf_nds_rflags; |
| 10159 | | | pvalues[1].voffset = foffset; |
| 10160 | | | foffset = foffset+4; |
| 10161 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10162 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10163 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 10164 | | | pvalues[2].vlength = 4; |
| 10165 | | | pvalues[2].voffset = foffset; |
| 10166 | | | pvalues[2].hfname= hf_nds_iteration; |
| 10167 | | | foffset = foffset+pvalues[2].vlength; |
| 10168 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10169 | | | pvalues[3].vstring = ""; |
| 10170 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 10171 | | | pvalues[3].vdesc = "Base Entry ID: 0x%08x"; |
| 10172 | | | pvalues[3].vlength = 4; |
| 10173 | | | resolve_eid = FALSE; |
| 10174 | | | global_eid = pvalues[3].vvalue; |
| 10175 | | | pvalues[3].voffset = foffset; |
| 10176 | | | pvalues[3].hfname= hf_nds_eid; |
| 10177 | | | foffset = foffset+pvalues[3].vlength; |
| 10178 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 10179 | | | pvalues[4].vstring = (char *)match_strval(pvalues[4].vvalue, nds_search_scope); |
| 10180 | | | if(pvalues[4].vstring == NULL) |
| 10181 | | | { |
| 10182 | | | pvalues[4].vstring = "No Search Scope Defined"; |
| 10183 | | | } |
| 10184 | | | pvalues[4].vtype = VTYPE_STRING; |
| 10185 | | | pvalues[4].vdesc = "Replica Type: %s"; |
| 10186 | | | pvalues[4].vlength = 4; |
| 10187 | | | pvalues[4].voffset = foffset; |
| 10188 | | | pvalues[4].mvtype = 0; |
| 10189 | | | pvalues[4].hfname= hf_nds_search_scope; |
| 10190 | | | foffset = foffset + pvalues[4].vlength; |
| 10191 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 10192 | | | pvalues[5].vtype = VTYPE_UINT32; |
| 10193 | | | pvalues[5].vdesc = "Number of Objects to Search: 0x%08x"; |
| 10194 | | | pvalues[5].vlength = 4; |
| 10195 | | | pvalues[5].voffset = foffset; |
| 10196 | | | pvalues[5].hfname= hf_nds_num_objects; |
| 10197 | | | foffset = foffset+pvalues[5].vlength; |
| 10198 | | | pvalues[6].vvalue = tvb_get_letohl(tvb, foffset); |
| 10199 | | | pvalues[6].vtype = VTYPE_BITFIELD; |
| 10200 | | | pvalues[6].vdesc = "Information Types:"; |
| 10201 | | | pvalues[6].vlength = 2; |
| 10202 | | | pvalues[6].hfname= hf_nds_nflags; |
| 10203 | | | pvalues[6].voffset = foffset; |
| 10204 | | | pvalues[6].bit1 = "Names"; |
| 10205 | | | pvalues[6].bit1hfname = hf_bit1siflags; |
| 10206 | | | pvalues[6].bit2 = "Names and Values"; |
| 10207 | | | pvalues[6].bit2hfname = hf_bit2siflags; |
| 10208 | | | pvalues[6].bit3 = "Effective Privileges"; |
| 10209 | | | pvalues[6].bit3hfname = hf_bit3siflags; |
| 10210 | | | pvalues[6].bit4 = "Value Info"; |
| 10211 | | | pvalues[6].bit4hfname = hf_bit4siflags; |
| 10212 | | | pvalues[6].bit5 = "Abbreviated Value"; |
| 10213 | | | pvalues[6].bit5hfname = hf_bit5siflags; |
| 10214 | | | pvalues[6].bit6 = "Not Defined"; |
| 10215 | | | pvalues[6].bit6hfname = hf_bit6siflags; |
| 10216 | | | pvalues[6].bit7 = "Not Defined"; |
| 10217 | | | pvalues[6].bit7hfname = hf_bit7siflags; |
| 10218 | | | pvalues[6].bit8 = "Not Defined"; |
| 10219 | | | pvalues[6].bit8hfname = hf_bit8siflags; |
| 10220 | | | pvalues[6].bit9 = "Expanded Class"; |
| 10221 | | | pvalues[6].bit9hfname = hf_bit9siflags; |
| 10222 | | | pvalues[6].bit10 = "Not Defined"; |
| 10223 | | | pvalues[6].bit10hfname = hf_bit10siflags; |
| 10224 | | | pvalues[6].bit11= "Not Defined"; |
| 10225 | | | pvalues[6].bit11hfname = hf_bit11siflags; |
| 10226 | | | pvalues[6].bit12 = "Not Defined"; |
| 10227 | | | pvalues[6].bit12hfname = hf_bit12siflags; |
| 10228 | | | pvalues[6].bit13 = "Not Defined"; |
| 10229 | | | pvalues[6].bit13hfname = hf_bit13siflags; |
| 10230 | | | pvalues[6].bit14 = "Not Defined"; |
| 10231 | | | pvalues[6].bit14hfname = hf_bit14siflags; |
| 10232 | | | pvalues[6].bit15 = "Not Defined"; |
| 10233 | | | pvalues[6].bit15hfname = hf_bit15siflags; |
| 10234 | | | pvalues[6].bit16 = "Not Defined"; |
| 10235 | | | pvalues[6].bit16hfname = hf_bit16siflags; |
| 10236 | | | foffset = foffset+4; |
| 10237 | | | if(pvalues[0].vvalue != 2) |
| 10238 | | | { |
| 10239 | | | pvalues[7].vvalue = tvb_get_letohs(tvb, foffset); |
| 10240 | | | global_flags = tvb_get_letohl(tvb, foffset); |
| 10241 | | | pvalues[7].vtype = VTYPE_BITFIELD; |
| 10242 | | | pvalues[7].vdesc = "Information Flags (low) Byte:"; |
| 10243 | | | pvalues[7].vlength = 2; |
| 10244 | | | pvalues[7].hfname= hf_nds_rflags; |
| 10245 | | | pvalues[7].voffset = foffset; |
| 10246 | | | pvalues[7].bit1 = "Output Flags"; |
| 10247 | | | pvalues[7].bit1hfname = hf_bit1infoflagsl; |
| 10248 | | | pvalues[7].bit2 = "Entry ID"; |
| 10249 | | | pvalues[7].bit2hfname = hf_bit2infoflagsl; |
| 10250 | | | pvalues[7].bit3 = "Entry Flags"; |
| 10251 | | | pvalues[7].bit3hfname = hf_bit3infoflagsl; |
| 10252 | | | pvalues[7].bit4 = "Subordinate Count"; |
| 10253 | | | pvalues[7].bit4hfname = hf_bit4infoflagsl; |
| 10254 | | | pvalues[7].bit5 = "Modification Time"; |
| 10255 | | | pvalues[7].bit5hfname = hf_bit5infoflagsl; |
| 10256 | | | pvalues[7].bit6 = "Modification Timestamp"; |
| 10257 | | | pvalues[7].bit6hfname = hf_bit6infoflagsl; |
| 10258 | | | pvalues[7].bit7 = "Creation Timestamp"; |
| 10259 | | | pvalues[7].bit7hfname = hf_bit7infoflagsl; |
| 10260 | | | pvalues[7].bit8 = "Partition Root ID"; |
| 10261 | | | pvalues[7].bit8hfname = hf_bit8infoflagsl; |
| 10262 | | | pvalues[7].bit9 = "Parent ID"; |
| 10263 | | | pvalues[7].bit9hfname = hf_bit9infoflagsl; |
| 10264 | | | pvalues[7].bit10 = "Revision Count"; |
| 10265 | | | pvalues[7].bit10hfname = hf_bit10infoflagsl; |
| 10266 | | | pvalues[7].bit11 = "Replica Type"; |
| 10267 | | | pvalues[7].bit11hfname = hf_bit11infoflagsl; |
| 10268 | | | pvalues[7].bit12 = "Base Class"; |
| 10269 | | | pvalues[7].bit12hfname = hf_bit12infoflagsl; |
| 10270 | | | pvalues[7].bit13 = "Relative Distinguished Name"; |
| 10271 | | | pvalues[7].bit13hfname = hf_bit13infoflagsl; |
| 10272 | | | pvalues[7].bit14 = "Distinguished Name"; |
| 10273 | | | pvalues[7].bit14hfname = hf_bit14infoflagsl; |
| 10274 | | | pvalues[7].bit15 = "Root Distinguished Name"; |
| 10275 | | | pvalues[7].bit15hfname = hf_bit15infoflagsl; |
| 10276 | | | pvalues[7].bit16 = "Parent Distinguished Name"; |
| 10277 | | | pvalues[7].bit16hfname = hf_bit16infoflagsl; |
| 10278 | | | foffset = foffset+2; |
| 10279 | | | pvalues[8].vvalue = tvb_get_letohs(tvb, foffset); |
| 10280 | | | pvalues[8].vtype = VTYPE_BITFIELD; |
| 10281 | | | pvalues[8].vdesc = "Information Flags (high) Byte:"; |
| 10282 | | | pvalues[8].vlength = 2; |
| 10283 | | | pvalues[8].hfname= hf_nds_rflags; |
| 10284 | | | pvalues[8].voffset = foffset; |
| 10285 | | | pvalues[8].bit1 = "Purge Time"; |
| 10286 | | | pvalues[8].bit1hfname = hf_bit1infoflagsh; |
| 10287 | | | pvalues[8].bit2 = "Dereference Base Class"; |
| 10288 | | | pvalues[8].bit2hfname = hf_bit2infoflagsh; |
| 10289 | | | pvalues[8].bit3 = "Not Defined"; |
| 10290 | | | pvalues[8].bit3hfname = hf_bit3infoflagsh; |
| 10291 | | | pvalues[8].bit4 = "Not Defined"; |
| 10292 | | | pvalues[8].bit4hfname = hf_bit4infoflagsh; |
| 10293 | | | pvalues[8].bit5 = "Not Defined"; |
| 10294 | | | pvalues[8].bit5hfname = hf_bit5infoflagsh; |
| 10295 | | | pvalues[8].bit6 = "Not Defined"; |
| 10296 | | | pvalues[8].bit6hfname = hf_bit6infoflagsh; |
| 10297 | | | pvalues[8].bit7 = "Not Defined"; |
| 10298 | | | pvalues[8].bit7hfname = hf_bit7infoflagsh; |
| 10299 | | | pvalues[8].bit8 = "Not Defined"; |
| 10300 | | | pvalues[8].bit8hfname = hf_bit8infoflagsh; |
| 10301 | | | pvalues[8].bit9 = "Not Defined"; |
| 10302 | | | pvalues[8].bit9hfname = hf_bit9infoflagsh; |
| 10303 | | | pvalues[8].bit10 = "Not Defined"; |
| 10304 | | | pvalues[8].bit10hfname = hf_bit10infoflagsh; |
| 10305 | | | pvalues[8].bit11 = "Not Defined"; |
| 10306 | | | pvalues[8].bit11hfname = hf_bit11infoflagsh; |
| 10307 | | | pvalues[8].bit12 = "Not Defined"; |
| 10308 | | | pvalues[8].bit12hfname = hf_bit12infoflagsh; |
| 10309 | | | pvalues[8].bit13 = "Not Defined"; |
| 10310 | | | pvalues[8].bit13hfname = hf_bit13infoflagsh; |
| 10311 | | | pvalues[8].bit14 = "Not Defined"; |
| 10312 | | | pvalues[8].bit14hfname = hf_bit14infoflagsh; |
| 10313 | | | pvalues[8].bit15 = "Not Defined"; |
| 10314 | | | pvalues[8].bit15hfname = hf_bit15infoflagsh; |
| 10315 | | | pvalues[8].bit16 = "Not Defined"; |
| 10316 | | | pvalues[8].bit16hfname = hf_bit16infoflagsh; |
| 10317 | | | foffset = foffset+2; |
| 10318 | | | } |
| 10319 | | | break; |
| 10320 | | | case 0x07: |
| 10321 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10322 | | | pvalues[0].vstring = ""; |
| 10323 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10324 | | | pvalues[0].vdesc = "Version: %u"; |
| 10325 | | | pvalues[0].vlength = 4; |
| 10326 | | | pvalues[0].voffset = foffset; |
| 10327 | | | pvalues[0].hfname= hf_nds_ver; |
| 10328 | | | foffset = foffset+pvalues[0].vlength; |
| 10329 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10330 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10331 | | | pvalues[1].vstring = ""; |
| 10332 | | | pvalues[1].vdesc = "Request Flags: 0x%08x"; |
| 10333 | | | pvalues[1].vlength = 4; |
| 10334 | | | pvalues[1].hfname= hf_nds_rflags; |
| 10335 | | | pvalues[1].voffset = foffset; |
| 10336 | | | foffset = foffset+4; |
| 10337 | | | if(pvalues[0].vvalue == 0) |
| 10338 | | | { |
| 10339 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10340 | | | pvalues[2].vstring = ""; |
| 10341 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10342 | | | pvalues[2].vdesc = "Parent Entry ID: 0x%08x"; |
| 10343 | | | pvalues[2].vlength = 4; |
| 10344 | | | resolve_eid = FALSE; |
| 10345 | | | global_eid = pvalues[2].vvalue; |
| 10346 | | | pvalues[2].voffset = foffset; |
| 10347 | | | pvalues[2].hfname= hf_nds_eid; |
| 10348 | | | foffset = foffset+pvalues[2].vlength; |
| 10349 | | | pvalues[3].vtype = VTYPE_STRING; |
| 10350 | | | pvalues[3].vdesc = "Relative Distinguished Name: %s"; |
| 10351 | | | pvalues[3].vstring = ""; |
| 10352 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 10353 | | | pvalues[3].vvalue = 0; |
| 10354 | | | pvalues[3].vlength = 256; |
| 10355 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 10356 | | | if (pvalues[3].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 10357 | | | { |
| 10358 | | | pvalues[3].vtype = VTYPE_NONE; |
| 10359 | | | break; |
| 10360 | | | } |
| 10361 | | | pvalues[3].voffset = foffset+4; |
| 10362 | | | foffset = foffset + 4; |
| 10363 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 10364 | | | g_strlcpy(global_object_name, pvalues[3].vstring, 256); |
| 10365 | | | pvalues[3].hfname= hf_nds_relative_dn; |
| 10366 | | | foffset = foffset+pvalues[3].vlength; |
| 10367 | | | foffset += align_4(tvb, foffset); |
| 10368 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 10369 | | | pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10370 | | | pvalues[4].vstring = ""; |
| 10371 | | | pvalues[4].vdesc = "Attributes: %u"; |
| 10372 | | | pvalues[4].vlength = 4; |
| 10373 | | | pvalues[4].voffset = foffset; |
| 10374 | | | pvalues[4].mvtype = MVTYPE_ADD_ATTR_REQUEST; |
| 10375 | | | pvalues[4].hfname= hf_nds_attr; |
| 10376 | | | } |
| 10377 | | | else |
| 10378 | | | { |
| 10379 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10380 | | | pvalues[2].vstring = ""; |
| 10381 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10382 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 10383 | | | pvalues[2].vlength = 4; |
| 10384 | | | pvalues[2].voffset = foffset; |
| 10385 | | | pvalues[2].hfname= hf_nds_iteration; |
| 10386 | | | foffset = foffset+pvalues[2].vlength; |
| 10387 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10388 | | | pvalues[3].vstring = ""; |
| 10389 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 10390 | | | pvalues[3].vdesc = "Parent Entry ID: 0x%08x"; |
| 10391 | | | pvalues[3].vlength = 4; |
| 10392 | | | resolve_eid = FALSE; |
| 10393 | | | global_eid = pvalues[3].vvalue; |
| 10394 | | | pvalues[3].voffset = foffset; |
| 10395 | | | pvalues[3].hfname= hf_nds_eid; |
| 10396 | | | foffset = foffset+pvalues[3].vlength; |
| 10397 | | | pvalues[4].vtype = VTYPE_STRING; |
| 10398 | | | pvalues[4].vdesc = "Relative Distinguished Name: %s"; |
| 10399 | | | pvalues[4].vstring = ""; |
| 10400 | | | pvalues[4].mvtype = MVTYPE_ATTR_REQUEST; |
| 10401 | | | pvalues[4].vvalue = 0; |
| 10402 | | | pvalues[4].vlength = 256; |
| 10403 | | | pvalues[4].vlength = tvb_get_letohl(tvb, foffset); |
| 10404 | | | if (pvalues[4].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[4].vlength)) |
| 10405 | | | { |
| 10406 | | | pvalues[4].vtype = VTYPE_NONE; |
| 10407 | | | break; |
| 10408 | | | } |
| 10409 | | | pvalues[4].voffset = foffset+4; |
| 10410 | | | foffset = foffset + 4; |
| 10411 | | | pvalues[4].vstring = get_string(tvb, pvalues[4].voffset, pvalues[4].vlength); |
| 10412 | | | g_strlcpy(global_object_name, pvalues[4].vstring, 256); |
| 10413 | | | pvalues[4].hfname= hf_nds_relative_dn; |
| 10414 | | | foffset = foffset+pvalues[4].vlength; |
| 10415 | | | foffset += align_4(tvb, foffset); |
| 10416 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 10417 | | | pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10418 | | | pvalues[5].vstring = ""; |
| 10419 | | | pvalues[5].vdesc = "Attributes: %u"; |
| 10420 | | | pvalues[5].vlength = 4; |
| 10421 | | | pvalues[5].voffset = foffset; |
| 10422 | | | pvalues[5].mvtype = MVTYPE_ADD_ATTR_REQUEST; |
| 10423 | | | pvalues[5].hfname= hf_nds_attr; |
| 10424 | | | } |
| 10425 | | | break; |
| 10426 | | | case 0x08: |
| 10427 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10428 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10429 | | | pvalues[0].vdesc = "Version: %u"; |
| 10430 | | | pvalues[0].vlength = 4; |
| 10431 | | | pvalues[0].voffset = foffset; |
| 10432 | | | pvalues[0].hfname= hf_nds_ver; |
| 10433 | | | foffset = foffset+pvalues[0].vlength; |
| 10434 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10435 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10436 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 10437 | | | pvalues[1].vlength = 4; |
| 10438 | | | resolve_eid = TRUE; |
| 10439 | | | global_eid = pvalues[1].vvalue; |
| 10440 | | | pvalues[1].voffset = foffset; |
| 10441 | | | pvalues[1].hfname= hf_nds_eid; |
| 10442 | | | foffset = foffset+pvalues[1].vlength; |
| 10443 | | | break; |
| 10444 | | | case 0x09: |
| 10445 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10446 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10447 | | | pvalues[0].vdesc = "Version: %u"; |
| 10448 | | | pvalues[0].vlength = 4; |
| 10449 | | | pvalues[0].voffset = foffset; |
| 10450 | | | pvalues[0].hfname= hf_nds_ver; |
| 10451 | | | foffset = foffset+pvalues[0].vlength; |
| 10452 | | | if(pvalues[0].vvalue == 0) |
| 10453 | | | { |
| 10454 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10455 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10456 | | | pvalues[1].vstring = ""; |
| 10457 | | | pvalues[1].vdesc = "Iteration Handle: 0x%08x"; |
| 10458 | | | pvalues[1].vlength = 4; |
| 10459 | | | pvalues[1].hfname= hf_nds_iteration; |
| 10460 | | | pvalues[1].voffset = foffset; |
| 10461 | | | foffset = foffset+4; |
| 10462 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10463 | | | pvalues[2].vstring = ""; |
| 10464 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10465 | | | pvalues[2].vdesc = "Entry ID: 0x%08x"; |
| 10466 | | | pvalues[2].vlength = 4; |
| 10467 | | | pvalues[2].voffset = foffset; |
| 10468 | | | resolve_eid = TRUE; |
| 10469 | | | global_eid = pvalues[2].vvalue; |
| 10470 | | | pvalues[2].hfname = hf_nds_eid; |
| 10471 | | | foffset = foffset+pvalues[2].vlength; |
| 10472 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10473 | | | pvalues[3].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10474 | | | pvalues[3].vstring = ""; |
| 10475 | | | pvalues[3].vdesc = "Number of Attributes to Change %u"; |
| 10476 | | | pvalues[3].vlength = 4; |
| 10477 | | | pvalues[3].mvtype = MVTYPE_MODIFY_ATTR_REQUEST; |
| 10478 | | | pvalues[3].hfname= hf_nds_number_of_changes; |
| 10479 | | | pvalues[3].voffset = foffset; |
| 10480 | | | } |
| 10481 | | | else |
| 10482 | | | { |
| 10483 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10484 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10485 | | | pvalues[1].vstring = ""; |
| 10486 | | | pvalues[1].vdesc = "Request Flags: 0x%08x"; |
| 10487 | | | pvalues[1].vlength = 4; |
| 10488 | | | pvalues[1].hfname= hf_nds_rflags; |
| 10489 | | | pvalues[1].voffset = foffset; |
| 10490 | | | foffset = foffset+4; |
| 10491 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10492 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10493 | | | pvalues[2].vstring = ""; |
| 10494 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 10495 | | | pvalues[2].vlength = 4; |
| 10496 | | | pvalues[2].hfname= hf_nds_iteration; |
| 10497 | | | pvalues[2].voffset = foffset; |
| 10498 | | | foffset = foffset+4; |
| 10499 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10500 | | | pvalues[3].vstring = ""; |
| 10501 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 10502 | | | pvalues[3].vdesc = "Entry ID: 0x%08x"; |
| 10503 | | | pvalues[3].vlength = 4; |
| 10504 | | | pvalues[3].voffset = foffset; |
| 10505 | | | resolve_eid = TRUE; |
| 10506 | | | global_eid = pvalues[3].vvalue; |
| 10507 | | | pvalues[3].hfname = hf_nds_eid; |
| 10508 | | | foffset = foffset+pvalues[3].vlength; |
| 10509 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 10510 | | | pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10511 | | | pvalues[4].vstring = ""; |
| 10512 | | | pvalues[4].vdesc = "Number of Attributes to Change %u"; |
| 10513 | | | pvalues[4].vlength = 4; |
| 10514 | | | pvalues[4].mvtype = MVTYPE_MODIFY_ATTR_REQUEST; |
| 10515 | | | pvalues[4].hfname= hf_nds_number_of_changes; |
| 10516 | | | pvalues[4].voffset = foffset; |
| 10517 | | | } |
| 10518 | | | break; |
| 10519 | | | case 0x0a: |
| 10520 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10521 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10522 | | | pvalues[0].vdesc = "Version: %u"; |
| 10523 | | | pvalues[0].vlength = 4; |
| 10524 | | | pvalues[0].voffset = foffset; |
| 10525 | | | pvalues[0].hfname= hf_nds_ver; |
| 10526 | | | foffset = foffset+pvalues[0].vlength; |
| 10527 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10528 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10529 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 10530 | | | pvalues[1].vlength = 4; |
| 10531 | | | resolve_eid = TRUE; |
| 10532 | | | global_eid = pvalues[1].vvalue; |
| 10533 | | | pvalues[1].voffset = foffset; |
| 10534 | | | pvalues[1].hfname = hf_nds_eid; |
| 10535 | | | foffset = foffset+pvalues[1].vlength; |
| 10536 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10537 | | | pvalues[2].vtype = VTYPE_BOOLEAN; |
| 10538 | | | pvalues[2].vdesc = "Keep Original RDN: %s"; |
| 10539 | | | pvalues[2].vlength = 4; |
| 10540 | | | pvalues[2].voffset = foffset; |
| 10541 | | | pvalues[2].mvtype = 0; |
| 10542 | | | pvalues[2].hfname= hf_nds_keep; |
| 10543 | | | foffset = foffset+4; |
| 10544 | | | foffset += align_4(tvb, foffset); |
| 10545 | | | pvalues[3].vtype = VTYPE_STRING; |
| 10546 | | | pvalues[3].vdesc = "New RDN: %s"; |
| 10547 | | | pvalues[3].mvtype = 0; |
| 10548 | | | pvalues[3].vvalue = 0; |
| 10549 | | | pvalues[3].vlength = 256; |
| 10550 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 10551 | | | pvalues[3].voffset = foffset+4; |
| 10552 | | | foffset = foffset + 4; |
| 10553 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 10554 | | | pvalues[3].hfname= hf_nds_new_rdn; |
| 10555 | | | foffset = foffset+pvalues[3].vlength; |
| 10556 | | | break; |
| 10557 | | | case 0x0b: |
| 10558 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10559 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10560 | | | pvalues[0].vdesc = "Version: %u"; |
| 10561 | | | pvalues[0].vlength = 4; |
| 10562 | | | pvalues[0].voffset = foffset; |
| 10563 | | | pvalues[0].hfname= hf_nds_ver; |
| 10564 | | | foffset = foffset+pvalues[0].vlength; |
| 10565 | | | pvalues[1].vvalue = tvb_get_letohs(tvb, foffset); |
| 10566 | | | global_flags = tvb_get_letohl(tvb, foffset); |
| 10567 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 10568 | | | pvalues[1].vdesc = "Attribute Constraints:"; |
| 10569 | | | pvalues[1].vlength = 2; |
| 10570 | | | pvalues[1].hfname= hf_nds_acflags; |
| 10571 | | | pvalues[1].voffset = foffset; |
| 10572 | | | pvalues[1].bit1 = "Single Valued"; |
| 10573 | | | pvalues[1].bit1hfname = hf_bit1acflags; |
| 10574 | | | pvalues[1].bit2 = "Sized"; |
| 10575 | | | pvalues[1].bit2hfname = hf_bit2acflags; |
| 10576 | | | pvalues[1].bit3 = "Non-Removable"; |
| 10577 | | | pvalues[1].bit3hfname = hf_bit3acflags; |
| 10578 | | | pvalues[1].bit4 = "Read Only"; |
| 10579 | | | pvalues[1].bit4hfname = hf_bit4acflags; |
| 10580 | | | pvalues[1].bit5 = "Hidden"; |
| 10581 | | | pvalues[1].bit5hfname = hf_bit5acflags; |
| 10582 | | | pvalues[1].bit6 = "String"; |
| 10583 | | | pvalues[1].bit6hfname = hf_bit6acflags; |
| 10584 | | | pvalues[1].bit7 = "Synchronize Immediate"; |
| 10585 | | | pvalues[1].bit7hfname = hf_bit7acflags; |
| 10586 | | | pvalues[1].bit8 = "Public Read"; |
| 10587 | | | pvalues[1].bit8hfname = hf_bit8acflags; |
| 10588 | | | pvalues[1].bit9 = "Server Read"; |
| 10589 | | | pvalues[1].bit9hfname = hf_bit9acflags; |
| 10590 | | | pvalues[1].bit10 = "Write Managed"; |
| 10591 | | | pvalues[1].bit10hfname = hf_bit10acflags; |
| 10592 | | | pvalues[1].bit11 = "Per Replica"; |
| 10593 | | | pvalues[1].bit11hfname = hf_bit11acflags; |
| 10594 | | | pvalues[1].bit12 = "Never Schedule Synchronization"; |
| 10595 | | | pvalues[1].bit12hfname = hf_bit12acflags; |
| 10596 | | | pvalues[1].bit13 = "Operational"; |
| 10597 | | | pvalues[1].bit13hfname = hf_bit13acflags; |
| 10598 | | | pvalues[1].bit14 = "Not Defined"; |
| 10599 | | | pvalues[1].bit14hfname = hf_bit14acflags; |
| 10600 | | | pvalues[1].bit15 = "Not Defined"; |
| 10601 | | | pvalues[1].bit15hfname = hf_bit15acflags; |
| 10602 | | | pvalues[1].bit16 = "Not Defined"; |
| 10603 | | | pvalues[1].bit16hfname = hf_bit16acflags; |
| 10604 | | | foffset = foffset+4; |
| 10605 | | | pvalues[2].vtype = VTYPE_STRING; |
| 10606 | | | pvalues[2].vdesc = "Attribute Name: %s"; |
| 10607 | | | pvalues[2].mvtype = MVTYPE_ATTR_REQUEST; |
| 10608 | | | pvalues[2].vvalue = 0; |
| 10609 | | | pvalues[2].vlength = 256; |
| 10610 | | | pvalues[2].vlength = tvb_get_letohl(tvb, foffset); |
| 10611 | | | if (pvalues[2].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[2].vlength)) |
| 10612 | | | { |
| 10613 | | | pvalues[2].vtype = VTYPE_NONE; |
| 10614 | | | break; |
| 10615 | | | } |
| 10616 | | | pvalues[2].voffset = foffset+4; |
| 10617 | | | foffset = foffset + 4; |
| 10618 | | | pvalues[2].vstring = get_string(tvb, pvalues[2].voffset, pvalues[2].vlength); |
| 10619 | | | g_strlcpy(global_object_name, pvalues[2].vstring, 256); |
| 10620 | | | pvalues[2].hfname= hf_nds_name; |
| 10621 | | | foffset = foffset+pvalues[2].vlength; |
| 10622 | | | foffset += align_4(tvb, foffset); |
| 10623 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10624 | | | pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, nds_syntax); |
| 10625 | | | if(pvalues[3].vstring == NULL) |
| 10626 | | | { |
| 10627 | | | pvalues[3].vstring = "No Syntax Found"; |
| 10628 | | | } |
| 10629 | | | pvalues[3].vtype = VTYPE_STRING; |
| 10630 | | | pvalues[3].vdesc = "Syntax: %s"; |
| 10631 | | | pvalues[3].vlength = 4; |
| 10632 | | | pvalues[3].voffset = foffset; |
| 10633 | | | pvalues[3].hfname= hf_nds_syntax; |
| 10634 | | | pvalues[3].mvtype = 0; |
| 10635 | | | foffset = foffset+pvalues[3].vlength; |
| 10636 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 10637 | | | pvalues[4].vtype = VTYPE_UINT32; |
| 10638 | | | pvalues[4].vdesc = "Lower Limit Value %u"; |
| 10639 | | | pvalues[4].vlength = 4; |
| 10640 | | | pvalues[4].voffset = foffset; |
| 10641 | | | pvalues[4].hfname = hf_nds_lower; |
| 10642 | | | foffset += 4; |
| 10643 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 10644 | | | pvalues[5].vtype = VTYPE_UINT32; |
| 10645 | | | pvalues[5].vdesc = "Upper Limit Value %u"; |
| 10646 | | | pvalues[5].vlength = 4; |
| 10647 | | | pvalues[5].voffset = foffset; |
| 10648 | | | pvalues[5].hfname = hf_nds_upper; |
| 10649 | | | foffset += 4; |
| 10650 | | | pvalues[6].vvalue = tvb_get_letohl(tvb, foffset); |
| 10651 | | | foffset += 4; |
| 10652 | | | pvalues[6].vtype = VTYPE_BYTES; |
| 10653 | | | pvalues[6].vdesc = "ASN.1 ID"; |
| 10654 | | | pvalues[6].vlength = pvalues[6].vvalue; |
| 10655 | | | pvalues[6].voffset = foffset; |
| 10656 | | | pvalues[6].hfname = hf_nds_asn1; |
| 10657 | | | break; |
| 10658 | | | case 0x0c: |
| 10659 | | | pvalues[0].vtype = VTYPE_NONE; |
| 10660 | | | break; |
| 10661 | | | case 0x0d: |
| 10662 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10663 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10664 | | | pvalues[0].vdesc = "Version: %u"; |
| 10665 | | | pvalues[0].vlength = 4; |
| 10666 | | | pvalues[0].voffset = foffset; |
| 10667 | | | pvalues[0].hfname= hf_nds_ver; |
| 10668 | | | foffset = foffset+pvalues[0].vlength; |
| 10669 | | | pvalues[1].vtype = VTYPE_STRING; |
| 10670 | | | pvalues[1].vdesc = "Attribute Name: %s"; |
| 10671 | | | pvalues[1].mvtype = MVTYPE_ATTR_REQUEST; |
| 10672 | | | pvalues[1].vvalue = 0; |
| 10673 | | | pvalues[1].vlength = 256; |
| 10674 | | | pvalues[1].vlength = tvb_get_letohl(tvb, foffset); |
| 10675 | | | if (pvalues[1].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[1].vlength)) |
| 10676 | | | { |
| 10677 | | | pvalues[1].vtype = VTYPE_NONE; |
| 10678 | | | break; |
| 10679 | | | } |
| 10680 | | | pvalues[1].voffset = foffset+4; |
| 10681 | | | foffset = foffset + 4; |
| 10682 | | | pvalues[1].vstring = get_string(tvb, pvalues[1].voffset, pvalues[1].vlength); |
| 10683 | | | g_strlcpy(global_object_name, pvalues[1].vstring, 256); |
| 10684 | | | pvalues[1].hfname= hf_nds_attribute_dn; |
| 10685 | | | break; |
| 10686 | | | case 0x0e: |
| 10687 | | | pvalues[0].vtype = VTYPE_NONE; |
| 10688 | | | break; |
| 10689 | | | case 0x0f: |
| 10690 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10691 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10692 | | | pvalues[0].vdesc = "Version: %u"; |
| 10693 | | | pvalues[0].vlength = 4; |
| 10694 | | | pvalues[0].voffset = foffset; |
| 10695 | | | pvalues[0].hfname= hf_nds_ver; |
| 10696 | | | foffset = foffset+pvalues[0].vlength; |
| 10697 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10698 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10699 | | | pvalues[1].vdesc = "Iteration Handle: 0x%08x"; |
| 10700 | | | pvalues[1].vlength = 4; |
| 10701 | | | pvalues[1].voffset = foffset; |
| 10702 | | | pvalues[1].hfname= hf_nds_iteration; |
| 10703 | | | foffset = foffset+pvalues[1].vlength; |
| 10704 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10705 | | | global_flags = pvalues[2].vvalue; |
| 10706 | | | pvalues[2].vstring = (char *)match_strval(pvalues[2].vvalue, class_def_type); |
| 10707 | | | if(pvalues[2].vstring == NULL) |
| 10708 | | | { |
| 10709 | | | pvalues[2].vstring = "No Class Definition Type Set"; |
| 10710 | | | } |
| 10711 | | | pvalues[2].vtype = VTYPE_STRING; |
| 10712 | | | pvalues[2].vdesc = "Class Definition Type: %s"; |
| 10713 | | | pvalues[2].vlength = 4; |
| 10714 | | | pvalues[2].voffset = foffset; |
| 10715 | | | pvalues[2].mvtype = 0; |
| 10716 | | | pvalues[2].hfname= hf_nds_class_def_type; |
| 10717 | | | foffset = foffset + pvalues[2].vlength; |
| 10718 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 10719 | | | if (pvalues[3].vvalue == 0x00000000) |
| 10720 | | | { |
| 10721 | | | pvalues[3].vstring = "Do Not Return All Classes"; |
| 10722 | | | pvalues[3].mvtype = 0; |
| 10723 | | | } |
| 10724 | | | else |
| 10725 | | | { |
| 10726 | | | pvalues[3].vstring = "Return All Classes"; |
| 10727 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 10728 | | | } |
| 10729 | | | pvalues[3].vtype = VTYPE_STRING; |
| 10730 | | | pvalues[3].vdesc = "%s"; |
| 10731 | | | pvalues[3].vlength = 4; |
| 10732 | | | pvalues[3].voffset = foffset; |
| 10733 | | | pvalues[3].hfname= hf_nds_return_all_classes; |
| 10734 | | | foffset = foffset + pvalues[3].vlength; |
| 10735 | | | foffset += align_4(tvb, foffset); |
| 10736 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 10737 | | | pvalues[4].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10738 | | | pvalues[4].vdesc = "Classes: %u"; |
| 10739 | | | pvalues[4].vlength = 4; |
| 10740 | | | pvalues[4].voffset = foffset; |
| 10741 | | | pvalues[4].mvtype = MVTYPE_READ_CLASS_REQ; |
| 10742 | | | pvalues[4].hfname= hf_nds_classes; |
| 10743 | | | break; |
| 10744 | | | case 0x10: |
| 10745 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10746 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10747 | | | pvalues[0].vdesc = "Version: %u"; |
| 10748 | | | pvalues[0].vlength = 4; |
| 10749 | | | pvalues[0].voffset = foffset; |
| 10750 | | | pvalues[0].hfname= hf_nds_ver; |
| 10751 | | | foffset = foffset+pvalues[0].vlength; |
| 10752 | | | pvalues[1].vtype = VTYPE_STRING; |
| 10753 | | | pvalues[1].vdesc = "Class Name: %s"; |
| 10754 | | | pvalues[1].mvtype = MVTYPE_ATTR_REQUEST; |
| 10755 | | | pvalues[1].vvalue = 0; |
| 10756 | | | pvalues[1].vlength = 256; |
| 10757 | | | pvalues[1].vlength = tvb_get_letohl(tvb, foffset); |
| 10758 | | | if (pvalues[1].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[1].vlength)) |
| 10759 | | | { |
| 10760 | | | pvalues[1].vtype = VTYPE_NONE; |
| 10761 | | | break; |
| 10762 | | | } |
| 10763 | | | pvalues[1].voffset = foffset+4; |
| 10764 | | | foffset = foffset + 4; |
| 10765 | | | pvalues[1].vstring = get_string(tvb, pvalues[1].voffset, pvalues[1].vlength); |
| 10766 | | | g_strlcpy(global_object_name, pvalues[1].vstring, 256); |
| 10767 | | | pvalues[1].hfname= hf_nds_base_class; |
| 10768 | | | foffset = foffset+pvalues[1].vlength; |
| 10769 | | | foffset += align_4(tvb, foffset); |
| 10770 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10771 | | | pvalues[2].vtype = VTYPE_MULTIVALUE_UINT32; |
| 10772 | | | pvalues[2].vdesc = "Number of Attributes to Add: %u"; |
| 10773 | | | pvalues[2].vlength = 4; |
| 10774 | | | pvalues[2].voffset = foffset; |
| 10775 | | | pvalues[2].mvtype = MVTYPE_MODIFY_CLASS; |
| 10776 | | | pvalues[2].hfname= hf_nds_att_add; |
| 10777 | | | break; |
| 10778 | | | case 0x11: |
| 10779 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10780 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10781 | | | pvalues[0].vdesc = "Version: %u"; |
| 10782 | | | pvalues[0].vlength = 4; |
| 10783 | | | pvalues[0].voffset = foffset; |
| 10784 | | | pvalues[0].hfname= hf_nds_ver; |
| 10785 | | | foffset = foffset+pvalues[0].vlength; |
| 10786 | | | pvalues[1].vtype = VTYPE_STRING; |
| 10787 | | | pvalues[1].vdesc = "Class Name: %s"; |
| 10788 | | | pvalues[1].mvtype = MVTYPE_ATTR_REQUEST; |
| 10789 | | | pvalues[1].vvalue = 0; |
| 10790 | | | pvalues[1].vlength = 256; |
| 10791 | | | pvalues[1].vlength = tvb_get_letohl(tvb, foffset); |
| 10792 | | | if (pvalues[1].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[1].vlength)) |
| 10793 | | | { |
| 10794 | | | pvalues[1].vtype = VTYPE_NONE; |
| 10795 | | | break; |
| 10796 | | | } |
| 10797 | | | pvalues[1].voffset = foffset+4; |
| 10798 | | | foffset = foffset + 4; |
| 10799 | | | pvalues[1].vstring = get_string(tvb, pvalues[1].voffset, pvalues[1].vlength); |
| 10800 | | | g_strlcpy(global_object_name, pvalues[1].vstring, 256); |
| 10801 | | | pvalues[1].hfname= hf_nds_base; |
| 10802 | | | break; |
| 10803 | | | case 0x12: |
| 10804 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10805 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10806 | | | pvalues[0].vdesc = "Version: %u"; |
| 10807 | | | pvalues[0].vlength = 4; |
| 10808 | | | pvalues[0].voffset = foffset; |
| 10809 | | | pvalues[0].hfname= hf_nds_ver; |
| 10810 | | | foffset = foffset+pvalues[0].vlength; |
| 10811 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10812 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10813 | | | pvalues[1].vdesc = "Iteration Handle: 0x%08x"; |
| 10814 | | | pvalues[1].vlength = 4; |
| 10815 | | | pvalues[1].voffset = foffset; |
| 10816 | | | pvalues[1].hfname= hf_nds_iteration; |
| 10817 | | | foffset = foffset+pvalues[1].vlength; |
| 10818 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10819 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10820 | | | pvalues[2].vdesc = "Entry ID: 0x%08x"; |
| 10821 | | | pvalues[2].vlength = 4; |
| 10822 | | | resolve_eid = TRUE; |
| 10823 | | | global_eid = pvalues[2].vvalue; |
| 10824 | | | pvalues[2].voffset = foffset; |
| 10825 | | | pvalues[2].hfname= hf_nds_eid; |
| 10826 | | | foffset = foffset+pvalues[2].vlength; |
| 10827 | | | break; |
| 10828 | | | case 0x13: |
| 10829 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10830 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10831 | | | pvalues[0].vdesc = "Version: %u"; |
| 10832 | | | pvalues[0].vlength = 4; |
| 10833 | | | pvalues[0].voffset = foffset; |
| 10834 | | | pvalues[0].hfname= hf_nds_ver; |
| 10835 | | | foffset = foffset+pvalues[0].vlength; |
| 10836 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10837 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 10838 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 10839 | | | pvalues[1].vlength = 4; |
| 10840 | | | resolve_eid = TRUE; |
| 10841 | | | global_eid = pvalues[1].vvalue; |
| 10842 | | | pvalues[1].voffset = foffset; |
| 10843 | | | pvalues[1].hfname= hf_nds_eid; |
| 10844 | | | foffset = foffset+pvalues[1].vlength; |
| 10845 | | | pvalues[2].vtype = VTYPE_STRING; |
| 10846 | | | pvalues[2].vdesc = "Trustee Name: %s"; |
| 10847 | | | pvalues[2].mvtype = MVTYPE_ATTR_REQUEST; |
| 10848 | | | pvalues[2].vvalue = 0; |
| 10849 | | | pvalues[2].vlength = 256; |
| 10850 | | | pvalues[2].vlength = tvb_get_letohl(tvb, foffset); |
| 10851 | | | if (pvalues[2].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[2].vlength)) |
| 10852 | | | { |
| 10853 | | | pvalues[2].vtype = VTYPE_NONE; |
| 10854 | | | break; |
| 10855 | | | } |
| 10856 | | | pvalues[2].voffset = foffset+4; |
| 10857 | | | foffset = foffset + 4; |
| 10858 | | | pvalues[2].vstring = get_string(tvb, pvalues[2].voffset, pvalues[2].vlength); |
| 10859 | | | pvalues[2].hfname= hf_nds_name; |
| 10860 | | | foffset = foffset+pvalues[2].vlength; |
| 10861 | | | foffset += align_4(tvb, foffset); |
| 10862 | | | pvalues[3].vtype = VTYPE_STRING; |
| 10863 | | | pvalues[3].vdesc = "Attribute to be Checked: %s"; |
| 10864 | | | pvalues[3].mvtype = 0; |
| 10865 | | | pvalues[3].vvalue = 0; |
| 10866 | | | pvalues[3].vlength = 256; |
| 10867 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 10868 | | | if (pvalues[3].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 10869 | | | { |
| 10870 | | | pvalues[3].vtype = VTYPE_NONE; |
| 10871 | | | break; |
| 10872 | | | } |
| 10873 | | | pvalues[3].voffset = foffset+4; |
| 10874 | | | foffset = foffset + 4; |
| 10875 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 10876 | | | pvalues[3].hfname= hf_nds_name; |
| 10877 | | | foffset = foffset+pvalues[3].vlength; |
| 10878 | | | foffset += align_4(tvb, foffset); |
| 10879 | | | if(pvalues[0].vvalue != 0) |
| 10880 | | | { |
| 10881 | | | pvalues[4].vtype = VTYPE_STRING; |
| 10882 | | | pvalues[4].vdesc = "Security Equivalence: %s"; |
| 10883 | | | pvalues[4].mvtype = MVTYPE_ATTR_REQUEST; |
| 10884 | | | pvalues[4].vvalue = 0; |
| 10885 | | | pvalues[4].vlength = 256; |
| 10886 | | | pvalues[4].vlength = tvb_get_letohl(tvb, foffset); |
| 10887 | | | if (pvalues[4].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[4].vlength)) |
| 10888 | | | { |
| 10889 | | | pvalues[4].vtype = VTYPE_NONE; |
| 10890 | | | break; |
| 10891 | | | } |
| 10892 | | | pvalues[4].voffset = foffset+4; |
| 10893 | | | foffset = foffset + 4; |
| 10894 | | | pvalues[4].vstring = get_string(tvb, pvalues[4].voffset, pvalues[4].vlength); |
| 10895 | | | pvalues[4].hfname= hf_nds_name; |
| 10896 | | | foffset = foffset+pvalues[4].vlength; |
| 10897 | | | foffset += align_4(tvb, foffset); |
| 10898 | | | } |
| 10899 | | | break; |
| 10900 | | | case 0x14: |
| 10901 | | | pvalues[0].vtype = VTYPE_NONE; |
| 10902 | | | break; |
| 10903 | | | case 0x15: |
| 10904 | | | pvalues[0].vtype = VTYPE_NONE; |
| 10905 | | | break; |
| 10906 | | | case 0x16: |
| 10907 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 10908 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 10909 | | | pvalues[0].vdesc = "Version: %u"; |
| 10910 | | | pvalues[0].vlength = 4; |
| 10911 | | | pvalues[0].voffset = foffset; |
| 10912 | | | pvalues[0].hfname= hf_nds_ver; |
| 10913 | | | foffset = foffset+pvalues[0].vlength; |
| 10914 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 10915 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 10916 | | | pvalues[1].vdesc = "Request Flags:"; |
| 10917 | | | pvalues[1].vlength = 2; |
| 10918 | | | pvalues[1].hfname= hf_nds_rflags; |
| 10919 | | | pvalues[1].voffset = foffset; |
| 10920 | | | pvalues[1].bit1 = "Typeless"; |
| 10921 | | | pvalues[1].bit1hfname = hf_nds_bit1; |
| 10922 | | | pvalues[1].bit2 = "All Containers"; |
| 10923 | | | pvalues[1].bit2hfname = hf_nds_bit2; |
| 10924 | | | pvalues[1].bit3 = "Slashed"; |
| 10925 | | | pvalues[1].bit3hfname = hf_nds_bit3; |
| 10926 | | | pvalues[1].bit4 = "Dotted"; |
| 10927 | | | pvalues[1].bit4hfname = hf_nds_bit4; |
| 10928 | | | pvalues[1].bit5 = "Tuned"; |
| 10929 | | | pvalues[1].bit5hfname = hf_nds_bit5; |
| 10930 | | | pvalues[1].bit6 = "Not Defined"; |
| 10931 | | | pvalues[1].bit6hfname = hf_nds_bit6; |
| 10932 | | | pvalues[1].bit7 = "Not Defined"; |
| 10933 | | | pvalues[1].bit7hfname = hf_nds_bit7; |
| 10934 | | | pvalues[1].bit8 = "Not Defined"; |
| 10935 | | | pvalues[1].bit8hfname = hf_nds_bit8; |
| 10936 | | | pvalues[1].bit9 = "Not Defined"; |
| 10937 | | | pvalues[1].bit9hfname = hf_nds_bit9; |
| 10938 | | | pvalues[1].bit10 = "Not Defined"; |
| 10939 | | | pvalues[1].bit10hfname = hf_nds_bit10; |
| 10940 | | | pvalues[1].bit11 = "Not Defined"; |
| 10941 | | | pvalues[1].bit11hfname = hf_nds_bit11; |
| 10942 | | | pvalues[1].bit12 = "Not Defined"; |
| 10943 | | | pvalues[1].bit12hfname = hf_nds_bit12; |
| 10944 | | | pvalues[1].bit13 = "Not Defined"; |
| 10945 | | | pvalues[1].bit13hfname = hf_nds_bit13; |
| 10946 | | | pvalues[1].bit14 = "Not Defined"; |
| 10947 | | | pvalues[1].bit14hfname = hf_nds_bit14; |
| 10948 | | | pvalues[1].bit15 = "Not Defined"; |
| 10949 | | | pvalues[1].bit15hfname = hf_nds_bit15; |
| 10950 | | | pvalues[1].bit16 = "Not Defined"; |
| 10951 | | | pvalues[1].bit16hfname = hf_nds_bit16; |
| 10952 | | | foffset = foffset+pvalues[1].vlength; |
| 10953 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 10954 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 10955 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 10956 | | | pvalues[2].vlength = 4; |
| 10957 | | | pvalues[2].voffset = foffset; |
| 10958 | | | pvalues[2].hfname= hf_nds_iteration; |
| 10959 | | | foffset = foffset+pvalues[2].vlength; |
| 10960 | | | if(pvalues[0].vvalue == 0) |
| 10961 | | | { |
| 10962 | | | global_flags = 0x000000c0; |
| 10963 | | | break; |
| 10964 | | | } |
| 10965 | | | pvalues[3].vvalue = tvb_get_letohs(tvb, foffset); |
| 10966 | | | pvalues[3].vtype = VTYPE_BITFIELD; |
| 10967 | | | pvalues[3].vdesc = "Information Flags (low) Byte:"; |
| 10968 | | | pvalues[3].vlength = 2; |
| 10969 | | | pvalues[3].hfname= hf_nds_rflags; |
| 10970 | | | pvalues[3].voffset = foffset; |
| 10971 | | | pvalues[3].bit1 = "Output Flags"; |
| 10972 | | | pvalues[3].bit1hfname = hf_bit1l1flagsl; |
| 10973 | | | pvalues[3].bit2 = "Entry ID"; |
| 10974 | | | pvalues[3].bit2hfname = hf_bit2l1flagsl; |
| 10975 | | | pvalues[3].bit3 = "Replica State"; |
| 10976 | | | pvalues[3].bit3hfname = hf_bit3l1flagsl; |
| 10977 | | | pvalues[3].bit4 = "Modification Timestamp"; |
| 10978 | | | pvalues[3].bit4hfname = hf_bit4l1flagsl; |
| 10979 | | | pvalues[3].bit5 = "Purge Time"; |
| 10980 | | | pvalues[3].bit5hfname = hf_bit5l1flagsl; |
| 10981 | | | pvalues[3].bit6 = "Local Partition ID"; |
| 10982 | | | pvalues[3].bit6hfname = hf_bit6l1flagsl; |
| 10983 | | | pvalues[3].bit7 = "Distinguished Name"; |
| 10984 | | | pvalues[3].bit7hfname = hf_bit7l1flagsl; |
| 10985 | | | pvalues[3].bit8 = "Replica Type"; |
| 10986 | | | pvalues[3].bit8hfname = hf_bit8l1flagsl; |
| 10987 | | | pvalues[3].bit9 = "Partition Busy"; |
| 10988 | | | pvalues[3].bit9hfname = hf_bit9l1flagsl; |
| 10989 | | | pvalues[3].bit10 = "Not Defined"; |
| 10990 | | | pvalues[3].bit10hfname = hf_bit10l1flagsl; |
| 10991 | | | pvalues[3].bit11 = "Not Defined"; |
| 10992 | | | pvalues[3].bit11hfname = hf_bit11l1flagsl; |
| 10993 | | | pvalues[3].bit12 = "Not Defined"; |
| 10994 | | | pvalues[3].bit12hfname = hf_bit12l1flagsl; |
| 10995 | | | pvalues[3].bit13 = "Not Defined"; |
| 10996 | | | pvalues[3].bit13hfname = hf_bit13l1flagsl; |
| 10997 | | | pvalues[3].bit14 = "Not Defined"; |
| 10998 | | | pvalues[3].bit14hfname = hf_bit14l1flagsl; |
| 10999 | | | pvalues[3].bit15 = "Not Defined"; |
| 11000 | | | pvalues[3].bit15hfname = hf_bit15l1flagsl; |
| 11001 | | | pvalues[3].bit16 = "Not Defined"; |
| 11002 | | | pvalues[3].bit16hfname = hf_bit16l1flagsl; |
| 11003 | | | global_flags = pvalues[3].vvalue; |
| 11004 | | | foffset = foffset+2; |
| 11005 | | | pvalues[4].vvalue = tvb_get_letohs(tvb, foffset); |
| 11006 | | | pvalues[4].vtype = VTYPE_BITFIELD; |
| 11007 | | | pvalues[4].vdesc = "Information Flags (high) Byte:"; |
| 11008 | | | pvalues[4].vlength = 2; |
| 11009 | | | pvalues[4].hfname= hf_nds_rflags; |
| 11010 | | | pvalues[4].voffset = foffset; |
| 11011 | | | pvalues[4].bit1 = "Not Defined"; |
| 11012 | | | pvalues[4].bit1hfname = hf_bit1l1flagsl; |
| 11013 | | | pvalues[4].bit2 = "Not Defined"; |
| 11014 | | | pvalues[4].bit2hfname = hf_bit2l1flagsl; |
| 11015 | | | pvalues[4].bit3 = "Not Defined"; |
| 11016 | | | pvalues[4].bit3hfname = hf_bit3l1flagsl; |
| 11017 | | | pvalues[4].bit4 = "Not Defined"; |
| 11018 | | | pvalues[4].bit4hfname = hf_bit4l1flagsl; |
| 11019 | | | pvalues[4].bit5 = "Not Defined"; |
| 11020 | | | pvalues[4].bit5hfname = hf_bit5l1flagsl; |
| 11021 | | | pvalues[4].bit6 = "Not Defined"; |
| 11022 | | | pvalues[4].bit6hfname = hf_bit6l1flagsl; |
| 11023 | | | pvalues[4].bit7 = "Not Defined"; |
| 11024 | | | pvalues[4].bit7hfname = hf_bit7l1flagsl; |
| 11025 | | | pvalues[4].bit8 = "Not Defined"; |
| 11026 | | | pvalues[4].bit8hfname = hf_bit8l1flagsl; |
| 11027 | | | pvalues[4].bit9 = "Not Defined"; |
| 11028 | | | pvalues[4].bit9hfname = hf_bit9l1flagsl; |
| 11029 | | | pvalues[4].bit10 = "Not Defined"; |
| 11030 | | | pvalues[4].bit10hfname = hf_bit10l1flagsl; |
| 11031 | | | pvalues[4].bit11 = "Not Defined"; |
| 11032 | | | pvalues[4].bit11hfname = hf_bit11l1flagsl; |
| 11033 | | | pvalues[4].bit12 = "Not Defined"; |
| 11034 | | | pvalues[4].bit12hfname = hf_bit12l1flagsl; |
| 11035 | | | pvalues[4].bit13 = "Not Defined"; |
| 11036 | | | pvalues[4].bit13hfname = hf_bit13l1flagsl; |
| 11037 | | | pvalues[4].bit14 = "Not Defined"; |
| 11038 | | | pvalues[4].bit14hfname = hf_bit14l1flagsl; |
| 11039 | | | pvalues[4].bit15 = "Not Defined"; |
| 11040 | | | pvalues[4].bit15hfname = hf_bit15l1flagsl; |
| 11041 | | | pvalues[4].bit16 = "Not Defined"; |
| 11042 | | | pvalues[4].bit16hfname = hf_bit16l1flagsl; |
| 11043 | | | foffset = foffset+2; |
| 11044 | | | if(pvalues[0].vvalue == 1) |
| 11045 | | | { |
| 11046 | | | break; |
| 11047 | | | } |
| 11048 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 11049 | | | pvalues[5].vtype = VTYPE_UINT32; |
| 11050 | | | pvalues[5].vdesc = "Partition Root ID: 0x%08x"; |
| 11051 | | | pvalues[5].vlength = 4; |
| 11052 | | | pvalues[5].voffset = foffset; |
| 11053 | | | pvalues[5].hfname= hf_nds_partition_root_id; |
| 11054 | | | foffset = foffset+pvalues[5].vlength; |
| 11055 | | | break; |
| 11056 | | | case 0x17: |
| 11057 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11058 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11059 | | | pvalues[0].vdesc = "Version: %u"; |
| 11060 | | | pvalues[0].vlength = 4; |
| 11061 | | | pvalues[0].hfname = hf_nds_ver; |
| 11062 | | | pvalues[0].voffset = foffset; |
| 11063 | | | foffset = foffset+pvalues[0].vlength; |
| 11064 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11065 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11066 | | | pvalues[1].vdesc = "Flags: 0x%08x"; |
| 11067 | | | pvalues[1].vlength = 4; |
| 11068 | | | pvalues[1].hfname = hf_nds_req_flags; |
| 11069 | | | pvalues[1].voffset = foffset; |
| 11070 | | | foffset = foffset+pvalues[1].vlength; |
| 11071 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11072 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11073 | | | pvalues[2].vdesc = "New Partition Root ID: 0x%08x"; |
| 11074 | | | pvalues[2].vlength = 4; |
| 11075 | | | pvalues[2].voffset = foffset; |
| 11076 | | | pvalues[2].hfname= hf_nds_new_part_id; |
| 11077 | | | foffset = foffset+pvalues[2].vlength; |
| 11078 | | | break; |
| 11079 | | | case 0x18: |
| 11080 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11081 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11082 | | | pvalues[0].vdesc = "Version: %u"; |
| 11083 | | | pvalues[0].vlength = 4; |
| 11084 | | | pvalues[0].hfname = hf_nds_ver; |
| 11085 | | | pvalues[0].voffset = foffset; |
| 11086 | | | foffset = foffset+pvalues[0].vlength; |
| 11087 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11088 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11089 | | | pvalues[1].vdesc = "Flags: 0x%08x"; |
| 11090 | | | pvalues[1].vlength = 4; |
| 11091 | | | pvalues[1].hfname = hf_nds_req_flags; |
| 11092 | | | pvalues[1].voffset = foffset; |
| 11093 | | | foffset = foffset+pvalues[1].vlength; |
| 11094 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11095 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11096 | | | pvalues[2].vdesc = "Child Partition Root ID: 0x%08x"; |
| 11097 | | | pvalues[2].vlength = 4; |
| 11098 | | | pvalues[2].voffset = foffset; |
| 11099 | | | pvalues[2].hfname= hf_nds_child_part_id; |
| 11100 | | | foffset = foffset+pvalues[2].vlength; |
| 11101 | | | break; |
| 11102 | | | case 0x19: |
| 11103 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11104 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11105 | | | pvalues[0].vdesc = "Version: %u"; |
| 11106 | | | pvalues[0].vlength = 4; |
| 11107 | | | pvalues[0].hfname = hf_nds_ver; |
| 11108 | | | pvalues[0].voffset = foffset; |
| 11109 | | | foffset = foffset+pvalues[0].vlength; |
| 11110 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11111 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11112 | | | pvalues[1].vdesc = "Flags: 0x%08x"; |
| 11113 | | | pvalues[1].vlength = 4; |
| 11114 | | | pvalues[1].hfname = hf_nds_req_flags; |
| 11115 | | | pvalues[1].voffset = foffset; |
| 11116 | | | foffset = foffset+pvalues[1].vlength; |
| 11117 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11118 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11119 | | | pvalues[2].vdesc = "Master Partition Root ID: 0x%08x"; |
| 11120 | | | pvalues[2].vlength = 4; |
| 11121 | | | pvalues[2].voffset = foffset; |
| 11122 | | | pvalues[2].hfname= hf_nds_master_part_id; |
| 11123 | | | foffset = foffset+pvalues[2].vlength; |
| 11124 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 11125 | | | pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, nds_replica_type); |
| 11126 | | | if(pvalues[3].vstring == NULL) |
| 11127 | | | { |
| 11128 | | | pvalues[3].vstring = "No Replica Type Found"; |
| 11129 | | | } |
| 11130 | | | pvalues[3].vtype = VTYPE_STRING; |
| 11131 | | | pvalues[3].vdesc = "Replica Type: %s"; |
| 11132 | | | pvalues[3].vlength = 4; |
| 11133 | | | pvalues[3].voffset = foffset; |
| 11134 | | | pvalues[3].mvtype = 0; |
| 11135 | | | pvalues[3].hfname= hf_replica_type; |
| 11136 | | | foffset = foffset + pvalues[3].vlength; |
| 11137 | | | pvalues[4].vtype = VTYPE_STRING; |
| 11138 | | | pvalues[4].vdesc = "Target Server Name: %s"; |
| 11139 | | | pvalues[4].mvtype = 0; |
| 11140 | | | pvalues[4].vvalue = 0; |
| 11141 | | | pvalues[4].vlength = 256; |
| 11142 | | | pvalues[4].vlength = tvb_get_letohl(tvb, foffset); |
| 11143 | | | if (pvalues[4].vlength == 0x00 && !tvb_bytes_exist(tvb, foffset, pvalues[4].vlength)) |
| 11144 | | | { |
| 11145 | | | pvalues[4].vtype = VTYPE_NONE; |
| 11146 | | | break; |
| 11147 | | | } |
| 11148 | | | pvalues[4].voffset = foffset+4; |
| 11149 | | | foffset = foffset + 4; |
| 11150 | | | pvalues[4].vstring = get_string(tvb, pvalues[4].voffset, pvalues[4].vlength); |
| 11151 | | | pvalues[4].hfname= hf_nds_target_name; |
| 11152 | | | break; |
| 11153 | | | case 0x1a: |
| 11154 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11155 | | | break; |
| 11156 | | | case 0x1b: |
| 11157 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11158 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11159 | | | pvalues[0].vdesc = "Version: %u"; |
| 11160 | | | pvalues[0].vlength = 4; |
| 11161 | | | pvalues[0].hfname = hf_nds_ver; |
| 11162 | | | pvalues[0].voffset = foffset; |
| 11163 | | | foffset = foffset+pvalues[0].vlength; |
| 11164 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11165 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11166 | | | pvalues[1].vdesc = "Streams Flags: 0x%08x"; |
| 11167 | | | pvalues[1].vlength = 4; |
| 11168 | | | pvalues[1].hfname = hf_nds_stream_flags; |
| 11169 | | | pvalues[1].voffset = foffset; |
| 11170 | | | foffset = foffset+pvalues[1].vlength; |
| 11171 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11172 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11173 | | | pvalues[2].vdesc = "Entry ID: 0x%08x"; |
| 11174 | | | pvalues[2].vlength = 4; |
| 11175 | | | resolve_eid = TRUE; |
| 11176 | | | global_eid = pvalues[2].vvalue; |
| 11177 | | | pvalues[2].voffset = foffset; |
| 11178 | | | pvalues[2].hfname= hf_nds_eid; |
| 11179 | | | foffset = foffset+pvalues[2].vlength; |
| 11180 | | | pvalues[3].vtype = VTYPE_STRING; |
| 11181 | | | pvalues[3].vdesc = "Stream Name: %s"; |
| 11182 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 11183 | | | pvalues[3].vvalue = 0; |
| 11184 | | | pvalues[3].vlength = 256; |
| 11185 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 11186 | | | if (pvalues[3].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 11187 | | | { |
| 11188 | | | pvalues[3].vtype = VTYPE_NONE; |
| 11189 | | | break; |
| 11190 | | | } |
| 11191 | | | pvalues[3].voffset = foffset+4; |
| 11192 | | | foffset += 4; |
| 11193 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 11194 | | | foffset += pvalues[3].vlength; |
| 11195 | | | foffset += align_4(tvb, foffset); |
| 11196 | | | pvalues[3].hfname= hf_nds_stream_name; |
| 11197 | | | break; |
| 11198 | | | case 0x1c: |
| 11199 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11200 | | | break; |
| 11201 | | | case 0x1d: |
| 11202 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11203 | | | break; |
| 11204 | | | case 0x1e: |
| 11205 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11206 | | | break; |
| 11207 | | | case 0x1f: |
| 11208 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11209 | | | break; |
| 11210 | | | case 0x20: |
| 11211 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11212 | | | break; |
| 11213 | | | case 0x21: |
| 11214 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11215 | | | break; |
| 11216 | | | case 0x22: |
| 11217 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11218 | | | break; |
| 11219 | | | case 0x23: |
| 11220 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11221 | | | break; |
| 11222 | | | case 0x24: |
| 11223 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11224 | | | break; |
| 11225 | | | case 0x25: |
| 11226 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11227 | | | break; |
| 11228 | | | case 0x26: |
| 11229 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11230 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11231 | | | pvalues[0].vdesc = "Version: %u"; |
| 11232 | | | pvalues[0].vlength = 4; |
| 11233 | | | pvalues[0].hfname = hf_nds_ver; |
| 11234 | | | pvalues[0].voffset = foffset; |
| 11235 | | | foffset = foffset+pvalues[0].vlength; |
| 11236 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11237 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11238 | | | pvalues[1].vdesc = "Flags: 0x%08x"; |
| 11239 | | | pvalues[1].vlength = 4; |
| 11240 | | | pvalues[1].hfname = hf_nds_req_flags; |
| 11241 | | | pvalues[1].voffset = foffset; |
| 11242 | | | foffset = foffset+pvalues[1].vlength; |
| 11243 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11244 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11245 | | | pvalues[2].vdesc = "Time Delay in Seconds: %u"; |
| 11246 | | | pvalues[2].vlength = 4; |
| 11247 | | | pvalues[2].voffset = foffset; |
| 11248 | | | pvalues[2].hfname= hf_nds_time_delay; |
| 11249 | | | foffset = foffset+pvalues[2].vlength; |
| 11250 | | | if(pvalues[0].vvalue == 0) |
| 11251 | | | { |
| 11252 | | | pvalues[3].vtype = VTYPE_STRING; |
| 11253 | | | pvalues[3].vdesc = "Root Most Object Name: %s"; |
| 11254 | | | pvalues[3].mvtype = MVTYPE_ATTR_REQUEST; |
| 11255 | | | pvalues[3].vvalue = 0; |
| 11256 | | | pvalues[3].vlength = 256; |
| 11257 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 11258 | | | if (pvalues[3].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 11259 | | | { |
| 11260 | | | pvalues[3].vtype = VTYPE_NONE; |
| 11261 | | | break; |
| 11262 | | | } |
| 11263 | | | pvalues[3].voffset = foffset+4; |
| 11264 | | | foffset += 4; |
| 11265 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 11266 | | | foffset += pvalues[3].vlength; |
| 11267 | | | foffset += align_4(tvb, foffset); |
| 11268 | | | pvalues[3].hfname= hf_nds_root_name; |
| 11269 | | | } |
| 11270 | | | else |
| 11271 | | | { |
| 11272 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 11273 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 11274 | | | pvalues[3].vdesc = "Entry ID: 0x%08x"; |
| 11275 | | | pvalues[3].vlength = 4; |
| 11276 | | | resolve_eid = TRUE; |
| 11277 | | | global_eid = pvalues[3].vvalue; |
| 11278 | | | pvalues[3].voffset = foffset; |
| 11279 | | | pvalues[3].hfname= hf_nds_eid; |
| 11280 | | | foffset = foffset+pvalues[3].vlength; |
| 11281 | | | resolve_eid = TRUE; |
| 11282 | | | global_eid = pvalues[3].vvalue; |
| 11283 | | | } |
| 11284 | | | break; |
| 11285 | | | case 0x27: |
| 11286 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11287 | | | break; |
| 11288 | | | case 0x28: |
| 11289 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11290 | | | break; |
| 11291 | | | case 0x29: |
| 11292 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11293 | | | break; |
| 11294 | | | case 0x2a: |
| 11295 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11296 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11297 | | | pvalues[0].vdesc = "Version: %u"; |
| 11298 | | | pvalues[0].vlength = 4; |
| 11299 | | | pvalues[0].hfname = hf_nds_ver; |
| 11300 | | | pvalues[0].voffset = foffset; |
| 11301 | | | foffset = foffset+pvalues[0].vlength; |
| 11302 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11303 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11304 | | | pvalues[1].vdesc = "Flags: 0x%08x"; |
| 11305 | | | pvalues[1].vlength = 4; |
| 11306 | | | pvalues[1].hfname = hf_nds_req_flags; |
| 11307 | | | pvalues[1].voffset = foffset; |
| 11308 | | | foffset = foffset+pvalues[1].vlength; |
| 11309 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11310 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11311 | | | pvalues[2].vdesc = "Destination Parent Entry ID: 0x%08x"; |
| 11312 | | | pvalues[2].vlength = 4; |
| 11313 | | | resolve_eid = TRUE; |
| 11314 | | | global_eid = pvalues[2].vvalue; |
| 11315 | | | pvalues[2].voffset = foffset; |
| 11316 | | | pvalues[2].hfname= hf_nds_eid; |
| 11317 | | | foffset = foffset+pvalues[2].vlength; |
| 11318 | | | resolve_eid = TRUE; |
| 11319 | | | global_eid = pvalues[2].vvalue; |
| 11320 | | | pvalues[3].vtype = VTYPE_STRING; |
| 11321 | | | pvalues[3].vdesc = "New RDN: %s"; |
| 11322 | | | pvalues[3].mvtype = 0; |
| 11323 | | | pvalues[3].vvalue = 0; |
| 11324 | | | pvalues[3].vlength = 256; |
| 11325 | | | pvalues[3].vlength = tvb_get_letohl(tvb, foffset); |
| 11326 | | | pvalues[3].voffset = foffset+4; |
| 11327 | | | foffset = foffset + 4; |
| 11328 | | | pvalues[3].vstring = get_string(tvb, pvalues[3].voffset, pvalues[3].vlength); |
| 11329 | | | pvalues[3].hfname= hf_nds_new_rdn; |
| 11330 | | | foffset = foffset+pvalues[3].vlength; |
| 11331 | | | foffset += align_4(tvb, foffset); |
| 11332 | | | pvalues[4].vtype = VTYPE_STRING; |
| 11333 | | | pvalues[4].vdesc = "Source Server Name: %s"; |
| 11334 | | | pvalues[4].mvtype = 0; |
| 11335 | | | pvalues[4].vvalue = 0; |
| 11336 | | | pvalues[4].vlength = 256; |
| 11337 | | | pvalues[4].vlength = tvb_get_letohl(tvb, foffset); |
| 11338 | | | if (pvalues[4].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 11339 | | | { |
| 11340 | | | pvalues[4].vtype = VTYPE_NONE; |
| 11341 | | | break; |
| 11342 | | | } |
| 11343 | | | pvalues[4].voffset = foffset+4; |
| 11344 | | | foffset = foffset + 4; |
| 11345 | | | pvalues[4].vstring = get_string(tvb, pvalues[4].voffset, pvalues[4].vlength); |
| 11346 | | | pvalues[4].hfname= hf_nds_target_name; |
| 11347 | | | break; |
| 11348 | | | case 0x2b: |
| 11349 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11350 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11351 | | | pvalues[0].vdesc = "Version: %u"; |
| 11352 | | | pvalues[0].vlength = 4; |
| 11353 | | | pvalues[0].hfname = hf_nds_ver; |
| 11354 | | | pvalues[0].voffset = foffset; |
| 11355 | | | foffset = foffset+pvalues[0].vlength; |
| 11356 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11357 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11358 | | | pvalues[1].vdesc = (char *)match_strval(pvalues[1].vvalue, nds_verb2b_flag_vals); |
| 11359 | | | if(pvalues[1].vdesc == NULL) |
| 11360 | | | { |
| 11361 | | | pvalues[1].vdesc = "No Flag Definition Found"; |
| 11362 | | | } |
| 11363 | | | pvalues[1].vlength = 4; |
| 11364 | | | pvalues[1].hfname = hf_nds_verb2b_req_flags; |
| 11365 | | | pvalues[1].voffset = foffset; |
| 11366 | | | foffset = foffset+pvalues[1].vlength; |
| 11367 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11368 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11369 | | | pvalues[2].vdesc = "Source Entry ID: 0x%08x"; |
| 11370 | | | pvalues[2].vlength = 4; |
| 11371 | | | resolve_eid = TRUE; |
| 11372 | | | global_eid = pvalues[2].vvalue; |
| 11373 | | | pvalues[2].voffset = foffset; |
| 11374 | | | pvalues[2].hfname= hf_nds_eid; |
| 11375 | | | foffset = foffset+pvalues[2].vlength; |
| 11376 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 11377 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 11378 | | | pvalues[3].vdesc = "Destination Parent Entry ID: 0x%08x"; |
| 11379 | | | pvalues[3].vlength = 4; |
| 11380 | | | pvalues[3].voffset = foffset; |
| 11381 | | | pvalues[3].hfname= hf_nds_eid; |
| 11382 | | | foffset = foffset+pvalues[3].vlength; |
| 11383 | | | pvalues[4].vtype = VTYPE_STRING; |
| 11384 | | | pvalues[4].vdesc = "New RDN: %s"; |
| 11385 | | | pvalues[4].mvtype = 0; |
| 11386 | | | pvalues[4].vvalue = 0; |
| 11387 | | | pvalues[4].vlength = 256; |
| 11388 | | | pvalues[4].vlength = tvb_get_letohl(tvb, foffset); |
| 11389 | | | pvalues[4].voffset = foffset+4; |
| 11390 | | | foffset = foffset + 4; |
| 11391 | | | pvalues[4].vstring = get_string(tvb, pvalues[4].voffset, pvalues[4].vlength); |
| 11392 | | | pvalues[4].hfname= hf_nds_new_rdn; |
| 11393 | | | foffset = foffset+pvalues[4].vlength; |
| 11394 | | | foffset += align_4(tvb, foffset); |
| 11395 | | | pvalues[5].vtype = VTYPE_STRING; |
| 11396 | | | pvalues[5].vdesc = "Source Server Name: %s"; |
| 11397 | | | pvalues[5].mvtype = 0; |
| 11398 | | | pvalues[5].vvalue = 0; |
| 11399 | | | pvalues[5].vlength = 256; |
| 11400 | | | pvalues[5].vlength = tvb_get_letohl(tvb, foffset); |
| 11401 | | | if (pvalues[5].vlength == 0x00 || !tvb_bytes_exist(tvb, foffset, pvalues[3].vlength)) |
| 11402 | | | { |
| 11403 | | | pvalues[5].vtype = VTYPE_NONE; |
| 11404 | | | break; |
| 11405 | | | } |
| 11406 | | | pvalues[5].voffset = foffset+4; |
| 11407 | | | foffset = foffset + 4; |
| 11408 | | | pvalues[5].vstring = get_string(tvb, pvalues[5].voffset, pvalues[5].vlength); |
| 11409 | | | pvalues[5].hfname= hf_nds_target_name; |
| 11410 | | | break; |
| 11411 | | | case 0x2c: |
| 11412 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11413 | | | break; |
| 11414 | | | case 0x2d: |
| 11415 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11416 | | | break; |
| 11417 | | | case 0x2e: |
| 11418 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11419 | | | break; |
| 11420 | | | case 0x2f: |
| 11421 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11422 | | | break; |
| 11423 | | | case 0x30: |
| 11424 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11425 | | | break; |
| 11426 | | | case 0x31: |
| 11427 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11428 | | | break; |
| 11429 | | | case 0x32: |
| 11430 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11431 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11432 | | | pvalues[0].vdesc = "Version: %u"; |
| 11433 | | | pvalues[0].vlength = 4; |
| 11434 | | | pvalues[0].hfname = hf_nds_ver; |
| 11435 | | | pvalues[0].voffset = foffset; |
| 11436 | | | foffset = foffset+pvalues[0].vlength; |
| 11437 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11438 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11439 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 11440 | | | pvalues[2].vlength = 4; |
| 11441 | | | pvalues[2].voffset = foffset; |
| 11442 | | | pvalues[2].hfname= hf_nds_iteration; |
| 11443 | | | foffset = foffset+pvalues[2].vlength; |
| 11444 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 11445 | | | pvalues[3].vtype = VTYPE_STRING; |
| 11446 | | | pvalues[3].vdesc = "NDS Verb: %s"; |
| 11447 | | | pvalues[3].vstring = (char *)match_strval(pvalues[3].vvalue, ncp_nds_verb_vals); |
| 11448 | | | pvalues[3].vlength = 4; |
| 11449 | | | pvalues[3].voffset = foffset; |
| 11450 | | | pvalues[3].hfname= hf_mv_string; |
| 11451 | | | foffset = foffset+pvalues[3].vlength; |
| 11452 | | | break; |
| 11453 | | | case 0x33: |
| 11454 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11455 | | | break; |
| 11456 | | | case 0x34: |
| 11457 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11458 | | | break; |
| 11459 | | | case 0x35: |
| 11460 | | | if (nds_version != 0) |
| 11461 | | | { |
| 11462 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11463 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11464 | | | pvalues[0].vdesc = "Version: %u"; |
| 11465 | | | pvalues[0].vlength = 4; |
| 11466 | | | pvalues[0].hfname = hf_nds_ver; |
| 11467 | | | pvalues[0].voffset = foffset; |
| 11468 | | | foffset = foffset+pvalues[0].vlength; |
| 11469 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11470 | | | global_flags = pvalues[1].vvalue; |
| 11471 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 11472 | | | pvalues[1].vdesc = "Request Flags:"; |
| 11473 | | | pvalues[1].vlength = 2; |
| 11474 | | | pvalues[1].hfname= hf_nds_rflags; |
| 11475 | | | pvalues[1].voffset = foffset; |
| 11476 | | | pvalues[1].bit1 = "Typeless"; |
| 11477 | | | pvalues[1].bit1hfname = hf_bit1rflags; |
| 11478 | | | pvalues[1].bit2 = "Slashed"; |
| 11479 | | | pvalues[1].bit2hfname = hf_bit2rflags; |
| 11480 | | | pvalues[1].bit3 = "Dotted"; |
| 11481 | | | pvalues[1].bit3hfname = hf_bit3rflags; |
| 11482 | | | pvalues[1].bit4 = "Tuned"; |
| 11483 | | | pvalues[1].bit4hfname = hf_bit4rflags; |
| 11484 | | | pvalues[1].bit5 = "Not Defined"; |
| 11485 | | | pvalues[1].bit5hfname = hf_bit5rflags; |
| 11486 | | | pvalues[1].bit6 = "Not Defined"; |
| 11487 | | | pvalues[1].bit6hfname = hf_bit6rflags; |
| 11488 | | | pvalues[1].bit7 = "Not Defined"; |
| 11489 | | | pvalues[1].bit7hfname = hf_bit7rflags; |
| 11490 | | | pvalues[1].bit8 = "Not Defined"; |
| 11491 | | | pvalues[1].bit8hfname = hf_bit8rflags; |
| 11492 | | | pvalues[1].bit9 = "Not Defined"; |
| 11493 | | | pvalues[1].bit9hfname = hf_bit9rflags; |
| 11494 | | | pvalues[1].bit10 = "Not Defined"; |
| 11495 | | | pvalues[1].bit10hfname = hf_bit10rflags; |
| 11496 | | | pvalues[1].bit11 = "Not Defined"; |
| 11497 | | | pvalues[1].bit11hfname = hf_bit11rflags; |
| 11498 | | | pvalues[1].bit12 = "Not Defined"; |
| 11499 | | | pvalues[1].bit12hfname = hf_bit12rflags; |
| 11500 | | | pvalues[1].bit13 = "Not Defined"; |
| 11501 | | | pvalues[1].bit13hfname = hf_bit13rflags; |
| 11502 | | | pvalues[1].bit14 = "Not Defined"; |
| 11503 | | | pvalues[1].bit14hfname = hf_bit14rflags; |
| 11504 | | | pvalues[1].bit15 = "Not Defined"; |
| 11505 | | | pvalues[1].bit15hfname = hf_bit15rflags; |
| 11506 | | | pvalues[1].bit16 = "Not Defined"; |
| 11507 | | | pvalues[1].bit16hfname = hf_bit16rflags; |
| 11508 | | | } |
| 11509 | | | break; |
| 11510 | | | case 0x36: |
| 11511 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11512 | | | break; |
| 11513 | | | case 0x37: |
| 11514 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11515 | | | break; |
| 11516 | | | case 0x38: |
| 11517 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11518 | | | break; |
| 11519 | | | case 0x39: |
| 11520 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11521 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11522 | | | pvalues[0].vdesc = "Version: %u"; |
| 11523 | | | pvalues[0].vlength = 4; |
| 11524 | | | pvalues[0].voffset = foffset; |
| 11525 | | | pvalues[0].hfname= hf_nds_ver; |
| 11526 | | | foffset = foffset+pvalues[0].vlength; |
| 11527 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11528 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11529 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 11530 | | | pvalues[1].vlength = 4; |
| 11531 | | | resolve_eid = TRUE; |
| 11532 | | | global_eid = pvalues[1].vvalue; |
| 11533 | | | pvalues[1].voffset = foffset; |
| 11534 | | | pvalues[1].hfname= hf_nds_eid; |
| 11535 | | | foffset = foffset+pvalues[1].vlength; |
| 11536 | | | break; |
| 11537 | | | case 0x3a: |
| 11538 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11539 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11540 | | | pvalues[0].vdesc = "Reply Buffer Size: %u"; |
| 11541 | | | pvalues[0].vlength = 4; |
| 11542 | | | pvalues[0].voffset = foffset; |
| 11543 | | | pvalues[0].hfname= hf_nds_buffer_size; |
| 11544 | | | foffset = foffset+pvalues[0].vlength; |
| 11545 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11546 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11547 | | | pvalues[1].vdesc = "Version: %u"; |
| 11548 | | | pvalues[1].vlength = 4; |
| 11549 | | | pvalues[1].voffset = foffset; |
| 11550 | | | pvalues[1].hfname= hf_nds_ver; |
| 11551 | | | foffset = foffset+pvalues[1].vlength; |
| 11552 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11553 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11554 | | | pvalues[2].vdesc = "Entry ID: 0x%08x"; |
| 11555 | | | pvalues[2].vlength = 4; |
| 11556 | | | resolve_eid = TRUE; |
| 11557 | | | global_eid = pvalues[2].vvalue; |
| 11558 | | | pvalues[2].voffset = foffset; |
| 11559 | | | pvalues[2].hfname= hf_nds_eid; |
| 11560 | | | foffset = foffset+pvalues[2].vlength; |
| 11561 | | | break; |
| 11562 | | | case 0x3b: |
| 11563 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11564 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11565 | | | pvalues[0].vdesc = "Version: %u"; |
| 11566 | | | pvalues[0].vlength = 4; |
| 11567 | | | pvalues[0].voffset = foffset; |
| 11568 | | | pvalues[0].hfname= hf_nds_ver; |
| 11569 | | | foffset = foffset+pvalues[0].vlength; |
| 11570 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11571 | | | pvalues[1].vtype = VTYPE_UINT32; |
| 11572 | | | pvalues[1].vdesc = "Entry ID: 0x%08x"; |
| 11573 | | | pvalues[1].vlength = 4; |
| 11574 | | | resolve_eid = TRUE; |
| 11575 | | | global_eid = pvalues[1].vvalue; |
| 11576 | | | pvalues[1].voffset = foffset; |
| 11577 | | | pvalues[1].hfname= hf_nds_eid; |
| 11578 | | | foffset = foffset+pvalues[1].vlength; |
| 11579 | | | break; |
| 11580 | | | case 0x3c: |
| 11581 | | | break; |
| 11582 | | | case 0x3d: |
| 11583 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11584 | | | break; |
| 11585 | | | case 0x3e: |
| 11586 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11587 | | | break; |
| 11588 | | | case 0x3f: |
| 11589 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11590 | | | break; |
| 11591 | | | case 0x40: |
| 11592 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11593 | | | break; |
| 11594 | | | case 0x41: |
| 11595 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11596 | | | break; |
| 11597 | | | case 0x42: |
| 11598 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11599 | | | break; |
| 11600 | | | case 0x43: |
| 11601 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11602 | | | break; |
| 11603 | | | case 0x44: |
| 11604 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11605 | | | break; |
| 11606 | | | case 0x45: |
| 11607 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11608 | | | break; |
| 11609 | | | case 0x46: |
| 11610 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11611 | | | break; |
| 11612 | | | case 0x47: |
| 11613 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11614 | | | break; |
| 11615 | | | case 0x48: |
| 11616 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11617 | | | break; |
| 11618 | | | case 0x49: |
| 11619 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11620 | | | break; |
| 11621 | | | case 0x4a: |
| 11622 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11623 | | | break; |
| 11624 | | | case 0x4b: |
| 11625 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11626 | | | break; |
| 11627 | | | case 0x4c: |
| 11628 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11629 | | | break; |
| 11630 | | | case 0x4d: |
| 11631 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11632 | | | break; |
| 11633 | | | case 0x6e: |
| 11634 | | | pvalues[0].vvalue = tvb_get_letohl(tvb, foffset); |
| 11635 | | | pvalues[0].vtype = VTYPE_UINT32; |
| 11636 | | | pvalues[0].vdesc = "Version: %u"; |
| 11637 | | | pvalues[0].vlength = 4; |
| 11638 | | | pvalues[0].hfname = hf_nds_ver; |
| 11639 | | | pvalues[0].voffset = foffset; |
| 11640 | | | foffset = foffset+pvalues[0].vlength; |
| 11641 | | | pvalues[1].vvalue = tvb_get_letohl(tvb, foffset); |
| 11642 | | | global_flags = pvalues[1].vvalue; |
| 11643 | | | pvalues[1].vtype = VTYPE_BITFIELD; |
| 11644 | | | pvalues[1].vdesc = "Request Flags:"; |
| 11645 | | | pvalues[1].vlength = 2; |
| 11646 | | | pvalues[1].hfname= hf_nds_rflags; |
| 11647 | | | pvalues[1].voffset = foffset; |
| 11648 | | | pvalues[1].bit1 = "Typeless"; |
| 11649 | | | pvalues[1].bit1hfname = hf_bit1rflags; |
| 11650 | | | pvalues[1].bit2 = "Slashed"; |
| 11651 | | | pvalues[1].bit2hfname = hf_bit2rflags; |
| 11652 | | | pvalues[1].bit3 = "Dotted"; |
| 11653 | | | pvalues[1].bit3hfname = hf_bit3rflags; |
| 11654 | | | pvalues[1].bit4 = "Tuned"; |
| 11655 | | | pvalues[1].bit4hfname = hf_bit4rflags; |
| 11656 | | | pvalues[1].bit5 = "Not Defined"; |
| 11657 | | | pvalues[1].bit5hfname = hf_bit5rflags; |
| 11658 | | | pvalues[1].bit6 = "Not Defined"; |
| 11659 | | | pvalues[1].bit6hfname = hf_bit6rflags; |
| 11660 | | | pvalues[1].bit7 = "Not Defined"; |
| 11661 | | | pvalues[1].bit7hfname = hf_bit7rflags; |
| 11662 | | | pvalues[1].bit8 = "Not Defined"; |
| 11663 | | | pvalues[1].bit8hfname = hf_bit8rflags; |
| 11664 | | | pvalues[1].bit9 = "Not Defined"; |
| 11665 | | | pvalues[1].bit9hfname = hf_bit9rflags; |
| 11666 | | | pvalues[1].bit10 = "Not Defined"; |
| 11667 | | | pvalues[1].bit10hfname = hf_bit10rflags; |
| 11668 | | | pvalues[1].bit11 = "Not Defined"; |
| 11669 | | | pvalues[1].bit11hfname = hf_bit11rflags; |
| 11670 | | | pvalues[1].bit12 = "Not Defined"; |
| 11671 | | | pvalues[1].bit12hfname = hf_bit12rflags; |
| 11672 | | | pvalues[1].bit13 = "Not Defined"; |
| 11673 | | | pvalues[1].bit13hfname = hf_bit13rflags; |
| 11674 | | | pvalues[1].bit14 = "Not Defined"; |
| 11675 | | | pvalues[1].bit14hfname = hf_bit14rflags; |
| 11676 | | | pvalues[1].bit15 = "Not Defined"; |
| 11677 | | | pvalues[1].bit15hfname = hf_bit15rflags; |
| 11678 | | | pvalues[1].bit16 = "Not Defined"; |
| 11679 | | | pvalues[1].bit16hfname = hf_bit16rflags; |
| 11680 | | | foffset = foffset+pvalues[1].vlength+2; |
| 11681 | | | pvalues[2].vvalue = tvb_get_letohl(tvb, foffset); |
| 11682 | | | pvalues[2].vtype = VTYPE_UINT32; |
| 11683 | | | pvalues[2].vdesc = "Iteration Handle: 0x%08x"; |
| 11684 | | | pvalues[2].vlength = 4; |
| 11685 | | | pvalues[2].voffset = foffset; |
| 11686 | | | pvalues[2].hfname= hf_nds_iteration; |
| 11687 | | | foffset = foffset+pvalues[2].vlength; |
| 11688 | | | pvalues[3].vvalue = tvb_get_letohl(tvb, foffset); |
| 11689 | | | pvalues[3].vtype = VTYPE_UINT32; |
| 11690 | | | pvalues[3].vdesc = "Base Entry ID: 0x%08x"; |
| 11691 | | | pvalues[3].vlength = 4; |
| 11692 | | | resolve_eid = TRUE; |
| 11693 | | | global_eid = pvalues[3].vvalue; |
| 11694 | | | pvalues[3].voffset = foffset; |
| 11695 | | | pvalues[3].hfname= hf_nds_eid; |
| 11696 | | | foffset = foffset+pvalues[3].vlength; |
| 11697 | | | pvalues[4].vvalue = tvb_get_letohl(tvb, foffset); |
| 11698 | | | pvalues[4].vtype = VTYPE_UINT32; |
| 11699 | | | pvalues[4].vdesc = (char *)match_strval(pvalues[4].vvalue, nds_scope_vals); |
| 11700 | | | if(pvalues[4].vdesc == NULL) |
| 11701 | | | { |
| 11702 | | | pvalues[4].vdesc = "Unknown Scope Defined"; |
| 11703 | | | } |
| 11704 | | | pvalues[4].vlength = 4; |
| 11705 | | | pvalues[4].hfname = hf_nds_scope; |
| 11706 | | | pvalues[4].voffset = foffset; |
| 11707 | | | foffset = foffset+pvalues[4].vlength; |
| 11708 | | | pvalues[5].vvalue = tvb_get_letohl(tvb, foffset); |
| 11709 | | | pvalues[5].vtype = VTYPE_MULTIVALUE_UINT32; |
| 11710 | | | pvalues[5].vdesc = "Iterator: 0x%08x"; |
| 11711 | | | pvalues[5].vlength = 4; |
| 11712 | | | pvalues[5].voffset = foffset; |
| 11713 | | | pvalues[5].hfname= hf_nds_iterator; |
| 11714 | | | pvalues[5].mvtype = MVTYPE_PROCESS_ITERATOR; |
| 11715 | | | foffset = foffset+pvalues[5].vlength; |
| 11716 | | | break; |
| 11717 | | | default: |
| 11718 | | | pvalues[0].vtype = VTYPE_NONE; |
| 11719 | | | break; |
| 11720 | | | } |
| 11721 | | | } |
| 11722 | | | |
| 11723 | | | if (check_col(pinfo->cinfo, COL_INFO)) { |
Event 5:
Taking true branch. check_col(...) evaluates to true.
hide
|
|
| 11724 | | | if (ncp_rec) { |
Event 6:
Taking true branch. ncp_rec evaluates to true.
hide
|
|
| 11725 | | | col_set_str(pinfo->cinfo, COL_PROTOCOL, "NDS"); |
| 11726 | | | if (nds_frag != 0xffffffff) { |
Event 7:
Taking true branch. nds_frag != 4294967295 evaluates to true.
hide
|
|
| 11727 | | | col_add_fstr(pinfo->cinfo, COL_INFO, "C Continue NDS Fragment 0x%08x", nds_frag); |
| 11728 | | | } |
| 11729 | | | else { |
| 11730 | | | col_add_fstr(pinfo->cinfo, COL_INFO, "C NDS %s", verb_string); |
| 11731 | | | } |
| 11732 | | | run_info_str = TRUE; |
Event 8:
!0 evaluates to true.
hide
|
|
| 11733 | | | } |
| 11734 | | | else { |
| 11735 | | | col_add_fstr(pinfo->cinfo, COL_INFO, |
| 11736 | | | "C Unknown Function %d (0x%02x)", |
| 11737 | | | func, func); |
| 11738 | | | } |
| 11739 | | | |
| 11740 | | | } |
| 11741 | | | |
| 11742 | | | |
| 11743 | | | |
| 11744 | | | |
| 11745 | | | |
| 11746 | | | |
| 11747 | | | |
| 11748 | | | |
| 11749 | | | conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, |
| 11750 | | | PT_NCP, nw_connection, nw_connection, 0); |
| 11751 | | | if (conversation == NULL) { |
Event 9:
Taking true branch. conversation == (void *)0 evaluates to true.
hide
|
|
| 11752 | | | |
| 11753 | | | conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, |
| 11754 | | | PT_NCP, nw_connection, nw_connection, 0); |
| 11755 | | | } |
| 11756 | | | |
| 11757 | | | if (!pinfo->fd->flags.visited) { |
Event 10:
Taking true branch. pinfo->fd->flags.visited evaluates to false.
hide
|
|
| 11758 | | | request_value = ncp_hash_insert(conversation, sequence, ncp_rec); |
| 11759 | | | request_value->req_frame_num = pinfo->fd->num; |
| 11760 | | | request_value->req_frame_time=pinfo->fd->abs_ts; |
| 11761 | | | |
| 11762 | | | |
| 11763 | | | |
| 11764 | | | |
| 11765 | | | |
| 11766 | | | |
| 11767 | | | |
| 11768 | | | |
| 11769 | | | if (ncp_rec && !ncp_tree) { |
| 11770 | | | run_req_cond = TRUE; |
Event 12:
!0 evaluates to true.
hide
|
|
| 11771 | | | } |
| 11772 | | | |
| 11773 | | | request_value->nds_frag_num = nds_frag; |
| 11774 | | | } |
| 11775 | | | |
| 11776 | | | |
| 11777 | | | |
| 11778 | | | |
| 11779 | | | |
| 11780 | | | if ((run_info_str || run_req_cond) && !ncp_tree) { |
| 11781 | | | proto_item *ti; |
| 11782 | | | |
| 11783 | | | temp_tree = proto_tree_create_root(); |
| 11784 | | | proto_tree_set_visible(temp_tree, FALSE); |
| 11785 | | | ti = proto_tree_add_item(temp_tree, proto_ncp, tvb, 0, -1, FALSE); |
| 11786 | | | ncp_tree = proto_item_add_subtree(ti, ett_ncp); |
| 11787 | | | } |
| 11788 | | | |
| 11789 | | | if (ncp_tree) { |
Event 14:
Skipping " if". ncp_tree evaluates to false.
hide
|
|
| 11790 | | | |
| 11791 | | | |
| 11792 | | | |
| 11793 | | | |
| 11794 | | | |
| 11795 | | | |
| 11796 | | | |
| 11797 | | | |
| 11798 | | | CLEANUP_PUSH(free_proto_tree, temp_tree);
x /home/sate/Testcases/c/cve/wireshark-1.2.0/epan/except.h |
| |
124 | #define except_cleanup_push(F, C) \ |
125 | { \ |
126 | struct except_stacknode except_sn; \ |
127 | struct except_cleanup except_cl; \ |
128 | except_setup_clean(&except_sn, &except_cl, F, C) |
| |
|
| 11799 | | | |
| 11800 | | | #ifdef FAKE_TREE_IS_VISIBLE |
| 11801 | | | PTREE_DATA(ncp_tree)->visible=1;
x /home/sate/Testcases/c/cve/wireshark-1.2.0/epan/proto.h |
| |
346 | #define PTREE_DATA(proto_tree) ((proto_tree)->tree_data) |
| |
|
| 11802 | | | #endif |
| 11803 | | | |
| 11804 | | | request_value = ncp_hash_lookup(conversation, sequence); |
| 11805 | | | switch (type) { |
| 11806 | | | case NCP_BROADCAST_SLOT: |
| 11807 | | | ; |
| 11808 | | | break; |
| 11809 | | | |
| 11810 | | | case NCP_SERVICE_REQUEST: |
| 11811 | | | |
| 11812 | | | ptvc = ptvcursor_new(ncp_tree, tvb, 7); |
| 11813 | | | if (ncp_rec && ncp_rec->request_ptvc) |
| 11814 | | | { |
| 11815 | | | clear_repeat_vars(); |
| 11816 | | | process_ptvc_record(ptvc, ncp_rec->request_ptvc, NULL, TRUE, ncp_rec); |
| 11817 | | | } |
| 11818 | | | proto_tree_add_uint_format(ncp_tree, hf_ncp_func, tvb, 6, 1, |
| 11819 | | | func, "Function: %d (0x%02X), %s", |
| 11820 | | | func, func, ncp_rec ? ncp_rec->name : "Unknown"); |
| 11821 | | | |
| 11822 | | | proto_tree_add_uint_format(ncp_tree, hf_ncp_subfunc, tvb, 7, 1, |
| 11823 | | | subfunc, "SubFunction: %d (0x%02x)", |
| 11824 | | | subfunc, subfunc); |
| 11825 | | | |
| 11826 | | | proto_tree_add_uint(ncp_tree, hf_ncp_fragment_handle, tvb, 8, 4, |
| 11827 | | | nds_frag); |
| 11828 | | | |
| 11829 | | | if (nds_frag == 0xffffffff) { |
| 11830 | | | |
| 11831 | | | proto_tree_add_item(ncp_tree, hf_ncp_fragment_size, tvb, 12, 4, TRUE); |
| 11832 | | | |
| 11833 | | | proto_tree_add_item(ncp_tree, hf_ncp_message_size, tvb, 16, 4, TRUE); |
| 11834 | | | |
| 11835 | | | nds_prot_flags = tvb_get_letohs(tvb, 22); |
| 11836 | | | prot_flags[0].vvalue = nds_prot_flags; |
| 11837 | | | prot_flags[0].vtype = VTYPE_BITFIELD; |
| 11838 | | | prot_flags[0].vdesc = "NDS Protocol Flags:"; |
| 11839 | | | prot_flags[0].vlength = 2; |
| 11840 | | | prot_flags[0].hfname= hf_ncp_nds_flag; |
| 11841 | | | prot_flags[0].voffset = 22; |
| 11842 | | | prot_flags[0].bit1 = "Not Defined"; |
| 11843 | | | prot_flags[0].bit1hfname = hf_ndsprot1flag; |
| 11844 | | | prot_flags[0].bit2 = "Not Defined"; |
| 11845 | | | prot_flags[0].bit2hfname = hf_ndsprot2flag; |
| 11846 | | | prot_flags[0].bit3 = "Not Defined"; |
| 11847 | | | prot_flags[0].bit3hfname = hf_ndsprot3flag; |
| 11848 | | | prot_flags[0].bit4 = "Not Defined"; |
| 11849 | | | prot_flags[0].bit4hfname = hf_ndsprot4flag; |
| 11850 | | | prot_flags[0].bit5 = "Not Defined"; |
| 11851 | | | prot_flags[0].bit5hfname = hf_ndsprot5flag; |
| 11852 | | | prot_flags[0].bit6 = "Not Defined"; |
| 11853 | | | prot_flags[0].bit6hfname = hf_ndsprot6flag; |
| 11854 | | | prot_flags[0].bit7 = "Not Defined"; |
| 11855 | | | prot_flags[0].bit7hfname = hf_ndsprot7flag; |
| 11856 | | | prot_flags[0].bit8 = "Not Defined"; |
| 11857 | | | prot_flags[0].bit8hfname = hf_ndsprot8flag; |
| 11858 | | | prot_flags[0].bit9 = "Not Defined"; |
| 11859 | | | prot_flags[0].bit9hfname = hf_ndsprot9flag; |
| 11860 | | | prot_flags[0].bit10 = "Not Defined"; |
| 11861 | | | prot_flags[0].bit10hfname = hf_ndsprot10flag; |
| 11862 | | | prot_flags[0].bit11= "Not Defined"; |
| 11863 | | | prot_flags[0].bit11hfname = hf_ndsprot11flag; |
| 11864 | | | prot_flags[0].bit12 = "Not Defined"; |
| 11865 | | | prot_flags[0].bit12hfname = hf_ndsprot12flag; |
| 11866 | | | prot_flags[0].bit13 = "Not Defined"; |
| 11867 | | | prot_flags[0].bit13hfname = hf_ndsprot13flag; |
| 11868 | | | prot_flags[0].bit14 = "Not Defined"; |
| 11869 | | | prot_flags[0].bit14hfname = hf_ndsprot14flag; |
| 11870 | | | prot_flags[0].bit15 = "Include CRC in NDS "; |
| 11871 | | | prot_flags[0].bit15hfname = hf_ndsprot15flag; |
| 11872 | | | prot_flags[0].bit16 = "Client is a Server"; |
| 11873 | | | prot_flags[0].bit16hfname = hf_ndsprot16flag; |
| 11874 | | | |
| 11875 | | | process_bitfield(ncp_tree, tvb, &prot_flags[0]); |
| 11876 | | | |
| 11877 | | | if (nds_version == 0) { |
| 11878 | | | proto_tree_add_uint_format(ncp_tree, hf_ncp_nds_verb, tvb, 24, 4, |
| 11879 | | | nds_verb, "NDS Verb: %d, (0x%02x), %s", |
| 11880 | | | nds_verb, nds_verb, verb_string); |
| 11881 | | | } |
| 11882 | | | else { |
| 11883 | | | proto_tree_add_uint_format(ncp_tree, hf_ncp_nds_verb, tvb, 32, 4, |
| 11884 | | | nds_verb, "NDS Verb: %d, (0x%02x), %s", |
| 11885 | | | nds_verb, nds_verb, verb_string); |
| 11886 | | | } |
| 11887 | | | added_arrow = FALSE; |
| 11888 | | | for (i = 0; i < 9; i++) { |
| 11889 | | | switch (pvalues[i].vtype) { |
| 11890 | | | |
| 11891 | | | case VTYPE_NONE: |
| 11892 | | | break; |
| 11893 | | | |
| 11894 | | | case VTYPE_UINT8: |
| 11895 | | | proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, |
| 11896 | | | pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u", |
| 11897 | | | pvalues[i].vtype); |
| 11898 | | | break; |
| 11899 | | | |
| 11900 | | | case VTYPE_UINT16: |
| 11901 | | | proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, |
| 11902 | | | pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u", |
| 11903 | | | pvalues[i].vtype); |
| 11904 | | | break; |
| 11905 | | | |
| 11906 | | | case VTYPE_UINT32: |
| 11907 | | | proto_tree_add_uint_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, |
| 11908 | | | pvalues[i].vlength, pvalues[i].vvalue, pvalues[i].vdesc, |
| 11909 | | | pvalues[i].vvalue); |
| 11910 | | | break; |
| 11911 | | | |
| 11912 | | | case VTYPE_STRING: |
| 11913 | | | proto_tree_add_string_format(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, |
| 11914 | | | pvalues[i].vlength, pvalues[i].vstring, pvalues[i].vdesc, pvalues[i].vstring); |
| 11915 | | | if (pvalues[i].mvtype == MVTYPE_ATTR_REQUEST) { |
| 11916 | | | |
| 11917 | | | |
| 11918 | | | |
| 11919 | | | |
| 11920 | | | |
| 11921 | | | if (check_col(pinfo->cinfo, COL_INFO)) { |
| 11922 | | | if (!added_arrow) { |
| 11923 | | | col_append_str(pinfo->cinfo, COL_INFO, " -> "); |
| 11924 | | | added_arrow = TRUE; |
| 11925 | | | } |
| 11926 | | | col_append_str(pinfo->cinfo, COL_INFO, pvalues[i].vstring); |
| 11927 | | | } |
| 11928 | | | } |
| 11929 | | | break; |
| 11930 | | | |
| 11931 | | | case VTYPE_BITFIELD: |
| 11932 | | | process_bitfield(ncp_tree, tvb, &pvalues[i]); |
| 11933 | | | break; |
| 11934 | | | |
| 11935 | | | case VTYPE_MULTIVALUE_UINT32: |
| 11936 | | | process_multivalues(ncp_tree, tvb, pinfo, &pvalues[i]); |
| 11937 | | | if (pvalues[i].mvtype == MVTYPE_PROC_ENTRY_SPECIFIERS) { |
| 11938 | | | |
| 11939 | | | |
| 11940 | | | |
| 11941 | | | |
| 11942 | | | g_strlcpy(global_object_name, mv_resolve_name_string, 256); |
| 11943 | | | } |
| 11944 | | | if (pvalues[i].mvtype == MVTYPE_ATTR_REQUEST || pvalues[i].mvtype == MVTYPE_PROC_ENTRY_SPECIFIERS || pvalues[i].mvtype == MVTYPE_PROCESS_ITERATOR) { |
| 11945 | | | |
| 11946 | | | |
| 11947 | | | |
| 11948 | | | |
| 11949 | | | |
| 11950 | | | |
| 11951 | | | if (check_col(pinfo->cinfo, COL_INFO)) { |
| 11952 | | | col_append_str(pinfo->cinfo, COL_INFO, pvalues[i].vstring); |
| 11953 | | | if (pvalues[i].mvtype != MVTYPE_PROCESS_ITERATOR) { |
| 11954 | | | if (!added_arrow) { |
| 11955 | | | col_append_str(pinfo->cinfo, COL_INFO, " -> "); |
| 11956 | | | added_arrow = TRUE; |
| 11957 | | | } |
| 11958 | | | col_append_str(pinfo->cinfo, COL_INFO, mv_resolve_name_string); |
| 11959 | | | } |
| 11960 | | | } |
| 11961 | | | } |
| 11962 | | | break; |
| 11963 | | | |
| 11964 | | | case VTYPE_BYTES: |
| 11965 | | | proto_tree_add_bytes(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, |
| 11966 | | | pvalues[i].vlength, tvb_get_ptr(tvb, pvalues[i].voffset, pvalues[i].vvalue)); |
| 11967 | | | break; |
| 11968 | | | |
| 11969 | | | case VTYPE_BOOLEAN: |
| 11970 | | | proto_tree_add_item(ncp_tree, pvalues[i].hfname, tvb, pvalues[i].voffset, pvalues[i].vlength, TRUE); |
| 11971 | | | break; |
| 11972 | | | |
| 11973 | | | default: |
| 11974 | | | proto_tree_add_uint_format(ncp_tree, hf_nds_p1type, tvb, pvalues[i].voffset, |
| 11975 | | | pvalues[i].vlength, pvalues[i].vtype, "NDS Parameter not defined %u", |
| 11976 | | | pvalues[i].vtype); |
| 11977 | | | break; |
| 11978 | | | } |
| 11979 | | | } |
| 11980 | | | |
| 11981 | | | request_eid_value = ncp_eid_hash_lookup(conversation, global_eid); |
| 11982 | | | if(resolve_eid) { |
| 11983 | | | if (request_eid_value) { |
| 11984 | | | g_strlcpy(global_object_name, request_eid_value->object_name, 256); |
| 11985 | | | if (check_col(pinfo->cinfo, COL_INFO)) |
| 11986 | | | { |
| 11987 | | | col_append_str(pinfo->cinfo, COL_INFO, ", Object Name - "); |
| 11988 | | | col_append_str(pinfo->cinfo, COL_INFO, global_object_name); |
| 11989 | | | } |
| 11990 | | | } |
| 11991 | | | } |
| 11992 | | | if (request_value) |
| 11993 | | | { |
| 11994 | | | request_value->nds_request_verb = nds_verb; |
| 11995 | | | request_value->nds_version = nds_version; |
| 11996 | | | g_strlcpy(request_value->object_name, global_object_name, 256); |
| 11997 | | | request_value->req_nds_flags = global_flags; |
| 11998 | | | request_value->req_nds_prot_flags = nds_prot_flags; |
| 11999 | | | } |
| 12000 | | | } |
| 12001 | | | break; |
| 12002 | | | |
| 12003 | | | default: |
| 12004 | | | ; |
| 12005 | | | break; |
| 12006 | | | } |
| 12007 | | | ptvcursor_free(ptvc); |
| 12008 | | | |
| 12009 | | | |
| 12010 | | | CLEANUP_CALL_AND_POP;
x /home/sate/Testcases/c/cve/wireshark-1.2.0/epan/except.h |
| |
130 | #define except_cleanup_pop(E) \ |
131 | except_pop(); \ |
132 | if (E) \ |
133 | except_cl.except_func(except_cl.except_context); \ |
134 | } |
| |
|
| 12011 | | | } |
| 12012 | | | } |
| |