staging: add mausezahn staging directory

After some back and forth, we decided that it is easier to maintain
mausezahn in a staging directory until it is fully reworked and
cleaned up to be ready to be fully integrated. This way, it is better
than having it in a separate branch, and we can also accept patches
from outside more easily. Also, while at it, fix up some function
mismatches with libcli.

Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Signed-off-by: Tobias Klauser <tklauser@distanz.ch>

1 files changed, 888 insertions, 0 deletions

diff --git a/staging/cli_ip.c b/staging/cli_ip.c
new file mode 100644
index 0000000..55f5683
--- /dev/null
+++ b/staging/cli_ip.c
@@ -0,0 +1,888 @@
+/*
+ * Mausezahn - A fast versatile traffic generator
+ * Copyright (C) 2008-2010 Herbert Haas
+ * 
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the 
+ * Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT 
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ * 
+ * You should have received a copy of the GNU General Public License along with 
+ * this program; if not, see http://www.gnu.org/licenses/gpl-2.0.html
+ * 
+*/
+
+
+
+#include "mz.h"
+#include "cli.h"
+#include "mops.h"
+
+
+// ------- TOC ---------
+// 
+// int     cmd_ip_address_source       (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_address_destination  (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_version              (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_ttl                  (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_protocol             (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_hlen                 (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_len                  (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_id                   (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_offset               (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_sum                  (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_tos                  (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_dscp                 (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_rsv                  (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_df                   (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_mf                   (struct cli_def *cli, char *command, char *argv[], int argc)
+// int     cmd_ip_option               (struct cli_def *cli, char *command, char *argv[], int argc)
+
+
+
+// ip-address source default|<IP>|rand|range
+// 
+//   default
+//   random
+//   A.B.C.D
+//   A.B.C.D  /24
+//   A.B.C.D  E.F.G.H
+int cmd_ip_address_source (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   u_int8_t IP1[4], IP2[4];
+   u_int32_t ip1, ip2;
+   unsigned int prefix;
+   u_int32_t mask, invmask;
+   int i,r;
+
+   if ( (strcmp(argv[argc-1],"?")==0) || (argc>2) )
+     {
+	cli_print(cli, "A.B.C.D     configure a source IP address\n");
+	cli_print(cli, "Optionally you may specify\r");
+	cli_print(cli, "- a range of addresses, such as: 192.168.0.0 /16\r");
+	cli_print(cli, "                             or: 192.168.0.1 192.168.255.255\r");
+	cli_print(cli, "- 'random' for a randomly generated source address\r");
+	cli_print(cli, "- 'default' for the interface default settings\n");
+	return CLI_OK;
+     }
+   
+   switch (argc)
+     {
+      case 1:
+	if (mz_strcmp(argv[0], "default", 3)==0)
+	  {
+	     // find index of device_list with the device configured in clipkt:
+	     i=0;
+	     while (strncmp(device_list[i].dev, clipkt->device, 10) && (i<device_list_entries)) i++;
+	     clipkt->ip_src = device_list[i].ip_mops[3] 
+	                    + device_list[i].ip_mops[2] * 256
+	                    + device_list[i].ip_mops[1] * 256 * 256 
+			    + device_list[i].ip_mops[0] * 256 * 256 * 256;
+	     clipkt->ip_src_israndom = 0;
+	     clipkt->ip_src_isrange = 0;
+	  }
+	else if (mz_strcmp(argv[0], "random", 3)==0)
+	  {
+	     clipkt->ip_src_israndom = 1;
+	     clipkt->ip_src_isrange = 0;
+	  }
+	else if (mops_pdesc_ip (IP1, argv[0])==0) // check if format is really an IP address
+	  { 
+	     clipkt->ip_src =  str2ip32(argv[0]);
+	     clipkt->ip_src_israndom = 0;
+	     clipkt->ip_src_isrange = 0;
+	  }
+	else // wrong input
+	  {
+	     cli_print(cli,"Invalid address/keyword\n");
+	  }
+	break;
+      case 2: // MUST be either like '10.1.1.0 /24' or '10.1.1.1 10.1.1.254'
+	if (mops_pdesc_ip (IP1, argv[0])==0) // check if format is really an IP address
+	  { 
+	     clipkt->ip_src_start = str2ip32(argv[0]);
+	     if (strlen(argv[1])<4) // probably prefix?
+	       {
+		  r=sscanf(argv[1],"/%u",&prefix);
+		  if ((r==EOF) || (r==0) || (prefix<1) || (prefix>31))
+		    cli_print(cli, "Invalid prefix!\n");
+		  else
+		    {
+		       mask = 0xffffffff;
+                       mask <<= (32-prefix);
+		       invmask = 0xffffffff - mask; 
+		       ip1 = ((str2ip32 (argv[0])) & mask) +1; // the '+1' is to ensure that we do not start with the net-id
+		       ip2 = ip1 | invmask;        
+		       clipkt->ip_src_start    = ip1;
+		       clipkt->ip_src_stop     = ip2;
+		       clipkt->ip_src_isrange  = 1;
+		       clipkt->ip_src_israndom = 0;
+		    }
+	       }
+	     else if (mops_pdesc_ip (IP2, argv[1])==0) // probably 2nd IP address?
+	       {
+		  if (str2ip32(argv[1]) > clipkt->ip_src_start)
+		    {
+		       clipkt->ip_src_stop = str2ip32(argv[1]);
+		       clipkt->ip_src_isrange  = 1;
+		       clipkt->ip_src_israndom = 0;
+		    }
+		  else
+		    {
+		       cli_print(cli, "Invalid range! The second IP address must be greater than the first!\n");
+		    }
+	       }
+	     else 
+	       {
+		  cli_print(cli, "Second parameter must be either a valid IP address or a prefix length \n");
+	       }
+	  }
+	else // first string is not a valid IP address
+	  {
+	     cli_print(cli, "First parameter must be a valid IP address\n");
+	  }
+	break;
+      default:
+	cli_print(cli, "Invalid format!\n");
+     }
+   
+   return CLI_OK;
+}
+
+
+
+// ip-address destination <IP>|range
+int cmd_ip_address_destination (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   u_int8_t IP1[4], IP2[4];
+   u_int32_t ip1, ip2;
+   unsigned int prefix;
+   u_int32_t mask, invmask;
+   int r;
+
+   if ( (strcmp(argv[argc-1],"?")==0) || (argc>2) )
+     {
+	cli_print(cli, "A.B.C.D     configure a destination IP address\n");
+	cli_print(cli, "Optionally specify a range of addresses, such as: 192.168.0.0 /16\r");
+	cli_print(cli, "                                              or: 192.168.0.1 192.168.255.255\n");
+	return CLI_OK;
+     }
+   
+   switch (argc)
+     {
+      case 1:
+	if (mops_pdesc_ip (IP1, argv[0])==0)  // check if format is really an IP address
+	  { 
+	     clipkt->ip_dst =  str2ip32(argv[0]);
+	     clipkt->ip_dst_isrange = 0;
+	  }
+	else // wrong input
+	  {
+	     cli_print(cli,"Invalid address/range\n");
+	  }
+	break;
+      case 2: // MUST be either like '10.1.1.0 /24' or '10.1.1.1 10.1.1.254'
+	if (mops_pdesc_ip (IP1, argv[0])==0) // check if format is really an IP address
+	  { 
+	     clipkt->ip_dst_start = str2ip32(argv[0]);
+	     if (strlen(argv[1])<4) // probably prefix?
+	       {
+		  r=sscanf(argv[1],"/%u",&prefix);
+		  if ((r==EOF) || (r==0) || (prefix<1) || (prefix>31))
+		    cli_print(cli, "Invalid prefix!\n");
+		  else
+		    {
+                       mask = 0xffffffff;
+		       mask <<= (32-prefix);
+		       invmask = 0xffffffff - mask; 
+		       ip1 = ((str2ip32 (argv[0])) & mask) +1; // the '+1' is to ensure that we do not start with the net-id
+		       ip2 = ip1 | invmask;        
+		       clipkt->ip_dst_start    = ip1;
+		       clipkt->ip_dst_stop     = ip2;
+		       clipkt->ip_dst_isrange  = 1;
+		    }
+	       }
+	     else if (mops_pdesc_ip (IP2, argv[1])==0) // probably 2nd IP address?
+	       {
+		  if (str2ip32(argv[1]) > clipkt->ip_dst_start)
+		    {
+		       clipkt->ip_dst_stop = str2ip32(argv[1]);
+		       clipkt->ip_dst_isrange  = 1;
+		    }
+		  else
+		    {
+		       cli_print(cli, "Range requirement: The second IP address must be greater than the first!\n");
+		    }
+	       }
+	     else 
+	       {
+		  cli_print(cli, "Second parameter must be either a valid IP address or a prefix length \n");
+	       }
+	  }
+	else // first string is not a valid IP address
+	  {
+	     cli_print(cli, "First parameter must be a valid IP address\n");
+	  }
+	break;
+      default:
+	cli_print(cli, "Invalid IP or range specification!\n");
+     }
+   
+   return CLI_OK;   
+}
+
+
+
+
+int cmd_ip_version (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   int ver;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the IP version (default: 4).\n");
+	return CLI_OK;
+     }
+
+   ver = (int) str2int(argv[0]);
+   
+   if (ver>15) 
+     {
+	cli_print(cli, "Version must be within range 0..15\n");
+	return CLI_OK;
+     }
+   
+   clipkt->ip_version = ver;
+   
+   return CLI_OK;
+}
+
+
+
+int cmd_ip_ttl (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   int ttl;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the TTL (default: 255).\n");
+	
+	return CLI_OK;
+     }
+
+   ttl = (int) str2int(argv[0]);
+   
+   if (ttl>255) 
+     {
+	cli_print(cli, "TTL must be within range 0..255\n");
+	return CLI_OK;
+     }
+   
+   clipkt->ip_ttl = ttl;
+
+   
+   return CLI_OK;
+}
+
+
+
+int cmd_ip_protocol (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   int proto;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the protocol number (default: 0).\n");
+	
+	return CLI_OK;
+     }
+
+   proto = (int) str2int(argv[0]);
+   
+   if (proto>255) 
+     {
+	cli_print(cli, "The protocol number must be within range 0..255\n");
+	return CLI_OK;
+     }
+   
+   clipkt->ip_proto = proto;
+   
+   return CLI_OK;
+}
+
+
+
+
+
+int cmd_ip_hlen (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   int ihl;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the header length in multiple of 4 bytes.\n");
+	
+	return CLI_OK;
+     }
+   
+   ihl = (int) str2int(argv[0]);
+   
+   if (ihl>15) 
+     {
+	cli_print(cli, "The IHL must be within range 0..15\n");
+	return CLI_OK;
+     }
+   
+   clipkt->ip_IHL = ihl;
+   
+   return CLI_OK;
+}
+
+
+
+
+
+int cmd_ip_len (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   int len;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the total packet length (0..65535).\n");
+	
+	return CLI_OK;
+     }
+
+   len = (int) str2int(argv[0]);
+   
+   if (len>65535) 
+     {
+	cli_print(cli, "The packet length must be within range 0..65535\n");
+	return CLI_OK;
+     }
+   
+   clipkt->ip_len = len;
+
+   return CLI_OK;
+}
+
+
+
+
+
+int cmd_ip_id (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+
+   u_int32_t id;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the packet identification number (0..4294967295).\n");
+	return CLI_OK;
+     }
+
+   if (mz_strcmp(argv[0], "hex", 2)==0)
+     {
+	id = xstr2int (argv[1]);
+     }
+   else
+     {
+	id = str2int (argv[0]);
+     }
+   
+   clipkt->ip_id = id;
+   
+   return CLI_OK;
+}
+
+
+
+
+
+
+int cmd_ip_offset (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   
+	int offset;
+   
+	if (strncmp(argv[argc-1], "?", 2)==0) {
+		cli_print(cli, "Specify the fragment offset in multiples of 8 bytes.\n");
+		return CLI_OK;
+	}
+   
+	offset = (int) str2int(argv[0]);
+	
+	if (offset>8191) {
+		cli_print(cli, "The fragment offset must be within range 0..8191\n");
+		return CLI_OK;
+	}
+   
+	clipkt->ip_frag_offset = offset;
+	
+	return CLI_OK;
+}
+
+
+
+
+
+int cmd_ip_sum (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   int sum;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the IP checksum in hexadecimal or use the keyword 'auto'.\r");
+	cli_print(cli, "By default, the checksum is computed automatically.\n");
+	return CLI_OK;
+     }
+
+   if (mz_strcmp(argv[0], "auto", 2)==0)
+     {
+	clipkt->ip_sum_false=0;
+	return CLI_OK;
+     }
+   
+   sum = (int) xstr2int(argv[0]);
+   
+   if (sum>0xffff) 
+     {
+	cli_print(cli, "The checksum must be within range 0..ffff\n");
+	return CLI_OK;
+     }
+   
+   clipkt->ip_sum = (u_int16_t) sum;
+   clipkt->ip_sum_false=1;
+   
+   return CLI_OK;
+}
+
+
+
+
+
+
+
+int cmd_ip_tos (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   char *tmp;
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Specify the Type of Service field: <IPP> [<ToS>] [MBZ]\n");
+	cli_print(cli, "  - IP precedence (IPP) 0..7\r");
+	cli_print(cli, "  - ToS: delay/throughput/reliability/cost 0..15\r");
+	cli_print(cli, "  - MBZ ('must be zero' - however, not with Mausezahn...)\r");
+	cli_print(cli, "Or, alternatively, configure the whole byte in hex.\n");
+	cli_print(cli, "EXAMPLES:\n");
+	cli_print(cli, "  5          ... IPP = 5\r");
+	cli_print(cli, "  5 9        ... IPP = 5 and ToS = 9\r");
+	cli_print(cli, "  5 MBZ      ... IPP = 5 and MBZ is set\r");
+	cli_print(cli, "  5 9 MBZ    ... All three fields configured\r");
+	cli_print(cli, "  hex a8     ... the whole byte is set to 10101000\r");
+	cli_print(cli, "  10101000   ... the whole byte in binary\n");
+	return CLI_OK;
+     }
+   
+   if ((argc==1) && (mz_strisbinary(argv[0])==8))
+     {
+	clipkt->ip_tos = (u_int8_t) str2bin8 (argv[0]);
+	return CLI_OK;
+     }
+   
+   if ((argc==2) && (mz_strcmp(argv[0], "hex", 2)==0))
+     {
+	tmp = argv[1];
+	
+	if (strlen(tmp)!=2) 
+	  {
+	     cli_print(cli, "You must specify a 2-digit hexadecimal value\n");
+	     return CLI_OK;
+	  }
+	
+	if (!(isxdigit(tmp[0])) || (!(isxdigit(tmp[1]))))
+	  {
+	     cli_print(cli, "Non-hexadecimal value!\n");
+	     return CLI_OK;
+	  }
+	
+	clipkt->ip_tos = (u_int8_t) xstr2int (tmp);
+	return CLI_OK;
+     }
+   
+   switch (argc)
+     {
+      case 1:
+	if (mz_strcmp(argv[0], "mbz", 1)==0)
+	  {
+	     mops_ip_tos(clipkt, -1, -1, 1);
+	  }
+	else
+	  {
+	     if (mops_ip_tos(clipkt, (int)str2int(argv[0]), -1, 0))
+	       cli_print(cli, "Invalid IP Precedence value\n");
+	  }
+	break;
+	
+      case 2:
+	if (mz_strcmp(argv[1], "mbz", 1)==0)
+	  {
+	     if (mops_ip_tos(clipkt, (int)str2int(argv[0]), -1, 1))
+	       cli_print(cli, "Invalid IP Precedence value\n");
+	  }
+	else
+	  {
+	     if (mops_ip_tos(clipkt, (int)str2int(argv[0]), (int)str2int(argv[1]), 0))
+	       cli_print(cli, "Invalid values\n");
+	  }
+	break;
+	
+      case 3:
+	if (mz_strcmp(argv[2], "mbz", 1)!=0)
+	  cli_print(cli, "In this case the 3rd argument must be 'mbz'\n");
+	else
+	  if (mops_ip_tos(clipkt, (int)str2int(argv[0]), (int)str2int(argv[1]),  1))
+	    cli_print(cli, "Invalid values\n");
+	break;
+     }
+   
+   return CLI_OK;
+}
+
+
+
+
+
+
+
+int cmd_ip_dscp (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   if ((argc!=1) || (strncmp(argv[argc-1], "?", 2)==0))
+     {
+	cli_print(cli, "Specify the Type of Service field using the DSCP format.\r");
+	cli_print(cli, "Multiple notations are supported.\n");
+	cli_print(cli, "Examples:\r");
+	cli_print(cli, "    AF32        .... specify AF codepoint with class 3 and drop probability 2\r");
+	cli_print(cli, "    EF          .... specify Expedited Forwarding\r");
+	cli_print(cli, "    CS7         .... specify Code Selector 7\r");
+	cli_print(cli, "    101110      .... specify the DSCP in binary\r");
+	cli_print(cli, "    56          .... specify the DSCP in decimal\r");
+	cli_print(cli, "\r");
+	return CLI_OK;
+     }
+   
+   switch (mops_ip_dscp(clipkt, argv[0]))
+     {
+      case -1:
+	cli_print(cli, "Invalid DSCP specification (use '?')\n");
+	break;
+      case 1:
+	cli_print(cli, "Invalid AF code point (use '?')\n");
+	break;
+      case 2:
+	cli_print(cli, "Invalid Code Selector (CS0..CS7)\n");
+	break;
+      case 3:
+	cli_print(cli, "Invalid DSCP value (0..63)\n");
+	break;
+     }
+   
+   return CLI_OK;
+}
+
+
+
+
+
+int cmd_ip_rsv (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Set or unset the reserved flag.\n");
+	return CLI_OK;
+     }
+   
+   if (argc!=1)
+     {
+	cli_print(cli, "Use the 'set' or 'unset' keywords.\n");
+	return CLI_OK;
+     }
+   
+	
+   if (mz_strcmp(argv[0], "set", 1)==0)
+     {
+	clipkt->ip_flags_RS = 1;
+	return CLI_OK;
+     }
+       
+   if (mz_strcmp(argv[0], "unset", 1)==0)
+     {
+	clipkt->ip_flags_RS = 0;
+	return CLI_OK;
+     }
+   
+   cli_print(cli, "Unknown keyword. Use the 'set' or 'unset' keywords.\n");
+   
+   return CLI_OK;
+   
+}
+
+
+
+
+
+int cmd_ip_df (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Set or unset the don't fragment flag.\n");
+	
+	return CLI_OK;
+     }
+
+   if (argc!=1)
+     {
+	cli_print(cli, "Use the 'set' or 'unset' keywords.\n");
+	return CLI_OK;
+     }
+
+   
+   if (mz_strcmp(argv[0], "set", 1)==0)
+     {
+	clipkt->ip_flags_DF = 1;
+	return CLI_OK;
+     }
+   
+   if (mz_strcmp(argv[0], "unset", 1)==0)
+     {
+	clipkt->ip_flags_DF = 0;
+	return CLI_OK;
+     }
+   
+   cli_print(cli, "Unknown keyword. Use the 'set' or 'unset' keywords.\n");
+
+   
+   return CLI_OK;
+   
+}
+
+
+
+
+
+int cmd_ip_mf (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   
+   if (strncmp(argv[argc-1], "?", 2)==0)
+     {
+	cli_print(cli, "Set or unset the more fragments flag.\n");
+	
+	return CLI_OK;
+     }
+
+   if (argc!=1)
+     {
+	cli_print(cli, "Use the 'set' or 'unset' keywords.\n");
+	return CLI_OK;
+     }
+
+   
+   if (mz_strcmp(argv[0], "set", 1)==0)
+     {
+	clipkt->ip_flags_MF = 1;
+	return CLI_OK;
+     }
+       
+   if (mz_strcmp(argv[0], "unset", 1)==0)
+     {
+	clipkt->ip_flags_MF = 0;
+	return CLI_OK;
+     }
+
+   cli_print(cli, "Unknown keyword. Use the 'set' or 'unset' keywords.\n");
+   
+   return CLI_OK;
+   
+}
+
+
+int cmd_ip_fragsize (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+	u_int32_t fragsize=0; 
+	
+	if (strncmp(argv[argc-1], "?", 2)==0) {
+		cli_print(cli, "Enable fragmentation by configuring a fragment size.\n");
+		cli_print(cli, "Note that the fragment size specifies the number of bytes in the IP payload\r");
+		cli_print(cli, "and NOT the assumed MTU on that link. The total packet size of each fragment\r");
+		cli_print(cli, "will be 20 bytes larger (=size of IP header if no IP options are used).\n");
+		cli_print(cli, "WARNING: The fragment size SHOULD be a multiple of 8 bytes if you expect\r");
+		cli_print(cli, "         a valid result.\n");
+		cli_print(cli, "ARGUMENTS: <frag-size>\n");
+		return CLI_OK;
+	}
+	
+	if (argc!=1) {
+		cli_print(cli, "Specify the fragment size in bytes.\n");
+		return CLI_OK;
+	}
+
+       
+	fragsize = (u_int32_t) str2int(argv[0]);
+	
+	if ((fragsize<0) || (fragsize>8000)) { 
+		cli_print(cli, "The fragment size must be within range 0..8000\n");
+		return CLI_OK;
+	}
+	
+	if (fragsize%8) {
+		cli_print(cli, "Warning: The fragment-size is not a multiple of 8.\n");
+	}
+	
+	clipkt->ip_fragsize = fragsize;
+
+	return CLI_OK;
+   
+}
+
+
+
+int cmd_ip_fragoverlap (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+	u_int32_t overlap=0; 
+	
+	if (strncmp(argv[argc-1], "?", 2)==0) {
+		cli_print(cli, "Specify how many bytes should overlap when IP fragmentation is enabled.\n");
+		cli_print(cli, "NOTE: The number of overlap bytes is either 0 (default, no overlap) or\r");
+		cli_print(cli, "      a multiple of 8 bytes but smaller than frag-size.\n");
+		cli_print(cli, "ARGUMENTS: <overlap>\n");
+		return CLI_OK;
+	}
+	
+	if (argc!=1) {
+		cli_print(cli, "Specify how many bytes should overlap between successive IP fragments.\n");
+		return CLI_OK;
+	}
+
+       
+	overlap = (u_int32_t) str2int(argv[0]);
+	
+	if (clipkt->ip_fragsize == 0) {
+		cli_print(cli, "Please configure the fragment size first.\n");
+		return CLI_OK;
+	}
+	
+	if ((overlap>clipkt->ip_fragsize) || (overlap%8)) {
+		cli_print(cli, "The overlap MUST be a multiple of 8 and MUST NOT exceed frag-size!\n");
+		return CLI_OK;
+	}
+	
+	clipkt->ip_frag_overlap = overlap;
+
+	return CLI_OK;
+}
+
+
+
+
+
+int cmd_ip_option (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+	int val=0;
+	
+	if ((strncmp(argv[argc-1], "?", 2)==0) || (argc==0)) {
+		cli_print(cli, "Add or delete IP options.\n");
+		cli_print(cli, "You can only add one option after the other; if you want to configure multiple\r");
+		cli_print(cli, "options then repeat this command. The options are added to the IP header in the\r");
+		cli_print(cli, "same order as you configure them.\n");
+		cli_print(cli, "Currently the following options are supported:\n");
+		cli_print(cli, "router-alert [<value>]   ... signal transit routers to examine the content of this\r");
+		cli_print(cli, "                             packet.\r");
+		cli_print(cli, "\n");
+		cli_print(cli, "clear  ..................... remove all options from the packet\n");
+		return CLI_OK;
+	}
+   
+	if (mz_strcmp(argv[0], "router-alert", 3)==0) {
+		switch (argc) {
+		 case 1:
+			val=0;
+			break;
+		 case 2:
+			val = (int) str2int(argv[1]);
+			break;
+		 default:
+			cli_print(cli, "Too many arguments!\n");
+			return CLI_OK;
+		}
+		if (mops_ip_option_ra (clipkt, val)) {
+			cli_print(cli, "Value must be within 0..65535\n");
+			return CLI_OK;
+		}
+		    
+	} else if (mz_strcmp(argv[0], "loose-source-route", 3)==0) {
+		cli_print(cli, "Currently not implemented\n");
+		return CLI_OK;
+	} else if (mz_strcmp(argv[0], "record-route", 3)==0) {
+		cli_print(cli, "Currently not implemented\n");
+		return CLI_OK;
+	}
+	
+	else if (mz_strcmp(argv[0], "clear", 2)==0) {
+		mops_ip_option_remove_all (clipkt);
+	}
+   
+   return CLI_OK;
+}
+
+
+
+// By default we use ARP to determine the destination MAC and therefore support
+// automatic (in)direct delivery of IP packets. Alternatively the user may turn
+// this off and may configure an arbitrary destination MAC address
+// 
+int cmd_ip_delivery (struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+	char str[16];
+	if (strncmp(argv[argc-1], "?", 2)==0) {
+		cli_print(cli, "Enable or disable IP auto-delivery.\n");
+		sprintf(str, "%s", (clipkt->auto_delivery_off) ? "DISABLED" : "ENABLED");
+		cli_print(cli, "Currently, IP auto-delivery is %s\n", str);
+		return CLI_OK;
+	}
+	
+	if (argc!=1) {
+		cli_print(cli, "Argument missing. Enter either 'enable' or 'disable'\n");
+		return CLI_OK;
+	}
+	
+	if (mz_strcmp(argv[0], "enable", 1)==0) 
+		clipkt->auto_delivery_off=0;
+	else if (mz_strcmp(argv[0], "disable", 1)==0)
+		clipkt->auto_delivery_off=1;
+	else {
+		cli_print(cli, "Unknown keyword.  Enter either 'enable' or 'disable'\n");
+		return CLI_OK;
+	}
+	
+	sprintf(str, "%s", (clipkt->auto_delivery_off) ? "DISABLED" : "ENABLED");
+	cli_print(cli, "IP auto-delivery is now %s\n", str);
+		
+	return CLI_OK;
+   
+}
+
+
+
+int cmd_ip_end(struct cli_def *cli, const char *command, char *argv[], int argc)
+{
+   char prompt[16];
+   sprintf(prompt, "pkt-%i",clipkt->id);
+   cli_set_configmode(cli, MZ_MODE_PACKET, prompt);
+   return CLI_OK;
+}