/*
   * Authors:
   * Copyright 2001, 2002 by Robert Olsson <robert.olsson@its.uu.se>
   *                             Uppsala University and
   *                             Swedish University of Agricultural Sciences
   *
   * Alexey Kuznetsov  <kuznet@ms2.inr.ac.ru>
   * Ben Greear <greearb@candelatech.com>

   * Jens Låås <jens.laas@data.slu.se>

   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * as published by the Free Software Foundation; either version
   * 2 of the License, or (at your option) any later version.
   *
   *
   * A tool for loading the network with preconfigurated packets.

   * The tool is implemented as a linux module.  Parameters are output

   * device, delay (to hard_xmit), number of packets, and whether
   * to use multiple SKBs or just the same one.
   * pktgen uses the installed interface's output routine.
   *
   * Additional hacking by:
   *
   * Jens.Laas@data.slu.se
   * Improved by ANK. 010120.
   * Improved by ANK even more. 010212.
   * MAC address typo fixed. 010417 --ro
   * Integrated.  020301 --DaveM
   * Added multiskb option 020301 --DaveM
   * Scaling of results. 020417--sigurdur@linpro.no
   * Significant re-work of the module:
   *   *  Convert to threaded model to more efficiently be able to transmit
   *       and receive on multiple interfaces at once.
   *   *  Converted many counters to __u64 to allow longer runs.
   *   *  Allow configuration of ranges, like min/max IP address, MACs,
   *       and UDP-ports, for both source and destination, and can
   *       set to use a random distribution or sequentially walk the range.
   *   *  Can now change most values after starting.
   *   *  Place 12-byte packet in UDP payload with magic number,
   *       sequence number, and timestamp.
   *   *  Add receiver code that detects dropped pkts, re-ordered pkts, and
   *       latencies (with micro-second) precision.
   *   *  Add IOCTL interface to easily get counters & configuration.
   *   --Ben Greear <greearb@candelatech.com>
   *

   * Renamed multiskb to clone_skb and cleaned up sending core for two distinct
   * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0

   * as a "fastpath" with a configurable number of clones after alloc's.

   * clone_skb=0 means all packets are allocated this also means ranges time
   * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100

   * clones.
   *

   * Also moved to /proc/net/pktgen/

   * --ro
   *
   * Sept 10:  Fixed threading/locking.  Lots of bone-headed and more clever
   *    mistakes.  Also merged in DaveM's patch in the -pre6 patch.
   * --Ben Greear <greearb@candelatech.com>
   *
   * Integrated to 2.5.x 021029 --Lucio Maciel (luciomaciel@zipmail.com.br)
   *

   *

   * 021124 Finished major redesign and rewrite for new functionality.
   * See Documentation/networking/pktgen.txt for how to use this.
   *
   * The new operation:

   * For each CPU one thread/process is created at start. This process checks
   * for running devices in the if_list and sends packets until count is 0 it
   * also the thread checks the thread->control which is used for inter-process
   * communication. controlling process "posts" operations to the threads this

   * way. The if_lock should be possible to remove when add/rem_device is merged
   * into this too.
   *

   * By design there should only be *one* "controlling" process. In practice
   * multiple write accesses gives unpredictable result. Understood by "write"

   * to /proc gives result code thats should be read be the "writer".

   * For practical use this should be no problem.

   *

   * Note when adding devices to a specific CPU there good idea to also assign
   * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU.

   * --ro
   *

   * Fix refcount off by one if first packet fails, potential null deref,

   * memleak 030710- KJP
   *
   * First "ranges" functionality for ipv6 030726 --ro
   *
   * Included flow support. 030802 ANK.
   *
   * Fixed unaligned access on IA-64 Grant Grundler <grundler@parisc-linux.org>

   *

   * Remove if fix from added Harald Welte <laforge@netfilter.org> 040419
   * ia64 compilation fix from  Aron Griffis <aron@hp.com> 040604
   *

   * New xmit() return, do_div and misc clean up by Stephen Hemminger

   * <shemminger@osdl.org> 040923
   *

   * Randy Dunlap fixed u64 printk compiler waring

   *
   * Remove FCS from BW calculation.  Lennert Buytenhek <buytenh@wantstofly.org>
   * New time handling. Lennert Buytenhek <buytenh@wantstofly.org> 041213
   *

   * Corrections from Nikolai Malykh (nmalykh@bilim.com)

   * Removed unused flags F_SET_SRCMAC & F_SET_SRCIP 041230
   *

   * interruptible_sleep_on_timeout() replaced Nishanth Aravamudan <nacc@us.ibm.com>

   * 050103

   *
   * MPLS support by Steven Whitehouse <steve@chygwyn.com>
   *

   * 802.1Q/Q-in-Q support by Francesco Fondelli (FF) <francesco.fondelli@gmail.com>
   *

   * Fixed src_mac command to set source mac of packet to value specified in
   * command by Adit Ranadive <adit.262@gmail.com>
   *

   */

  
  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

  #include <linux/sys.h>
  #include <linux/types.h>
  #include <linux/module.h>
  #include <linux/moduleparam.h>
  #include <linux/kernel.h>

  #include <linux/mutex.h>

  #include <linux/sched.h>
  #include <linux/slab.h>
  #include <linux/vmalloc.h>

  #include <linux/unistd.h>
  #include <linux/string.h>
  #include <linux/ptrace.h>
  #include <linux/errno.h>
  #include <linux/ioport.h>
  #include <linux/interrupt.h>

  #include <linux/capability.h>

  #include <linux/hrtimer.h>

  #include <linux/freezer.h>

  #include <linux/delay.h>
  #include <linux/timer.h>

  #include <linux/list.h>

  #include <linux/init.h>
  #include <linux/skbuff.h>
  #include <linux/netdevice.h>
  #include <linux/inet.h>
  #include <linux/inetdevice.h>
  #include <linux/rtnetlink.h>
  #include <linux/if_arp.h>

  #include <linux/if_vlan.h>

  #include <linux/in.h>
  #include <linux/ip.h>
  #include <linux/ipv6.h>
  #include <linux/udp.h>
  #include <linux/proc_fs.h>

  #include <linux/seq_file.h>

  #include <linux/wait.h>

  #include <linux/etherdevice.h>

  #include <linux/kthread.h>

  #include <linux/prefetch.h>

  #include <net/net_namespace.h>

  #include <net/checksum.h>
  #include <net/ipv6.h>
  #include <net/addrconf.h>

  #ifdef CONFIG_XFRM
  #include <net/xfrm.h>
  #endif

  #include <asm/byteorder.h>
  #include <linux/rcupdate.h>

  #include <linux/bitops.h>

  #include <linux/io.h>
  #include <linux/timex.h>
  #include <linux/uaccess.h>

  #include <asm/dma.h>

  #include <asm/div64.h>		/* do_div */

  #define VERSION	"2.74"

  #define IP_NAME_SZ 32

  #define MAX_MPLS_LABELS 16 /* This is the max label stack depth */

  #define MPLS_STACK_BOTTOM htonl(0x00000100)

  #define func_enter() pr_debug("entering %s
  ", __func__);

  /* Device flag bits */

  #define F_IPSRC_RND   (1<<0)	/* IP-Src Random  */
  #define F_IPDST_RND   (1<<1)	/* IP-Dst Random  */
  #define F_UDPSRC_RND  (1<<2)	/* UDP-Src Random */
  #define F_UDPDST_RND  (1<<3)	/* UDP-Dst Random */
  #define F_MACSRC_RND  (1<<4)	/* MAC-Src Random */
  #define F_MACDST_RND  (1<<5)	/* MAC-Dst Random */
  #define F_TXSIZE_RND  (1<<6)	/* Transmit size is random */
  #define F_IPV6        (1<<7)	/* Interface in IPV6 Mode */

  #define F_MPLS_RND    (1<<8)	/* Random MPLS labels */

  #define F_VID_RND     (1<<9)	/* Random VLAN ID */
  #define F_SVID_RND    (1<<10)	/* Random SVLAN ID */

  #define F_FLOW_SEQ    (1<<11)	/* Sequential flows */

  #define F_IPSEC_ON    (1<<12)	/* ipsec on for flows */

  #define F_QUEUE_MAP_RND (1<<13)	/* queue map Random */

  #define F_QUEUE_MAP_CPU (1<<14)	/* queue map mirrors smp_processor_id() */

  #define F_NODE          (1<<15)	/* Node memory alloc*/

  
  /* Thread control flag bits */

  #define T_STOP        (1<<0)	/* Stop run */
  #define T_RUN         (1<<1)	/* Start run */
  #define T_REMDEVALL   (1<<2)	/* Remove all devs */
  #define T_REMDEV      (1<<3)	/* Remove one dev */

  /* If lock -- can be removed after some work */
  #define   if_lock(t)           spin_lock(&(t->if_lock));
  #define   if_unlock(t)           spin_unlock(&(t->if_lock));
  
  /* Used to help with determining the pkts on receive */
  #define PKTGEN_MAGIC 0xbe9be955

  #define PG_PROC_DIR "pktgen"
  #define PGCTRL	    "pgctrl"

  static struct proc_dir_entry *pg_proc_dir;

  
  #define MAX_CFLOWS  65536

  #define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
  #define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)

  struct flow_state {

  	__be32 cur_daddr;

  	int count;

  #ifdef CONFIG_XFRM
  	struct xfrm_state *x;
  #endif

  	__u32 flags;

  };

  /* flow flag bits */
  #define F_INIT   (1<<0)		/* flow has been initialized */

  struct pktgen_dev {

  	/*
  	 * Try to keep frequent/infrequent used vars. separated.
  	 */

  	struct proc_dir_entry *entry;	/* proc file */
  	struct pktgen_thread *pg_thread;/* the owner */

  	struct list_head list;		/* chaining in the thread's run-queue */

  	int running;		/* if false, the test will stop */

  	/* If min != max, then we will either do a linear iteration, or
  	 * we will do a random selection from within the range.
  	 */
  	__u32 flags;

  	int removal_mark;	/* non-zero => the device is marked for
  				 * removal by worker thread */

  	int min_pkt_size;	/* = ETH_ZLEN; */
  	int max_pkt_size;	/* = ETH_ZLEN; */

  	int pkt_overhead;	/* overhead for MPLS, VLANs, IPSEC etc */

  	int nfrags;

  	struct page *page;

  	u64 delay;		/* nano-seconds */

  	__u64 count;		/* Default No packets to send */
  	__u64 sofar;		/* How many pkts we've sent so far */
  	__u64 tx_bytes;		/* How many bytes we've transmitted */

  	__u64 errors;		/* Errors when trying to transmit, */

  
  	/* runtime counters relating to clone_skb */

  
  	__u64 allocated_skbs;
  	__u32 clone_count;
  	int last_ok;		/* Was last skb sent?

  				 * Or a failed transmit of some sort?
  				 * This will keep sequence numbers in order

  				 */

  	ktime_t next_tx;
  	ktime_t started_at;
  	ktime_t stopped_at;
  	u64	idle_acc;	/* nano-seconds */

  	__u32 seq_num;

  	int clone_skb;		/*
  				 * Use multiple SKBs during packet gen.
  				 * If this number is greater than 1, then
  				 * that many copies of the same packet will be
  				 * sent before a new packet is allocated.
  				 * If you want to send 1024 identical packets
  				 * before creating a new packet,
  				 * set clone_skb to 1024.

  				 */
  
  	char dst_min[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
  	char dst_max[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
  	char src_min[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
  	char src_max[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
  
  	struct in6_addr in6_saddr;
  	struct in6_addr in6_daddr;
  	struct in6_addr cur_in6_daddr;
  	struct in6_addr cur_in6_saddr;

  	/* For ranges */

  	struct in6_addr min_in6_daddr;
  	struct in6_addr max_in6_daddr;
  	struct in6_addr min_in6_saddr;
  	struct in6_addr max_in6_saddr;
  
  	/* If we're doing ranges, random or incremental, then this
  	 * defines the min/max for those ranges.
  	 */

  	__be32 saddr_min;	/* inclusive, source IP address */
  	__be32 saddr_max;	/* exclusive, source IP address */
  	__be32 daddr_min;	/* inclusive, dest IP address */
  	__be32 daddr_max;	/* exclusive, dest IP address */

  
  	__u16 udp_src_min;	/* inclusive, source UDP port */
  	__u16 udp_src_max;	/* exclusive, source UDP port */
  	__u16 udp_dst_min;	/* inclusive, dest UDP port */
  	__u16 udp_dst_max;	/* exclusive, dest UDP port */

  	/* DSCP + ECN */

  	__u8 tos;            /* six MSB of (former) IPv4 TOS
  				are for dscp codepoint */
  	__u8 traffic_class;  /* ditto for the (former) Traffic Class in IPv6
  				(see RFC 3260, sec. 4) */

  	/* MPLS */
  	unsigned nr_labels;	/* Depth of stack, 0 = no MPLS */
  	__be32 labels[MAX_MPLS_LABELS];

  	/* VLAN/SVLAN (802.1Q/Q-in-Q) */
  	__u8  vlan_p;
  	__u8  vlan_cfi;
  	__u16 vlan_id;  /* 0xffff means no vlan tag */
  
  	__u8  svlan_p;
  	__u8  svlan_cfi;
  	__u16 svlan_id; /* 0xffff means no svlan tag */

  	__u32 src_mac_count;	/* How many MACs to iterate through */
  	__u32 dst_mac_count;	/* How many MACs to iterate through */
  
  	unsigned char dst_mac[ETH_ALEN];
  	unsigned char src_mac[ETH_ALEN];
  
  	__u32 cur_dst_mac_offset;
  	__u32 cur_src_mac_offset;

  	__be32 cur_saddr;
  	__be32 cur_daddr;

  	__u16 ip_id;

  	__u16 cur_udp_dst;
  	__u16 cur_udp_src;

  	__u16 cur_queue_map;

  	__u32 cur_pkt_size;

  	__u32 last_pkt_size;

  
  	__u8 hh[14];
  	/* = {
  	   0x00, 0x80, 0xC8, 0x79, 0xB3, 0xCB,
  
  	   We fill in SRC address later
  	   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  	   0x08, 0x00
  	   };
  	 */
  	__u16 pad;		/* pad out the hh struct to an even 16 bytes */

  	struct sk_buff *skb;	/* skb we are to transmit next, used for when we

  				 * are transmitting the same one multiple times
  				 */

  	struct net_device *odev; /* The out-going device.
  				  * Note that the device should have it's
  				  * pg_info pointer pointing back to this
  				  * device.
  				  * Set when the user specifies the out-going
  				  * device name (not when the inject is
  				  * started as it used to do.)
  				  */

  	char odevname[32];

  	struct flow_state *flows;

  	unsigned cflows;	/* Concurrent flows (config) */
  	unsigned lflow;		/* Flow length  (config) */
  	unsigned nflows;	/* accumulated flows (stats) */

  	unsigned curfl;		/* current sequenced flow (state)*/

  
  	u16 queue_map_min;
  	u16 queue_map_max;

  	__u32 skb_priority;	/* skb priority field */

  	int node;               /* Memory node */

  #ifdef CONFIG_XFRM
  	__u8	ipsmode;		/* IPSEC mode (config) */
  	__u8	ipsproto;		/* IPSEC type (config) */
  #endif

  	char result[512];

  };
  
  struct pktgen_hdr {

  	__be32 pgh_magic;
  	__be32 seq_num;
  	__be32 tv_sec;
  	__be32 tv_usec;

  };

  static bool pktgen_exiting __read_mostly;

  struct pktgen_thread {

  	spinlock_t if_lock;		/* for list of devices */

  	struct list_head if_list;	/* All device here */

  	struct list_head th_list;

  	struct task_struct *tsk;

  	char result[512];

  	/* Field for thread to receive "posted" events terminate,
  	   stop ifs etc. */

  
  	u32 control;

  	int cpu;

  	wait_queue_head_t queue;

  	struct completion start_done;

  };
  
  #define REMOVE 1
  #define FIND   0

  static inline ktime_t ktime_now(void)

  {

  	struct timespec ts;
  	ktime_get_ts(&ts);
  
  	return timespec_to_ktime(ts);

  }

  /* This works even if 32 bit because of careful byte order choice */
  static inline int ktime_lt(const ktime_t cmp1, const ktime_t cmp2)

  {

  	return cmp1.tv64 < cmp2.tv64;

  }

  static const char version[] =

  	"Packet Generator for packet performance testing. "
  	"Version: " VERSION "
  ";

  static int pktgen_remove_device(struct pktgen_thread *t, struct pktgen_dev *i);
  static int pktgen_add_device(struct pktgen_thread *t, const char *ifname);
  static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t,

  					  const char *ifname, bool exact);

  static int pktgen_device_event(struct notifier_block *, unsigned long, void *);
  static void pktgen_run_all_threads(void);

  static void pktgen_reset_all_threads(void);

  static void pktgen_stop_all_threads_ifs(void);

  static void pktgen_stop(struct pktgen_thread *t);

  static void pktgen_clear_counters(struct pktgen_dev *pkt_dev);

  static unsigned int scan_ip6(const char *s, char ip[16]);

  
  /* Module parameters, defaults. */

  static int pg_count_d __read_mostly = 1000;
  static int pg_delay_d __read_mostly;
  static int pg_clone_skb_d  __read_mostly;
  static int debug  __read_mostly;

  static DEFINE_MUTEX(pktgen_thread_lock);

  static LIST_HEAD(pktgen_threads);

  static struct notifier_block pktgen_notifier_block = {
  	.notifier_call = pktgen_device_event,
  };

  /*

   * /proc handling functions

   *
   */

  static int pgctrl_show(struct seq_file *seq, void *v)

  {

  	seq_puts(seq, version);

  	return 0;

  }

  static ssize_t pgctrl_write(struct file *file, const char __user *buf,
  			    size_t count, loff_t *ppos)

  {

  	int err = 0;

  	char data[128];

  	if (!capable(CAP_NET_ADMIN)) {
  		err = -EPERM;

  		goto out;

  	}

  	if (count > sizeof(data))
  		count = sizeof(data);

  	if (copy_from_user(data, buf, count)) {

  		err = -EFAULT;

  		goto out;

  	}
  	data[count - 1] = 0;	/* Make string */

  	if (!strcmp(data, "stop"))

  		pktgen_stop_all_threads_ifs();

  	else if (!strcmp(data, "start"))

  		pktgen_run_all_threads();

  	else if (!strcmp(data, "reset"))
  		pktgen_reset_all_threads();

  	else

  		pr_warning("Unknown command: %s
  ", data);

  
  	err = count;

  out:
  	return err;

  }

  static int pgctrl_open(struct inode *inode, struct file *file)
  {
  	return single_open(file, pgctrl_show, PDE(inode)->data);
  }

  static const struct file_operations pktgen_fops = {

  	.owner   = THIS_MODULE,
  	.open    = pgctrl_open,
  	.read    = seq_read,
  	.llseek  = seq_lseek,
  	.write   = pgctrl_write,
  	.release = single_release,

  };
  
  static int pktgen_if_show(struct seq_file *seq, void *v)

  {

  	const struct pktgen_dev *pkt_dev = seq->private;

  	ktime_t stopped;
  	u64 idle;

  
  	seq_printf(seq,
  		   "Params: count %llu  min_pkt_size: %u  max_pkt_size: %u
  ",
  		   (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size,
  		   pkt_dev->max_pkt_size);
  
  	seq_printf(seq,

  		   "     frags: %d  delay: %llu  clone_skb: %d  ifname: %s
  ",
  		   pkt_dev->nfrags, (unsigned long long) pkt_dev->delay,

  		   pkt_dev->clone_skb, pkt_dev->odevname);

  
  	seq_printf(seq, "     flows: %u flowlen: %u
  ", pkt_dev->cflows,
  		   pkt_dev->lflow);

  	seq_printf(seq,
  		   "     queue_map_min: %u  queue_map_max: %u
  ",
  		   pkt_dev->queue_map_min,
  		   pkt_dev->queue_map_max);

  	if (pkt_dev->skb_priority)
  		seq_printf(seq, "     skb_priority: %u
  ",
  			   pkt_dev->skb_priority);

  	if (pkt_dev->flags & F_IPV6) {

  		seq_printf(seq,

  			   "     saddr: %pI6c  min_saddr: %pI6c  max_saddr: %pI6c
  "
  			   "     daddr: %pI6c  min_daddr: %pI6c  max_daddr: %pI6c
  ",
  			   &pkt_dev->in6_saddr,
  			   &pkt_dev->min_in6_saddr, &pkt_dev->max_in6_saddr,
  			   &pkt_dev->in6_daddr,
  			   &pkt_dev->min_in6_daddr, &pkt_dev->max_in6_daddr);

  	} else {
  		seq_printf(seq,
  			   "     dst_min: %s  dst_max: %s
  ",
  			   pkt_dev->dst_min, pkt_dev->dst_max);

  		seq_printf(seq,

  			   "        src_min: %s  src_max: %s
  ",
  			   pkt_dev->src_min, pkt_dev->src_max);
  	}

  	seq_puts(seq, "     src_mac: ");

  	seq_printf(seq, "%pM ",
  		   is_zero_ether_addr(pkt_dev->src_mac) ?
  			     pkt_dev->odev->dev_addr : pkt_dev->src_mac);

  
  	seq_printf(seq, "dst_mac: ");

  	seq_printf(seq, "%pM
  ", pkt_dev->dst_mac);

  
  	seq_printf(seq,

  		   "     udp_src_min: %d  udp_src_max: %d"
  		   "  udp_dst_min: %d  udp_dst_max: %d
  ",

  		   pkt_dev->udp_src_min, pkt_dev->udp_src_max,
  		   pkt_dev->udp_dst_min, pkt_dev->udp_dst_max);
  
  	seq_printf(seq,

  		   "     src_mac_count: %d  dst_mac_count: %d
  ",

  		   pkt_dev->src_mac_count, pkt_dev->dst_mac_count);

  	if (pkt_dev->nr_labels) {
  		unsigned i;
  		seq_printf(seq, "     mpls: ");

  		for (i = 0; i < pkt_dev->nr_labels; i++)

  			seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]),
  				   i == pkt_dev->nr_labels-1 ? "
  " : ", ");
  	}

  	if (pkt_dev->vlan_id != 0xffff)

  		seq_printf(seq, "     vlan_id: %u  vlan_p: %u  vlan_cfi: %u
  ",

  			   pkt_dev->vlan_id, pkt_dev->vlan_p,
  			   pkt_dev->vlan_cfi);

  	if (pkt_dev->svlan_id != 0xffff)

  		seq_printf(seq, "     svlan_id: %u  vlan_p: %u  vlan_cfi: %u
  ",

  			   pkt_dev->svlan_id, pkt_dev->svlan_p,
  			   pkt_dev->svlan_cfi);

  	if (pkt_dev->tos)

  		seq_printf(seq, "     tos: 0x%02x
  ", pkt_dev->tos);

  	if (pkt_dev->traffic_class)

  		seq_printf(seq, "     traffic_class: 0x%02x
  ", pkt_dev->traffic_class);

  	if (pkt_dev->node >= 0)
  		seq_printf(seq, "     node: %d
  ", pkt_dev->node);

  	seq_printf(seq, "     Flags: ");

  	if (pkt_dev->flags & F_IPV6)
  		seq_printf(seq, "IPV6  ");

  	if (pkt_dev->flags & F_IPSRC_RND)
  		seq_printf(seq, "IPSRC_RND  ");

  	if (pkt_dev->flags & F_IPDST_RND)
  		seq_printf(seq, "IPDST_RND  ");

  	if (pkt_dev->flags & F_TXSIZE_RND)
  		seq_printf(seq, "TXSIZE_RND  ");

  	if (pkt_dev->flags & F_UDPSRC_RND)
  		seq_printf(seq, "UDPSRC_RND  ");

  	if (pkt_dev->flags & F_UDPDST_RND)
  		seq_printf(seq, "UDPDST_RND  ");

  	if (pkt_dev->flags & F_MPLS_RND)
  		seq_printf(seq,  "MPLS_RND  ");

  	if (pkt_dev->flags & F_QUEUE_MAP_RND)
  		seq_printf(seq,  "QUEUE_MAP_RND  ");

  	if (pkt_dev->flags & F_QUEUE_MAP_CPU)
  		seq_printf(seq,  "QUEUE_MAP_CPU  ");

  	if (pkt_dev->cflows) {
  		if (pkt_dev->flags & F_FLOW_SEQ)
  			seq_printf(seq,  "FLOW_SEQ  "); /*in sequence flows*/
  		else
  			seq_printf(seq,  "FLOW_RND  ");
  	}

  #ifdef CONFIG_XFRM
  	if (pkt_dev->flags & F_IPSEC_ON)
  		seq_printf(seq,  "IPSEC  ");
  #endif

  	if (pkt_dev->flags & F_MACSRC_RND)
  		seq_printf(seq, "MACSRC_RND  ");

  	if (pkt_dev->flags & F_MACDST_RND)
  		seq_printf(seq, "MACDST_RND  ");

  	if (pkt_dev->flags & F_VID_RND)
  		seq_printf(seq, "VID_RND  ");
  
  	if (pkt_dev->flags & F_SVID_RND)
  		seq_printf(seq, "SVID_RND  ");

  	if (pkt_dev->flags & F_NODE)
  		seq_printf(seq, "NODE_ALLOC  ");

  	seq_puts(seq, "
  ");

  	/* not really stopped, more like last-running-at */
  	stopped = pkt_dev->running ? ktime_now() : pkt_dev->stopped_at;
  	idle = pkt_dev->idle_acc;
  	do_div(idle, NSEC_PER_USEC);

  	seq_printf(seq,

  		   "Current:
       pkts-sofar: %llu  errors: %llu
  ",

  		   (unsigned long long)pkt_dev->sofar,

  		   (unsigned long long)pkt_dev->errors);
  
  	seq_printf(seq,
  		   "     started: %lluus  stopped: %lluus idle: %lluus
  ",
  		   (unsigned long long) ktime_to_us(pkt_dev->started_at),
  		   (unsigned long long) ktime_to_us(stopped),
  		   (unsigned long long) idle);

  	seq_printf(seq,
  		   "     seq_num: %d  cur_dst_mac_offset: %d  cur_src_mac_offset: %d
  ",

  		   pkt_dev->seq_num, pkt_dev->cur_dst_mac_offset,
  		   pkt_dev->cur_src_mac_offset);

  	if (pkt_dev->flags & F_IPV6) {

  		seq_printf(seq, "     cur_saddr: %pI6c  cur_daddr: %pI6c
  ",
  				&pkt_dev->cur_in6_saddr,
  				&pkt_dev->cur_in6_daddr);

  	} else
  		seq_printf(seq, "     cur_saddr: 0x%x  cur_daddr: 0x%x
  ",

  			   pkt_dev->cur_saddr, pkt_dev->cur_daddr);

  	seq_printf(seq, "     cur_udp_dst: %d  cur_udp_src: %d
  ",

  		   pkt_dev->cur_udp_dst, pkt_dev->cur_udp_src);

  	seq_printf(seq, "     cur_queue_map: %u
  ", pkt_dev->cur_queue_map);

  	seq_printf(seq, "     flows: %u
  ", pkt_dev->nflows);

  
  	if (pkt_dev->result[0])

  		seq_printf(seq, "Result: %s
  ", pkt_dev->result);

  	else

  		seq_printf(seq, "Result: Idle
  ");

  	return 0;

  }

  static int hex32_arg(const char __user *user_buffer, unsigned long maxlen,
  		     __u32 *num)

  {
  	int i = 0;
  	*num = 0;

  	for (; i < maxlen; i++) {

  		int value;

  		char c;
  		*num <<= 4;
  		if (get_user(c, &user_buffer[i]))
  			return -EFAULT;

  		value = hex_to_bin(c);
  		if (value >= 0)
  			*num |= value;

  		else
  			break;
  	}
  	return i;
  }

  static int count_trail_chars(const char __user * user_buffer,
  			     unsigned int maxlen)

  {
  	int i;
  
  	for (i = 0; i < maxlen; i++) {

  		char c;
  		if (get_user(c, &user_buffer[i]))
  			return -EFAULT;
  		switch (c) {

  		case '\"':
  		case '
  ':
  		case '\r':
  		case '\t':
  		case ' ':
  		case '=':
  			break;
  		default:
  			goto done;

  		}

  	}
  done:
  	return i;
  }

  static unsigned long num_arg(const char __user * user_buffer,
  			     unsigned long maxlen, unsigned long *num)

  {

  	int i;

  	*num = 0;

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

  		char c;
  		if (get_user(c, &user_buffer[i]))
  			return -EFAULT;
  		if ((c >= '0') && (c <= '9')) {

  			*num *= 10;

  			*num += c - '0';

  		} else
  			break;
  	}
  	return i;
  }

  static int strn_len(const char __user * user_buffer, unsigned int maxlen)

  {

  	int i;

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

  		char c;
  		if (get_user(c, &user_buffer[i]))
  			return -EFAULT;
  		switch (c) {

  		case '\"':
  		case '
  ':
  		case '\r':
  		case '\t':
  		case ' ':
  			goto done_str;
  			break;
  		default:
  			break;

  		}

  	}
  done_str:

  	return i;
  }

  static ssize_t get_labels(const char __user *buffer, struct pktgen_dev *pkt_dev)
  {
  	unsigned n = 0;
  	char c;
  	ssize_t i = 0;
  	int len;
  
  	pkt_dev->nr_labels = 0;
  	do {
  		__u32 tmp;

  		len = hex32_arg(&buffer[i], 8, &tmp);

  		if (len <= 0)
  			return len;
  		pkt_dev->labels[n] = htonl(tmp);
  		if (pkt_dev->labels[n] & MPLS_STACK_BOTTOM)
  			pkt_dev->flags |= F_MPLS_RND;
  		i += len;
  		if (get_user(c, &buffer[i]))
  			return -EFAULT;
  		i++;
  		n++;
  		if (n >= MAX_MPLS_LABELS)
  			return -E2BIG;

  	} while (c == ',');

  
  	pkt_dev->nr_labels = n;
  	return i;
  }

  static ssize_t pktgen_if_write(struct file *file,
  			       const char __user * user_buffer, size_t count,
  			       loff_t * offset)

  {

  	struct seq_file *seq = file->private_data;

  	struct pktgen_dev *pkt_dev = seq->private;

  	int i, max, len;

  	char name[16], valstr[32];
  	unsigned long value = 0;

  	char *pg_result = NULL;
  	int tmp = 0;

  	char buf[128];

  
  	pg_result = &(pkt_dev->result[0]);

  	if (count < 1) {

  		pr_warning("wrong command format
  ");

  		return -EINVAL;
  	}

  	max = count;
  	tmp = count_trail_chars(user_buffer, max);

  	if (tmp < 0) {

  		pr_warning("illegal format
  ");

  		return tmp;

  	}

  	i = tmp;

  	/* Read variable name */
  
  	len = strn_len(&user_buffer[i], sizeof(name) - 1);

  	if (len < 0)

  		return len;

  	memset(name, 0, sizeof(name));

  	if (copy_from_user(name, &user_buffer[i], len))

  		return -EFAULT;
  	i += len;

  
  	max = count - i;

  	len = count_trail_chars(&user_buffer[i], max);

  	if (len < 0)
  		return len;

  	i += len;
  
  	if (debug) {

  		size_t copy = min_t(size_t, count, 1023);

  		char tb[copy + 1];
  		if (copy_from_user(tb, user_buffer, copy))

  			return -EFAULT;

  		tb[copy] = 0;

  		printk(KERN_DEBUG "pktgen: %s,%lu  buffer -:%s:-
  ", name,

  		       (unsigned long)count, tb);
  	}

  
  	if (!strcmp(name, "min_pkt_size")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value < 14 + 20 + 8)
  			value = 14 + 20 + 8;
  		if (value != pkt_dev->min_pkt_size) {
  			pkt_dev->min_pkt_size = value;
  			pkt_dev->cur_pkt_size = value;
  		}
  		sprintf(pg_result, "OK: min_pkt_size=%u",
  			pkt_dev->min_pkt_size);

  		return count;
  	}

  	if (!strcmp(name, "max_pkt_size")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value < 14 + 20 + 8)
  			value = 14 + 20 + 8;
  		if (value != pkt_dev->max_pkt_size) {
  			pkt_dev->max_pkt_size = value;
  			pkt_dev->cur_pkt_size = value;
  		}
  		sprintf(pg_result, "OK: max_pkt_size=%u",
  			pkt_dev->max_pkt_size);

  		return count;
  	}

  	/* Shortcut for min = max */

  
  	if (!strcmp(name, "pkt_size")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value < 14 + 20 + 8)
  			value = 14 + 20 + 8;
  		if (value != pkt_dev->min_pkt_size) {
  			pkt_dev->min_pkt_size = value;
  			pkt_dev->max_pkt_size = value;
  			pkt_dev->cur_pkt_size = value;
  		}

  		sprintf(pg_result, "OK: pkt_size=%u", pkt_dev->min_pkt_size);
  		return count;
  	}

  	if (!strcmp(name, "debug")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		debug = value;

  		sprintf(pg_result, "OK: debug=%u", debug);
  		return count;
  	}

  	if (!strcmp(name, "frags")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;
  		pkt_dev->nfrags = value;
  		sprintf(pg_result, "OK: frags=%u", pkt_dev->nfrags);
  		return count;
  	}
  	if (!strcmp(name, "delay")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value == 0x7FFFFFFF)
  			pkt_dev->delay = ULLONG_MAX;
  		else

  			pkt_dev->delay = (u64)value;

  
  		sprintf(pg_result, "OK: delay=%llu",
  			(unsigned long long) pkt_dev->delay);

  		return count;
  	}

  	if (!strcmp(name, "rate")) {
  		len = num_arg(&user_buffer[i], 10, &value);
  		if (len < 0)
  			return len;
  
  		i += len;
  		if (!value)
  			return len;
  		pkt_dev->delay = pkt_dev->min_pkt_size*8*NSEC_PER_USEC/value;
  		if (debug)

  			pr_info("Delay set at: %llu ns
  ", pkt_dev->delay);

  
  		sprintf(pg_result, "OK: rate=%lu", value);
  		return count;
  	}
  	if (!strcmp(name, "ratep")) {
  		len = num_arg(&user_buffer[i], 10, &value);
  		if (len < 0)
  			return len;
  
  		i += len;
  		if (!value)
  			return len;
  		pkt_dev->delay = NSEC_PER_SEC/value;
  		if (debug)

  			pr_info("Delay set at: %llu ns
  ", pkt_dev->delay);

  
  		sprintf(pg_result, "OK: rate=%lu", value);
  		return count;
  	}

  	if (!strcmp(name, "udp_src_min")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value != pkt_dev->udp_src_min) {
  			pkt_dev->udp_src_min = value;
  			pkt_dev->cur_udp_src = value;
  		}

  		sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min);
  		return count;
  	}

  	if (!strcmp(name, "udp_dst_min")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value != pkt_dev->udp_dst_min) {
  			pkt_dev->udp_dst_min = value;
  			pkt_dev->cur_udp_dst = value;
  		}

  		sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min);
  		return count;
  	}

  	if (!strcmp(name, "udp_src_max")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value != pkt_dev->udp_src_max) {
  			pkt_dev->udp_src_max = value;
  			pkt_dev->cur_udp_src = value;
  		}

  		sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max);
  		return count;
  	}

  	if (!strcmp(name, "udp_dst_max")) {

  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;

  		if (value != pkt_dev->udp_dst_max) {
  			pkt_dev->udp_dst_max = value;
  			pkt_dev->cur_udp_dst = value;
  		}

  		sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max);
  		return count;
  	}
  	if (!strcmp(name, "clone_skb")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		if ((value > 0) &&
  		    (!(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))
  			return -ENOTSUPP;

  		i += len;

  		pkt_dev->clone_skb = value;

  		sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb);
  		return count;
  	}
  	if (!strcmp(name, "count")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;
  		pkt_dev->count = value;
  		sprintf(pg_result, "OK: count=%llu",

  			(unsigned long long)pkt_dev->count);

  		return count;
  	}
  	if (!strcmp(name, "src_mac_count")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;
  		if (pkt_dev->src_mac_count != value) {

  			pkt_dev->src_mac_count = value;
  			pkt_dev->cur_src_mac_offset = 0;
  		}
  		sprintf(pg_result, "OK: src_mac_count=%d",
  			pkt_dev->src_mac_count);

  		return count;
  	}
  	if (!strcmp(name, "dst_mac_count")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;
  		if (pkt_dev->dst_mac_count != value) {

  			pkt_dev->dst_mac_count = value;
  			pkt_dev->cur_dst_mac_offset = 0;
  		}
  		sprintf(pg_result, "OK: dst_mac_count=%d",
  			pkt_dev->dst_mac_count);

  		return count;
  	}

  	if (!strcmp(name, "node")) {
  		len = num_arg(&user_buffer[i], 10, &value);
  		if (len < 0)
  			return len;
  
  		i += len;
  
  		if (node_possible(value)) {
  			pkt_dev->node = value;
  			sprintf(pg_result, "OK: node=%d", pkt_dev->node);

  			if (pkt_dev->page) {
  				put_page(pkt_dev->page);
  				pkt_dev->page = NULL;
  			}

  		}
  		else
  			sprintf(pg_result, "ERROR: node not possible");
  		return count;
  	}

  	if (!strcmp(name, "flag")) {

  		char f[32];
  		memset(f, 0, 32);

  		len = strn_len(&user_buffer[i], sizeof(f) - 1);

  		if (len < 0)

  			return len;

  		if (copy_from_user(f, &user_buffer[i], len))
  			return -EFAULT;
  		i += len;

  		if (strcmp(f, "IPSRC_RND") == 0)
  			pkt_dev->flags |= F_IPSRC_RND;
  
  		else if (strcmp(f, "!IPSRC_RND") == 0)
  			pkt_dev->flags &= ~F_IPSRC_RND;
  
  		else if (strcmp(f, "TXSIZE_RND") == 0)
  			pkt_dev->flags |= F_TXSIZE_RND;
  
  		else if (strcmp(f, "!TXSIZE_RND") == 0)
  			pkt_dev->flags &= ~F_TXSIZE_RND;
  
  		else if (strcmp(f, "IPDST_RND") == 0)
  			pkt_dev->flags |= F_IPDST_RND;
  
  		else if (strcmp(f, "!IPDST_RND") == 0)
  			pkt_dev->flags &= ~F_IPDST_RND;
  
  		else if (strcmp(f, "UDPSRC_RND") == 0)
  			pkt_dev->flags |= F_UDPSRC_RND;
  
  		else if (strcmp(f, "!UDPSRC_RND") == 0)
  			pkt_dev->flags &= ~F_UDPSRC_RND;
  
  		else if (strcmp(f, "UDPDST_RND") == 0)
  			pkt_dev->flags |= F_UDPDST_RND;
  
  		else if (strcmp(f, "!UDPDST_RND") == 0)
  			pkt_dev->flags &= ~F_UDPDST_RND;
  
  		else if (strcmp(f, "MACSRC_RND") == 0)
  			pkt_dev->flags |= F_MACSRC_RND;
  
  		else if (strcmp(f, "!MACSRC_RND") == 0)
  			pkt_dev->flags &= ~F_MACSRC_RND;
  
  		else if (strcmp(f, "MACDST_RND") == 0)
  			pkt_dev->flags |= F_MACDST_RND;
  
  		else if (strcmp(f, "!MACDST_RND") == 0)
  			pkt_dev->flags &= ~F_MACDST_RND;

  		else if (strcmp(f, "MPLS_RND") == 0)
  			pkt_dev->flags |= F_MPLS_RND;
  
  		else if (strcmp(f, "!MPLS_RND") == 0)
  			pkt_dev->flags &= ~F_MPLS_RND;

  		else if (strcmp(f, "VID_RND") == 0)
  			pkt_dev->flags |= F_VID_RND;
  
  		else if (strcmp(f, "!VID_RND") == 0)
  			pkt_dev->flags &= ~F_VID_RND;
  
  		else if (strcmp(f, "SVID_RND") == 0)
  			pkt_dev->flags |= F_SVID_RND;
  
  		else if (strcmp(f, "!SVID_RND") == 0)
  			pkt_dev->flags &= ~F_SVID_RND;

  		else if (strcmp(f, "FLOW_SEQ") == 0)
  			pkt_dev->flags |= F_FLOW_SEQ;

  		else if (strcmp(f, "QUEUE_MAP_RND") == 0)
  			pkt_dev->flags |= F_QUEUE_MAP_RND;
  
  		else if (strcmp(f, "!QUEUE_MAP_RND") == 0)
  			pkt_dev->flags &= ~F_QUEUE_MAP_RND;

  
  		else if (strcmp(f, "QUEUE_MAP_CPU") == 0)
  			pkt_dev->flags |= F_QUEUE_MAP_CPU;
  
  		else if (strcmp(f, "!QUEUE_MAP_CPU") == 0)
  			pkt_dev->flags &= ~F_QUEUE_MAP_CPU;

  #ifdef CONFIG_XFRM
  		else if (strcmp(f, "IPSEC") == 0)
  			pkt_dev->flags |= F_IPSEC_ON;
  #endif

  		else if (strcmp(f, "!IPV6") == 0)
  			pkt_dev->flags &= ~F_IPV6;

  		else if (strcmp(f, "NODE_ALLOC") == 0)
  			pkt_dev->flags |= F_NODE;
  
  		else if (strcmp(f, "!NODE_ALLOC") == 0)
  			pkt_dev->flags &= ~F_NODE;

  		else {
  			sprintf(pg_result,
  				"Flag -:%s:- unknown
  Available flags, (prepend ! to un-set flag):
  %s",
  				f,

  				"IPSRC_RND, IPDST_RND, UDPSRC_RND, UDPDST_RND, "

  				"MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND, FLOW_SEQ, IPSEC, NODE_ALLOC
  ");

  			return count;
  		}

  		sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
  		return count;
  	}
  	if (!strcmp(name, "dst_min") || !strcmp(name, "dst")) {
  		len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_min) - 1);

  		if (len < 0)

  			return len;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;
  		if (strcmp(buf, pkt_dev->dst_min) != 0) {
  			memset(pkt_dev->dst_min, 0, sizeof(pkt_dev->dst_min));
  			strncpy(pkt_dev->dst_min, buf, len);
  			pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
  			pkt_dev->cur_daddr = pkt_dev->daddr_min;
  		}
  		if (debug)

  			printk(KERN_DEBUG "pktgen: dst_min set to: %s
  ",

  			       pkt_dev->dst_min);
  		i += len;

  		sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min);
  		return count;
  	}
  	if (!strcmp(name, "dst_max")) {
  		len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_max) - 1);

  		if (len < 0)

  			return len;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;
  		if (strcmp(buf, pkt_dev->dst_max) != 0) {
  			memset(pkt_dev->dst_max, 0, sizeof(pkt_dev->dst_max));
  			strncpy(pkt_dev->dst_max, buf, len);
  			pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
  			pkt_dev->cur_daddr = pkt_dev->daddr_max;
  		}
  		if (debug)

  			printk(KERN_DEBUG "pktgen: dst_max set to: %s
  ",

  			       pkt_dev->dst_max);

  		i += len;
  		sprintf(pg_result, "OK: dst_max=%s", pkt_dev->dst_max);
  		return count;
  	}
  	if (!strcmp(name, "dst6")) {
  		len = strn_len(&user_buffer[i], sizeof(buf) - 1);

  		if (len < 0)
  			return len;

  
  		pkt_dev->flags |= F_IPV6;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;

  
  		scan_ip6(buf, pkt_dev->in6_daddr.s6_addr);

  		snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_daddr);

  		pkt_dev->cur_in6_daddr = pkt_dev->in6_daddr;

  		if (debug)

  			printk(KERN_DEBUG "pktgen: dst6 set to: %s
  ", buf);

  		i += len;

  		sprintf(pg_result, "OK: dst6=%s", buf);
  		return count;
  	}
  	if (!strcmp(name, "dst6_min")) {
  		len = strn_len(&user_buffer[i], sizeof(buf) - 1);

  		if (len < 0)
  			return len;

  
  		pkt_dev->flags |= F_IPV6;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;

  
  		scan_ip6(buf, pkt_dev->min_in6_daddr.s6_addr);

  		snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->min_in6_daddr);

  		pkt_dev->cur_in6_daddr = pkt_dev->min_in6_daddr;

  		if (debug)

  			printk(KERN_DEBUG "pktgen: dst6_min set to: %s
  ", buf);

  		i += len;

  		sprintf(pg_result, "OK: dst6_min=%s", buf);
  		return count;
  	}
  	if (!strcmp(name, "dst6_max")) {
  		len = strn_len(&user_buffer[i], sizeof(buf) - 1);

  		if (len < 0)
  			return len;

  
  		pkt_dev->flags |= F_IPV6;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;

  
  		scan_ip6(buf, pkt_dev->max_in6_daddr.s6_addr);

  		snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->max_in6_daddr);

  		if (debug)

  			printk(KERN_DEBUG "pktgen: dst6_max set to: %s
  ", buf);

  		i += len;

  		sprintf(pg_result, "OK: dst6_max=%s", buf);
  		return count;
  	}
  	if (!strcmp(name, "src6")) {
  		len = strn_len(&user_buffer[i], sizeof(buf) - 1);

  		if (len < 0)
  			return len;

  
  		pkt_dev->flags |= F_IPV6;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;

  
  		scan_ip6(buf, pkt_dev->in6_saddr.s6_addr);

  		snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_saddr);

  		pkt_dev->cur_in6_saddr = pkt_dev->in6_saddr;

  		if (debug)

  			printk(KERN_DEBUG "pktgen: src6 set to: %s
  ", buf);

  
  		i += len;

  		sprintf(pg_result, "OK: src6=%s", buf);
  		return count;
  	}
  	if (!strcmp(name, "src_min")) {
  		len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_min) - 1);

  		if (len < 0)

  			return len;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;
  		if (strcmp(buf, pkt_dev->src_min) != 0) {
  			memset(pkt_dev->src_min, 0, sizeof(pkt_dev->src_min));
  			strncpy(pkt_dev->src_min, buf, len);
  			pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
  			pkt_dev->cur_saddr = pkt_dev->saddr_min;
  		}
  		if (debug)

  			printk(KERN_DEBUG "pktgen: src_min set to: %s
  ",

  			       pkt_dev->src_min);

  		i += len;
  		sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min);
  		return count;
  	}
  	if (!strcmp(name, "src_max")) {
  		len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_max) - 1);

  		if (len < 0)

  			return len;

  		if (copy_from_user(buf, &user_buffer[i], len))

  			return -EFAULT;

  		buf[len] = 0;
  		if (strcmp(buf, pkt_dev->src_max) != 0) {
  			memset(pkt_dev->src_max, 0, sizeof(pkt_dev->src_max));
  			strncpy(pkt_dev->src_max, buf, len);
  			pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
  			pkt_dev->cur_saddr = pkt_dev->saddr_max;
  		}
  		if (debug)

  			printk(KERN_DEBUG "pktgen: src_max set to: %s
  ",

  			       pkt_dev->src_max);

  		i += len;
  		sprintf(pg_result, "OK: src_max=%s", pkt_dev->src_max);
  		return count;
  	}
  	if (!strcmp(name, "dst_mac")) {

  		len = strn_len(&user_buffer[i], sizeof(valstr) - 1);

  		if (len < 0)

  			return len;

  		memset(valstr, 0, sizeof(valstr));

  		if (copy_from_user(valstr, &user_buffer[i], len))

  			return -EFAULT;

  		if (!mac_pton(valstr, pkt_dev->dst_mac))
  			return -EINVAL;

  		/* Set up Dest MAC */

  		memcpy(&pkt_dev->hh[0], pkt_dev->dst_mac, ETH_ALEN);

  		sprintf(pg_result, "OK: dstmac %pM", pkt_dev->dst_mac);

  		return count;
  	}
  	if (!strcmp(name, "src_mac")) {

  		len = strn_len(&user_buffer[i], sizeof(valstr) - 1);

  		if (len < 0)

  			return len;

  		memset(valstr, 0, sizeof(valstr));

  		if (copy_from_user(valstr, &user_buffer[i], len))

  			return -EFAULT;

  		if (!mac_pton(valstr, pkt_dev->src_mac))
  			return -EINVAL;

  		/* Set up Src MAC */

  		memcpy(&pkt_dev->hh[6], pkt_dev->src_mac, ETH_ALEN);

  		sprintf(pg_result, "OK: srcmac %pM", pkt_dev->src_mac);

  		return count;
  	}

  	if (!strcmp(name, "clear_counters")) {
  		pktgen_clear_counters(pkt_dev);
  		sprintf(pg_result, "OK: Clearing counters.
  ");
  		return count;
  	}

  
  	if (!strcmp(name, "flows")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)

  			return len;

  		i += len;
  		if (value > MAX_CFLOWS)
  			value = MAX_CFLOWS;
  
  		pkt_dev->cflows = value;
  		sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows);
  		return count;
  	}
  
  	if (!strcmp(name, "flowlen")) {
  		len = num_arg(&user_buffer[i], 10, &value);

  		if (len < 0)