staging/layer3.c

   1 /*
   2  * Mausezahn - A fast versatile traffic generator
   3  * Copyright (C) 2008-2010 Herbert Haas
   4  *
   5  * This program is free software; you can redistribute it and/or modify it under
   6  * the terms of the GNU General Public License version 2 as published by the
   7  * Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  12  * details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, see http://www.gnu.org/licenses/gpl-2.0.html
  16  *
  17 */
  18
  19
  20
  21 // ***************************************************************************
  22 //    This sections contains functions to send various L3-based PDUs such as
  23 //
  24 //     * IP
  25 //
  26 //     (ahem, yes this is currently all here...)
  27 //
  28 // ***************************************************************************
  29
  30 #include "mz.h"
  31 #include "cli.h"
  32
  33 #define MZ_IP_HELP \
  34                 "| IP type: Send raw IP packets.\n" \
  35                 "|\n" \
  36                 "| Supports L3 mode (automatic L2 creation) or 'L2-L3' mode (MAC addresses must be provided).\n" \
  37                 "| In L3 mode the IP checksum and length cannot be manipulated to wrong values (currently).\n" \
  38                 "| The L2-L3 mode is activated when specifying any MAC addresses on the command line\n" \
  39                 "| (options -a, -b). \n" \
  40                 "|\n" \
  41                 "| The IP addresses can be specified via the -A and -B options, which identify the source\n" \
  42                 "| and destination addresses, respectively. A dotted decimal notation, an IP range, or a\n" \
  43                 "| FQDN can be used. The source address can also be random (-A rand).\n" \
  44                 "|\n" \
  45                 "| ARGUMENT SYNTAX:  [<comma separated parameter list>]\n" \
  46                 "|\n" \
  47                 "| Parameters:\n" \
  48                 "|\n" \
  49                 "|  len      0-65535        Only accessible in L2 mode\n" \
  50                 "|  sum      0-65535        Only accessible in L2 mode (0 means auto-calculation)\n" \
  51                 "|  tos      00-ff          Full 8-bit control via hex input (use this also for ECN bits).\n" \
  52                 "|  dscp     0-63           Allows easier specification of DSCP (PHB and Drop Propability)\n" \
  53                 "|  ttl      0-255\n" \
  54                 "|  proto    0-255\n" \
  55                 "|  frag     0-65535        Includes flags (MSB) and offset (LSB)\n" \
  56                 "|  df                      Sets the \"Don't Fragment\" flag\n" \
  57                 "|  mf                      Sets the \"More Fragments\" flag\n" \
  58                 "|  rf                      Sets the reserved flag.\n" \
  59                 "|  id       0-65535\n" \
  60                 "|  loose    <addresses>    Loose Source Route (LSR) option; specify a sequence of hops\n" \
  61                 "|                          using the notation: 1.1.1.1+2.2.2.2+3.3.3.3+...\n" \
  62                 "|  strict   <addresses>    Strict Source Route (SSR) option; same address notation as above\n" \
  63                 "|  option   <hex_string>   Specify any IP option using a hexadecimal string (aa:bb:cc:...)\n" \
  64                 "|\n" \
  65                 "| Additionally the Ethertype can be specified:\n" \
  66                 "|\n" \
  67                 "|  ether_type 00:00-ff:ff  Only accessible in L2 mode (default = 08:00 = IPv4)\n" \
  68                 "|  \n"
  69
  70
  71 #define MZ_IP6_HELP \
  72                 "| IP type: Send raw IPv6 packets.\n" \
  73                 "|\n" \
  74                 "| Supports L3 mode (automatic L2 creation) or 'L2-L3' mode (MAC addresses must be provided).\n" \
  75                 "| In L3 mode the IP checksum and length cannot be manipulated to wrong values (currently).\n" \
  76                 "| The L2-L3 mode is activated when specifying any MAC addresses on the command line\n" \
  77                 "| (options -a, -b). \n" \
  78                 "|\n" \
  79                 "| ARGUMENT SYNTAX:  [<comma separated parameter list>]\n" \
  80                 "|\n" \
  81                 "| Parameters:\n" \
  82                 "|\n" \
  83                 "|  len      0-65535        Only accessible in L2 mode\n" \
  84                 "|  sum      0-65535        Only accessible in L2 mode (0 means auto-calculation)\n" \
  85                 "|  tos      00-ff          Full 8-bit control via hex input (use this also for ECN bits).\n" \
  86                 "|  dscp     0-63           Allows easier specification of DSCP (PHB and Drop Propability)\n" \
  87                 "|  flow     0-1048575      Flow label\n" \
  88                 "|  hop      0-255          Hop limit\n" \
  89                 "|  next     0-255          Next protocol or header type\n" \
  90                 "|  frag     0-65535        Includes flags (MSB) and offset (LSB)\n" \
  91                 "|  mf                      Sets the \"More Fragments\" flag\n" \
  92                 "|  frag_res1               Sets the reserved flag 1.\n" \
  93                 "|  frag_res2               Sets the reserved flag 2.\n" \
  94                 "|  id       0-65535        Fragment ID\n" \
  95                 "|  loose    <addresses>    Source Routing Header\n" \
  96                 "|  rtype    0,2            Source Routing Type: 0 (Deprecated in RFC 5095) or 2 for Mobile IP\n" \
  97                 "|  segments 0-255          Number of route segments left, used by RH0\n" \
  98                 "|\n" \
  99                 "| Additionally the Ethertype can be specified:\n" \
 100                 "|\n" \
 101                 "|  ether_type 00:00-ff:ff  Only accessible in L2 mode (default = 86:dd = IPv6)\n" \
 102                 "|  \n"
 103
 104
 105 // Only used to simplify initialization of libnet
 106 // Return pointer to context
 107 libnet_t* get_link_context()
 108 {
 109    libnet_t * l;
 110    char errbuf[LIBNET_ERRBUF_SIZE];
 111
 112    // Don't open context if only a help text is requested
 113    if  (getarg(tx.arg_string,"help", NULL)==1)
 114      {
 115         return NULL;
 116      }
 117
 118
 119    if (tx.packet_mode)
 120      {  // Let libnet create an appropriate Ethernet frame
 121         if (ipv6_mode)
 122           l = libnet_init (LIBNET_RAW6_ADV, tx.device, errbuf);
 123         else
 124           l = libnet_init (LIBNET_RAW4_ADV, tx.device, errbuf);
 125      }
 126    else // User specified Ethernet header details (src or dst)
 127      {
 128         l = libnet_init (LIBNET_LINK_ADV, tx.device, errbuf);
 129      }
 130
 131    if (l == NULL)
 132      {
 133         fprintf(stderr, "%s", errbuf);
 134         exit(EXIT_FAILURE);
 135      }
 136    return l;
 137 }
 138
 139
 140 //////////////////////////////////////////////////////////////////////////////
 141 // Prepare IP packet
 142 libnet_ptag_t  create_ip_packet (libnet_t *l)
 143 {
 144    libnet_ptag_t  t;
 145    char argval[MAX_PAYLOAD_SIZE];
 146    int i, T; // only an abbreviation for tx.packet_mode
 147
 148    if (ipv6_mode)
 149      return create_ip6_packet(l);
 150
 151    // Default IP header fields
 152    tx.ip_len   = LIBNET_IPV4_H;  // Don't forget to add payload length
 153    tx.ip_id    = 0;
 154    tx.ip_frag  = 0;              // Flags and Offset !!!
 155    tx.ip_sum   = 0;              // default: automatically calculate checksum
 156    tx.ip_tos   = 0;
 157    tx.ip_ttl   = 255;
 158
 159
 160    // temporary variables
 161    unsigned int dummy;
 162    size_t len;
 163    char *s;
 164
 165
 166    T = tx.packet_mode; // >0 means automatic L2 creation
 167
 168    if ( (getarg(tx.arg_string,"help", NULL)==1) && (mode==IP) )
 169      {
 170         if (mz_port)
 171           {
 172              cli_print(gcli, "%s", MZ_IP_HELP);
 173              return -1;
 174           }
 175         else
 176           {
 177
 178              fprintf(stderr,"\n"
 179                      MAUSEZAHN_VERSION
 180                      "\n%s", MZ_IP_HELP);
 181
 182              exit(0);
 183           }
 184      }
 185
 186    // Check if hex_payload already specified (externally)
 187    if (tx.hex_payload_s)
 188      {
 189         memcpy( (void*) tx.ip_payload, (void*) tx.hex_payload, tx.hex_payload_s);
 190         tx.ip_payload_s = tx.hex_payload_s;
 191      }
 192
 193
 194    // Evaluate CLI parameters:
 195
 196    if ( (getarg(tx.arg_string,"payload", argval)==1) || (getarg(tx.arg_string,"p", argval)==1))
 197      {
 198         if (mode==IP)
 199           tx.ip_payload_s = str2hex (argval, tx.ip_payload, MAX_PAYLOAD_SIZE);
 200      }
 201    // else payload has been specified as ASCII text via -P option
 202
 203
 204    // NOTE: If 'mode' is NOT IP (e. g. UDP or TCP or something else)
 205    // then the argument 'len' and 'sum' is NOT meant for the IP header!
 206    // Instead the user can use 'iplen' and 'ipsum'.
 207    if (mode==IP)
 208      {
 209         if (getarg(tx.arg_string,"len", argval)==1)
 210           {
 211              if (T) fprintf(stderr, " IP_Warning: 'len' cannot be set in this mode.\n");
 212              tx.ip_len = (u_int16_t) str2int(argval);
 213           }
 214         else
 215           {
 216              tx.ip_len = LIBNET_IPV4_H + tx.ip_payload_s;
 217           }
 218
 219         if (getarg(tx.arg_string,"sum", argval)==1)
 220           {
 221              if (T) fprintf(stderr, " IP_Warning: 'sum' cannot be set in this mode.\n");
 222              tx.ip_sum = (u_int16_t) str2int(argval);
 223           }
 224      }
 225    else // mode is NOT IP
 226      {
 227         if (getarg(tx.arg_string,"iplen", argval)==1)
 228           {
 229              if (T) fprintf(stderr, " IP_Warning: 'len' cannot be set in this mode.\n");
 230              tx.ip_len = (u_int16_t) str2int(argval);
 231           }
 232         else
 233           {
 234              tx.ip_len = LIBNET_IPV4_H + tx.ip_payload_s;
 235           }
 236
 237         if (getarg(tx.arg_string,"ipsum", argval)==1)
 238           {
 239              if (T) fprintf(stderr, " IP_Warning: 'sum' cannot be set in this mode.\n");
 240              tx.ip_sum = (u_int16_t) str2int(argval);
 241           }
 242      }
 243
 244
 245    if (getarg(tx.arg_string,"tos", argval)==1)
 246      {
 247         tx.ip_tos = (u_int8_t) strtol(argval,NULL,16);
 248         dummy = (unsigned int) strtol(argval,NULL,16);
 249         if (dummy > 255) fprintf(stderr, " IP_Warning: 'tos' too big, adjusted to LSBs\n");
 250      }
 251
 252    if (getarg(tx.arg_string,"dscp", argval)==1)
 253      {
 254         dummy = (unsigned int) str2int(argval);
 255         if (dummy > 63)
 256           {
 257              fprintf(stderr, " IP_Warning: 'dscp' too big, adjusted to 63\n");
 258              dummy = 63;
 259           }
 260         tx.ip_tos = (u_int8_t) dummy*4;
 261      }
 262
 263    if (getarg(tx.arg_string,"id", argval)==1)
 264      {
 265         tx.ip_id = (u_int16_t) str2int(argval);
 266      }
 267
 268    if (getarg(tx.arg_string,"frag", argval)==1)
 269      {
 270         tx.ip_frag = (u_int16_t) str2int(argval);
 271      }
 272
 273    if (getarg(tx.arg_string,"df", NULL)==1)
 274      {
 275         tx.ip_frag |= 0x4000;
 276      }
 277
 278    if (getarg(tx.arg_string,"mf", NULL)==1)
 279      {
 280         tx.ip_frag |= 0x2000;
 281      }
 282
 283    if (getarg(tx.arg_string,"rf", NULL)==1)
 284      {
 285         tx.ip_frag |= 0x8000;
 286      }
 287
 288
 289    if (getarg(tx.arg_string,"ttl", argval)==1)
 290      {
 291         tx.ip_ttl = (u_int8_t) str2int(argval);
 292      }
 293
 294    if (getarg(tx.arg_string,"proto", argval)==1)
 295      {
 296         tx.ip_proto = (u_int8_t) str2int(argval);
 297      }
 298
 299
 300    if ((tx.ascii)&&(mode==IP)) // ASCII PAYLOAD overrides hex payload
 301      {
 302         strncpy((char *)tx.ip_payload, (char *)tx.ascii_payload, MAX_PAYLOAD_SIZE);
 303         tx.ip_payload_s = strlen((char *)tx.ascii_payload);
 304         tx.ip_len += tx.ip_payload_s;
 305      }
 306
 307
 308    /////////
 309    // Want some padding? The specified number of padding bytes are ADDED to the
 310    // payload. Note that this is only evaluated if we are in IP mode because
 311    // UDP and TCP already might have been padded and set the ip_payload_s.
 312    // (Note the difference in send_eth() where you specified the total number
 313    // of bytes in the frame)
 314    //
 315    if ((tx.padding)&&(mode==IP))
 316      {
 317         for (i=0; i<tx.padding; i++)
 318           {
 319              tx.ip_payload[tx.ip_payload_s+i] = 0x42; // pad with THE ANSWER (why random?)
 320           }
 321         tx.ip_payload_s += tx.padding;
 322         tx.ip_len += tx.padding;
 323      }
 324
 325
 326
 327
 328
 329    // Loose and Strict Source Route
 330    // See RFC 791 for most the detailed description
 331    //
 332    if ( (getarg(tx.arg_string,"loose", argval)==1) ||
 333         (getarg(tx.arg_string,"strict", argval)==1) )
 334      {
 335         len = strlen(argval);
 336
 337         if (len<7) // not even a single dotted decimal IP address given!
 338           {
 339              fprintf(stderr, " IP_Warning: Source route option requires at least one IP address!\n");
 340              // But we allow this :-)
 341           }
 342
 343
 344         // determine how many IP addresses have been specified
 345         dummy=0;
 346         for (i=0; i<len; i++)
 347           {
 348              if (ispunct(*(argval+i))) dummy++ ;
 349           }
 350         dummy = (dummy+1) / 4; // the number of IP addresses
 351
 352         // Specify: type code, length, pointer
 353         if (getarg(tx.arg_string,"loose", argval)==1)
 354           {
 355              tx.ip_option[0] = 131; // loose source route
 356           }
 357         else
 358           {
 359              tx.ip_option[0] = 137; // strict source route
 360           }
 361         tx.ip_option[1] = 3+(dummy*4); // length
 362         tx.ip_option[2] = 4; // Use first IP address as next hop
 363         //tx.ip_option[2] = 4+4*dummy;   // smallest pointer, points to first address, which is
 364                                        // the 4th byte within this option
 365
 366         tx.ip_option_s = 3;
 367         s = strtok(argval, ".+-:;/>");
 368         do
 369           {
 370              len--;
 371              tx.ip_option[tx.ip_option_s] = (u_int8_t) str2int(s);
 372              tx.ip_option_s++;
 373           } while ( (s=strtok(NULL, ".+-:;/>")) != NULL );
 374
 375         tx.ip_option_s++; // EOL
 376
 377         // add empty space for record route: //// NONSENSE? /////
 378         /*
 379          for (i=0; i<(4*dummy); i++)
 380          {
 381          tx.ip_option[tx.ip_option_s] = 0x00;
 382          tx.ip_option_s++;
 383          }
 384          */
 385      }
 386
 387
 388
 389    // Allow any IP option specified as hex string
 390    // An option can be a single byte or consist of multiple bytes in which case
 391    // a length field is needed, see RFC 791.
 392    if (getarg(tx.arg_string,"option", argval)==1)
 393      {
 394         // check if conflicting with argument "loose" or "strict"
 395         if (tx.ip_option_s)
 396           {
 397              fprintf(stderr, " IP_Error: Another IP option already specified. Please check your arguments.\n");
 398              exit(1);
 399           }
 400
 401         tx.ip_option_s = str2hex (argval, tx.ip_option, 1023);
 402      }
 403
 404
 405
 406    if (tx.ip_option_s)
 407      {
 408         t = libnet_build_ipv4_options (tx.ip_option,
 409                                        tx.ip_option_s,
 410                                        l,
 411                                        0);
 412         tx.ip_len += tx.ip_option_s;
 413      }
 414
 415
 416    ///////
 417    // Did the user specify ANY payload? We require at least one byte!
 418    /*
 419    if (!tx.ip_payload_s)
 420      {
 421         tx.ip_payload[0] = 0x42;
 422         tx.ip_payload_s = 1;
 423      }
 424    */
 425
 426    t = libnet_build_ipv4 (tx.ip_len,
 427                           tx.ip_tos,
 428                           tx.ip_id,
 429                           tx.ip_frag,
 430                           tx.ip_ttl,
 431                           tx.ip_proto,
 432                           tx.ip_sum,
 433                           tx.ip_src, // init.c defaults this to own SA
 434                           tx.ip_dst, // init.c defaults this to 255.255.255.255
 435                           (mode==IP) ? (tx.ip_payload_s) ? tx.ip_payload : NULL : NULL,  // if e.g. mode=UDP ignore payload argument
 436                           (mode==IP) ? tx.ip_payload_s : 0,
 437
 438                           /*
 439                           (mode==IP) ? tx.ip_payload : NULL,  // if e.g. mode=UDP ignore payload argument
 440                           (mode==IP) ? tx.ip_payload_s : 0,
 441                            */
 442                           l,
 443                           0);
 444
 445
 446    if (t == -1)
 447      {
 448         fprintf(stderr, " mz/create_ip_packet: Can't build IP header: %s\n", libnet_geterror(l));
 449         exit (0);
 450      }
 451
 452
 453    return t;
 454
 455 }
 456
 457 //////////////////////////////////////////////////////////////////////////////
 458 // Prepare IPv6 packet
 459 libnet_ptag_t  create_ip6_packet (libnet_t *l)
 460 {
 461    libnet_ptag_t  t;
 462    char argval[MAX_PAYLOAD_SIZE];
 463    int i, T; // only an abbreviation for tx.packet_mode
 464
 465    // Default IP header fields
 466    tx.ip_len   = 0;
 467    tx.ip_id    = 0;
 468    tx.ip6_segs = 0;
 469    tx.ip6_rtype = 0;
 470    tx.ip6_id   = 0;
 471    tx.ip_frag  = 0;              // Flags and Offset !!!
 472    tx.ip_tos   = 0;
 473    tx.ip_ttl   = 255;
 474
 475    // temporary variables
 476    unsigned int dummy;
 477    size_t len;
 478    char *s;
 479
 480    T = tx.packet_mode; // >0 means automatic L2 creation
 481
 482    if ( (getarg(tx.arg_string,"help", NULL)==1) && (mode==IP) )
 483      {
 484         if (mz_port)
 485           {
 486              cli_print(gcli, "%s", MZ_IP6_HELP);
 487              return -1;
 488           }
 489         else
 490           {
 491              fprintf(stderr,"\n"
 492                      MAUSEZAHN_VERSION
 493                      "\n%s", MZ_IP6_HELP);
 494
 495              exit(0);
 496           }
 497      }
 498
 499    // Check if hex_payload already specified (externally)
 500    if (tx.hex_payload_s)
 501      {
 502         memcpy( (void*) tx.ip_payload, (void*) tx.hex_payload, tx.hex_payload_s);
 503         tx.ip_payload_s = tx.hex_payload_s;
 504      }
 505
 506    // Evaluate CLI parameters:
 507    if ( (getarg(tx.arg_string,"payload", argval)==1) || (getarg(tx.arg_string,"p", argval)==1))
 508      {
 509         if (mode==IP)
 510           tx.ip_payload_s = str2hex (argval, tx.ip_payload, MAX_PAYLOAD_SIZE);
 511      }
 512    // else payload has been specified as ASCII text via -P option
 513
 514    // NOTE: If 'mode' is NOT IP (e. g. UDP or TCP or something else)
 515    // then the argument 'len' and 'sum' is NOT meant for the IP header!
 516    // Instead the user can use 'iplen' and 'ipsum'.
 517    if (mode==IP)
 518      {
 519         if (getarg(tx.arg_string,"len", argval)==1)
 520           {
 521              if (T) fprintf(stderr, " IP_Warning: 'len' cannot be set in this mode.\n");
 522              tx.ip_len = (u_int16_t) str2int(argval);
 523           }
 524         else
 525           {
 526              tx.ip_len += tx.ip_payload_s;
 527           }
 528      }
 529    else // mode is NOT IP
 530      {
 531         if (getarg(tx.arg_string,"iplen", argval)==1)
 532           {
 533              if (T) fprintf(stderr, " IP_Warning: 'len' cannot be set in this mode.\n");
 534              tx.ip_len = (u_int16_t) str2int(argval);
 535           }
 536         else
 537           {
 538              tx.ip_len += tx.ip_payload_s;
 539           }
 540      }
 541
 542
 543    if (getarg(tx.arg_string,"tos", argval)==1)
 544      {
 545         tx.ip_tos = (u_int8_t) strtol(argval,NULL,16);
 546         dummy = (unsigned int) strtol(argval,NULL,16);
 547         if (dummy > 255) fprintf(stderr, " IP_Warning: 'tos' too big, adjusted to LSBs\n");
 548      }
 549
 550    if (getarg(tx.arg_string,"flow", argval)==1)
 551      {
 552         dummy = (unsigned int) strtol(argval,NULL,16);
 553         if (dummy > 1048575)
 554           {
 555             fprintf(stderr, " IP_Warning: 'flow label' too big, adjusted to 0xfffff\n");
 556             dummy = 0xfffff;
 557           }
 558         tx.ip_flow = dummy;
 559      }
 560
 561    if (getarg(tx.arg_string,"dscp", argval)==1)
 562      {
 563         dummy = (unsigned int) str2int(argval);
 564         if (dummy > 63)
 565           {
 566              fprintf(stderr, " IP_Warning: 'dscp' too big, adjusted to 63\n");
 567              dummy = 63;
 568           }
 569         tx.ip_tos = (u_int8_t) dummy*4;
 570      }
 571
 572    if (getarg(tx.arg_string,"id", argval)==1)
 573      {
 574           tx.ip6_id = str2int(argval);
 575      }
 576
 577    if (getarg(tx.arg_string,"frag", argval)==1)
 578      {
 579           tx.ip_frag = ((u_int16_t) str2int(argval)) << 3;
 580      }
 581
 582    if (getarg(tx.arg_string,"mf", NULL)==1)
 583      {
 584           tx.ip_frag |= 0x0001;
 585      }
 586
 587    if (getarg(tx.arg_string,"frag_res1", NULL)==1)
 588      {
 589           tx.ip_frag |= 0x0002;
 590      }
 591
 592    if (getarg(tx.arg_string,"frag_res2", NULL)==1)
 593      {
 594           tx.ip_frag |= 0x0004;
 595      }
 596
 597    if (getarg(tx.arg_string,"hop", argval)==1)
 598      {
 599         tx.ip_ttl = (u_int8_t) str2int(argval);
 600      }
 601
 602    if (getarg(tx.arg_string,"next", argval)==1)
 603      {
 604         tx.ip_proto = (u_int8_t) str2int(argval);
 605      }
 606    else if (mode==IP)
 607      {
 608         tx.ip_proto = 59; // No Next Header for IPv6
 609      }
 610
 611
 612    if ((tx.ascii)&&(mode==IP)) // ASCII PAYLOAD overrides hex payload
 613      {
 614         strncpy((char *)tx.ip_payload, (char *)tx.ascii_payload, MAX_PAYLOAD_SIZE);
 615         tx.ip_payload_s = strlen((char *)tx.ascii_payload);
 616         tx.ip_len += tx.ip_payload_s;
 617      }
 618
 619
 620    /////////
 621    // Want some padding? The specified number of padding bytes are ADDED to the
 622    // payload. Note that this is only evaluated if we are in IP mode because
 623    // UDP and TCP already might have been padded and set the ip_payload_s.
 624    // (Note the difference in send_eth() where you specified the total number
 625    // of bytes in the frame)
 626    //
 627    if ((tx.padding)&&(mode==IP))
 628      {
 629         for (i=0; i<tx.padding; i++)
 630           {
 631              tx.ip_payload[tx.ip_payload_s+i] = 0x42; // pad with THE ANSWER (why random?)
 632           }
 633         tx.ip_payload_s += tx.padding;
 634         tx.ip_len += tx.padding;
 635      }
 636
 637    if (tx.ip6_id) {
 638      t = libnet_build_ipv6_frag (tx.ip_proto,
 639                                  0,
 640                                  htons(tx.ip_frag),
 641                                  htonl(tx.ip6_id),
 642                                  (mode==IP) ? (tx.ip_payload_s) ? tx.ip_payload : NULL : NULL,
 643                                  (mode==IP) ? tx.ip_payload_s : 0,
 644                                  l,
 645                                  0);
 646      tx.ip_len += LIBNET_IPV6_FRAG_H;
 647      tx.ip_payload_s = 0;
 648      tx.ip_proto = LIBNET_IPV6_NH_FRAGMENT;
 649    }
 650
 651    // See RFC 2460 Routing Header
 652    //
 653    if ( (getarg(tx.arg_string,"segments", argval)==1) )
 654      {
 655         dummy = (unsigned int) str2int(argval);
 656         if (dummy > 255) {
 657           fprintf(stderr, " IP_Error: Maximal Routing Segments are 255!\n");
 658           exit(1);
 659         }
 660         tx.ip6_segs = dummy;
 661      }
 662
 663    if ( (getarg(tx.arg_string,"rtype", argval)==1) )
 664      {
 665         dummy = (unsigned int) str2int(argval);
 666         if (dummy > 255) {
 667           fprintf(stderr, " IP_Error: Maximum Routing Type is 255!\n");
 668           exit(1);
 669         }
 670         tx.ip6_segs = dummy;
 671      }
 672
 673    if ( (getarg(tx.arg_string,"loose", argval)==1) )
 674      {
 675         // Fill reserved
 676         memset(tx.ip_option, 0, 4);
 677         tx.ip_option_s=4;
 678
 679         len = strlen(argval);
 680         s = strtok(argval, ".+-;/>");
 681         do
 682           {
 683              len--;
 684              *((struct libnet_in6_addr *) &tx.ip_option[tx.ip_option_s]) = libnet_name2addr6 (l, s, LIBNET_DONT_RESOLVE);
 685              tx.ip_option_s += 16;
 686           } while ( (s=strtok(NULL, ".+-;/>")) != NULL );
 687
 688         if (!tx.ip_option_s) {
 689           fprintf(stderr, " IP_Error: No Routing Hops found!\n");
 690           exit(1);
 691         }
 692
 693         if (mode==IP && tx.ip_payload_s)
 694           memmove(tx.ip_payload+tx.ip_option_s, tx.ip_payload, tx.ip_payload_s);
 695         else
 696           tx.ip_payload_s = 0;
 697
 698         memcpy(tx.ip_payload, tx.ip_option, tx.ip_option_s);
 699         tx.ip_payload_s += tx.ip_option_s;
 700
 701         t = libnet_build_ipv6_routing(tx.ip_proto,
 702                                       (tx.ip_option_s -4) / 8,
 703                                       tx.ip6_rtype,
 704                                       tx.ip6_segs,
 705                                       tx.ip_payload,
 706                                       tx.ip_payload_s,
 707                                       l,
 708                                       0);
 709         tx.ip_len += LIBNET_IPV6_ROUTING_H + tx.ip_option_s;
 710         tx.ip_payload_s = 0;
 711         tx.ip_proto = LIBNET_IPV6_NH_ROUTING;
 712      }
 713
 714    t = libnet_build_ipv6 (tx.ip_tos,
 715                           tx.ip_flow,
 716                           tx.ip_len,
 717                           tx.ip_proto,
 718                           tx.ip_ttl,
 719                           tx.ip6_src,
 720                           tx.ip6_dst,
 721                           (mode==IP) ? (tx.ip_payload_s) ? tx.ip_payload : NULL : NULL,
 722                           (mode==IP) ? tx.ip_payload_s : 0,
 723                           l,
 724                           0);
 725
 726    if (t == -1)
 727      {
 728         fprintf(stderr, " mz/create_ip_packet: Can't build IPv6 header: %s\n", libnet_geterror(l));
 729         exit (0);
 730      }
 731
 732    return t;
 733 }
 734