Text   |  XML   |  ReML   |   Visible Warnings:

Ignored Return Value  at packet-ses.c:671

No properties have been set. | edit properties
Jump to warning location ↓ warning details...
Show Events | Options

dissect_parameter

(/home/sate/Testcases/c/cve/wireshark-1.2.0/epan/dissectors/packet-ses.c)expand/collapse
Show more  
 336  dissect_parameter(tvbuff_t *tvb, int offset, proto_tree *tree,
 337      proto_tree *param_tree, packet_info *pinfo, guint8 param_type,
 338      guint16 param_len, struct SESSION_DATA_STRUCTURE *session)
 339  {
 340          gboolean has_user_information = TRUE;
 341          guint16       flags;
 342          proto_item   *tf;
 343          proto_tree   *flags_tree;
 344          asn1_ctx_t asn1_ctx;
 345          asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
 346   
 347          switch (param_type)
 348          {
 349          case Called_SS_user_Reference:
 350                  if (param_len == 0)
 351                          break;
 352                  if (tree)
 353                  {
 354                          proto_tree_add_item(param_tree,
 355                              hf_called_ss_user_reference,
 356                              tvb, offset, param_len, FALSE);
 357                  }
 358                  break;
 359   
 360          case Calling_SS_user_Reference:
 361                  if (param_len == 0)
 362                          break;
 363                  if (tree)
 364                  {
 365                          proto_tree_add_item(param_tree,
 366                              hf_calling_ss_user_reference,
 367                              tvb, offset, param_len, FALSE);
 368                  }
 369                  break;
 370   
 371          case Common_Reference:
 372                  if (param_len == 0)
 373                          break;
 374                  if (tree)
 375                  {
 376                          proto_tree_add_item(param_tree,
 377                              hf_common_reference,
 378                              tvb, offset, param_len, FALSE);
 379                  }
 380                  break;
 381   
 382          case Additional_Reference_Information:
 383                  if (param_len == 0)
 384                          break;
 385                  if (tree)
 386                  {
 387                          proto_tree_add_item(param_tree,
 388                              hf_additional_reference_information,
 389                              tvb, offset, param_len, FALSE);
 390                  }
 391                  break;
 392   
 393          case Token_Item:
 394                  if (param_len != 1)
 395                  {
 396                          proto_tree_add_text(param_tree, tvb, offset,
 397                              param_len, "Length is %u, should be 1",
 398                              param_len);
 399                          break;
 400                  }
 401                  if (tree)
 402                  {
 403                          flags = tvb_get_guint8(tvb, offset);
 404                          tf = proto_tree_add_uint(param_tree,
 405                              hf_token_item_options_flags, tvb, offset, 1,
 406                              flags);
 407                          flags_tree = proto_item_add_subtree(tf,
 408                              ett_token_item_flags);
 409                          proto_tree_add_boolean(flags_tree, hf_release_token,
 410                              tvb, offset, 1, flags);
 411                          proto_tree_add_boolean(flags_tree,
 412                              hf_major_activity_token, tvb, offset, 1, flags);
 413                          proto_tree_add_boolean(flags_tree,
 414                              hf_synchronize_minor_token, tvb, offset, 1, flags);
 415                          proto_tree_add_boolean(flags_tree, hf_data_token, tvb,
 416                              offset, 1, flags);
 417                  }
 418                  break;
 419   
 420          case Transport_Disconnect:
 421                  if (param_len != 1)
 422                  {
 423                          proto_tree_add_text(param_tree, tvb, offset,
 424                              param_len, "Length is %u, should be 1",
 425                              param_len);
 426                          break;
 427                  }
 428                  if (tree)
 429                  {
 430                          guint8       flags;
 431   
 432                          flags = tvb_get_guint8(tvb, offset);
 433                          if(flags & transport_connection_is_released )
 434                          {
 435                                  proto_tree_add_text(param_tree, tvb, offset, 1,
 436                                      "transport connection is released");
 437                          }
 438                          else 
 439                          {
 440                                  proto_tree_add_text(param_tree, tvb, offset, 1,
 441                                      "transport connection is kept");
 442                          }
 443   
 444                          if(flags & user_abort )
 445                          {
 446                                  proto_tree_add_text(param_tree, tvb, offset, 1,
 447                                      "user abort");
 448                                  session->abort_type = SESSION_USER_ABORT;
 449                          }
 450                          else 
 451                          {
 452                                  session->abort_type = SESSION_PROVIDER_ABORT;
 453                          }
 454   
 455                          if(flags & protocol_error )
 456                          {
 457                                  proto_tree_add_text(param_tree, tvb, offset, 1,
 458                                      "protocol error");
 459                          }
 460   
 461                          if(flags & no_reason )
 462                          {
 463                                  proto_tree_add_text(param_tree, tvb, offset, 1,
 464                                      "no reason");
 465                          }
 466   
 467                          if(flags & implementation_restriction )
 468                          {
 469                                  proto_tree_add_text(param_tree, tvb, offset, 1,
 470                                      "implementation restriction");
 471                          }
 472                  }
 473                  break;
 474   
 475          case Protocol_Options:
 476                  if (param_len != 1)
 477                  {
 478                          proto_tree_add_text(param_tree, tvb, offset,
 479                              param_len, "Length is %u, should be 1",
 480                              param_len);
 481                          break;
 482                  }
 483                  if (tree)
 484                  {
 485                          flags = tvb_get_guint8(tvb, offset);
 486                          tf = proto_tree_add_uint(param_tree,
 487                              hf_connect_protocol_options_flags, tvb, offset, 1,
 488                              flags);
 489                          flags_tree = proto_item_add_subtree(tf,  
 490                              ett_connect_protocol_options_flags);
 491                          proto_tree_add_boolean(flags_tree,  
 492                              hf_able_to_receive_extended_concatenated_SPDU,
 493                              tvb, offset, 1, flags);
 494                  }
 495                  break;
 496   
 497          case Session_Requirement:
 498                  if (param_len != 2)
 499                  {
 500                          proto_tree_add_text(param_tree, tvb, offset,
 501                              param_len, "Length is %u, should be 2",
 502                              param_len);
 503                          break;
 504                  }
 505                  if (tree)
 506                  {
 507                          flags = tvb_get_ntohs(tvb, offset);
 508                          tf = proto_tree_add_uint(param_tree,
 509                              hf_session_user_req_flags, tvb, offset, 2,
 510                              flags);
 511                          flags_tree = proto_item_add_subtree(tf,
 512                              ett_ses_req_options_flags);
 513                          proto_tree_add_boolean(flags_tree,
 514                              hf_session_exception_report, tvb, offset, 2, flags);
 515                          proto_tree_add_boolean(flags_tree,
 516                              hf_data_separation_function_unit, tvb, offset, 2,
 517                              flags);
 518                          proto_tree_add_boolean(flags_tree,
 519                              hf_symmetric_synchronize_function_unit,  
 520                              tvb, offset, 2, flags);
 521                          proto_tree_add_boolean(flags_tree,
 522                              hf_typed_data_function_unit, tvb, offset, 2, flags);
 523                          proto_tree_add_boolean(flags_tree,
 524                              hf_exception_function_unit, tvb, offset, 2, flags);
 525                          proto_tree_add_boolean(flags_tree,
 526                              hf_capability_function_unit, tvb, offset, 2, flags);
 527                          proto_tree_add_boolean(flags_tree,
 528                              hf_negotiated_release_function_unit,  
 529                              tvb, offset, 2, flags);
 530                          proto_tree_add_boolean(flags_tree,
 531                              hf_activity_management_function_unit,  
 532                              tvb, offset, 2, flags);
 533                          proto_tree_add_boolean(flags_tree,
 534                              hf_resynchronize_function_unit, tvb, offset, 2,
 535                              flags);
 536                          proto_tree_add_boolean(flags_tree,
 537                              hf_major_resynchronize_function_unit,  
 538                              tvb, offset, 2, flags);
 539                          proto_tree_add_boolean(flags_tree,
 540                              hf_minor_resynchronize_function_unit,  
 541                              tvb, offset, 2, flags);
 542                          proto_tree_add_boolean(flags_tree,  
 543                              hf_expedited_data_resynchronize_function_unit,
 544                              tvb, offset, 2, flags);
 545                          proto_tree_add_boolean(flags_tree,
 546                              hf_duplex_function_unit, tvb, offset, 2, flags);
 547                          proto_tree_add_boolean(flags_tree,
 548                              hf_half_duplex_function_unit,
 549                              tvb, offset, 2, flags);
 550                  }
 551                  break;
 552   
 553          case TSDU_Maximum_Size:
 554                  if (param_len != 4)
 555                  {
 556                          proto_tree_add_text(param_tree, tvb, offset,
 557                              param_len, "Length is %u, should be 4",
 558                              param_len);
 559                          break;
 560                  }
 561                  if (tree)
 562                  {
 563                          proto_tree_add_item(param_tree,
 564                              hf_proposed_tsdu_maximum_size_i2r,
 565                              tvb, offset, 2, FALSE);
 566                          proto_tree_add_item(param_tree,
 567                              hf_proposed_tsdu_maximum_size_r2i,
 568                              tvb, offset+2, 2, FALSE);
 569                  }
 570                  break;
 571   
 572          case Version_Number:
 573                  if (param_len != 1)
 574                  {
 575                          proto_tree_add_text(param_tree, tvb, offset,
 576                              param_len, "Length is %u, should be 1",
 577                              param_len);
 578                          break;
 579                  }
 580                  if (tree)
 581                  {
 582                          flags = tvb_get_guint8(tvb, offset);
 583                          tf = proto_tree_add_uint(param_tree,
 584                              hf_version_number_options_flags, tvb, offset, 1,
 585                              flags);
 586                          flags_tree = proto_item_add_subtree(tf,
 587                              ett_protocol_version_flags);
 588                          proto_tree_add_boolean(flags_tree,
 589                              hf_protocol_version_2, tvb, offset, 1, flags);
 590                          proto_tree_add_boolean(flags_tree,
 591                              hf_protocol_version_1, tvb, offset, 1, flags);
 592                  }
 593                  break;
 594   
 595          case Initial_Serial_Number:
 596                  if (param_len == 0)
 597                          break;
 598                  if (tree)
 599                  {
 600                          proto_tree_add_item(param_tree,
 601                              hf_initial_serial_number,
 602                              tvb, offset, param_len, FALSE);
 603                  }
 604                  break;
 605   
 606          case EnclosureItem:
 607                  if (param_len != 1)
 608                  {
 609                          proto_tree_add_text(param_tree, tvb, offset,
 610                              param_len, "Length is %u, should be 1",
 611                              param_len);
 612                          break;
 613                  }
 614                  flags = tvb_get_guint8(tvb, offset);
 615                  if (tree)
 616                  {
 617                          tf = proto_tree_add_uint(param_tree,
 618                              hf_enclosure_item_options_flags, tvb, offset, 1,
 619                              flags);
 620                          flags_tree = proto_item_add_subtree(tf,
 621                              ett_enclosure_item_flags);
 622                          proto_tree_add_boolean(flags_tree, hf_end_of_SSDU,
 623                              tvb, offset, 1, flags);
 624                          proto_tree_add_boolean(flags_tree, hf_beginning_of_SSDU,
 625                              tvb, offset, 1, flags);
 626                  }
 627                  if (flags & END_SPDU) {
 628                          /*
 629                           * In Data Transfer and Typed Data SPDUs,
 630                           * "The User Information Field shall be present
 631                           * if the Enclosure Item is not present, or has
 632                           * bit 2 = 0", which presumably means it shall 
 633                           * *not* be present if the Enclosure item *is*
 634                           * present and has bit 2 = 1.
 635                           */
 636                          has_user_information = FALSE;
 637                  }
 638                  break;
 639   
 640          case Token_Setting_Item:
 641                  if (param_len != 1)
 642                  {
 643                          proto_tree_add_text(param_tree, tvb, offset,
 644                              param_len, "Length is %u, should be 1",
 645                              param_len);
 646                          break;
 647                  }
 648                  if (tree)
 649                  {
 650                          proto_tree_add_item(param_tree,
 651                              hf_release_token_setting,
 652                              tvb, offset, 1, FALSE);
 653                          proto_tree_add_item(param_tree,
 654                              hf_major_activity_token_setting,
 655                              tvb, offset, 1, FALSE);
 656                          proto_tree_add_item(param_tree,
 657                              hf_synchronize_minor_token_setting,
 658                              tvb, offset, 1, FALSE);
 659                          proto_tree_add_item(param_tree,
 660                              hf_data_token_setting,
 661                              tvb, offset, 1, FALSE);
 662                  }
 663                  break;
 664   
 665          case Activity_Identifier:
 666                  if (param_len == 0)
 667                          break;
 668                  if (tree)
 669                  {
 670                          dissect_ber_integer(FALSE, &asn1_ctx, param_tree, tvb, offset,
 671                              hf_activity_identifier, NULL);
 672                  }
 673                  break;
 674   
 675          case Serial_Number:
 676                  if (param_len == 0)
 677                          break;
 678                  if (tree)
 679                  {
 680                          proto_tree_add_item(param_tree,
 681                              hf_serial_number,
 682                              tvb, offset, param_len, FALSE);
 683                  }
 684                  break;
 685   
 686          case Reason_Code:
 687  /*
 688          0:      Rejection by called SS-user; reason not specified.
 689          1:      Rejection by called SS-user due to temporary congestion.
 690          2:      Rejection by called SS-user. Subsequent octets may be used for user data  
 691  up to a length of 512 octets if Protocol Version 1 has been selected, and up  
 692  to a length such that the total length (including SI and LI)  of the SPDU  
 693  does not exceed 65 539 octets if Protocol Version 2 has been selected.
 694          128 + 1:        Session Selector unknown.
 695          128 + 2:        SS-user not attached to SSAP.
 696          128 + 3:        SPM congestion at connect time.
 697          128 + 4:        Proposed protocol versions not supported.
 698          128 + 5:        Rejection by the SPM; reason not specified.
 699          128 + 6:        Rejection by the SPM; implementation restriction stated in the 
 700  PICS.    */
 701                  if (param_len < 1)
 702                  {
 703                          proto_tree_add_text(param_tree, tvb, offset,
 704                              param_len, "Length is %u, should be >= 1",
 705                              param_len);
 706                          break;
 707                  }
 708                  if (tree)
 709                  {
 710                          guint8      reason_code;
 711   
 712                          reason_code = tvb_get_guint8(tvb, offset);
 713                          proto_tree_add_text(param_tree, tvb, offset, 1,
 714                              "Reason Code: %s",
 715                              val_to_str(reason_code, reason_vals, "Unknown (%u)"));
 716                  }
 717                  offset++;
 718                  param_len--;
 719                  if (param_len != 0)
 720                  {
 721                          call_pres_dissector(tvb, offset, param_len,
 722                              pinfo, tree, param_tree, session);
 723                  }
 724                  break;
 725   
 726          case Calling_Session_Selector:
 727                  if (param_len == 0)
 728                          break;
 729                  if (tree)
 730                  {
 731                          proto_tree_add_item(param_tree,
 732                              hf_calling_session_selector,
 733                              tvb, offset, param_len, FALSE);
 734                  }
 735                  break;
 736   
 737          case Called_Session_Selector:
 738                  if (param_len == 0)
 739                          break;
 740                  if (tree)
 741                  {
 742                          proto_tree_add_item(param_tree,
 743                              hf_called_session_selector,
 744                              tvb, offset, param_len, FALSE);
 745                  }
 746                  break;
 747   
 748          case Second_Serial_Number:
 749                  if (param_len == 0)
 750                          break;
 751                  if (tree)
 752                  {
 753                          proto_tree_add_item(param_tree,
 754                              hf_second_serial_number,
 755                              tvb, offset, param_len, FALSE);
 756                  }
 757                  break;
 758   
 759          case Second_Initial_Serial_Number:
 760                  if (param_len == 0)
 761                          break;
 762                  if (tree)
 763                  {
 764                          proto_tree_add_item(param_tree,
 765                              hf_second_initial_serial_number,
 766                              tvb, offset, param_len, FALSE);
 767                  }
 768                  break;
 769   
 770          case Large_Initial_Serial_Number:
 771                  if (param_len == 0)
 772                          break;
 773                  if (tree)
 774                  {
 775                          proto_tree_add_item(param_tree,
 776                              hf_large_initial_serial_number,
 777                              tvb, offset, param_len, FALSE);
 778                  }
 779                  break;
 780   
 781          case Large_Second_Initial_Serial_Number:
 782                  if (param_len == 0)
 783                          break;
 784                  if (tree)
 785                  {
 786                          proto_tree_add_item(param_tree,
 787                              hf_large_second_initial_serial_number,
 788                              tvb, offset, param_len, FALSE);
 789                  }
 790                  break;
 791   
 792          default:
 793                  break;
 794          }
 795          return has_user_information;
 796  }
Show more  




Change Warning 5400.35612 : Ignored Return Value

Priority:
State:
Finding:
Owner:
Note: