flow-gen.c

netflow,抓包

  bzero(&rec_v8_3, sizeof rec_v8_3);

  rec_v8_3.Last = 0xFFFF0000;

  for (i = 0; i < count; ++i) {

    rec_v8_3.dPkts ++;
    rec_v8_3.dOctets ++;
    rec_v8_3.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_3) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_3.First ++;
    rec_v8_3.Last ++;

    rec_v8_3.srcaddr ++;
    rec_v8_3.src_mask ++;
    rec_v8_3.src_as ++;
    rec_v8_3.input ++;
   

  } /* for */

  return 0;

} /* gen_v8_3 */

int gen_v8_4(struct ftio *ftio, int count)
{
  struct fts3rec_v8_4 rec_v8_4;
  int i;

  bzero(&rec_v8_4, sizeof rec_v8_4);

  rec_v8_4.Last = 0xFFFF0000;

  for (i = 0; i < count; ++i) {

    rec_v8_4.dPkts ++;
    rec_v8_4.dOctets ++;
    rec_v8_4.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_4) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_4.First ++;
    rec_v8_4.Last ++;

    rec_v8_4.dstaddr ++;
    rec_v8_4.dst_mask ++;
    rec_v8_4.dst_as ++;
    rec_v8_4.output ++;
   
  } /* for */

  return 0;

} /* gen_v8_4 */

int gen_v8_5(struct ftio *ftio, int count)
{
  struct fts3rec_v8_5 rec_v8_5;
  int i;

  bzero(&rec_v8_5, sizeof rec_v8_5);

  rec_v8_5.Last = 0xFFFF0000;
  rec_v8_5.dstaddr = 0xFFFF0000;
  rec_v8_5.dst_as = 0xFF00;
  rec_v8_5.output = 0xFF00;

  for (i = 0; i < count; ++i) {

    rec_v8_5.dPkts ++;
    rec_v8_5.dOctets ++;
    rec_v8_5.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_5) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_5.First ++;
    rec_v8_5.Last ++;

    rec_v8_5.srcaddr ++;
    rec_v8_5.src_mask ++;
    rec_v8_5.src_as ++;
    rec_v8_5.input ++;

    rec_v8_5.dstaddr ++;
    rec_v8_5.dst_mask ++;
    rec_v8_5.dst_as ++;
    rec_v8_5.output ++;
   
  } /* for */

  return 0;

} /* gen_v8_5 */

int gen_v8_6(struct ftio *ftio, int count)
{
  struct fts3rec_v8_6 rec_v8_6;
  int i;

  bzero(&rec_v8_6, sizeof rec_v8_6);

  rec_v8_6.Last = 0xFFFF0000;
  rec_v8_6.dstaddr = 0xFFFF0000;
  rec_v8_6.output = 0xFF00;
  rec_v8_6.marked_tos = 0xFF;

  for (i = 0; i < count; ++i) {

    rec_v8_6.dPkts ++;
    rec_v8_6.dOctets ++;

    if (ftio_write(ftio, &rec_v8_6) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_6.First ++;
    rec_v8_6.Last ++;

    rec_v8_6.dstaddr ++;
    rec_v8_6.output ++;

    rec_v8_6.tos ++;
    rec_v8_6.marked_tos ++;
    rec_v8_6.router_sc ++;
    rec_v8_6.extra_pkts ++;
    rec_v8_6.router_sc ++;
   
  } /* for */

  return 0;

} /* gen_v8_6 */

int gen_v8_7(struct ftio *ftio, int count)
{
  struct fts3rec_v8_7 rec_v8_7;
  int i;

  bzero(&rec_v8_7, sizeof rec_v8_7);

  rec_v8_7.Last = 0xFFFF0000;
  rec_v8_7.dstaddr = 0xFFFF0000;
  rec_v8_7.output = 0xFF00;
  rec_v8_7.marked_tos = 0xFF;

  for (i = 0; i < count; ++i) {

    rec_v8_7.dPkts ++;
    rec_v8_7.dOctets ++;

    if (ftio_write(ftio, &rec_v8_7) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_7.First ++;
    rec_v8_7.Last ++;

    rec_v8_7.dstaddr ++;
    rec_v8_7.srcaddr ++;
    rec_v8_7.output ++;
    rec_v8_7.input ++;

    rec_v8_7.tos ++;
    rec_v8_7.marked_tos ++;
    rec_v8_7.router_sc ++;
    rec_v8_7.extra_pkts ++;
    rec_v8_7.router_sc ++;
   
  } /* for */

  return 0;

} /* gen_v8_7 */

int gen_v8_8(struct ftio *ftio, int count)
{
  struct fts3rec_v8_8 rec_v8_8;
  int i;

  bzero(&rec_v8_8, sizeof rec_v8_8);

  rec_v8_8.Last = 0xFFFF0000;
  rec_v8_8.dstaddr = 0xFFFF0000;
  rec_v8_8.output = 0xFF00;
  rec_v8_8.marked_tos = 0xFF;

  for (i = 0; i < count; ++i) {

    rec_v8_8.dPkts ++;
    rec_v8_8.dOctets ++;

    if (ftio_write(ftio, &rec_v8_8) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_8.First ++;
    rec_v8_8.Last ++;

    rec_v8_8.dstaddr ++;
    rec_v8_8.srcaddr ++;
    rec_v8_8.output ++;
    rec_v8_8.input ++;

    rec_v8_8.dstport ++;
    rec_v8_8.srcport ++;

    rec_v8_8.prot ++;
    rec_v8_8.tos ++;
    rec_v8_8.marked_tos ++;
    rec_v8_8.router_sc ++;
    rec_v8_8.extra_pkts ++;
    rec_v8_8.router_sc ++;
   
  } /* for */

  return 0;

} /* gen_v8_8 */

int gen_v8_9(struct ftio *ftio, int count)
{
  struct fts3rec_v8_9 rec_v8_9;
  int i;

  bzero(&rec_v8_9, sizeof rec_v8_9);

  rec_v8_9.output = 0xFF00;
  rec_v8_9.Last = 0xFFFF0000;
  rec_v8_9.dst_as = 0xFF00;

  for (i = 0; i < count; ++i) {

    rec_v8_9.dPkts ++;
    rec_v8_9.dOctets ++;
    rec_v8_9.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_9) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_9.input ++;
    rec_v8_9.output ++;

    rec_v8_9.First ++;
    rec_v8_9.Last ++;

    rec_v8_9.src_as ++;
    rec_v8_9.dst_as ++;

    rec_v8_9.tos ++;

  } /* for */

  return 0;

} /* gen_v8_9 */

int gen_v8_10(struct ftio *ftio, int count)
{
  struct fts3rec_v8_10 rec_v8_10;
  int i;

  bzero(&rec_v8_10, sizeof rec_v8_10);

  rec_v8_10.Last = 0xFFFF0000;
  rec_v8_10.dstport = 0xFF00;

  for (i = 0; i < count; ++i) {

    rec_v8_10.dPkts ++;
    rec_v8_10.dOctets ++;
    rec_v8_10.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_10) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_10.First ++;
    rec_v8_10.Last ++;

    rec_v8_10.srcport ++;
    rec_v8_10.dstport ++;

    rec_v8_10.tos ++;

  } /* for */

  return 0;

} /* gen_v8_10 */

int gen_v8_11(struct ftio *ftio, int count)
{
  struct fts3rec_v8_11 rec_v8_11;
  int i;

  bzero(&rec_v8_11, sizeof rec_v8_11);

  rec_v8_11.Last = 0xFFFF0000;

  for (i = 0; i < count; ++i) {

    rec_v8_11.dPkts ++;
    rec_v8_11.dOctets ++;
    rec_v8_11.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_11) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_11.First ++;
    rec_v8_11.Last ++;

    rec_v8_11.srcaddr ++;
    rec_v8_11.src_mask ++;
    rec_v8_11.src_as ++;
    rec_v8_11.input ++;
   
    rec_v8_11.tos ++;

  } /* for */

  return 0;

} /* gen_v8_11 */

int gen_v8_12(struct ftio *ftio, int count)
{
  struct fts3rec_v8_12 rec_v8_12;
  int i;

  bzero(&rec_v8_12, sizeof rec_v8_12);

  rec_v8_12.Last = 0xFFFF0000;

  for (i = 0; i < count; ++i) {

    rec_v8_12.dPkts ++;
    rec_v8_12.dOctets ++;
    rec_v8_12.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_12) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_12.First ++;
    rec_v8_12.Last ++;

    rec_v8_12.dstaddr ++;
    rec_v8_12.dst_mask ++;
    rec_v8_12.dst_as ++;
    rec_v8_12.output ++;

    rec_v8_12.tos ++;
   
  } /* for */

  return 0;

} /* gen_v8_12 */

int gen_v8_13(struct ftio *ftio, int count)
{
  struct fts3rec_v8_13 rec_v8_13;
  int i;

  bzero(&rec_v8_13, sizeof rec_v8_13);

  rec_v8_13.Last = 0xFFFF0000;
  rec_v8_13.dstaddr = 0xFFFF0000;
  rec_v8_13.dst_as = 0xFF00;
  rec_v8_13.output = 0xFF00;

  for (i = 0; i < count; ++i) {

    rec_v8_13.dPkts ++;
    rec_v8_13.dOctets ++;
    rec_v8_13.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_13) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_13.First ++;
    rec_v8_13.Last ++;

    rec_v8_13.srcaddr ++;
    rec_v8_13.src_mask ++;
    rec_v8_13.src_as ++;
    rec_v8_13.input ++;

    rec_v8_13.dstaddr ++;
    rec_v8_13.dst_mask ++;
    rec_v8_13.dst_as ++;
    rec_v8_13.output ++;
   
    rec_v8_13.tos ++;

  } /* for */

  return 0;

} /* gen_v8_13 */

int gen_v8_14(struct ftio *ftio, int count)
{
  struct fts3rec_v8_14 rec_v8_14;
  int i;

  bzero(&rec_v8_14, sizeof rec_v8_14);

  rec_v8_14.Last = 0xFFFF0000;
  rec_v8_14.dstaddr = 0xFFFF0000;
  rec_v8_14.output = 0xFF00;
  rec_v8_14.dstport = 0xFF00;

  for (i = 0; i < count; ++i) {

    rec_v8_14.dPkts ++;
    rec_v8_14.dOctets ++;
    rec_v8_14.dFlows += 2;

    if (ftio_write(ftio, &rec_v8_14) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v8_14.First ++;
    rec_v8_14.Last ++;

    rec_v8_14.srcport ++;
    rec_v8_14.dstport ++;

    rec_v8_14.srcaddr ++;
    rec_v8_14.src_mask ++;
    rec_v8_14.input ++;

    rec_v8_14.dstaddr ++;
    rec_v8_14.dst_mask ++;
    rec_v8_14.output ++;

    rec_v8_14.tos ++;
    rec_v8_14.prot ++;

  } /* for */

  return 0;

} /* gen_v8_14 */

int gen_v1005(struct ftio *ftio, int count)
{
  struct fts3rec_v1005 rec_v1005;
  int i;

  bzero(&rec_v1005, sizeof rec_v1005);

  rec_v1005.dstaddr = 0x8092C500;
  rec_v1005.dstport = 0xFF00;
  rec_v1005.output = 0xFF00;
  rec_v1005.Last = 0xFFFF0000;
  rec_v1005.dst_as = 0xFF00;
  rec_v1005.prot = 17;
  rec_v1005.dst_tag = 0xFF;
  rec_v1005.nexthop = 0x8092C500;

  for (i = 0; i < count; ++i) {

    rec_v1005.dPkts ++;
    rec_v1005.dOctets ++;

    if (ftio_write(ftio, &rec_v1005) < 0) {
      fterr_warnx("ftio_write(): failed");
      return -1;
    }

    rec_v1005.srcaddr ++;
    rec_v1005.dstaddr ++;

    rec_v1005.srcport ++;
    rec_v1005.dstport ++;

    rec_v1005.input ++;
    rec_v1005.output ++;

    rec_v1005.First ++;
    rec_v1005.Last ++;

    rec_v1005.src_as ++;
    rec_v1005.dst_as ++;

    rec_v1005.src_tag ++;
    rec_v1005.dst_tag ++;

    rec_v1005.tos ++;

    rec_v1005.nexthop ++;

  } /* for */

  return 0;

} /* gen_v1005 */
void usage(void) {

  fprintf(stderr, "Usage: flow-gen [-h] [-b big|little] [-d debug_level] [-n count]\n");
  fprintf(stderr, "       [-V version] [-z z_level]\n");
  fprintf(stderr, "\n%s version %s: built by %s\n", PACKAGE, VERSION, FT_PROG_BUILD);

} /* usage */