Text   |  XML   |  ReML   |   Visible Warnings:

Unreachable Data Flow  at editcap.c:1177

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

main

(/home/sate/Testcases/c/cve/wireshark-1.2.0/editcap.c)expand/collapse
Show more  
 670  main(int argc, char *argv[])
 671  {
 672    wtap *wth;
 673    int i, j, err;
 674    gchar *err_info;
 675    extern char *optarg;
 676    extern int optind;
 677    int opt;
 678    char *p;
 679    unsigned int snaplen = 0;             /* No limit               */
 680    unsigned int choplen = 0;             /* No chop                */
 681    wtap_dumper *pdh = NULL;
 682    int count = 1;
 683    unsigned duplicate_count = 0;
 684    gint64 data_offset;
 685    struct wtap_pkthdr snap_phdr;
 686    const struct wtap_pkthdr *phdr;
 687    int err_type;
 688    guint8 *buf;
 689    int split_packet_count = 0;
 690    int written_count = 0;
 691    char *filename = NULL;
 692    gboolean check_ts;
 693    int secs_per_block = 0;
 694    int block_cnt = 0;
 695    nstime_t block_start;
 696    gchar *fprefix = NULL;
 697    gchar *fsuffix = NULL;
 698   
 699  #ifdef HAVE_PLUGINS 
 700    char* init_progfile_dir_error;
 701  #endif
 702   
 703    /*
 704     * Get credential information for later use.
 705     */
 706    get_credential_info();
 707   
 708  #ifdef HAVE_PLUGINS 
 709    /* Register wiretap plugins */
 710    if ((init_progfile_dir_error = init_progfile_dir(argv[0], main))) {
 711      g_warning("capinfos: init_progfile_dir(): %s", init_progfile_dir_error);
 712      g_free(init_progfile_dir_error);
 713    } else {
 714      init_report_err(failure_message,NULL,NULL,NULL);
 715      init_plugins();
 716    }
 717  #endif
 718   
 719    /* Process the options */
 720    while ((opt = getopt(argc, argv, "A:B:c:C:dD:E:F:hrs:i:t:T:vw:")) !=-1) {
 721   
 722      switch (opt) {
 723   
 724      case 'E':
 725        err_prob = strtod(optarg, &p);
 726        if (p == optarg || err_prob < 0.0 || err_prob > 1.0) {
 727          fprintf(stderr, "editcap: probability \"%s\" must be between 0.0 and 1.0\n",
 728              optarg);
 729          exit(1);
 730        }
 731        srand( (unsigned int) (time(NULL) + getpid()) );
 732        break;
 733   
 734      case 'F':
 735        out_file_type = wtap_short_string_to_file_type(optarg);
 736        if (out_file_type < 0) {
 737          fprintf(stderr, "editcap: \"%s\" isn't a valid capture file type\n\n",
 738              optarg);
 739          list_capture_types();
 740          exit(1);
 741        }
 742        break;
 743   
 744      case 'c':
 745        split_packet_count = strtol(optarg, &p, 10);
 746        if (p == optarg || *p != '\0') {
 747          fprintf(stderr, "editcap: \"%s\" isn't a valid packet count\n",
 748              optarg);
 749          exit(1);
 750        }
 751        if (split_packet_count <= 0) {
 752          fprintf(stderr, "editcap: \"%d\" packet count must be larger than zero\n",
 753              split_packet_count);
 754          exit(1);
 755        }
 756        break;
 757   
 758      case 'C':
 759        choplen = strtol(optarg, &p, 10);
 760        if (p == optarg || *p != '\0') {
 761          fprintf(stderr, "editcap: \"%s\" isn't a valid chop length\n",
 762              optarg);
 763          exit(1);
 764        }
 765        break;
 766   
 767      case 'd':
 768        dup_detect = TRUE;
 769        dup_detect_by_time = FALSE;
 770        dup_window = DEFAULT_DUP_DEPTH;
 771        break;
 772   
 773      case 'D':
 774        dup_detect = TRUE;
 775        dup_detect_by_time = FALSE;
 776        dup_window = strtol(optarg, &p, 10);
 777        if (p == optarg || *p != '\0') {
 778          fprintf(stderr, "editcap: \"%s\" isn't a valid dupicate window value\n",
 779              optarg);
 780          exit(1);
 781        }
 782        if (dup_window < 0 || dup_window > MAX_DUP_DEPTH) {
 783          fprintf(stderr, "editcap: \"%d\" duplicate window value must be between 0 and %d inclusive.\n",
 784              dup_window, MAX_DUP_DEPTH);
 785          exit(1);
 786        }
 787        break;
 788   
 789      case 'w':
 790        dup_detect = FALSE;
 791        dup_detect_by_time = TRUE;
 792        dup_window = MAX_DUP_DEPTH;
 793        set_rel_time(optarg);
 794        break;
 795   
 796      case '?':              /* Bad options if GNU getopt */
 797        switch(optopt) {
 798        case'F':
 799          list_capture_types();
 800          break;
 801        case'T':
 802          list_encap_types();
 803          break;
 804        default:
 805          usage();
 806        }
 807        exit(1);
 808        break;
 809   
 810      case 'h':
 811        usage();
 812        exit(1);
 813        break;
 814   
 815      case 'r':
 816        keep_em = !keep_em;  /* Just invert */
 817        break;
 818   
 819      case 's':
 820        snaplen = strtol(optarg, &p, 10);
 821        if (p == optarg || *p != '\0') {
 822          fprintf(stderr, "editcap: \"%s\" isn't a valid snapshot length\n",
 823                  optarg);
 824          exit(1);
 825        }
 826        break;
 827   
 828      case 't':
 829        set_time_adjustment(optarg);
 830        break;
 831   
 832      case 'T':
 833        out_frame_type = wtap_short_string_to_encap(optarg);
 834        if (out_frame_type < 0) {
 835          fprintf(stderr, "editcap: \"%s\" isn't a valid encapsulation type\n\n",
 836              optarg);
 837          list_encap_types();
 838          exit(1);
 839        }
 840        break;
 841   
 842      case 'v':
 843        verbose = !verbose;  /* Just invert */
 844        break;
 845   
 846      case 'i': /* break capture file based on time interval */
 847        secs_per_block = atoi(optarg);
 848        if(secs_per_block <= 0) {
 849          fprintf(stderr, "editcap: \"%s\" isn't a valid time interval\n\n", optarg);
 850          exit(1);
 851          }
 852        break;
 853   
 854      case 'A':
 855      {
 856        struct tm starttm;
 857   
 858        memset(&starttm,0,sizeof(struct tm));
 859   
 860        if(!strptime(optarg,"%Y-%m-%d %T",&starttm)) {
 861          fprintf(stderr, "editcap: \"%s\" isn't a valid time format\n\n", optarg);
 862          exit(1);
 863        }
 864   
 865        check_startstop = TRUE;
 866        starttm.tm_isdst = -1;
 867   
 868        starttime = mktime(&starttm);
 869        break;
 870      }
 871   
 872      case 'B':
 873      {
 874        struct tm stoptm;
 875   
 876        memset(&stoptm,0,sizeof(struct tm));
 877   
 878        if(!strptime(optarg,"%Y-%m-%d %T",&stoptm)) {
 879          fprintf(stderr, "editcap: \"%s\" isn't a valid time format\n\n", optarg);
 880          exit(1);
 881        }
 882        check_startstop = TRUE;
 883        stoptm.tm_isdst = -1;
 884        stoptime = mktime(&stoptm);
 885        break;
 886      }
 887      }
 888   
 889    }
 890   
 891  #ifdef DEBUG 
 892    printf("Optind = %i, argc = %i\n", optind, argc);
 893  #endif
 894   
 895    if ((argc - optind) < 1) {
 896   
 897      usage();
 898      exit(1);
 899   
 900    }
 901   
 902    if (check_startstop && !stoptime) {
 903      struct tm stoptm;
 904      /* XXX: will work until 2035 */
 905      memset(&stoptm,0,sizeof(struct tm));
 906      stoptm.tm_year = 135;
 907      stoptm.tm_mday = 31;
 908      stoptm.tm_mon = 11;
 909   
 910      stoptime = mktime(&stoptm);
 911    }
 912   
 913    nstime_set_unset(&block_start);
 914   
 915    if (starttime > stoptime) {
 916      fprintf(stderr, "editcap: start time is after the stop time\n");
 917      exit(1);
 918    }
 919   
 920    if (split_packet_count > 0 && secs_per_block > 0) {
 921      fprintf(stderr, "editcap: can't split on both packet count and time interval\n");
 922      fprintf(stderr, "editcap: at the same time\n");
 923      exit(1);
 924    }
 925   
 926    wth = wtap_open_offline(argv[optind], &err, &err_info, FALSE);
 927   
 928    if (!wth) {
 929      fprintf(stderr, "editcap: Can't open %s: %s\n", argv[optind],
 930          wtap_strerror(err));
 931      switch (err) {
 932   
 933      case WTAP_ERR_UNSUPPORTED:
 934      case WTAP_ERR_UNSUPPORTED_ENCAP:
 935      case WTAP_ERR_BAD_RECORD:
 936        fprintf(stderr, "(%s)\n", err_info);
 937        g_free(err_info);
 938        break;
 939      }
 940      exit(2);
 941   
 942    }
 943   
 944    if (verbose) {
 945      fprintf(stderr, "File %s is a %s capture file.\n", argv[optind],
 946              wtap_file_type_string(wtap_file_type(wth)));
 947    }
 948   
 949    /*
 950     * Now, process the rest, if any ... we only write if there is an extra
 951     * argument or so ...
 952     */
 953   
 954    if ((argc - optind) >= 2) {
 955   
 956      if (out_frame_type == -2)
 957        out_frame_type = wtap_file_encap(wth);
 958   
 959      for (i = optind + 2; i < argc; i++)
 960        if (add_selection(argv[i]) == FALSE)
 961          break;
 962   
 963      if (dup_detect || dup_detect_by_time) {
 964        for (i = 0; i < dup_window; i++) {
 965          memset(&fd_hash[i].digest, 0, 16);
 966          fd_hash[i].len = 0;
 967          nstime_set_unset(&fd_hash[i].time);
 968        }
 969      }
 970   
 971      while (wtap_read(wth, &err, &err_info, &data_offset)) {
 972        phdr = wtap_phdr(wth);
 973   
 974        if (nstime_is_unset(&block_start)) {  /* should only be the first packet */
 975          block_start.secs = phdr->ts.secs;
 976          block_start.nsecs = phdr->ts.nsecs;
 977   
 978          if (split_packet_count > 0 || secs_per_block > 0) {
 979            if (!fileset_extract_prefix_suffix(argv[optind+1], &fprefix, &fsuffix))
 980                exit(2);
 981   
 982            filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
 983          } else 
 984            filename = g_strdup(argv[optind+1]);
 985   
 986          pdh = wtap_dump_open(filename, out_file_type,
 987              out_frame_type, wtap_snapshot_length(wth),
 988              FALSE /* compressed */, &err);
 989          if (pdh == NULL) {  
 990            fprintf(stderr, "editcap: Can't open or create %s: %s\n", filename,
 991                    wtap_strerror(err));
 992            exit(2);
 993          }
 994        }
 995   
 996        g_assert(filename);
 997   
 998        if (secs_per_block > 0) {
 999          while ((phdr->ts.secs - block_start.secs >  secs_per_block) ||
 1000                 (phdr->ts.secs - block_start.secs == secs_per_block &&
 1001                  phdr->ts.nsecs >= block_start.nsecs )) { /* time for the next file */
 1002   
 1003            if (!wtap_dump_close(pdh, &err)) {
 1004              fprintf(stderr, "editcap: Error writing to %s: %s\n", filename,
 1005                  wtap_strerror(err));
 1006              exit(2);
 1007            }
 1008            block_start.secs = block_start.secs +  secs_per_block; /* reset for next interval */
 1009            g_free(filename);
 1010            filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
 1011            g_assert(filename);
 1012   
 1013            if (verbose) {
 1014              fprintf(stderr, "Continuing writing in file %s\n", filename);
 1015            }
 1016   
 1017            pdh = wtap_dump_open(filename, out_file_type,
 1018               out_frame_type, wtap_snapshot_length(wth), FALSE /* compressed */, &err);
 1019   
 1020            if (pdh == NULL) {
 1021              fprintf(stderr, "editcap: Can't open or create %s: %s\n", filename,
 1022                wtap_strerror(err));
 1023              exit(2);
 1024            }
 1025          }
 1026        }
 1027   
 1028        if (split_packet_count > 0) {
 1029   
 1030          /* time for the next file? */
 1031          if (written_count > 0 &&  
 1032              written_count % split_packet_count == 0) {
 1033            if (!wtap_dump_close(pdh, &err)) {
 1034              fprintf(stderr, "editcap: Error writing to %s: %s\n", filename,
 1035                  wtap_strerror(err));
 1036              exit(2);
 1037            }
 1038   
 1039            g_free(filename);
 1040            filename = fileset_get_filename_by_pattern(block_cnt++, &phdr->ts, fprefix, fsuffix);
 1041            g_assert(filename);
 1042   
 1043            if (verbose) {
 1044              fprintf(stderr, "Continuing writing in file %s\n", filename);
 1045            }
 1046   
 1047            pdh = wtap_dump_open(filename, out_file_type,
 1048                out_frame_type, wtap_snapshot_length(wth), FALSE /* compressed */, &err);
 1049            if (pdh == NULL) {
 1050              fprintf(stderr, "editcap: Can't open or create %s: %s\n", filename,
 1051                  wtap_strerror(err));
 1052              exit(2);
 1053            }
 1054          }
 1055        }
 1056   
 1057        check_ts = check_timestamp(wth);
 1058   
 1059        if ( ((check_startstop && check_ts) || (!check_startstop && !check_ts)) && ((!selected(count) && !keep_em) ||
 1060            (selected(count) && keep_em)) ) {
 1061   
 1062          if (verbose && !dup_detect && !dup_detect_by_time)
 1063            printf("Packet: %u\n", count);
 1064   
 1065          /* We simply write it, perhaps after truncating it; we could do other
 1066             things, like modify it. */
 1067   
 1068          phdr = wtap_phdr(wth);
 1069   
 1070          if (choplen != 0 && phdr->caplen > choplen) {
 1071            snap_phdr = *phdr;
 1072            snap_phdr.caplen -= choplen;
 1073            phdr = &snap_phdr;
 1074          }
 1075   
 1076          if (snaplen != 0 && phdr->caplen > snaplen) {
 1077            snap_phdr = *phdr;
 1078            snap_phdr.caplen = snaplen;
 1079            phdr = &snap_phdr;
 1080          }
 1081   
 1082          /* assume that if the frame's tv_sec is 0, then 
 1083           * the timestamp isn't supported */
 1084          if (phdr->ts.secs > 0 && time_adj.tv.tv_sec != 0) {
 1085            snap_phdr = *phdr;
 1086            if (time_adj.is_negative)
 1087              snap_phdr.ts.secs -= time_adj.tv.tv_sec;
 1088            else 
 1089              snap_phdr.ts.secs += time_adj.tv.tv_sec;
 1090            phdr = &snap_phdr;
 1091          }
 1092   
 1093          /* assume that if the frame's tv_sec is 0, then 
 1094           * the timestamp isn't supported */
 1095          if (phdr->ts.secs > 0 && time_adj.tv.tv_usec != 0) {
 1096            snap_phdr = *phdr;
 1097            if (time_adj.is_negative) { /* subtract */
 1098              if (snap_phdr.ts.nsecs/1000 < time_adj.tv.tv_usec) { /* borrow */
 1099                snap_phdr.ts.secs--;
 1100                snap_phdr.ts.nsecs += ONE_MILLION * 1000;
 1101              }
 1102              snap_phdr.ts.nsecs -= time_adj.tv.tv_usec * 1000;
 1103            } else {                  /* add */
 1104              if (snap_phdr.ts.nsecs + time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {
 1105                /* carry */
 1106                snap_phdr.ts.secs++;
 1107                snap_phdr.ts.nsecs += (time_adj.tv.tv_usec - ONE_MILLION) * 1000;
 1108              } else {
 1109                snap_phdr.ts.nsecs += time_adj.tv.tv_usec * 1000;
 1110              }
 1111            }
 1112            phdr = &snap_phdr;
 1113          }
 1114   
 1115          /* suppress duplicates by packet window */
 1116          if (dup_detect) {
 1117            buf = wtap_buf_ptr(wth);
 1118            if (is_duplicate(buf, phdr->caplen)) {
 1119              if (verbose) {
 1120                fprintf(stdout, "Skipped: %u, Len: %u, MD5 Hash: ", count, phdr->caplen);
 1121                for (i = 0; i < 16; i++) {
 1122                  fprintf(stdout, "%02x", (unsigned char)fd_hash[cur_dup_entry].digest[i]);
 1123                }
 1124                fprintf(stdout, "\n");
 1125              }
 1126              duplicate_count++;
 1127              count++;
 1128              continue;
 1129            } else {
 1130              if (verbose) {
 1131                fprintf(stdout, "Packet: %u, Len: %u, MD5 Hash: ", count, phdr->caplen);
 1132                for (i = 0; i < 16; i++) {
 1133                  fprintf(stdout, "%02x", (unsigned char)fd_hash[cur_dup_entry].digest[i]);
 1134                }
 1135                fprintf(stdout, "\n");
 1136              }
 1137            }
 1138          }
 1139   
 1140          /* suppress duplicates by time window */
 1141          if (dup_detect_by_time) {
 1142            nstime_t current;
 1143   
 1144            current.secs = phdr->ts.secs;
 1145            current.nsecs = phdr->ts.nsecs;
 1146   
 1147            buf = wtap_buf_ptr(wth);
 1148   
 1149            if (is_duplicate_rel_time(buf, phdr->caplen, &current)) {
 1150              if (verbose) {
 1151                fprintf(stdout, "Skipped: %u, Len: %u, MD5 Hash: ", count, phdr->caplen);
 1152                for (i = 0; i < 16; i++) {
 1153                  fprintf(stdout, "%02x", (unsigned char)fd_hash[cur_dup_entry].digest[i]);
 1154                }
 1155                fprintf(stdout, "\n");
 1156              }
 1157              duplicate_count++;
 1158              count++;
 1159              continue;
 1160            } else {
 1161              if (verbose) {
 1162                fprintf(stdout, "Packet: %u, Len: %u, MD5 Hash: ", count, phdr->caplen);
 1163                for (i = 0; i < 16; i++) {
 1164                  fprintf(stdout, "%02x", (unsigned char)fd_hash[cur_dup_entry].digest[i]);
 1165                }
 1166                fprintf(stdout, "\n");
 1167              }
 1168            }
 1169          }
 1170   
 1171          /* Random error mutation */
 1172          if (err_prob > 0.0) {
 1173            int real_data_start = 0;
 1174            buf = wtap_buf_ptr(wth);
 1175            /* Protect non-protocol data */
 1176            if (wtap_file_type(wth) == WTAP_FILE_CATAPULT_DCT2000) {
 1177              real_data_start = find_dct2000_real_data(buf);
 1178            }
 1179            for (i = real_data_start; i < (int) phdr->caplen; i++) {
 1180              if (rand() <= err_prob * RAND_MAX) {
 1181                err_type = rand() / (RAND_MAX / ERR_WT_TOTAL + 1);
 1182   
 1183                if (err_type < ERR_WT_BIT) {
 1184                  buf[i] ^= 1 << (rand() / (RAND_MAX / 8 + 1));
 1185                  err_type = ERR_WT_TOTAL;
 1186                } else {
 1187                  err_type -= ERR_WT_BYTE;
 1188                }
 1189   
 1190                if (err_type < ERR_WT_BYTE) {
 1191                  buf[i] = rand() / (RAND_MAX / 255 + 1);
 1192                  err_type = ERR_WT_TOTAL;
 1193                } else {
 1194                  err_type -= ERR_WT_BYTE;
 1195                }
 1196   
 1197                if (err_type < ERR_WT_ALNUM) {
 1198                  buf[i] = ALNUM_CHARS[rand() / (RAND_MAX / ALNUM_LEN + 1)];
 1199                  err_type = ERR_WT_TOTAL;
 1200                } else {
 1201                  err_type -= ERR_WT_ALNUM;
 1202                }
 1203   
 1204                if (err_type < ERR_WT_FMT) {
 1205                  if ((unsigned int)i < phdr->caplen - 2)
 1206                    strncpy((char*) &buf[i],  "%s", 2);
 1207                  err_type = ERR_WT_TOTAL;
 1208                } else {
 1209                  err_type -= ERR_WT_FMT;
 1210                }
 1211   
 1212                if (err_type < ERR_WT_AA) {
 1213                  for (j = i; j < (int) phdr->caplen; j++) {
 1214                    buf[j] = 0xAA;
 1215                  }
 1216                  i = phdr->caplen;
 1217                }
 1218              }
 1219            }
 1220          }
 1221   
 1222          if (!wtap_dump(pdh, phdr, wtap_pseudoheader(wth), wtap_buf_ptr(wth),
 1223                         &err)) {
 1224            fprintf(stderr, "editcap: Error writing to %s: %s\n",
 1225                    filename, wtap_strerror(err));
 1226            exit(2);
 1227          }
 1228          written_count++;
 1229        }
 1230        count++;
 1231      }
 1232   
 1233      g_free(filename);
 1234      g_free(fprefix);
 1235      g_free(fsuffix);
 1236   
 1237      if (err != 0) {
 1238        /* Print a message noting that the read failed somewhere along the line. */
 1239        fprintf(stderr,
 1240                "editcap: An error occurred while reading \"%s\": %s.\n",
 1241                argv[optind], wtap_strerror(err));
 1242        switch (err) {
 1243   
 1244        case WTAP_ERR_UNSUPPORTED:
 1245        case WTAP_ERR_UNSUPPORTED_ENCAP:
 1246        case WTAP_ERR_BAD_RECORD:
 1247          fprintf(stderr, "(%s)\n", err_info);
 1248          g_free(err_info);
 1249          break;
 1250        }
 1251      }
 1252   
 1253      if (!wtap_dump_close(pdh, &err)) {
 1254   
 1255        fprintf(stderr, "editcap: Error writing to %s: %s\n", filename,
 1256            wtap_strerror(err));
 1257        exit(2);
 1258   
 1259      }
 1260    }
 1261   
 1262    if (dup_detect) {
 1263      fprintf(stdout, "%u packet%s seen, %u packet%s skipped with duplicate window of %u packets.\n",
 1264                  count - 1, plurality(count - 1, "", "s"),
 1265                  duplicate_count, plurality(duplicate_count, "", "s"), dup_window);
 1266    } else if (dup_detect_by_time) {
 1267      fprintf(stdout, "%u packet%s seen, %u packet%s skipped with duplicate time window equal to or less than %ld.%09ld seconds.\n",
 1268                  count - 1, plurality(count - 1, "", "s"),
 1269                  duplicate_count, plurality(duplicate_count, "", "s"),
 1270                  (long)relative_time_window.secs, (long int)relative_time_window.nsecs);
 1271    }
 1272   
 1273    return 0;
 1274  }
Show more  




Change Warning 4974.30742 : Unreachable Data Flow

Priority:
State:
Finding:
Owner:
Note: