ti/runtime/netapi/test/net_test.c

   1 /******************************************
   2  * File: net_test.c
   3  * Purpose: test app for netapi
   4  **************************************************************
   5  * FILE:  net_test.c
   6  *
   7  * DESCRIPTION:  netapi user space transport
   8  *               library  test application
   9  *
  10  * REVISION HISTORY:  rev 0.0.1
  11  *
  12  *  Copyright (c) Texas Instruments Incorporated 2010-2011
  13  *
  14  *  Redistribution and use in source and binary forms, with or without
  15  *  modification, are permitted provided that the following conditions
  16  *  are met:
  17  *
  18  *    Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  *
  21  *    Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the
  24  *    distribution.
  25  *
  26  *    Neither the name of Texas Instruments Incorporated nor the names of
  27  *    its contributors may be used to endorse or promote products derived
  28  *    from this software without specific prior written permission.
  29  *
  30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41
  42  *****************************************/
  43
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <unistd.h>
  47 #include <string.h>
  48
  49
  50 #include "trie.h"
  51 #include "string.h"
  52 #include "netapi.h"
  53 #include "pktio.h"
  54 #include <sys/resource.h>
  55 #include "net_test.h"
  56 #include <ti/drv/sa/salld.h>
  57 #define EXPERIMENTAL
  58 #ifdef EXPERIMENTAL
  59 #include "router.c"
  60 Trie * our_router;
  61
  62 OUR_ROUTE_T routes[MAX_ROUTES]=
  63 {
  64 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
  65 {0,{0x00,0x00,0x0,0x00,0x0,0x0, 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00},0},
  66 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
  67 {0,{0x00,0x15,0x60,0xa1,0xf7,0xbe, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0},
  68 {0,{0xd4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0}};
  69
  70 unsigned int ip[MAX_ROUTES]={BE(0x0a0100c8),BE(0x0a00000a),BE(0x0a02000a),BE(0xc0a8010a),BE(0x9eda6719)};
  71
  72 #endif
  73 //#define TEST_TIMERS
  74
  75 /*************debug********************/
  76 void dump_descr(unsigned long *p, int n)
  77 {
  78    printf("--------dump of descriptor %d %x\n", n, (int) p);
  79    printf("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
  80    printf("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
  81    printf("-----------------------------\n");
  82 }
  83 void dump_header(unsigned long *p, int n, int a, int r)
  84 {
  85    printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
  86    printf("> %x %x %x %x %x %x %x %x\n",p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7]);
  87    printf("> %x %x %x %x %x %x %x %x\n",p[8],p[9],p[10],p[11],p[12],p[13],p[14],p[15]);
  88    printf("> %x %x %x %x %x %x %x %x\n",p[16],p[17],p[18],p[19],p[20],p[21],p[22],p[23]);
  89    printf("> %x %x %x %x %x %x %x %x\n",p[24],p[25],p[26],p[27],p[28],p[29],p[30],p[31]);
  90    printf("-----------------------------\n");
  91 }
  92
  93 /*****************************************/
  94
  95
  96 //************for multi pkt burst  xfer test in loopback mode
  97 #define TX_BURST 700
  98 int pktloopback=TUNE_NETAPI_NWAL_ENABLE_PASS_LOOPBACK;
  99 nwalTxPSCmdInfo_t   flowPSCmdInfo;
 100
 101 //this device: 10.0.0.100, mac 0x,01,02,03,04,05  and .. 0x6
 102
 103 //test packet, setup for loopback (so dest is ourself)
 104 static uint8_t testPkt[] = {
 105
 106   /* MAC header */
 107   0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
 108   0x00, 0xe0, 0xa6, 0x66, 0x57, 0x04,
 109   0x08, 0x00,
 110
 111   /* IP header */
 112   0x45, 0x00,
 113   0x00, 0x6c,  /* Length (including this header) */
 114   0x00, 0x00, 0x00, 0x00, 0x05, 0x11,
 115   0x00, 0x00,  /* Header checksum */
 116   0x0a, 0x00, 0x00, 0x0a, 0x0a, 0x00, 0x00, 0x64,
 117
 118   /* UDP header */
 119   0x12, 0x34, 0x05, 0x55,
 120   0x00, 0x58,  /* Length, including this header */
 121   0x00, 0x00,  /* Header checksum */
 122
 123  /* Payload */
 124   0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 125   0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41,
 126   0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 127   0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
 128   0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 129   0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61,
 130   0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 131   0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71,
 132   0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 133   0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81
 134
 135 };
 136
 137 char    input_file_name[] = "net_test_config.txt";
 138 #define MAX_LINE_LENGTH 40
 139
 140 #define TEST_PAYLOAD_LEN            80
 141
 142 #define TEST_PKT_IP_OFFSET_BYTES        14
 143 #define TEST_PKT_UDP_OFFSET_BYTES       34
 144 #define TEST_PKT_PLOAD_OFFSET_BYTES     42
 145 #define TEST_PKT_UDP_HDR_LEN            8
 146 /* Offsets to length fields */
 147 #define TEST_PKT_OFFSET_IP_LEN      16
 148 #define TEST_PKT_OFFSET_UDP_LEN     38
 149
 150 #define TEST_PKT_LEN                122
 151
 152 /* The pseudo header checksum of the packet except for the 16 bit length */
 153 #define TEST_PKT_PSEUDO_HDR_CHKSUM_SANS_LEN  0x0FFC
 154
 155 void example_fast_poll( PKTIO_HANDLE_T * p_pktio, int max_pkts);
 156 void example_fast_pushpop(Pktlib_HeapHandle p_heap, int ntrials);
 157
 158 void recv_cb_router(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
 159                          PKTIO_METADATA_T meta[], int n_pkts,
 160                          uint64_t ts );
 161
 162
 163 //#include "arpa/inet.h"
 164 long htonl(long x)
 165 {
 166         long temp = (x&0xff000000)>>24 | (x&0xff0000)>>8 | (x&0xff00)<<8 |  (x&0xff)<<24 ;
 167         return temp;
 168 }
 169
 170 /********************************************************************
 171  *  FUNCTION PURPOSE: Ones complement addition utility
 172  ********************************************************************
 173  ********************************************************************/
 174 uint16_t test_utilOnesComplementAdd (uint16_t v1, uint16_t v2)
 175 {
 176   uint32_t result;
 177
 178   result = (uint32_t)v1 + (uint32_t)v2;
 179   result = (result >> 16) + (result & 0xffff);
 180   result = (result >> 16) + (result & 0xffff);
 181
 182   return ((uint16_t)result);
 183 }
 184
 185 /********************************************************************
 186  *  FUNCTION PURPOSE: Ones complement checksum utility
 187  ********************************************************************
 188  ********************************************************************/
 189  uint16_t test_utilOnesCompChkSum (uint8_t *p, uint32_t nwords)
 190 {
 191   uint16_t chksum = 0;
 192   uint16_t v;
 193   uint32_t i;
 194   uint32_t j;
 195
 196   for (i = j = 0; i < nwords; i++, j+=2)  {
 197     v = (p[j] << 8) | p[j+1];
 198     chksum = test_utilOnesComplementAdd (chksum, v);
 199   }
 200   return (chksum);
 201 } /* utilOnesCompChkSum */
 202
 203 /**************************************************************************************
 204  * FUNCTION PURPOSE: Compute ipv4 psudo checksum
 205  **************************************************************************************
 206  * DESCRIPTION: Compute ipv4 psudo checksum
 207  **************************************************************************************/
 208 uint16_t test_utilGetIpv4PsudoChkSum (uint8_t *data, uint16_t payloadLen)
 209 {
 210   uint16_t psudo_chksum;
 211
 212   psudo_chksum = test_utilOnesCompChkSum (&data[12], 4);
 213   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, (uint16_t) data[9]);
 214   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, payloadLen);
 215
 216   return (psudo_chksum);
 217
 218 } /* utilGetIpv4PsudoChkSum */
 219
 220
 221
 222 /* net test default configuration */
 223 netTestConfig_t config =
 224 {
 225     {0x00,0x01,0x02,0x03,0x05,0x05},
 226     {0x00,0x01,0x02,0x03,0x05,0x06},
 227     {10, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 228     {10, 0, 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 229     {10, 0, 2, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 230     {192,168 , 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 231     {192,168 , 1, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 232     IPSEC_MODE_RX_SIDEBAND,
 233     IPSEC_MODE_TX_SIDEBAND,
 234     0
 235 };
 236
 237 #if 1  //goes with real tx (to laptop)
 238 unsigned char real_mac_header[]={0xd4,0xbe,0xd9,0x00,0xd3,0x7e,
 239                       0x00,0x01,0x02,0x03,0x04,0x05,
 240                       0x08,0x00};
 241 unsigned char real_ip_addr[]={0xa,0x00,0x00,0x64,0xa,0x0,0x0,0xa};
 242 #endif
 243
 244 #if 0  //goes with loopback
 245 unsigned char mac_header[]={0x00,0x01,0x02,0x03,0x04,0x05,
 246                       0x00,0x11,0x22,0x33,0x44,0x55,
 247                       0x08,0x00};
 248 #endif
 249 #define NE 65536
 250 HEAD_T *nat;
 251
 252 #define NP 5000
 253 int n_pkt = NP;
 254 STATS_T stats;
 255
 256 Trie * P_trie;
 257 Trie *p_trie_sa;
 258 HEAD_T pkts[NP];
 259 #define PERSLOW  10  //% of pkts that will not be fastpath'd
 260 int perslow= PERSLOW;
 261
 262 /*******************************************
 263  *************NETAPI OBJECTS***************
 264  *****************************************/
 265 static NETAPI_CFG_T our_netapi_default_cfg=
 266 {
 267 TUNE_NETAPI_PERM_MEM_SZ,
 268 128,  //start of packet offset for hw to place data on rx for default flow
 269 TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
 270 TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
 271 TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
 272 64, //#descriptors w/o buffers in default heap
 273 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
 274 128   ,  //tail room
 275 256      //extra room
 276 };
 277
 278 Pktlib_HeapHandle OurHeap;
 279 Pktlib_HeapHandle specialSmall;
 280 Pktlib_HeapHandle specialLarge;
 281
 282 PKTIO_HANDLE_T *our_chan;
 283 PKTIO_HANDLE_T *netcp_rx_chan;
 284 PKTIO_HANDLE_T *netcp_rx_chan2;
 285 PKTIO_HANDLE_T *netcp_tx_chan;
 286 PKTIO_HANDLE_T *netcp_sb_tx_chan;
 287 PKTIO_HANDLE_T *netcp_sb_rx_chan;
 288 PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
 289 PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
 290 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
 291 PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
 292 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
 293 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
 294
 295 void house(NETAPI_SCHED_HANDLE_T *s);
 296 NETAPI_T netapi_handle;
 297 NETAPI_SCHED_HANDLE_T * our_sched;
 298 NETAPI_SCHED_CONFIG_T our_sched_cfg={
 299   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 5000000  //every 5000000 poll loops
 300 };
 301 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats);
 302 NETAPI_TIMER_GROUP_HANDLE_T ourTimerBlock;
 303 NETAPI_TIMER_T t1;
 304 NETAPI_TIMER_T t2;
 305 NETAPI_TIMER_T t3;
 306
 307 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,
 308         int n_fired,     //# timers fired
 309         NETAPI_TIMER_LIST_T fired_list,
 310         uint64_t currentTime);
 311
 312 NETCP_CFG_IP_T ip_rule0;
 313 NETCP_CFG_IP_T ip_rule1;
 314 NETCP_CFG_CLASS_T class_0;
 315 NETCP_CFG_CLASS_T class_1;
 316 NETCP_CFG_CLASS_T class_2;
 317 NETCP_CFG_FLOW_HANDLE_T specialFlow;
 318
 319 NETCP_CFG_CLASSIFIER_T class_0_cfg=
 320 {
 321    NETCP_CFG_CLASS_TYPE_L4,
 322    {
 323         {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2500}}
 324    }
 325 };
 326
 327 NETCP_CFG_CLASSIFIER_T class_1_cfg=
 328 {
 329    NETCP_CFG_CLASS_TYPE_L4,
 330    {
 331         {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2502}}
 332    }
 333 };
 334
 335 NETCP_CFG_ROUTE_T  class2_route=
 336 {
 337 NULL, NULL  //* to be filled in
 338 };
 339 NETCP_CFG_CLASSIFIER_T class_2_cfg=
 340 {
 341    NETCP_CFG_CLASS_TYPE_L3_L4,
 342    {
 343         {0,  4 ,0/*fill in below*/ , NULL, NULL,          //L2/L3
 344            NWAL_APP_PLOAD_PROTO_UDP, {2504}}   //L4
 345    }
 346 };
 347
 348 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
 349
 350 /* security objects. (for loopback mode) */
 351 netTestSA_t sa_info[6];
 352 int netapi_algorithm_set = 0;
 353 int netapi_sec_sa_mode = 2;
 354 /* tmannan-end */
 355 //NETCP_CFG_SA_T rx_tunnel;
 356 //NETCP_CFG_SA_T tx_tunnel;
 357 NETCP_CFG_IPSEC_POLICY_T rx_policy[4];
 358 //void * rx_data_mode_handle;
 359 //void * tx_data_mode_handle;
 360 //void * rx_inflow_mode_handle;
 361 //void * tx_inflow_mode_handle;
 362 /* rx */
 363
 364
 365 NETAPI_SEC_SA_INFO_T rx_sa [4] = {
 366 {
 367     NWAL_SA_DIR_INBOUND,
 368     0x11111111,  //spi
 369     nwal_IpSecProtoESP, //ESP mode
 370     nwal_SA_MODE_TUNNEL,  //tunnel mode
 371     nwal_IPV4, //v4
 372     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
 373     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
 374     64,/* replayWindow */
 375     NWAL_SA_AALG_HMAC_SHA1,
 376     NWAL_SA_EALG_AES_CBC,
 377     0,0  //na
 378 },
 379 {
 380     NWAL_SA_DIR_INBOUND,
 381     0x22222222,  //spi
 382     nwal_IpSecProtoESP, //ESP mode
 383     nwal_SA_MODE_TUNNEL,  //tunnel mode
 384     nwal_IPV4, //v4
 385     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
 386     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
 387     64,/* replayWindow */
 388     NWAL_SA_AALG_HMAC_SHA2_256,
 389     NWAL_SA_EALG_AES_CTR,
 390     0,0  //na
 391 },
 392 {
 393     NWAL_SA_DIR_INBOUND,
 394     0x33333333,  //spi
 395     nwal_IpSecProtoESP, //ESP mode
 396     nwal_SA_MODE_TUNNEL,  //tunnel mode
 397     nwal_IPV4, //v4
 398     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
 399     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
 400     64,/* replayWindow */
 401     NWAL_SA_AALG_HMAC_SHA2_256,
 402     NWAL_SA_EALG_3DES_CBC,
 403     0,0  //na
 404 },
 405 {
 406     NWAL_SA_DIR_INBOUND,
 407     0x44444444,  //spi
 408     nwal_IpSecProtoESP, //ESP mode
 409     nwal_SA_MODE_TUNNEL,  //tunnel mode
 410     nwal_IPV4, //v4
 411     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
 412     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
 413     64,/* replayWindow */
 414     NWAL_SA_AALG_HMAC_MD5,
 415     NWAL_SA_EALG_NULL,
 416     0,0  //na
 417 }
 418 };
 419
 420 /*tx */
 421 NETAPI_SEC_SA_INFO_T tx_sa[4]= {
 422 {
 423     NWAL_SA_DIR_OUTBOUND,
 424     0x11111111,  //spi
 425     nwal_IpSecProtoESP, //ESP mode
 426     nwal_SA_MODE_TUNNEL,  //tunnel mode
 427     nwal_IPV4, //v4
 428     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
 429     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
 430     64, /* NA replayWindow */
 431     NWAL_SA_AALG_HMAC_SHA1,
 432     NWAL_SA_EALG_AES_CBC,
 433     0,0  //seq no
 434 },
 435     {
 436     NWAL_SA_DIR_OUTBOUND,
 437     0x22222222,  //spi
 438     nwal_IpSecProtoESP, //ESP mode
 439     nwal_SA_MODE_TUNNEL,  //tunnel mode
 440     nwal_IPV4, //v4
 441     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
 442     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
 443     64, /* NA replayWindow */
 444     NWAL_SA_AALG_HMAC_SHA2_256,
 445     NWAL_SA_EALG_AES_CTR,
 446     0,0  //seq no
 447 },
 448 {
 449     NWAL_SA_DIR_OUTBOUND,
 450     0x33333333,  //spi
 451     nwal_IpSecProtoESP, //ESP mode
 452     nwal_SA_MODE_TUNNEL,  //tunnel mode
 453     nwal_IPV4, //v4
 454     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
 455     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
 456     64, /* NA replayWindow */
 457     NWAL_SA_AALG_HMAC_SHA2_256,
 458     NWAL_SA_EALG_3DES_CBC,
 459     0,0  //seq no
 460 },
 461 {
 462     NWAL_SA_DIR_OUTBOUND,
 463     0x44444444,  //spi
 464     nwal_IpSecProtoESP, //ESP mode
 465     nwal_SA_MODE_TUNNEL,  //tunnel mode
 466     nwal_IPV4, //v4
 467     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
 468     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
 469     64, /* NA replayWindow */
 470     NWAL_SA_AALG_HMAC_MD5,
 471     NWAL_SA_EALG_NULL,
 472     0,0  //seq no
 473 }
 474 };
 475
 476 static nwalSecKeyParams_t ourTXKeyParams[4] ={
 477 {
 478     16, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
 479     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
 480     NULL, //set below
 481     NULL, //set below
 482 },
 483 {
 484     20, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
 485     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
 486     NULL, //set below
 487     NULL, //set below
 488 },
 489 {
 490     24, /* encKeySize: DES-CBC: 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
 491     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
 492     NULL, //set below
 493     NULL, //set below
 494 },
 495 {
 496     0, /* NULL*/
 497     16, /* MD5, 16 bytes */
 498     NULL, //set below
 499     NULL, //set below
 500 }
 501 };
 502
 503 /* these keys are for aes-ctr and hmac sha2_256 */
 504 static nwalSecKeyParams_t ourRXKeyParams[4] ={
 505 {
 506     16, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
 507     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
 508     NULL, //set below
 509     NULL, //set below
 510 },
 511 {
 512     20, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
 513     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
 514     NULL, //set below
 515     NULL, //set below
 516 },
 517 {
 518     24, /* encKeySize: DES-CBC: 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
 519     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
 520     NULL, //set below
 521     NULL, //set below
 522 },
 523 {
 524     0, /* NWAL_SA_EALG_NULL*/
 525     16, /* NWAL_SA_AALG_HMAC_MD5, 16 bytes */
 526     NULL, //set below
 527     NULL, //set below
 528 }
 529 };
 530
 531
 532 static uint8_t ourAuthKey[36] =
 533         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 534          0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 535          0x20, 0x21, 0x22, 0x23 };
 536 ;
 537
 538 static uint8_t ourEncrKey[36] =
 539         {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
 540          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
 541          0x30, 0x31, 0x32, 0x33 };
 542
 543
 544 /*************************END NETAPI OBJECTS***********************/
 545
 546 #define START_SRC_IP 0x0a00000a
 547 #define DST_IP       0xc0a80001
 548 #define NEW_START_SRC_IP 0x9eda000a
 549 #define DST_PORT 0x555
 550 #define START_SRC_PORT 0x1234
 551 #define NEW_START_SRC_PORT 100
 552 void update_header(HEAD_T * p_head, int len)
 553 {
 554    unsigned char *p = (unsigned char *) &p_head->udp[1];
 555    len -= (20+14);
 556    /* update ip checksum */
 557    /* update udp checksum */
 558    /* update length */
 559    *p= (len&0xff00)>>8;
 560    *(p+1) = len&0xff;
 561 }
 562
 563 #if 0
 564 void gen_pkts(int np)
 565 {
 566 int i;
 567 int ip = START_SRC_IP &0xff;
 568 int port= START_SRC_PORT;
 569 //HEAD_T temp={{0x25000200,0xdead0000,0x80110000,START_SRC_IP,DST_IP},
 570 //             {START_SRC_PORT<<16|DST_PORT,0x01ec<<16|0x0000}};
 571 HEAD_T temp;
 572 memcpy(&temp,&testPkt[0],sizeof(HEAD_T));
 573
 574 for(i=0;(i<np) && (i<NP);i++)
 575   {
 576        memcpy(&pkts[i],&temp,sizeof(temp));
 577        update_header(&pkts[i],512);      /* update checksums etc */
 578        /* change template for new pkt */
 579        ip+=1;
 580        if(ip>254) {(ip=START_SRC_IP&0xff); port+=1; }
 581        temp.ip[3] = htonl((START_SRC_IP&0xffffff00)| ip);
 582        temp.udp[0] = htonl( (temp.udp[0]&0xffff0000)| port);
 583        temp.udp[1] = htonl(temp.udp[1]);
 584
 585   }
 586   n_pkt=np;
 587 }
 588 #endif
 589
 590 void build_table(Trie * p_trie)
 591 {
 592 int i;
 593 int sport=NEW_START_SRC_PORT;
 594 HEAD_T temp,temp2;
 595 KEY_T key;
 596
 597 memcpy(&temp,&testPkt[14],sizeof(temp));
 598
 599  //insert entry into trie
 600 key.src_ip = temp.ip[3];
 601 key.dst_ip = temp.ip[4];
 602 key.src_port= (temp.udp[0]&0xffff0000)>>16;
 603 key.dst_port= (temp.udp[0]&0x0000ffff);
 604 trie_insert(p_trie,(char *)&key,sizeof(key), (void *) &nat[0]); //asociate with nat entry 0
 605
 606 //build nat table
 607 for(i=0;i<100;i++)
 608 {
 609    memcpy(&temp2,&testPkt[14],sizeof(temp));
 610    temp2.udp[0] = (temp2.udp[0] & 0xffff0000) |  sport;
 611    memcpy(&nat[i], &temp2, sizeof(temp2));
 612    sport+= 1;
 613 }
 614 }
 615
 616 //===========stub transmitter==================
 617 void send_pkt(Ti_Pkt *pkt, int len)
 618 {
 619 //just free pkt.  Don't send
 620 Pktlib_freePacket((Ti_Pkt*)pkt);
 621         return;
 622 }
 623
 624 //==========stub slow path============
 625 void slow_path(Ti_Pkt *pkt, int len)
 626 {
 627 // debug: check descriptor for validity by verifying that desciptor link field is null as expected\n");
 628          {Ti_Pkt * k= Pktlib_getNextPacket(pkt); if(k != 0) {printf(" slowpath, nexpkt != NULL");}}
 629 //just free pkt
 630 Pktlib_freePacket((Ti_Pkt*)pkt);
 631         return;
 632 }
 633 /* check header */
 634 struct LastPktInfo
 635 {
 636 int iface;
 637 int ipcsum;
 638 int l4csum;
 639 } ;
 640 static struct LastPktInfo lpInfo;
 641
 642 int check_header(HEAD_T * p_head, PKTIO_METADATA_T * p_meta)
 643 {
 644 if (NWAL_RX_FLAG1_META_DATA_VALID & p_meta->u.rx_meta->rxFlag1)
 645 {
 646 lpInfo.iface = ((unsigned int)p_meta->u.rx_meta->appId) &0xff; //last byte is interface num
 647 lpInfo.ipcsum =(p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_MASK )== NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_ACK ? 1 : 0;
 648 lpInfo.l4csum = (p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_L4_CHKSUM_VERIFY_MASK )== ((NWAL_RX_FLAG1_L4_CHKSUM_VERIFY_ACK) << NWAL_RX_FLAG1_L4_CHKSUM_VERIFY_SHIFT) ? 1 : 0;
 649 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC)
 650 {
 651    stats.sec_rx++;
 652 }
 653 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC_POLICY)
 654 {
 655    stats.secp_rx++;
 656 }
 657
 658 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_CLASS)
 659 {
 660   int c= ((unsigned int)p_meta->u.rx_meta->appId >>8)&0xffff;
 661   if (c==0)  stats.n_class0_rx +=1;
 662   else if (c==1) stats.n_class1_rx +=1;
 663   else if (c==2) stats.n_class2_rx +=1;
 664   else printf("**NET_TEST RX -unknown class: %x\n",  p_meta->u.rx_meta->appId);
 665 }
 666 }
 667
 668  return 1;
 669 }
 670
 671 #define PKT_LEN 1400
 672 void test_alloc_free(int n)
 673 {
 674 int i;
 675 Ti_Pkt * b;
 676
 677 for(i=0;i<n;i++)
 678 {
 679   b=Pktlib_allocPacket(OurHeap,PKT_LEN);
 680   Pktlib_freePacket(b);
 681 }
 682 }
 683
 684 //measurement test points
 685 unsigned int vv1;
 686 unsigned int vv2;
 687 unsigned int vv3;
 688 unsigned int vv4;
 689 unsigned int vv5;
 690 unsigned int vv6;
 691 //these are updated by pktio.
 692 #ifdef PKTIO_GET_BENCHMARK
 693 extern unsigned int vv7p;
 694 extern unsigned int vv8p;
 695 extern unsigned int vv9p;
 696 extern unsigned int vv10p;
 697 extern unsigned int vv11p;
 698 extern unsigned int vv12p;
 699
 700 extern unsigned int vv13p;  //rcv path
 701 extern unsigned int vv14p;
 702 extern unsigned int vv15p;
 703 #endif
 704
 705 unsigned int vv11;
 706
 707 extern unsigned int nwal_prof1,nwal_prof2,nwal_prof3,nwal_prof4,nwal_prof5,nwal_prof6;
 708
 709 //#define REASSEMBLE_BENCH
 710 #ifdef REASSEMBLE_BENCH
 711 #include <ti/drv/pa/example/reassemLib/reassemLib.h>
 712 /*--------------reassembly benchmark--------------------------------*/
 713 void our_reassemble_bench(int nfrags)
 714 {
 715 paIPReassemblyConfig_t Config={5,128,10000 };
 716 int i,j;
 717 int len;
 718 Ti_Pkt tip;
 719 char *buffer;
 720 unsigned long v1;
 721 unsigned long v2;
 722 unsigned long sum1=0;
 723 unsigned long sum2=0;
 724 paEx_reassemLibInit(&Config);
 725 for(j=0;j<200/nfrags;j++)
 726 {
 727   for(i=0;i<nfrags;i++)
 728   {
 729     short temp;
 730     tip=Pktlib_allocPacket(OurHeap,PKT_LEN);
 731     Pktlib_getDataBuffer(tip,(uint8_t**)&buffer,&len);
 732     memcpy(&buffer[0],&testPkt[14],20); //IP header
 733     if (i < (nfrags-1)) buffer[6] = 0x20;
 734     temp = i*40;
 735     buffer[6]|= (temp&0x1f00)>>8;
 736     buffer[7]= (temp&0xff);
 737     temp = 20+40*8;
 738     buffer[2]= (temp&0xff00)>>8;
 739     buffer[3]= (temp&0xff);
 740     Pktlib_setPacketLen(tip, temp);
 741     v1= netapi_timing_stop();
 742     paEx_reassemLibProc(tip, 0xffff);
 743     v2= netapi_timing_stop();
 744     sum1+= v2-v1;
 745   }
 746   sum2 += v2-v1;
 747 }
 748 printf("reasssembly test:  %d trials, %d frags/pkt  %d cycles/frag %d cycles/last frag\n",j,nfrags, sum1/(j*nfrags), sum2/(j));
 749 }
 750 #endif
 751
 752 /*--------------basic pktio send/recv benchmark----------------------*/
 753 unsigned int timings[10];
 754 void our_pktio_bench(int ntrials)
 755 {
 756 int i;
 757 #define NBATCH 8
 758 Ti_Pkt tip;
 759 unsigned char * pData;
 760 int len;
 761 int n;
 762 int err;
 763 int sum =0;
 764
 765    Osal_cache_op_measure_reset();
 766    for(i=0;i<10;i++) timings[i]=0;
 767    printf("calibration loop .. ");
 768    for(i=0;i<1000;i++)
 769    {
 770    vv1= netapi_timing_stop();
 771    vv2= netapi_timing_stop();
 772    sum+=(vv2-vv1);
 773    }
 774    printf(" accuracy = +- %d cycles\n", sum/1000);
 775    sleep(1);
 776
 777 PKTIO_METADATA_T meta[10]={0};
 778 //send single, recv single
 779 for(i=0;i<ntrials;i++)
 780 {
 781    vv1= netapi_timing_stop();
 782    tip=Pktlib_allocPacket(OurHeap,PKT_LEN);
 783    vv2= netapi_timing_stop();
 784    Pktlib_getDataBuffer(tip,&pData,&len);
 785    vv3= netapi_timing_stop();
 786    pktio_send(our_chan,tip,&meta[0],&err);
 787    vv4= netapi_timing_stop();
 788    n=pktio_poll(our_chan,NULL , &err);
 789    vv5=   netapi_timing_stop();
 790    timings[0]+=(vv6-vv4);
 791    timings[1]+=(vv5-vv4);
 792    timings[3]+=(vv4-vv3);
 793    timings[5]+=(vv3-vv1);
 794    timings[8]+=(vv11-vv6);
 795
 796 #ifdef PKTIO_GET_BENCHMARK
 797    timings[2]+=(vv7p-vv4);
 798    timings[4]+=(vv8p-vv3);
 799    timings[6]+=(vv9p-vv8p);
 800    timings[7]+=(vv10p-vv7p);
 801 #endif
 802 }
 803
 804 #ifdef PKTIO_GET_BENCHMARK
 805    printf("pktio bench. rx=%d (wcb%d) (toqm%d) tx=%d (toqm%d) alloc=%d qpush=%d qpop=%d free=%d\n", timings[0]/ntrials,
 806            timings[1]/ntrials, timings[2]/ntrials,timings[3]/ntrials, timings[4]/ntrials,timings[5]/ntrials,
 807            timings[6]/ntrials,timings[7]/ntrials, timings[8]/ntrials );
 808    {
 809        unsigned int ccycles;
 810        int n_c_ops;
 811        ccycles =Osal_cache_op_measure(&n_c_ops);
 812        printf("n_c_ops=%d cache_op_time=%d (total) = %d (pp)\n", n_c_ops, ccycles,  n_c_ops? (ccycles/(n_c_ops)) : 0);
 813    }
 814 #endif
 815
 816 }
 817 /*-----------test driver: gen an input pkt------- */
 818 //char buffer[sizeof(HEAD_T)+PKT_LEN];
 819 Ti_Pkt * get_pkt(int n, unsigned int *p_len, Pktlib_HeapHandle heap2use, int size, unsigned char * buf2cpy, int copy_size)
 820 {
 821    int ind;
 822    long long temp;
 823    Ti_Pkt * b;
 824    char * buffer;
 825    unsigned int len;
 826
 827   if (pktloopback==0)
 828   {
 829         if (n>=TX_BURST) return NULL;   //just gen pkts to warm swtich, so that it knows
 830                                 //our mac is valid
 831   }
 832   b=Pktlib_allocPacket(heap2use,size);
 833   if (!b)
 834     {printf("net_test: get_pkt() heap empty!! %d pkts gen'd %d \n", n); return NULL;};
 835
 836     //debug - way to validate descriptor
 837     {Ti_Pkt* k= Pktlib_getNextPacket(b);
 838          if(k != 0) {printf(" genpkt, nexpkt != NULL");}}
 839
 840
 841    //get pointer to buffer area of packet
 842    Pktlib_getDataBuffer(b,(uint8_t**)&buffer,&len);
 843    if (!buffer)
 844     {printf("net_test: get_pkt() heap returned empty buffer %d \n", n); return NULL;};
 845
 846 #if 0
 847 if (pktloopback==0)
 848 {
 849    temp = (long long) rand();
 850    temp *= PKT_LEN;
 851    temp /= RAND_MAX;
 852    temp +=2;
 853    *p_len = (int) temp;
 854    *p_len = *p_len &0xfffffffe;
 855    temp = (long long) rand();
 856    temp *= n_pkt;
 857    temp /= RAND_MAX;
 858    ind = (int) temp;
 859    update_header(&pkts[ind],*p_len);
 860    //printf("get pkt:%d %d ind=%d len=%d\n",RAND_MAX, rand(),ind, *p_len);
 861     memcpy(&buffer[0], &mac_header[0],14);
 862     memcpy(&buffer[14],(char*)&pkts[ind],sizeof(HEAD_T));
 863 }
 864 else
 865 #endif
 866
 867    //copy test packet into buffer
 868 {
 869     memcpy(&buffer[0], buf2cpy, copy_size);
 870     *p_len = copy_size;
 871 }
 872     return b;
 873 }
 874
 875 static int eof=0;
 876 /*--------------------------------------------------------------
 877  *----------utility to flip a packet and send
 878  *--------------------back to source----------------------------
 879  *                   flag=1 => ipsec
 880  *--------------------------------------------------------------*/
 881 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag)
 882 {
 883 unsigned char mac_temp[6];
 884 unsigned char ip_temp[4];
 885 unsigned char new_dest_port[2]={0x75,0x30};  // 30000
 886 uint16_t blah;
 887 uint16_t i=1;   /* for testing only */
 888
 889 uint8_t *p_spi;
 890 netTestSA_t * p_sa_info;
 891 uint8_t p_iv[16];
 892
 893 Pktlib_setPacketLen(tip,len);
 894 //mac
 895 memcpy(&mac_temp,&p_pkt[0],6);
 896 memcpy(&p_pkt[0],&p_pkt[6],6);
 897 memcpy(&p_pkt[6],&mac_temp,6);
 898 //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
 899
 900 //ip  (outer in case of ipsec)
 901 memcpy(&ip_temp, &p_pkt[14+12],4);
 902 memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);
 903 memcpy(&p_pkt[14+12+4],&ip_temp,4);
 904
 905 //outer checksum to 0
 906 if (!flag) memset(&p_pkt[14+10],0,2);
 907
 908
 909
 910
 911 //inner ip &udp for ipsec
 912 if (flag)
 913 {
 914     p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
 915     p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
 916     if (p_sa_info == NULL)
 917     {
 918         printf("flip_and_send_pkt(): trie_lookup() failed\n");
 919         return;
 920     }
 921     //just drop non-udp packet
 922     if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
 923
 924     {
 925         stats.n_new+=1;Pktlib_freePacket(tip); return;
 926     }
 927
 928 memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
 929 memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
 930 memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
 931
 932 //udp
 933 memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+2],&new_dest_port[0],2);
 934 memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+6],0,2); //checksum
 935
 936
 937
 938
 939 if (config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
 940 {
 941     //inner ip checksum : leave alone
 942 #if 0
 943     blah=test_utilOnesCompChkSum (&p_pkt[14+20+8+16], 10);
 944     p_pkt[14+20+8+16+10]= (blah&0xff00)>>8;
 945     p_pkt[14+20+8+16+11]= blah&0xff;
 946 #endif
 947
 948     //tbd udp checksum (leave at 0)
 949
 950     //outer ip, set to 0 (we will compute on way out
 951     memset(&p_pkt[14+10],0,2);
 952 }
 953 else
 954 {
 955 //#else //inflow, don't touch outer , clear inner
 956 //DALmemset(&p_pkt[14+20+8+16+10],0,2); //inner checksum, we will compute on way out
 957 //outer ip checksum : leave alone
 958
 959 #if 0
 960 blah = test_utilOnesCompChkSum (&p_pkt[14], 10);
 961 p_pkt[14+10]= (blah&0xff00)>>8;
 962 p_pkt[14+11]= blah&0xff;
 963 #endif
 964
 965 }
 966 }
 967 else
 968 {
 969 memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out
 970 memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);
 971 }
 972
 973 //IPSEC case,
 974 if (flag)
 975 {
 976         if (config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
 977  //send to crypto for encryption
 978 //12 byte auth tag
 979         {
 980            PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
 981            int err;
 982            nwalDmTxPayloadInfo_t meta_tx={0};
 983            meta.sa_handle=p_sa_info->tx_data_mode_handle;  //use TX SA context
 984
 985 #if 0
 986            meta_tx.ploadLen = len;
 987
 988            meta_tx.encOffset =p_sa_info->tx_payload_info.encOffset;
 989
 990            meta_tx.authOffset =netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN;
 991
 992            //meta_tx.encSize=len - 14- 20-8-16-12;
 993            meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -netTest_ICV_LEN;
 994
 995            //meta_tx.authSize= len -14-20-12;
 996            meta_tx.authSize = len - meta_tx.authOffset - netTest_ICV_LEN;
 997            //meta_tx.encIvSize=16;
 998            meta_tx.encIvSize = p_sa_info->tx_payload_info.encIvSize;
 999            //meta_tx.pEncIV= &p_pkt[14+20+8];  //just use same IV..
1000 #endif
1001             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
1002
1003            meta_tx.ploadLen = len;
1004            meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -netTest_ICV_LEN;
1005            meta_tx.authSize = len - meta_tx.authOffset - netTest_ICV_LEN;
1006
1007            meta_tx.encIvSize = p_sa_info->tx_payload_info.encIvSize;
1008 #if 0
1009             printf("flip_and_send_pkt(): encOffset %d\n", meta_tx.encOffset);
1010             printf("flip_and_send_pkt():authOffset %d\n", meta_tx.authOffset);
1011             printf("flip_and_send_pkt(): encSize %d\n", meta_tx.encSize);
1012             printf("flip_and_send_pkt(): authSize %d\n", meta_tx.authSize);
1013             printf("flip_and_send_pkt(): encIvSize %d\n", meta_tx.encIvSize);
1014 #endif
1015
1016         if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
1017         {
1018            memcpy(&p_iv[0], &ourEncrKey[16], 4);
1019            memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1020             p_iv[12] = 0;
1021             p_iv[13] = 0;
1022             p_iv[14] = 0;
1023             p_iv[15] = 1;
1024            meta_tx.pEncIV = &p_iv[0];
1025          }
1026         else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
1027         {
1028             meta_tx.pEncIV = NULL;
1029         }
1030         else
1031         {
1032             meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
1033         }
1034            meta_tx.authIvSize=0;
1035            meta_tx.pAuthIV=NULL;
1036            meta_tx.aadSize=0;
1037            meta_tx.pAad=NULL;
1038            /* post it to netcp sb tx channel*/
1039            meta_tx.appCtxId = netapi_timing_start();
1040            meta.u.tx_sb_meta=&meta_tx;
1041            pktio_send(netcp_sb_tx_chan,tip,&meta,&err);
1042        }
1043 else
1044  {
1045   //inflow tx
1046   //send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
1047            PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
1048            int err;
1049            nwalTxPktInfo_t meta_tx={0};
1050 #define USE_COPY
1051 #ifdef USE_COPY
1052 //debug:  see if re-using RX descriptor for TX is causing our SA lockup
1053 {
1054   int new_len=0;
1055   Ti_Pkt new_tip =  get_pkt(0, &new_len, specialLarge , len+10 , &p_pkt[0]   , len);
1056   if (!new_tip)
1057   {
1058      printf("net_test> new_tip NULL\n");
1059   }
1060   else
1061   {
1062     Pktlib_setPacketLen(new_tip,new_len);
1063     Pktlib_freePacket(tip);
1064     tip=new_tip;
1065     Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&new_len);  //reset p_pkt to point to new buffer as its used below
1066     Cppi_setTimeStamp (Cppi_DescType_HOST, (Cppi_Desc *) tip,stats.sec_tx);
1067   }
1068 }
1069 if (len <1500)
1070 {
1071   eof+=1;
1072 }
1073 #endif
1074            meta.sa_handle=p_sa_info->tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied
1075            //meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_DO_IPSEC_CRYPTO| NWAL_TX_FLAG1_META_DATA_VALID );
1076            meta_tx.txFlag1 = p_sa_info->tx_pkt_info.txFlag1;
1077            meta_tx.enetPort=0;
1078            //meta_tx.saOffBytes=14+20;
1079            meta_tx.saOffBytes=  p_sa_info->tx_pkt_info.saOffBytes;
1080            meta_tx.saPayloadLen=len-14-20;   //don't include tag, mac and outer header
1081            //meta_tx.startOffset = 0;
1082            meta_tx.startOffset = p_sa_info->tx_pkt_info.startOffset;
1083            //meta_tx.ipOffBytes = 14+20+8+16;   //to inner header
1084            meta_tx.ipOffBytes =p_sa_info->tx_payload_info.encOffset;
1085            //meta_tx.l4OffBytes = 14+20+8+16+20; //to L4
1086            meta_tx.l4OffBytes = p_sa_info->tx_pkt_info.l4OffBytes;
1087            meta_tx.l4HdrLen = p_sa_info->tx_pkt_info.l4HdrLen;
1088            meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
1089            meta_tx.pseudoHdrChecksum =
1090              test_utilGetIpv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
1091
1092            /* post it to netcp tx channel*/
1093            meta.u.tx_meta=&meta_tx;
1094            if (stats.sec_tx<20) dump_descr((long *) tip, stats.sec_tx);
1095            pktio_send(netcp_tx_chan,tip,&meta,&err);
1096            stats.tx +=1;
1097            stats.sec_tx +=1;
1098      }
1099 }
1100 else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
1101 {
1102            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
1103            int err;
1104            nwalTxPktInfo_t meta_tx2={0};
1105            meta2.sa_handle=nwal_HANDLE_INVALID;
1106            meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
1107            meta_tx2.startOffset = 0;
1108            meta_tx2.ipOffBytes = 14;
1109            meta_tx2.l4OffBytes = 14+20;
1110            meta_tx2.l4HdrLen = 8;
1111            meta_tx2.ploadLen = (unsigned) ((p_pkt[14+20+4]<<8)|p_pkt[14+20+4+1]) -8 ;
1112            meta_tx2.pseudoHdrChecksum =
1113              test_utilGetIpv4PsudoChkSum(&p_pkt[14],8+ meta_tx2.ploadLen);
1114
1115            /* post it to netcp tx channel*/
1116            meta2.u.tx_meta=&meta_tx2;
1117            pktio_send(netcp_tx_chan,tip,&meta2,&err);
1118            stats.tx +=1;
1119 }
1120 }
1121
1122
1123
1124
1125 /***************************************
1126  benchmark receive handler
1127 ****************************************/
1128 void recv_cb_bench(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1129                          PKTIO_METADATA_T meta[], int n_pkts,
1130                          uint64_t ts )
1131 {
1132    int i;
1133    vv6=   netapi_timing_stop();
1134    for (i=0;i<n_pkts; i++)
1135    {
1136      Pktlib_freePacket(p_recv[i]);
1137    }
1138    vv11 = netapi_timing_stop();
1139 }
1140
1141 /****************************************************************************************/
1142 /******************SB Accelerator Callback PKT RECEIVE HANDLER *************************/
1143 /******************  Handles Decrypt and Encrypt operation callbacks ******************/
1144 /******************************************************************************************/
1145 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1146                          PKTIO_METADATA_T meta[], int n_pkts,
1147                          uint64_t ts )
1148 {
1149 int i;
1150 int len;
1151 int p;
1152 HEAD_T * p_res;
1153 Ti_Pkt * tip;
1154 unsigned int templen;
1155 int err;
1156 KEY_T key;
1157 char * p_pkt;
1158 HEAD_T * p_head;
1159 HEAD_T temp_head;
1160 int tag_cmp=0;
1161 unsigned int hash[3];
1162 uint8_t *p_spi;
1163 netTestSA_t *p_sa_info;
1164
1165 //nwal_AppId time;
1166 unsigned long time, delta_time;
1167  /* loop over received pkts */
1168    for(i=0;i<n_pkts;i++)
1169    {
1170         tip = p_recv[i];
1171         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
1172         len = Pktlib_getPacketLen(tip);//real length
1173
1174
1175          p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1176         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1177         if (p_sa_info == NULL)
1178         {
1179             printf("recv_sb_cb(): trie_lookup failed\n");
1180             continue;
1181         }
1182
1183
1184         //is this a decrypt (rx_tunnel) complete
1185         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
1186         {
1187
1188             time = netapi_timing_start();
1189            delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
1190             stats.total_decrypt_time += delta_time;
1191             stats.sb_rx+=1;
1192            //copy hash out of meta data (for some reason it needs endian conversion)
1193            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
1194            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
1195            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
1196
1197            if(stats.sb_rx<=16)
1198            {
1199              char *tp = (char *) &hash[0];
1200              //dump_header((long*)p_pkt, stats.sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
1201 #if 0
1202              printf("tag in pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1203                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],
1204                       p_pkt[len-7],p_pkt[len-6],
1205                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);
1206              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1207                        tp[0],tp[1],tp[2],tp[3],tp[4],tp[5],
1208                        tp[6],tp[7],tp[8],tp[9],tp[10],tp[11]);
1209 #endif
1210            }
1211            //check tag
1212            tag_cmp = memcmp(&p_pkt[len-12],(char*) &hash[0],12); //todo, really use meta->authTagLen
1213            stats.n_auth_ok += !(tag_cmp);
1214
1215             flip_and_send_pkt(tip, p_pkt, len,1);  //flip packet to echo back and send
1216         }
1217         //this is an encrypt (tx tunnel) complete
1218         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
1219         {
1220            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
1221            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
1222            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
1223            stats.sb_tx+=1;
1224            if(stats.sb_tx<=16)
1225            {
1226              char *tp1 = (char *) &hash[0];
1227              //dump_header((long*)p_pkt, stats.sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
1228 #if 0
1229              printf("tag in original rx pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1230                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],
1231                       p_pkt[len-7],p_pkt[len-6],
1232                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);
1233
1234              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",
1235                        tp1[0],tp1[1],tp1[2],tp1[3],tp1[4],tp1[5],
1236                        tp1[6],tp1[7],tp1[8],tp1[9],tp1[10],tp1[11]);
1237 #endif
1238            }
1239            //put the computed tag in the packet
1240            memcpy(&p_pkt[len-12],(char*)&hash[0],12); //todo, really use meta->authTagLen
1241            {
1242            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
1243            nwalTxPktInfo_t meta_tx={0};
1244            // now send directly
1245            meta2.sa_handle=nwal_HANDLE_INVALID;
1246            meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);//only outer IP header checksum. no udp checksum possible since pkt is already encrypted
1247            meta_tx.startOffset = 0;
1248            meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
1249            //not used
1250            meta_tx.l4OffBytes = 0;
1251            meta_tx.l4HdrLen = 0;
1252            meta_tx.ploadLen = 0;
1253             time = netapi_timing_start();
1254             delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
1255            stats.total_encrypt_time += delta_time;
1256
1257
1258            /* post it to netcp tx channel*/
1259            meta2.u.tx_meta=&meta_tx;
1260            pktio_send(netcp_tx_chan,tip,&meta2,&err);
1261            stats.tx +=1;
1262            }
1263         }
1264         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
1265     }
1266 }
1267
1268 /******************************************************/
1269 /******************PKT RECEIVE HANDLER *************************/
1270 /******************************************************/
1271 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1272                          PKTIO_METADATA_T meta[], int n_pkts,
1273                          uint64_t ts )
1274 {
1275 int i;
1276 int len;
1277 int p;
1278 HEAD_T * p_res;
1279 Ti_Pkt * tip;
1280 unsigned int templen;
1281 int err;
1282 KEY_T key;
1283 char * p_pkt;
1284 HEAD_T * p_head;
1285 HEAD_T temp_head;
1286 netTestSA_t *p_sa_info;
1287 uint8_t *p_spi;
1288 uint8_t p_iv[16];
1289
1290     p_head=&temp_head;
1291
1292     //debug
1293 #if 0
1294     if (n_pkts != TX_BURST) {
1295       printf("recv_cb, txsofar=%d rxsofar=%d  np = %d, NOT %d\n",
1296              stats.itx, stats.rx, n_pkts,TX_BURST);
1297       our_stats_cb(netapi_handle,NULL);
1298     }
1299 #endif
1300     //test_alloc_free(7);
1301     //printf("recv start\n");
1302
1303     /* loop over received pkts */
1304     for(i=0;i<n_pkts;i++)
1305    {
1306         tip = p_recv[i];
1307         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
1308         len = Pktlib_getPacketLen(tip)-4;//real length, subtract mac trailer
1309         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
1310         Pktlib_setPacketLen(tip,len);
1311
1312         //debug: validate descriptor */
1313         if(Pktlib_getNextPacket(tip) != 0)
1314         {
1315             printf(" rcv_cb, nexpkt != NULL");
1316         }
1317         //debug printf("recv pkt, len=%d %d\n", len, templen);
1318         stats.rx+=1;
1319
1320 #ifdef DEBUG_DESC
1321         if (stats.rx<16)
1322         {
1323             printf(">rx dmp..");
1324             dump_descr((long *) tip, stats.rx);
1325         }
1326         else if (stats.rx>99)
1327         {
1328             printf(">rx dmp..");
1329             dump_descr((long *) tip,stats.rx);
1330         }
1331 #endif
1332 #if 0
1333         if(stats.rx<=16)
1334         {
1335             dump_header((long*)p_pkt, stats.rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
1336         }
1337 #endif
1338         /* check header */
1339         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));
1340
1341         if ((p_head->ip[2]&0x0000ff00)==0x00003200)
1342         {
1343             if (!check_header(p_head,&meta[i]))
1344             {
1345                 stats.n_bad+=1;Pktlib_freePacket(tip);
1346                 continue;
1347             }
1348
1349
1350
1351
1352             //process IP SEC PACKET
1353         if (config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
1354         {
1355             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1356             p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1357             if (p_sa_info == NULL)
1358             {
1359                 printf("recv_cb(): trie_lookup() failed\n");
1360                 continue;
1361             }
1362            //ship to crypto for decrypt!!
1363            //12 byte auth tag
1364             PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
1365            nwalDmTxPayloadInfo_t meta_tx={0};
1366            meta2.sa_handle=p_sa_info->rx_data_mode_handle;
1367
1368            memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
1369
1370            meta_tx.ploadLen = len;
1371            meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -netTest_ICV_LEN;
1372            meta_tx.authSize = len - meta_tx.authOffset - netTest_ICV_LEN;
1373
1374            meta_tx.encIvSize = p_sa_info->tx_payload_info.encIvSize;
1375 #if 0
1376             printf("recv_cb(): encOffset %d\n", meta_tx.encOffset);
1377             printf("recv_cb():authOffset %d\n", meta_tx.authOffset);
1378             printf("recv_cb(): encSize %d\n", meta_tx.encSize);
1379             printf("recv_cb(): authSize %d\n", meta_tx.authSize);
1380             printf("recv_cb(): encIvSize %d\n", meta_tx.encIvSize);
1381 #endif
1382
1383             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
1384             {
1385                 memcpy(&p_iv[0], &ourEncrKey[16], 4);
1386                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1387                 p_iv[12] = 0;
1388                 p_iv[13] = 0;
1389                 p_iv[14] = 0;
1390                 p_iv[15] = 1;
1391                  meta_tx.pEncIV = &p_iv[0];
1392             }
1393             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
1394             {
1395                 meta_tx.pEncIV = NULL;
1396             }
1397             else
1398             {
1399                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
1400             }
1401             meta_tx.appCtxId = netapi_timing_start();
1402             //printf("recv_cb appCtxId: %lu\n", meta_tx.appCtxId);
1403
1404            /* post it to netcp sb tx channel*/
1405            meta2.u.tx_sb_meta=&meta_tx;
1406            pktio_send(netcp_sb_tx_chan,tip,&meta2,&err);
1407            continue;
1408         }
1409         else
1410             //inflow mode.  flip and send
1411             flip_and_send_pkt(tip,p_pkt,len,1);
1412     }
1413     else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
1414     {
1415         stats.n_new+=1;Pktlib_freePacket(tip); continue;
1416     }
1417     else  //non ipsec
1418     {
1419         if (!check_header(p_head,&meta[i])) {
1420                 stats.n_bad+=1;Pktlib_freePacket(tip);
1421         continue;
1422         }
1423
1424 #if 0
1425         /* lookup flow */
1426         key.src_ip = p_head->ip[3];
1427         key.dst_ip = p_head->ip[4];
1428         key.src_port= (p_head->udp[0]&0xffff0000)>>16;
1429         key.dst_port= (p_head->udp[0]&0x0000ffff);
1430         p_res= (HEAD_T *) trie_lookup(P_trie, (char *) &key, sizeof(key));
1431         if (!p_res) { stats.n_new+=1;  slow_path(tip, len); continue;}
1432
1433         /* copy header */
1434         memcpy((char *) p_head, (char *) p_res, sizeof(HEAD_T));
1435
1436         memcpy(&p_pkt[14],p_head,sizeof(HEAD_T));
1437         /* update_mac(&p_pkt[0]);  */
1438
1439         /* 'simulate' send pkt */
1440         send_pkt(tip,len);
1441 #endif
1442              //just flip and send
1443             flip_and_send_pkt(tip,p_pkt,len,0);
1444         }
1445     }
1446     //printf("recv done\n");
1447 }
1448
1449 //timer callback
1450 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,
1451         int n_fired,     //# timers fired
1452         NETAPI_TIMER_LIST_T fired_list,
1453         uint64_t currentTime)
1454 {
1455 int i;
1456 NETAPI_TIMER_T tx;
1457 int cookie;
1458 int err;
1459 unsigned long long et;
1460 //DEBUGprintf("TIMER CALLBACK @ %lld %d timers\n", currentTime, n_fired);
1461 tx = netapi_TimerGetFirst(fired_list);
1462 for(i=0;i<n_fired;i++)
1463 {
1464   cookie = (int) netapi_TimerGetCookie(tx);
1465   et =  netapi_TimerGetTs(tx); //debug
1466   //DEBUGprintf("   timer %d - cookie = %d expected ts=%lld (delta=%lld)\n", i, cookie, et, currentTime-et);
1467   if (cookie ==1)
1468   {
1469      stats.n_t1+=1;
1470      t1 = netapi_TimerGroupStartTimer(
1471         th,
1472         (void *) 1,
1473         100LL,  //timer group tics
1474         &err);
1475   }
1476   else if (cookie ==2)
1477   {
1478       stats.n_t2+=1;
1479       t2 = netapi_TimerGroupStartTimer(
1480         th,
1481         (void *) 2,
1482         200LL,  //timer group ticks
1483         &err);
1484   }
1485   else
1486   {
1487     stats.n_t3+=1;
1488     t3 = netapi_TimerGroupStartTimer(
1489         th,
1490         (void *) 3,
1491         300LL,  //timer group ticks
1492         &err);
1493     //cancel 1 and restart 1
1494    netapi_TimerGroupCancel(th,t1,&err);
1495    t1 = netapi_TimerGroupStartTimer(
1496         th,
1497         (void *) 1,
1498         100LL,  //timer group ticks
1499         &err);
1500  }
1501   tx = netapi_TimerGetNext(fired_list,tx);
1502 }
1503 }
1504
1505 void print_ipsec_stats(Sa_IpsecStats_t     *p_saIpsecStats, nwal_saAALG auth, nwal_saEALG cipher)
1506 {
1507 #if 0
1508     if(retVal != nwal_OK)
1509     {
1510         System_printf("CORE: %d Error getting IP Sec Stats: Ret Status: %d \n",
1511                        retVal);
1512         return(nwal_FALSE);
1513     }
1514     if((p_saIpsecStats->pktEncHi) ||(p_saIpsecStats->pktEncLo))
1515     {
1516         printf("------------- IPSec TX (Encryption Channel) Stats BEGIN --\n");
1517     }
1518     else
1519     {
1520         printf("------------- IPSec RX (Decryption Channel) Stats BEGIN --\n");
1521     }
1522 #endif
1523     printf("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
1524     printf("IPSec replayOld:0x%x,replayDup:0x%x,authFail:0x%x \n",
1525                    p_saIpsecStats->replayOld,p_saIpsecStats->replayDup,p_saIpsecStats->authFail);
1526     printf("IPSec txESN:0x%x,rxESN:0x%x,pktEncHi:0x%x,pktEncLo:0x%x,pktDecHi:0x%x,pktDecLo:0x%x \n",
1527                    p_saIpsecStats->txESN,p_saIpsecStats->rxESN,p_saIpsecStats->pktEncHi,
1528                    p_saIpsecStats->pktEncLo,p_saIpsecStats->pktDecHi,p_saIpsecStats->pktDecLo);
1529 }
1530
1531 void print_datamode_stats(Sa_DataModeStats_t     *p_saDataModeStats, nwal_saAALG auth, nwal_saEALG cipher)
1532 {
1533
1534     printf("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
1535     printf(" Packets processedHi: 0x%x, Packets processed Lo:0x%x\n",
1536             p_saDataModeStats->pktHi, p_saDataModeStats->pktLo);
1537 }
1538
1539
1540
1541
1542 static int np2process = NP;
1543 /******************************************************
1544  * stats callback
1545  *******************************************************/
1546 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats)
1547 {
1548 uint32_t numFreeDataPackets;
1549 uint32_t            numZeroBufferPackets;
1550 uint32_t            numPacketsinGarbage;
1551 Pktlib_HeapStats    pktLibHeapStats;
1552 int i;
1553 unsigned long long bcpp;
1554 unsigned long long bcpp_noc;
1555 unsigned long long bcpp_app;
1556 unsigned long long bcpp_tx;
1557 unsigned long long npL;
1558 unsigned long long cyclesL;
1559 unsigned long long ccyclesL; //cache cycles
1560 NETAPI_SA_STATS_T netapi_sa_stats;
1561
1562 printf(">*****stats @ %lld\n", netapi_getTimestamp());
1563 //printf("netcp_tx_handle check %x\n", netcp_tx_chan->back);
1564 printf(">itx=%d rx=%d tx=%d bad=%d slow=%d \n>rx_class0=%d rx_class1=%d rx_class2=%d  secRx=%d  secPRX=%d sb_rx=%d sb_tx=%d auth_ok=%d sec_tx=%d\n",
1565          stats.itx, stats.rx, stats.tx, stats.n_bad, stats.n_new,
1566          stats.n_class0_rx, stats.n_class1_rx,
1567          stats.n_class2_rx, stats.sec_rx, stats.secp_rx, stats.sb_rx, stats.sb_tx, stats.n_auth_ok,
1568          stats.sec_tx);
1569
1570 if (stats.rx && stats.tx)
1571     printf("decrypt time per packet(avg): %lu, encrypt  time per packet(avg): %lu\n",
1572     (unsigned long) stats.total_decrypt_time/stats.rx, (unsigned long) stats.total_encrypt_time/stats.tx);
1573 netapi_sched_get_stats(&npL,&cyclesL,&ccyclesL);
1574 if (npL && stats.rx) {
1575    bcpp = cyclesL/npL;
1576    bcpp_noc = (cyclesL-ccyclesL)/npL;
1577    bcpp_app = (stats.app_cycles-stats.tx_cache_cycles)/stats.rx;
1578 }
1579 else {bcpp = bcpp_noc=bcpp_app=0L;}
1580 if (stats.tx)
1581 {
1582     bcpp_tx = (stats.send_cycles-stats.tx_cache_cycles)/stats.tx;
1583 }else {bcpp_tx = 0L;}
1584 printf(">         ++ busy cycles pp=%lld (%lld wo cache ops) (app+tx= %lld) (tx= %lld) ++\n",
1585          bcpp,bcpp_noc,bcpp_app, bcpp_tx);
1586 if(pPaStats)
1587 {
1588        printf("C1 number of packets:           %d\n", pPaStats->classify1.nPackets);
1589        printf("C1 number IPv4 packets:         %d\n", pPaStats->classify1.nIpv4Packets);
1590        printf("C1 number IPv6 packets:        %d\n", pPaStats->classify1.nIpv6Packets);
1591        printf("C1 number Custom packets:        %d\n", pPaStats->classify1.nCustomPackets);
1592        printf("C1 number SRIO packets:        %d\n", pPaStats->classify1.nSrioPackets);
1593        printf("C1 number LLC/SNAP Fail packets:        %d\n", pPaStats->classify1.nLlcSnapFail);
1594        printf("C1 number table matched:        %d\n", pPaStats->classify1.nTableMatch);
1595        printf("C1 number failed table matched: %d\n", pPaStats->classify1.nNoTableMatch);
1596        printf("C1 number IP Fragmented packets: %d\n", pPaStats->classify1.nIpFrag);
1597        printf("C1 number IP Depth Overflow: %d\n", pPaStats->classify1.nIpDepthOverflow);
1598        printf("C1 number VLAN Depth Overflow: %d\n", pPaStats->classify1.nVlanDepthOverflow);
1599        printf("C1 number GRE Depth Overflow: %d\n", pPaStats->classify1.nGreDepthOverflow);
1600        printf("C1 number MPLS Packets: %d\n", pPaStats->classify1.nMplsPackets);
1601        printf ("C1 number of parse fail:        %d\n",pPaStats->classify1.nParseFail);
1602        printf("C1 number of Invalid IPv6 Opt:  %d\n", pPaStats->classify1.nInvalidIPv6Opt);
1603        printf("C1 number of TX IP Fragments:  %d\n", pPaStats->classify1.nTxIpFrag);
1604        printf ("C1 number of silent discard:    %d\n",pPaStats->classify1.nSilentDiscard);
1605        printf("C1 number of invalid control:   %d\n", pPaStats->classify1.nInvalidControl);
1606        printf ("C1 number of invalid states:    %d\n",pPaStats->classify1.nInvalidState);
1607        printf ("C1 number of system fails:      %d\n",pPaStats->classify1.nSystemFail);
1608        printf ("C2 number Packets  :           %d\n",pPaStats->classify2.nPackets);
1609        printf ("C2 number udp           :      %d\n",pPaStats->classify2.nUdp);
1610        printf ("C2 number tcp           :      %d\n",pPaStats->classify2.nTcp);
1611        printf ("C2 number Custom       :      %d\n",pPaStats->classify2.nCustom);
1612        printf ("C2 number silent drop   :      %d\n",pPaStats->classify2.nSilentDiscard);
1613        printf ("C2 number invalid cntrl :      %d\n\n",pPaStats->classify2.nInvalidControl);
1614        printf ("C2 number Modify Stats Cmd Fail :      %d\n\n",pPaStats->modify.nCommandFail);
1615 }
1616 Pktlib_getHeapStats(OurHeap, &pktLibHeapStats);
1617 printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
1618                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
1619 printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
1620                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
1621                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
1622
1623 Pktlib_getHeapStats(specialSmall, &pktLibHeapStats);
1624 printf("specialSmall heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
1625                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
1626 printf("                       >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
1627                                 pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
1628                                 pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
1629
1630
1631 Pktlib_getHeapStats(specialLarge, &pktLibHeapStats);
1632 printf("specialLarge heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
1633                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
1634 printf("                       >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n",
1635                                 pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
1636                                 pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
1637
1638
1639 #if 0
1640 printf("pa2sa descriptor area dump\n");
1641 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_PA_TO_SA_DESC;i++)
1642 {
1643    extern long * pa2sa_descr_base;
1644    long * tip= &pa2sa_descr_base[32*i];
1645    dump_descr(tip, i);
1646 }
1647 printf("sa2pa descriptor area dump\n");
1648 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC;i++)
1649 {
1650    extern long * sa2pa_descr_base;
1651    long * tip= &sa2pa_descr_base[32*i];
1652    dump_descr(tip, i);
1653 }
1654 #endif
1655 //debug = dump timer polling stats
1656 //dump_poll_stats();
1657
1658 #ifndef EXPERIMENTAL
1659     for (i = 0; i < MAX_SEC_INDEX; i++)
1660 #else
1661     for (i=0; i < 1;i++)
1662 #endif
1663     {
1664         if (config.ipsec_mode_rx == IPSEC_MODE_RX_INFLOW)
1665         {
1666             memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
1667             netapi_getSaStats(netapi_handle, sa_info[i].rx_tunnel, &netapi_sa_stats);
1668             if (netapi_sa_stats.mode_active & NETAPI_INFLOW_MODE_ACTIVE)
1669                 print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), rx_sa[i].authMode, rx_sa[i].cipherMode);
1670         }
1671 #if 0
1672         else
1673         {
1674             memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
1675             netapi_getSaStats(netapi_handle, sa_info[i].rx_tunnel, &netapi_sa_stats);
1676              if (netapi_sa_stats.mode_active & NETAPI_SIDEBAND_MODE_ACTIVE)
1677             print_datamode_stats(&(netapi_sa_stats.dataModeStats),rx_sa[i].authMode, rx_sa[i].cipherMode);
1678         }
1679 #endif
1680
1681         if (config.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
1682         {
1683             memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
1684             netapi_getSaStats(netapi_handle, sa_info[i].tx_tunnel, &netapi_sa_stats);
1685              if (netapi_sa_stats.mode_active & NETAPI_INFLOW_MODE_ACTIVE)
1686                 print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), tx_sa[i].authMode, tx_sa[i].cipherMode);
1687         }
1688 #if 0
1689         else
1690         {
1691             memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
1692             netapi_getSaStats(netapi_handle, sa_info[i].tx_tunnel, &netapi_sa_stats);
1693             if (netapi_sa_stats.mode_active & NETAPI_SIDEBAND_MODE_ACTIVE)
1694                 print_datamode_stats(&(netapi_sa_stats.dataModeStats),tx_sa[i].authMode, tx_sa[i].cipherMode);
1695         }
1696  #endif
1697
1698     }
1699 }
1700
1701 //******************************************************
1702 //use scheduling housekeeping callback to generate pkts
1703 //******************************************************
1704 static int done_burst=0;
1705 void house(NETAPI_SCHED_HANDLE_T * s)
1706 {
1707 Ti_Pkt * tip;
1708 unsigned int len;
1709 nwalTxPktInfo_t meta_tx = {0};
1710 PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
1711 int err;
1712 static int house_pkts_gened=0;
1713 int p;
1714 unsigned char * pIpHdr,* pData;
1715 unsigned int vv1,vv2,vv3;
1716 unsigned int sum_vv1=0;
1717 unsigned int sum_vv2=0;
1718 unsigned int sum_vv3=0;
1719 unsigned int sum_vv4=0;
1720 unsigned int sum_vv5=0;
1721
1722 unsigned int nwal_flow_vv1,nwal_flow_vv2;
1723 unsigned int nwal_sum_vv1=0;
1724 unsigned int nwal_sum_vv2=0;
1725 unsigned int nwal_sum_vv3=0;
1726 unsigned int nwal_sum_vv4=0;
1727 unsigned int nwal_sum_vv5=0;
1728 unsigned int nwal_sum_vv6=0;
1729
1730 unsigned int nwal_sum_flow_vv1=0;
1731 unsigned int nwal_sum_flow_vv2=0;
1732 unsigned int cache_op_b1;
1733 unsigned int cache_op_b2;
1734 int n_c_ops;
1735 static int first =0;
1736 Cppi_HostDesc*      pPktDesc;
1737
1738 if(done_burst)
1739 {
1740   house_pkts_gened+=TX_BURST;
1741   printf("net_test> request stats at n=%d \n",house_pkts_gened);
1742   netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err);
1743   if (err!=0) {printf("stats req failed\n");}
1744   if (house_pkts_gened >= np2process+ 100)
1745   {
1746      netapi_schedShutdown(s,NULL,&err);
1747   }
1748   return;
1749 }
1750 done_burst=1;
1751 Osal_cache_op_measure_reset();
1752 memset(&meta_tx,0,sizeof(meta_tx));
1753 for(p=0;p<TX_BURST;p++) {
1754 //reguest stats
1755 if ((house_pkts_gened>0) && (! (house_pkts_gened%1000)) )
1756 {
1757    printf("net_test> request stats at n=%d \n",house_pkts_gened);
1758    netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err);
1759    if (err!=0) {printf("stats req failed\n");}
1760 }
1761
1762
1763   if (house_pkts_gened >= np2process+ 100)
1764   {
1765      //shutdown
1766      netapi_schedShutdown(s,NULL,&err);
1767      continue;
1768   }
1769
1770   else if (house_pkts_gened >= np2process) { house_pkts_gened+=1;  continue;}
1771
1772
1773 /* manufacture a pkt to transmit */
1774    tip = get_pkt(house_pkts_gened, &len, OurHeap, PKT_LEN,&testPkt[0]  , TEST_PKT_LEN);
1775    if(!tip) { house_pkts_gened +=1; continue; }
1776
1777
1778    /* set the pkt length */
1779    vv1 = netapi_timing_start();
1780    Pktlib_setPacketLen(tip, len);
1781
1782    /* set up meta data */
1783     meta.sa_handle=nwal_HANDLE_INVALID;
1784 //#define BENCH_UDP_SEND
1785 #ifdef BEND_UDP_SEND
1786     meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM | NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);
1787     meta_tx.startOffset = 0;
1788     //GONE in V2 meta_tx.pktLen = len;
1789     meta_tx.ipOffBytes = TEST_PKT_IP_OFFSET_BYTES;
1790     meta_tx.l4OffBytes = TEST_PKT_UDP_OFFSET_BYTES;
1791     meta_tx.l4HdrLen = TEST_PKT_UDP_HDR_LEN;
1792     //GONE in V2 meta_tx.ploadOffBytes = TEST_PKT_PLOAD_OFFSET_BYTES;
1793     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
1794
1795     Pktlib_getDataBuffer(tip,&pData,&len);
1796    if(house_pkts_gened &0x1)
1797    {
1798         memcpy(&pData[6],&config.mac1[0] ,6);
1799    }
1800     pIpHdr = pData + meta_tx.ipOffBytes;
1801     meta_tx.pseudoHdrChecksum =
1802         test_utilGetIpv4PsudoChkSum(pIpHdr,(TEST_PAYLOAD_LEN+TEST_PKT_UDP_HDR_LEN));
1803 #else
1804    Pktlib_getDataBuffer(tip,&pData,&len);
1805    if(house_pkts_gened &0x1)
1806    {
1807         memcpy(&pData[6],&config.mac1[0] ,6);
1808    }
1809     meta_tx.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID;
1810     meta_tx.startOffset = 0;
1811     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
1812 #endif
1813    /* post it to netcp tx channel*/
1814    meta.u.tx_meta=&meta_tx;
1815 #ifdef DEBUG_DESC
1816    if (house_pkts_gened<16) dump_descr((long *) tip, house_pkts_gened);
1817    else if (house_pkts_gened>99) dump_descr((long *) tip,house_pkts_gened);
1818 #endif
1819
1820    if(!first)
1821    {
1822        first++;
1823        nwal_flow_vv1= netapi_timing_stop();
1824        if(nwal_initPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_tx_chan),
1825                              &meta_tx,
1826                              &flowPSCmdInfo) != nwal_OK)
1827        {
1828            printf("nwal_initPSCmdInfo() ERROR \n");
1829        }
1830        nwal_flow_vv2= netapi_timing_stop();
1831        nwal_sum_flow_vv1 += (nwal_flow_vv1-vv1);
1832        nwal_sum_flow_vv2 += (nwal_flow_vv2-nwal_flow_vv1);
1833    }
1834
1835    cache_op_b1= Osal_cache_op_measure(&n_c_ops);
1836    vv2= netapi_timing_stop();
1837 #ifdef BEND_UDP_SEND
1838    nwal_mCmdSetL4CkSumPort(  tip,
1839                              &flowPSCmdInfo,
1840                              TEST_PKT_UDP_OFFSET_BYTES,
1841                              (TEST_PKT_UDP_HDR_LEN + TEST_PAYLOAD_LEN),
1842                              meta_tx.pseudoHdrChecksum,
1843                              meta_tx.enetPort);
1844 #else
1845    nwal_mCmdSetPort  (tip,
1846                       &flowPSCmdInfo,  //could be NULL
1847                       0);  //port 0 -> switch decides
1848
1849 #endif
1850
1851    pPktDesc = Pktlib_getDescFromPacket(tip);
1852    /* Send the packet out to transmit Q*/
1853    Qmss_queuePushDescSize (flowPSCmdInfo.txQueue,
1854                         pPktDesc,
1855                         NWAL_DESC_SIZE);
1856    vv3= netapi_timing_stop();
1857    cache_op_b2= Osal_cache_op_measure(&n_c_ops);
1858
1859    sum_vv1 += (vv2-vv1);
1860    if(!house_pkts_gened)
1861    {
1862        /* first packet. Take out the PS command label creation cost */
1863        sum_vv1 = sum_vv1 - nwal_sum_flow_vv2;
1864    }
1865
1866    sum_vv3 += (vv3-vv2)-(cache_op_b2-cache_op_b1); //sub out cache op cost
1867
1868    // printf("pktio send. full=%d metadata=%d pktio_send=%d\n", vv3-vv1,  vv2-vv1,  vv3-vv2);
1869
1870
1871    stats.itx +=1;
1872    house_pkts_gened +=1;
1873  }
1874 {
1875    unsigned int ccycles;
1876    ccycles =Osal_cache_op_measure(&n_c_ops);
1877    if (sum_vv1)
1878    {
1879       printf("BURST NWAL Fast send %d pkts.  metadata=%d Cmd Label Creation Cost=%d  nwal Fast Send Cost (less cacheop)= %d n_c_ops=%d cache_op_time=%d (pp-> %d)\n",
1880               stats.itx, sum_vv1/stats.itx,  nwal_sum_flow_vv2, sum_vv3/stats.itx,
1881               n_c_ops, ccycles, n_c_ops? (ccycles/(n_c_ops/2)) : 0);
1882 #if 0
1883       printf("NWAL Profile Cycles: Prof1= %d,Prof2=%d,Prof3=%d,Prof4=%d,Prof5=%d ,Prof6=%d \n",
1884               nwal_sum_vv1/stats.itx,nwal_sum_vv2/stats.itx,nwal_sum_vv3/stats.itx,
1885               nwal_sum_vv4/stats.itx,nwal_sum_vv5/stats.itx,nwal_sum_vv6/stats.itx);
1886
1887 #endif
1888
1889       if(stats.itx2)
1890       {
1891           printf("nwal_flowSend Profile Cycles: Prof1= %d,Prof2=%d \n",
1892               nwal_sum_flow_vv1/stats.itx2,nwal_sum_flow_vv2/stats.itx2);
1893       }
1894
1895    }
1896 }
1897 }
1898
1899 void  build_sa_db(int i)
1900 {
1901
1902     if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA1) && (tx_sa[i].cipherMode == NWAL_SA_EALG_AES_CBC))
1903     {
1904         /* static configuration, will not change */
1905         sa_info[i].tx_payload_info.aadSize = 0;
1906         sa_info[i].tx_payload_info.pAad = NULL;
1907         sa_info[i].tx_payload_info.authIvSize = 0;
1908         sa_info[i].tx_payload_info.pAuthIV = NULL;
1909         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
1910         sa_info[i].tx_payload_info.encIvSize = netTest_AES_CBC_IV_LEN;
1911         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
1912                                                                      netTest_IP_HEADER_LEN +
1913                                                                     netTest_ESP_HEADER_LEN +
1914                                                                     netTest_AES_CBC_IV_LEN;
1915
1916
1917
1918         /* dynamic configuration, will  be calculated on the fly */
1919         sa_info[i].tx_payload_info.authSize = 0; /* pkt len - mac - ip -icv (12) */
1920         sa_info[i].tx_payload_info.encSize = 0;   /* authSize - esp header size (always 8 bytes) */
1921         sa_info[i].tx_payload_info.ploadLen = 0;  /* will be packet length */
1922         sa_info[i].tx_payload_info.pEncIV = 0;
1923        sa_info[i].tx_payload_info.pPkt = 0;     /* not being referenced in net_test */
1924
1925         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CBC;
1926         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
1927         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
1928 #ifdef EXPERIMENTAL
1929         sa_info[i].iv_len=16;
1930         sa_info[i].bl=16;
1931         sa_info[i].spi = tx_sa[i].spi;
1932         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
1933         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
1934 #endif
1935         sa_info[i].tx_pkt_info.enetPort = 0;
1936         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
1937         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
1938         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
1939         sa_info[i].tx_pkt_info.startOffset = 0;
1940         sa_info[i].tx_pkt_info.lpbackPass = 0;
1941         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
1942         sa_info[i].tx_pkt_info.pPkt = NULL;
1943         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
1944         sa_info[i].tx_pkt_info.saPayloadLen = 0;
1945         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
1946
1947         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
1948
1949          trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
1950
1951     }
1952     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA2_256) && (tx_sa[i].cipherMode == NWAL_SA_EALG_AES_CTR))
1953     {
1954         printf("inside build_sa_db, index %d\n", i);
1955         /* static configuration, will not change */
1956         sa_info[i].tx_payload_info.aadSize = 0;
1957         sa_info[i].tx_payload_info.pAad = NULL;
1958         sa_info[i].tx_payload_info.authIvSize = 0;
1959         sa_info[i].tx_payload_info.pAuthIV = NULL;
1960         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
1961         sa_info[i].tx_payload_info.encIvSize = netTest_AES_CTR_IV_CONTEXT_LEN;
1962         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
1963                                                                      netTest_IP_HEADER_LEN +
1964                                                                     netTest_ESP_HEADER_LEN +
1965                                                                     netTest_AES_CTR_IV_PACKET_LEN;
1966
1967
1968
1969
1970         /* dynamic configuration, will  be calculated on the fly */
1971         sa_info[i].tx_payload_info.authSize = 0;
1972         sa_info[i].tx_payload_info.encSize = 0;
1973         sa_info[i].tx_payload_info.ploadLen = 0;
1974         sa_info[i].tx_payload_info.pEncIV = 0;
1975         sa_info[i].tx_payload_info.pPkt = 0;
1976
1977         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CTR;
1978         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
1979         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
1980 #ifdef EXPERIMENTAL
1981         sa_info[i].iv_len=8;
1982         sa_info[i].bl=8;
1983         sa_info[i].spi = tx_sa[i].spi;
1984         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
1985         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
1986 #endif
1987
1988         sa_info[i].tx_pkt_info.enetPort = 0;
1989         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
1990         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
1991         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
1992         sa_info[i].tx_pkt_info.startOffset = 0;
1993         sa_info[i].tx_pkt_info.lpbackPass = 0;
1994         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
1995         sa_info[i].tx_pkt_info.pPkt = NULL;
1996         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
1997         sa_info[i].tx_pkt_info.saPayloadLen = 0;
1998         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
1999
2000         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2001
2002        trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2003     }
2004     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA2_256) && (tx_sa[i].cipherMode == NWAL_SA_EALG_3DES_CBC))
2005     {
2006         /* static configuration, will not change */
2007         sa_info[i].tx_payload_info.aadSize = 0;
2008         sa_info[i].tx_payload_info.pAad = NULL;
2009         sa_info[i].tx_payload_info.authIvSize = 0;
2010         sa_info[i].tx_payload_info.pAuthIV = NULL;
2011         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2012         sa_info[i].tx_payload_info.encIvSize = netTest_3DES_CBC_IV_LEN;
2013         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
2014                                                                      netTest_IP_HEADER_LEN +
2015                                                                     netTest_ESP_HEADER_LEN +
2016                                                                     netTest_3DES_CBC_IV_LEN;
2017
2018         /* dynamic configuration, will  be calculated on the fly */
2019         sa_info[i].tx_payload_info.authSize = 0;
2020         sa_info[i].tx_payload_info.encSize = 0;
2021         sa_info[i].tx_payload_info.ploadLen = 0;
2022         sa_info[i].tx_payload_info.pEncIV = 0;
2023         sa_info[i].tx_payload_info.pPkt = 0;
2024
2025         sa_info[i].cipherMode = NWAL_SA_EALG_3DES_CBC;
2026         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2027         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2028 #ifdef EXPERIMENTAL
2029         sa_info[i].iv_len=8;
2030         sa_info[i].bl=8;
2031         sa_info[i].spi = tx_sa[i].spi;
2032         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2033         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2034 #endif
2035
2036         sa_info[i].tx_pkt_info.enetPort = 0;
2037         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2038         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2039         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2040         sa_info[i].tx_pkt_info.startOffset = 0;
2041         sa_info[i].tx_pkt_info.lpbackPass = 0;
2042         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2043         sa_info[i].tx_pkt_info.pPkt = NULL;
2044         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2045         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2046         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2047
2048         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2049
2050        trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2051     }
2052     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_MD5) && (rx_sa[i].cipherMode == NWAL_SA_EALG_NULL))
2053     {
2054         /* static configuration, will not change */
2055         sa_info[i].tx_payload_info.aadSize = 0;
2056         sa_info[i].tx_payload_info.pAad = NULL;
2057         sa_info[i].tx_payload_info.authIvSize = 0;
2058         sa_info[i].tx_payload_info.pAuthIV = NULL;
2059         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2060         sa_info[i].tx_payload_info.encIvSize = netTest_NULL_IV_LEN;
2061
2062         sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
2063                                                                      netTest_IP_HEADER_LEN +
2064                                                                     netTest_ESP_HEADER_LEN +
2065                                                                     netTest_NULL_IV_LEN;
2066 #ifdef EXPERIMENTAL
2067         sa_info[i].iv_len=0;
2068         sa_info[i].bl=4;
2069         sa_info[i].spi = tx_sa[i].spi;
2070         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2071         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2072 #endif
2073
2074
2075         /* dynamic configuration, will  be calculated on the fly */
2076         sa_info[i].tx_payload_info.authSize = 0;
2077         sa_info[i].tx_payload_info.encSize = 0;
2078         sa_info[i].tx_payload_info.ploadLen = 0;
2079         sa_info[i].tx_payload_info.pEncIV = 0;
2080         sa_info[i].tx_payload_info.pPkt = 0;
2081
2082         sa_info[i].cipherMode = NWAL_SA_EALG_NULL;
2083         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2084         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2085
2086         sa_info[i].tx_pkt_info.enetPort = 0;
2087         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2088         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2089         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2090         sa_info[i].tx_pkt_info.startOffset = 0;
2091         sa_info[i].tx_pkt_info.lpbackPass = 0;
2092         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2093         sa_info[i].tx_pkt_info.pPkt = NULL;
2094         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2095         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2096         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2097
2098         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2099
2100        trie_insert(p_trie_sa,(char *)&(tx_sa[i].spi),4, (void *) &sa_info[i]); //asociate with tx sa SPI
2101     }
2102     else
2103         printf("build_sa_db(): invalid encryption/authentication combination selected\n");
2104
2105     //printf("sa_build_db(): authOffset %d, innerIpOffset %d, encOffset %d\n", sa_info[i].tx_payload_info.authOffset, sa_info[i].inner_ip_offset, sa_info[i].tx_payload_info.encOffset);
2106
2107
2108 }
2109
2110
2111
2112 #define CHECK_SET_PARAM(ARG1, ARG2)     \
2113     do { \
2114         if(strcmp(key, ARG1) == 0) { \
2115         if(data)strncpy(ARG2,data,CONFIG_STRING_LEN); \
2116         printf("CHECK_SET_PARM, match found, input cong string %s\n", ARG2); \
2117         continue; \
2118         } \
2119     } while(0)
2120
2121 #define CHECK_SET_PARAM2(ARG1, ARG2,  ARG3)     \
2122     do { \
2123         if(strcmp(key, ARG1) == 0) { \
2124         if(data) strncpy(ARG2,data,CONFIG_STRING_LEN); \
2125         if(data2) strncpy(ARG3,data2,CONFIG_STRING_LEN); \
2126         printf("CHECK_SET_PARM, match found, input cong string %s %s\n", ARG2, ARG3); \
2127         continue; \
2128         } \
2129     } while(0)
2130
2131 unsigned char hex2dec(char *p_s)
2132 {
2133   int val;
2134   sscanf(p_s,"%x",&val);
2135  return val&0xff;
2136 }
2137 void parse_one_mac(char * p_mac_str, unsigned char *p_mac)
2138 {
2139     int index = 0;
2140     int i;
2141     char *pch = strtok (&(p_mac_str[0]),"-");
2142
2143     while (pch != NULL)
2144     {
2145          printf ("%s\n",pch);
2146          p_mac[index] = hex2dec(pch);
2147          index++;
2148          pch = strtok (NULL,"-");
2149     }
2150      printf("index value : %d\n", index);
2151     for (i=0; i<6;i++)
2152          printf("************mac0[%d]: 0x%x\n",i,  p_mac[i]);
2153 }
2154
2155 void parse_one_ip(char * p_ip_addr_str, unsigned char * p_ip)
2156 {
2157     int index = 0;
2158     int i;
2159     char * pch = strtok (&p_ip_addr_str[0],".");
2160
2161      while (pch != NULL)
2162      {
2163         printf ("xxxxx: %s\n",pch);
2164         p_ip[index] = atoi(pch);
2165         index++;
2166         pch = strtok (NULL,".");
2167     }
2168     printf("index value : %d\n", index);
2169     for (i=0; i<4;i++)
2170         printf("************ip[%d]: 0x%x\n",i, p_ip[i]);
2171
2172
2173 }
2174
2175 void parse_mac_address(netTestConfigFile_t *pConfig)
2176 {
2177     if (strlen(&pConfig->mac0[0]))
2178         parse_one_mac(&pConfig->mac0[0],&config.mac0[0]);
2179     if (strlen(&pConfig->mac1[0]))
2180         parse_one_mac(&pConfig->mac1[0],&config.mac1[0]);
2181 }
2182 void parse_ip_address(netTestConfigFile_t *pConfig)
2183 {
2184     if (strlen(&pConfig->ip0[0]))
2185         parse_one_ip(&pConfig->ip0[0],&config.ip0.ipv4[0]);
2186     if (strlen(&pConfig->ip1[0]))
2187         parse_one_ip(&pConfig->ip1[0],&config.ip1.ipv4[0]);
2188     if (strlen(&pConfig->ip2[0]))
2189         parse_one_ip(&pConfig->ip2[0],&config.ip2.ipv4[0]);
2190     if (strlen(&pConfig->local_ipsec_ip[0]))
2191         parse_one_ip(&pConfig->local_ipsec_ip[0],&config.local_ipsec_ip.ipv4[0]);
2192     if (strlen(&pConfig->remote_ipsec_ip[0]))
2193     parse_one_ip(&pConfig->remote_ipsec_ip[0],&config.remote_ipsec_ip.ipv4[0]);
2194 }
2195
2196
2197 void parse_ipsec_mode(netTestConfigFile_t *pConfig)
2198 {
2199
2200     printf("parse_ipsec_mode, string length %d\n", strlen(&pConfig->ipsec_mode_rx));
2201     if (strlen(&pConfig->ipsec_mode_rx[0]))
2202     {
2203         if (strcmp(pConfig->ipsec_mode_rx, "SIDEBAND") == 0)
2204         {
2205             config.ipsec_mode_rx = IPSEC_MODE_RX_SIDEBAND;
2206         }
2207         else if (strcmp(pConfig->ipsec_mode_rx, "INFLOW") == 0)
2208         {
2209             config.ipsec_mode_rx = IPSEC_MODE_RX_INFLOW;
2210         }
2211         else
2212             printf("parse_ipsec_mode(), invalid RX ipsec mode in config file \n");
2213     }
2214
2215     if (strlen(&pConfig->ipsec_mode_tx[0]))
2216     {
2217         if (strcmp(pConfig->ipsec_mode_tx, "SIDEBAND") == 0)
2218         {
2219             config.ipsec_mode_tx = IPSEC_MODE_TX_SIDEBAND;
2220         }
2221         else if (strcmp(pConfig->ipsec_mode_tx, "INFLOW") == 0)
2222         {
2223             config.ipsec_mode_tx = IPSEC_MODE_TX_INFLOW;
2224         }
2225     else
2226         printf("parse_ipsec_mode(), invalid TX ipsec mode in config file \n");
2227     }
2228
2229     printf("parse_ipsec_mode(): RX mode %d\n", config.ipsec_mode_rx);
2230     printf("parse_ipsec_mode(): TX mode %d\n", config.ipsec_mode_tx);
2231
2232
2233 }
2234
2235 #ifdef EXPERIMENTAL
2236 int n_routes=0;
2237 int n_dst_ips=0;
2238 void parse_routes(netTestConfigFile_t *pConfig)
2239 {
2240 int i;
2241 int said=0;
2242 for(i=0;i<MAX_ROUTES;i++)
2243 {
2244    int port;
2245    if (pConfig->routes[i][0])
2246    {
2247       port=atoi(&pConfig->ports[i][0]);
2248       if((port<1)||(port>2)) continue; //bad port #: only 1 or 2 valid
2249       if(strncmp(&pConfig->routes[i][0],"MAC",3)==0)
2250       {
2251          routes[i].out_port = port;
2252          parse_one_mac(&pConfig->routes[i][3],&routes[i].out_mac[0]);
2253          memcpy(&routes[i].out_mac[6], ((port==1) ?&config.mac0[0]: &config.mac1[0] ),6);
2254          routes[i].out_mac[12]=0x08;
2255          routes[i].out_mac[13]=0x00;
2256          routes[i].sec_ptr=NULL;
2257          n_routes+=1;
2258       }
2259       else if (strncmp(&pConfig->routes[i][0],"SA",2)==0)
2260       {
2261          said=atoi(&pConfig->routes[i][2]) ;
2262          routes[i].sec_ptr=&sa_info[said];
2263          n_routes+=1;
2264       }
2265    }
2266 }
2267 our_router = route_init();
2268 for (i=0;i<MAX_ROUTES;i++)
2269 {
2270   unsigned long ip_be;
2271   int route_index;
2272   if (pConfig->dst_ips[i][0])
2273   {
2274      parse_one_ip(&pConfig->dst_ips[i][0],(unsigned char *)&ip_be);
2275      sscanf(&pConfig->paths[i][0],"route%d",&route_index);
2276      route_add(our_router,&ip_be,&routes[route_index]);
2277      n_dst_ips+=1;
2278   }
2279 }
2280 printf(">Route DB built.  %d entries\n",n_dst_ips);
2281 }
2282 #endif
2283 static void parse_config_file(FILE * fpr, netTestConfigFile_t *pConfig)
2284 {
2285     char line[MAX_LINE_LENGTH + 1];
2286     int i;
2287
2288     char *key, *data, *ep, *data2;
2289     char tokens[] = " :=;\n";
2290     char temp_str[50];
2291     memset(line, 0, MAX_LINE_LENGTH + 1);
2292     memset(pConfig, 0, sizeof(netTestConfigFile_t));
2293     while (fgets(line, MAX_LINE_LENGTH + 1, fpr))
2294     {
2295         if(line[0]=='#') continue; //skip comment
2296         key  = (char *)strtok(line, tokens);
2297         data = (char *)strtok(NULL, tokens);
2298         data2 = (char *)strtok(NULL, tokens);
2299         if (!key) continue;
2300         if (!data) continue;
2301
2302         if(strlen(data) == 0)
2303         {
2304             continue;
2305         }
2306
2307          CHECK_SET_PARAM(INIT_CONFIG_MAC0,&(pConfig->mac0[0]));
2308          CHECK_SET_PARAM(INIT_CONFIG_MAC1,&(pConfig->mac1[0]));
2309          CHECK_SET_PARAM(INIT_CONFIG_IP0,&(pConfig->ip0[0]));
2310          CHECK_SET_PARAM(INIT_CONFIG_IP1,&(pConfig->ip1[0]));
2311          CHECK_SET_PARAM(INIT_CONFIG_IP2,&(pConfig->ip2[0]));
2312          CHECK_SET_PARAM(INIT_CONFIG_LOCAL_IPSEC_IP,&(pConfig->local_ipsec_ip[0]));
2313          CHECK_SET_PARAM(INIT_CONFIG_REMOTE_IPSEC_IP,&(pConfig->remote_ipsec_ip[0]));
2314          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_RX,&(pConfig->ipsec_mode_rx[0]));
2315          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_TX,&(pConfig->ipsec_mode_tx[0]));
2316          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_IF_NO,&(pConfig->ipsec_if_no[0]));
2317 #ifdef EXPERIMENTAL
2318     for(i=0;i<MAX_ROUTES;i++)
2319     {
2320         sprintf(temp_str,"route%d",i);
2321         CHECK_SET_PARAM2(temp_str,&pConfig->routes[i][0],&pConfig->ports[i][0] );
2322     }
2323     for(i=0;i<MAX_ROUTES;i++)
2324     {
2325         sprintf(temp_str,"dstip%d",i);
2326         CHECK_SET_PARAM2(temp_str,&pConfig->dst_ips[i][0],&pConfig->paths[i][0] );
2327     }
2328 #endif
2329
2330     }
2331     parse_mac_address(pConfig);
2332
2333     parse_ip_address(pConfig);
2334
2335     parse_ipsec_mode(pConfig);
2336 #ifdef EXPERIMENTAL
2337      if (strlen(&pConfig->ipsec_if_no[0]))
2338         config.ipsec_if_no = atoi(&pConfig->ipsec_if_no[0]);
2339     parse_routes(pConfig);
2340 #endif
2341 }
2342
2343 static  netTestConfigFile_t config_file;
2344 /***************************************
2345  ********** test driver*****************
2346  ***************************************/
2347 int main(int argc, char **argv)
2348 {
2349     int err,i;
2350     rlim_t oss,ss = 1024*1024;
2351     struct rlimit rl;
2352
2353     Pktlib_HeapCfg      heapCfg;
2354     int32_t             errCode;
2355     Pktlib_HeapIfTable*  pPktifTable;
2356
2357     FILE * fpr = NULL;
2358
2359
2360
2361     err= getrlimit(RLIMIT_STACK,&rl);
2362     if (!err) printf(" stack limit = %d\n",rl.rlim_cur); else printf("getrlimit failed\n");
2363 #if 0
2364     rl.rlim_cur = ss;
2365     err=setrlimit(RLIMIT_STACK,&rl);
2366 i   f (!err) printf("set stack to %d\n",rl.rlim_cur); else printf("setrlimit failed\n");
2367 #endif
2368
2369
2370     if (argc>=2)  np2process = atoi(argv[1]);
2371         printf("*************** np2process %d\n", np2process);
2372     if (np2process<0) np2process = NP; /* default */
2373     if (argc==3)  perslow = atoi(argv[2]);
2374     if ((perslow<0)||(perslow>100)) perslow=PERSLOW;//default
2375     if (argc>3) {printf("net_test  <no of pkts to process> <percent slow path>\n"); exit(1);}
2376 #if 1
2377
2378 #if 0
2379     if (argc >= 2)
2380     {
2381         fpr = fopen(argv[2], "r");
2382         if (fpr == NULL)
2383         {
2384             printf("Error in opening %s input file\n", argv[2]);
2385         }
2386     }
2387     else
2388 #endif
2389     {
2390         fpr = fopen(input_file_name, "r");
2391         if (fpr == NULL)
2392         {
2393             printf("Error in opening %s input file\n", input_file_name);
2394         }
2395         else
2396         {
2397             parse_config_file(fpr,&config_file);
2398         }
2399     }
2400
2401 #endif
2402
2403     memset(&sa_info, 0, sizeof(sa_info));
2404
2405
2406 //real mode, so update our test packet mac header and ip header
2407 if (pktloopback==0)
2408 {
2409 memcpy(&testPkt,&real_mac_header[0],14); //overwrite test pkt mac address
2410 memcpy(&testPkt[26],&real_ip_addr[0],8);//overrite test pkt ip addresses
2411 }
2412 #if 0
2413 our_router = route_init();
2414 for (i=0;i<n_dst_ips;i++)
2415 {
2416   route_add(our_router,&ip[i],&routes[i]);
2417 }
2418 #endif
2419
2420 /*******************************************/
2421 /*************NETAPI STARTUP****************/
2422 /*******************************************/
2423
2424 /* create netapi */
2425 netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
2426
2427 /* open the main heap */
2428 OurHeap = Pktlib_findHeapByName("netapi");
2429 if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}
2430
2431 /* create two secondary heaps */
2432 /* Initialize the heap configuration. */
2433 memset ((void *)&heapCfg, 0, sizeof(Pktlib_HeapCfg));
2434
2435 pPktifTable = netapi_getPktlibIfTable();
2436 /* Populate the heap configuration */
2437 heapCfg.name                = "netapi-small";
2438 heapCfg.memRegion           = NETAPI_GLOBAL_REGION;
2439 heapCfg.sharedHeap          = 1;
2440 heapCfg.useStarvationQueue  = 0;
2441 heapCfg.dataBufferSize      = 512;
2442 heapCfg.numPkts             = 64;
2443 heapCfg.numZeroBufferPackets= 0;
2444 heapCfg.heapInterfaceTable.data_malloc  = pPktifTable->data_malloc;
2445 heapCfg.heapInterfaceTable.data_free    = pPktifTable->data_free;
2446 heapCfg.dataBufferPktThreshold   = 0;
2447 heapCfg.zeroBufferPktThreshold   = 0;
2448
2449 specialSmall = Pktlib_createHeap(&heapCfg, &errCode);
2450 heapCfg.name                = "netapi-big";
2451 heapCfg.dataBufferSize      = 1600;
2452 specialLarge = Pktlib_createHeap(&heapCfg, &errCode);
2453 //register these heaps so poll routine will include their garbage queues.
2454 netapi_registerHeap(netapi_handle, specialSmall);
2455 netapi_registerHeap(netapi_handle, specialLarge);
2456
2457 #ifdef REASSEMBLE_BENCH
2458 our_reassemble_bench(2);
2459 exit(1);
2460 #endif
2461
2462 #ifndef EXPERIMENTAL
2463 /* create a pktio channel */
2464 our_chan=pktio_create(netapi_handle,"our1stq",(PKTIO_CB) recv_cb_bench, &our_chan_cfg,&err);
2465 if (!our_chan) {printf("pktio create failed err=%d\n",err); exit(1);}
2466 #endif
2467
2468 /* open netcp default tx, rx queues */
2469 netcp_tx_chan= pktio_open(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
2470 if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}
2471 #ifdef EXPERIMENTAL
2472 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_router, &netcp_rx_cfg,  &err);
2473 #else
2474 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
2475 #endif
2476 if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}
2477
2478 #ifndef EXPERIMENTAL
2479 /* create a pktio channel for specially classified pkts */
2480 netcp_rx_chan2= pktio_create(netapi_handle, "classq", (PKTIO_CB) recv_cb, &netcp_rx_cfg2,  &err);
2481 if (!netcp_rx_chan2) {printf("pktio create RX2 failed err=%d\n",err); exit(1);}
2482
2483 /* open netcp default tx, rx queues for sideband crypto */
2484 netcp_sb_tx_chan= pktio_open(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
2485 if (!netcp_sb_tx_chan) {printf("pktio open SB TX failed err=%d\n",err); exit(1);}
2486 netcp_sb_rx_chan= pktio_open(netapi_handle, NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
2487 if (!netcp_sb_rx_chan) {printf("pktio open SB RX failed err=%d\n",err); exit(1);}
2488 #endif
2489
2490 printf("net_test> %d bytes left in our CMA area\n", netapi_getBufMemRemainder());
2491 /* create scheduler instance */
2492 our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
2493 if (!our_sched) {printf("sched create failed\n"); exit(1);}
2494
2495 #if 0
2496 /********************************************
2497 * Basic pkt loopback test
2498 *********************************************/
2499 printf("...running pure push/pop benchmark\n");
2500 our_pktio_bench(1000);
2501 our_pktio_bench(1000);
2502 our_pktio_bench(1000);
2503 our_pktio_bench(1000);
2504 our_pktio_bench(1000);
2505 /*********************************************/
2506 #endif
2507
2508
2509
2510
2511 /* add mac intefaces */
2512 netcp_cfgCreateMacInterface(
2513                   netapi_handle,
2514                   &config.mac0[0],
2515                   0,0,
2516                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
2517                   (NETCP_CFG_VLAN_T ) NULL ,  //future
2518                   1,
2519                   &err);
2520 if (err) {printf("addmac0 failed %d\n",err); exit(1); }
2521
2522 //attach an IP to this interface
2523 ip_rule0=netcp_addIp(
2524                   netapi_handle,
2525                   0,
2526                   nwal_IPV4,
2527                   &config.ip0,
2528                   NULL,  //all IP
2529                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,
2530                   &err
2531                   );
2532 if (err) {printf("addip0 failed %d\n",err); exit(1); }
2533
2534 //create a 2nd mac instance
2535 netcp_cfgCreateMacInterface(
2536                   netapi_handle,
2537                   &config.mac1[0],
2538                   1,1,
2539                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
2540                   (NETCP_CFG_VLAN_T ) NULL ,  //future
2541                   1,
2542                   &err);
2543 if (err) {printf("addmac1 failed %d\n",err); exit(1); }
2544
2545 //attach an IP to this interface
2546 ip_rule1=netcp_addIp(
2547                   netapi_handle,
2548                   1,
2549                   nwal_IPV4,
2550                   &config.ip1,
2551                   NULL,  //all IP
2552                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,
2553                   &err
2554                   );
2555 if (err) {printf("addip1 failed %d\n",err); exit(1); }
2556
2557 #ifndef EXPERIMENTAL
2558 //attach 2 classifiers to iface 0, ip0
2559 class_0_cfg.u.c_l4.ip = ip_rule0;
2560 class_0 =  netcp_cfgAddClass(netapi_handle,
2561                              &class_0_cfg,
2562                              NULL,
2563                              NETCP_CFG_ACTION_TO_SW,
2564                              &err);
2565 if (err) {printf("addclass0 failed %d\n",err); exit(1);}
2566
2567 class_1_cfg.u.c_l4.ip = ip_rule0;
2568 class_1 =  netcp_cfgAddClass(netapi_handle,
2569                              &class_1_cfg,
2570                              NULL,
2571                              NETCP_CFG_ACTION_TO_SW,
2572                              &err);
2573 if (err) {printf("addclass1 failed %d\n",err); exit(1);}
2574
2575
2576 //3rd classifier has a different IP and route
2577 class_2_cfg.u.c_l3_l4.ip_addr = &config.ip2;
2578
2579 //create specialFlow for this classifier
2580 {
2581 Pktlib_HeapHandle heaps[2];
2582 int sizes[2];
2583 heaps[0]= specialSmall;
2584 heaps[1]= specialLarge;
2585 #define SPECIAL_SOP_OFF 128
2586 sizes[0]=512-SPECIAL_SOP_OFF;
2587 sizes[1]=1600-SPECIAL_SOP_OFF;
2588 #if 0
2589 specialFlow = netcp_cfgAddFlow( netapi_handle,
2590                                 2,
2591                                 heaps,
2592                                 sizes,
2593                                 SPECIAL_SOP_OFF,  //offset to start rx is 128
2594                                 &err);
2595 if (err) {printf("add flow failed\n", err); exit(1);}
2596 #endif
2597 }
2598 #if 0
2599 //special route for this classifier:  different flow + destination q
2600 class2_route.p_dest_q = netcp_rx_chan2;
2601 class2_route.p_flow = specialFlow;
2602 class_2 = netcp_cfgAddClass(netapi_handle,
2603                             &class_2_cfg,
2604                             (void*) &class2_route,
2605                             NETCP_CFG_ACTION_TO_SW,
2606                             &err);
2607 if (err) {printf("addclass2 failed %d\n",err); exit(1);}
2608 #endif
2609
2610 #endif
2611 //security stuff
2612     p_trie_sa = trie_new();
2613    if (!p_trie_sa) {printf("trie alloc for SA  failed\n"); exit(1);}
2614
2615
2616
2617     for (i=0; i < MAX_SEC_INDEX;i++)
2618     {
2619         ourRXKeyParams[i].pEncKey = &ourEncrKey[0];
2620         ourRXKeyParams[i].pAuthKey = &ourAuthKey[0];
2621         memcpy(&(rx_sa[i].src), &config.remote_ipsec_ip,4);
2622         memcpy(&(rx_sa[i].dst), &config.local_ipsec_ip,4);
2623
2624         build_sa_db(i);
2625         sa_info[i].rx_tunnel = netapi_secAddSA(
2626             netapi_handle,
2627             config.ipsec_if_no, //iface #0
2628             &rx_sa[i],
2629             &ourRXKeyParams[i],
2630             config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND ? NETAPI_SEC_SA_SIDEBAND: NETAPI_SEC_SA_INFLOW,
2631                 NULL,  //use default route
2632             &(sa_info[i].rx_data_mode_handle),
2633             &(sa_info[i].rx_inflow_mode_handle),
2634             &err);
2635         if (err) {printf("addRxSa failed %d\n",err); exit(1);}
2636
2637     if (config.ipsec_mode_rx == IPSEC_MODE_RX_INFLOW)
2638     {
2639         //assume inner and outer ip is the same
2640         rx_policy[i]= netapi_secAddRxPolicy( netapi_handle,
2641                          sa_info[i].rx_tunnel,  //link to tunnel above
2642                          4,         //ipv4
2643                          &config.remote_ipsec_ip, //src -> them
2644                          &config.local_ipsec_ip,  //dst -> us
2645                         NULL,  // no qualifiers
2646                         NULL,  //default route
2647                          &err);
2648         if (err) {printf("addSaPolicy failed  %d, for index %d\n",err,i); exit(1);}
2649     }
2650     else
2651         rx_policy[i] = 0;
2652     }
2653
2654 //tx SA
2655 //security stuff
2656      for (i=0; i < MAX_SEC_INDEX;i++)
2657     {
2658     ourTXKeyParams[i].pEncKey = &ourEncrKey[0];
2659     ourTXKeyParams[i].pAuthKey = &ourAuthKey[0];
2660     memcpy(&(tx_sa[i].src), &config.local_ipsec_ip,4);
2661     memcpy(&(tx_sa[i].dst), &config.remote_ipsec_ip,4);
2662     sa_info[i].tx_tunnel = netapi_secAddSA( netapi_handle,
2663                  0, //iface #0
2664                 &(tx_sa[i]),
2665                 &ourTXKeyParams[i],
2666                 config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND ? NETAPI_SEC_SA_SIDEBAND: NETAPI_SEC_SA_INFLOW,
2667                 NULL,  //use default route
2668                 &(sa_info[i].tx_data_mode_handle),
2669                 &(sa_info[i].tx_inflow_mode_handle),
2670                 &err);
2671 if (err) {printf("addTxSa failed %d\n",err); exit(1);}
2672
2673     }
2674 #ifdef TEST_TIMERS
2675 //timers
2676 ourTimerBlock = netapi_TimerGroupCreate(
2677         netapi_handle,
2678         "our1sttimer",
2679         our_timer_cb,
2680         0,    //1 if timers local to thread
2681         0,    //1 if expect to cancel
2682         netapi_getTicksPerSec()/1000,  /* 1 msc resolution for these timers */
2683         netapi_getTicksPerSec()/5000, /* would like .5 msc tolerence */
2684         10,  //small # of timers to test garbage collection
2685         &err);
2686 if (err) {printf("timergroupcreate failed %d\n",err); exit(1);}
2687
2688 //start a couple of timers
2689 t1 = netapi_TimerGroupStartTimer(
2690         ourTimerBlock,
2691         (void *) 1,
2692         100LL,  //timer group ticks
2693         &err);
2694 if (err) {printf("timerstart failed %d\n");}
2695 t2 = netapi_TimerGroupStartTimer(
2696         ourTimerBlock,
2697         (void *) 2,
2698         200LL,  //timer group ticks
2699         &err);
2700 if (err) {printf("timerstart failed %d\n");}
2701 t3 = netapi_TimerGroupStartTimer(
2702         ourTimerBlock,
2703         (void *) 3,
2704         300LL,  //timer group ticks
2705         &err);
2706 if (err) {printf("timerstart failed %d\n");}
2707 #endif
2708 netcp_cfgReqStats(netapi_handle, our_stats_cb, 1,&err);
2709 if (err!=0) {printf("stats req failed\n");}
2710
2711 /*********************************************/
2712 /*****************end NETAPI STARTUP**********/
2713 /*********************************************/
2714
2715
2716 #if 0
2717 /********************************************
2718 * Basic pkt loopback test
2719 *********************************************/
2720 printf("...runnining pure push/pop benchmark\n");
2721 our_pktio_bench(100);
2722 #endif
2723
2724 /**************unused stuff******************/
2725 #if 0
2726 /* create TRIE */
2727 P_trie = trie_new();
2728 if (!P_trie) {printf("trie alloc failed\n"); exit(1);}
2729
2730 nat = (HEAD_T *) malloc(NE * sizeof(HEAD_T));
2731 if (!nat) {printf("malloc of nat table failed\n"); exit(1);}
2732
2733 //gen_pkts(np2process<NP ? np2process:NP);
2734 n_pkt= np2process;
2735
2736 /* build table */
2737 build_table(P_trie);
2738
2739
2740 /* processing loop: get pkt, check it, look up in table, copy new header,
2741    send packet */
2742 srand((unsigned) np2process);
2743 #endif
2744
2745 /*********************************************/
2746 /**************Entry point into scheduler ****/
2747 /*********************************************/
2748 netapi_schedWaitForEvents(our_sched, &err);
2749
2750 /* done */
2751 our_stats_cb(netapi_handle, NULL);
2752
2753
2754 #define DO_FAST_POLL
2755 #ifdef DO_FAST_POLL
2756 //example_fast_pushpop(OurHeap, 500);
2757 //example_fast_poll(netcp_rx_chan,20000);
2758 #endif
2759
2760 /*************************************************
2761  ************CLEAN UP****************************
2762  ************************************************/
2763
2764 #ifndef EXPERIMENTAL
2765 //delete Classifiers
2766 netcp_cfgDelClass(netapi_handle, class_0, &err);
2767 netcp_cfgDelClass(netapi_handle, class_1, &err);
2768 //netcp_cfgDelClass(netapi_handle, class_2, &err);
2769
2770 #if 0
2771 //delete flow
2772 netcp_cfgDelFlow(netapi_handle, specialFlow, &err);
2773 #endif
2774 #endif
2775 #if 1
2776 //delete policy
2777      for (i=0; i < MAX_SEC_INDEX;i++)
2778     {
2779         if (rx_policy[i])
2780             netapi_secDelRxPolicy(netapi_handle, rx_policy[i], &err);
2781
2782         //delete tunnels
2783         netapi_secDelSA(netapi_handle, 0, sa_info[i].rx_tunnel, &err);
2784         netapi_secDelSA(netapi_handle, 0, sa_info[i].tx_tunnel, &err);
2785 #endif
2786     }
2787 //delete IPs and MAC Interfacess
2788 netcp_cfgDelIp(netapi_handle, 0, 0, NULL, NULL, ip_rule0, &err);
2789 netcp_cfgDelIp(netapi_handle, 1, 0, NULL, NULL, ip_rule1, &err);
2790 netcp_cfgDelMac(netapi_handle,0,&err);
2791 netcp_cfgDelMac(netapi_handle,1,&err);
2792
2793
2794 //close pktio channels we opened
2795 pktio_close(netcp_tx_chan ,&err);
2796 pktio_close(netcp_rx_chan ,&err);
2797 #ifndef EXPERIMENTAL
2798 pktio_close(netcp_sb_tx_chan ,&err);
2799 pktio_close(netcp_sb_rx_chan ,&err);
2800
2801 //clear pktio channel we created
2802 pktio_control(our_chan, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);
2803 pktio_control(netcp_rx_chan2, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);
2804
2805 //delete pktio channels we created
2806 pktio_delete(our_chan, &err);
2807 pktio_delete(netcp_rx_chan2,&err);
2808 #endif
2809 netapi_shutdown(netapi_handle);
2810
2811 }
2812
2813 //EXAMPLE FAST POLL
2814 /* PLD */
2815 void netapi_pld(void * x)
2816 {
2817            asm volatile("pld [r0]");
2818 }
2819 #include "ti/drv/nwal/nwal_util.h"
2820
2821 #define M 1008
2822 static int l3_off[M], l4_off[M], L3_chk_ok[M], L4_chk_ok[M], len[M] ;
2823 static nwal_AppId appid[M];
2824 static unsigned char * buf[M];
2825 #define N2POLL 8 //batch size
2826 #define NTOPOP 190
2827 Ti_Pkt * pHd[NTOPOP];
2828 void example_fast_pushpop(Pktlib_HeapHandle h , int n_trials)
2829 {
2830 int i,j;
2831 unsigned long t1;
2832 unsigned long t2;
2833 unsigned long sumf=0;
2834 unsigned long sumt=0;
2835 unsigned long sump=0;
2836 #define NTOPOP 190
2837 Ti_Pkt * tempVA;
2838 Qmss_QueueHnd freeQ=Pktlib_getInternalHeapQueue(h);
2839
2840 //n_trials of NTOPOP actions
2841 for(i=0;i<n_trials;i++)
2842 {
2843     //raw pop
2844     t1= netapi_timing_start();
2845     pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (freeQ));
2846     for(j=1;j<NTOPOP;j++)
2847     {
2848        tempVA  =  _Osal_qmssPhyToVirt(pHd[j-1]);
2849        netapi_pld(tempVA);
2850         //__builtin_prefetch(tempVA);
2851        pHd[j] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (freeQ));
2852        sumf+= (int) (   ((Cppi_HostDesc *) tempVA)->origBuffPtr -
2853                   ((Cppi_HostDesc *) tempVA)->buffPtr);
2854     }
2855     tempVA  =  _Osal_qmssPhyToVirt(pHd[j-1]);
2856     sumf+= (int) (   ((Cppi_HostDesc *) tempVA)->origBuffPtr -
2857                   ((Cppi_HostDesc *) tempVA)->buffPtr);
2858     t2=netapi_timing_stop();
2859     sumt+= (t2-t1);
2860
2861     //invalidate/wb
2862     for(j=0;j<NTOPOP;j++)
2863     {
2864         tempVA  =  _Osal_qmssPhyToVirt(pHd[j]);
2865         netapi_utilCacheWbInv(tempVA,128);
2866     }
2867
2868     //raw push
2869     t1=netapi_timing_start();
2870     for(j=0;j<NTOPOP;j++)
2871     {
2872         PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
2873                                              (void *) pHd[j],
2874                                              128);
2875     }
2876     t2=netapi_timing_stop();
2877     sump += (t2-t1);
2878 }
2879 printf("\nfast poppush: np=%d  pop=%d  push=%d sumf=%d\n", (n_trials*NTOPOP),
2880         sumt/(n_trials*NTOPOP),  sump/(n_trials*NTOPOP), sumf);
2881 sleep(1);
2882 return;
2883 }
2884
2885
2886
2887 void example_fast_poll( PKTIO_HANDLE_T * p_pktio, int max_pkts)
2888 {
2889 int j=0;
2890 int jj=0;
2891 int i,k,l=0,ltot=0;
2892 int n= N2POLL; //max # of pkts to poll
2893 Ti_Pkt * tempVA;
2894 pasahoLongInfo_t* pinfo;
2895 unsigned long t1;
2896 unsigned long t2;
2897 unsigned long t11;
2898 unsigned long t12;
2899 unsigned long np;
2900 unsigned long sumt=0;
2901 unsigned long sumf=0;
2902 unsigned long sump=0;
2903 unsigned long totlen=0;
2904 int max_batch=0;
2905
2906 //this should  be done once and saved
2907 Qmss_QueueHnd rxQ= PKTIO_GET_DEFAULT_NETCP_Q(p_pktio);
2908 Qmss_QueueHnd freeQ;
2909 //loop forever
2910 for(;max_pkts>0;)
2911 {
2912     t1= netapi_timing_stop();
2913     pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
2914     if (!pHd[0]) continue;
2915     //got pkt
2916     for(i=1;(i<n) && (pHd[i-1]);i++)
2917     {
2918         //convert previous descriptor PA -> VA
2919         tempVA  =  Osal_qmssPhyToVirt(pHd[i-1]);
2920
2921         //try and preload desriptor
2922          __builtin_prefetch(tempVA);
2923         //netapi_pld(tempVA);
2924
2925         //read next descriptor from queue
2926         pHd[i] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
2927 #if 1
2928         /* extract some meta data */
2929         Cppi_getData (Cppi_DescType_HOST, (Cppi_Desc*)tempVA, &buf[jj], &len[jj]);
2930         pinfo =  nwal_mGetProtoInfo(tempVA);
2931         l3_off[jj]= nwal_mGetL3OffBytes(pinfo);
2932         l4_off[jj]= nwal_mGetL4Offset(pinfo);
2933         if(nwal_mGetAppidFmPkt(tempVA,&appid[jj]) != nwal_TRUE)
2934         {
2935             printf("ERROR!!!! AppID not available in incoming packet \n");
2936         }
2937 //#define VERIFY_SOP
2938 #ifdef VERIFY_SOP
2939   if (sump < 200)  printf("..sop off=%d\n", (int) buf[jj]-
2940            (int)  ((Cppi_HostDesc *) tempVA)->origBuffPtr) ;
2941 #endif
2942 #endif
2943         jj+=1;
2944     }
2945     //finish last pkt in burst
2946     if(pHd[i-1])
2947     {
2948         //convert previous descriptor PA -> VA
2949         tempVA  =  Osal_qmssPhyToVirt(pHd[i-1]);
2950
2951         /* extract some meta data */
2952 #if 1
2953         pinfo =  nwal_mGetProtoInfo(tempVA);
2954         l3_off[jj]= nwal_mGetL3OffBytes(pinfo);
2955         l4_off[jj]= nwal_mGetL4Offset(pinfo);
2956         if(nwal_mGetAppidFmPkt(tempVA,&appid[jj]) != nwal_TRUE)
2957         {
2958             printf("ERROR!!!! AppID not available in incoming packet \n");
2959         }
2960 #endif
2961         //get ptr (Physical address) and length of associate buffer
2962         Cppi_getData (Cppi_DescType_HOST, (Cppi_Desc*)tempVA, &buf[jj], &len[jj]);
2963         jj+=1;
2964     }
2965     t2= netapi_timing_stop();
2966     j+=(pHd[i-1]? i: (i-1)) ;
2967     if (jj>(M-n)) jj=0;
2968     l+=1;  //n batches
2969     ltot+=1;
2970     if(pHd[i-1])
2971     {
2972       if (i>max_batch) max_batch= i;
2973     }
2974     else
2975     {
2976       if( (i-1) >max_batch) max_batch = i-1;
2977     }
2978
2979     //cleanup
2980     //printf("cleanup %d\n",i);
2981     for(k=0;k<i;k++)
2982     {
2983         //cleanup.  need to covert all of desriptor to VA so that i can use freePacket()
2984         //alternative would be to just do cache ops plus descriptor raw push to pktlib
2985         // heap free queue
2986         if(pHd[k])
2987         {
2988
2989         //tempVA=Qmss_osalConvertDescPhyToVirt(pHd[k]);
2990         tempVA  =  Osal_qmssPhyToVirt(pHd[k]);
2991         freeQ=Qmss_getQueueHandle(Cppi_getReturnQueue (Cppi_DescType_HOST, (Cppi_Desc *)tempVA));
2992         netapi_utilCacheWbInv(tempVA,128);
2993         //would need to wbInv buffer also in practice. Also need to walk
2994         // descriptor chain
2995         t11= netapi_timing_stop();
2996        // Pktlib_freePacket(tempVA);
2997         PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
2998                                              (void *) pHd[k],
2999                                              128);
3000
3001         t12= netapi_timing_stop();
3002         sumf += (t12-t11);
3003         }
3004     }
3005     sumt += (t2-t1);
3006     sump +=(pHd[i-1]? i: (i-1));
3007     max_pkts -= (pHd[i-1]? i: (i-1));
3008
3009     //printf("end cleanup %d %d %d\n",sumt,sumf,sump );
3010     if (sump > 10000) {
3011        printf("pkts rx %d batches=%d  appid=%x l3_off=%d l4_off=%d len=%d buf=0x%x rxcycle= %d pkts/batchx1000=%d maxbatch=%d cycles per rawpush = %d\n",
3012                   j,ltot, appid[j%M],
3013                   l3_off[j%M],l4_off[j%M],
3014                   len[j%M],buf[j%M],
3015                    sumt/sump,  (sump*1000)/l, max_batch,
3016                    sumf/sump);
3017        sumt=sump=sumf=0;
3018        l=0;
3019     }
3020 }
3021
3022     //cleanup any remaining buffers
3023     for(;;)
3024     {
3025         pHd[0] = (Ti_Pkt *)QMSS_DESC_PTR(PKTIO_QMSS_QUEUE_POP_RAW (rxQ));
3026         if(!pHd[0]) break;
3027         tempVA  =  Osal_qmssPhyToVirt(pHd[0]);
3028         freeQ=Qmss_getQueueHandle(Cppi_getReturnQueue (Cppi_DescType_HOST, (Cppi_Desc *)tempVA));
3029         netapi_utilCacheWbInv(tempVA,128);
3030         PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW (freeQ,
3031                                              (void *) pHd[0],
3032                                              128);
3033     }
3034 }
3035
3036 #ifdef EXPERIMENTAL
3037
3038 static inline void send_it(Ti_Pkt *tip, int len, ROUTE_SEC_T * p_sec)
3039 {
3040   unsigned long st1;
3041   unsigned long st2;
3042   int err=0;
3043   PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
3044   nwalTxPktInfo_t meta_tx2={0};
3045   st1=netapi_timing_start();
3046   if (len<60)
3047   {
3048      unsigned int templen;
3049      char * p_pkt;
3050      len=60;
3051      Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
3052      Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
3053      stats.tx_min+=1;
3054   }
3055   Pktlib_setPacketLen(tip,len);
3056   meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
3057   meta_tx2.startOffset = 0;
3058   meta_tx2.ipOffBytes = 14;
3059   meta_tx2.ploadLen = len ;
3060   if(p_sec)
3061   {
3062        meta_tx2.txFlag1 |= NWAL_TX_FLAG1_DO_IPSEC_CRYPTO ;
3063        meta2.sa_handle=p_sec->tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied
3064        meta_tx2.enetPort=0;
3065        meta_tx2.saOffBytes=14+20;
3066        meta_tx2.saPayloadLen=len-14-20;   //don't include tag, mac and outer header
3067        stats.sec_tx+=1;
3068   }
3069   meta2.u.tx_meta=&meta_tx2;
3070   pktio_send(netcp_tx_chan,tip,&meta2,&err);
3071   stats.tx +=1;
3072   st2=netapi_timing_start();
3073   stats.send_cycles += (unsigned long long) (st2-st1);
3074 }
3075 void recv_cb_router(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
3076                          PKTIO_METADATA_T meta[], int n_pkts,
3077                          uint64_t ts )
3078 {
3079 int i;
3080 int len;
3081 int p;
3082 Ti_Pkt * tip;
3083 unsigned int templen;
3084 char * p_pkt;
3085 HEAD_T temp_head;
3086 unsigned int appid;
3087 IP_HEAD_T th;
3088 ROUTE_SEC_T *sec_data=NULL;
3089 unsigned long t1;
3090 unsigned long t2;
3091 unsigned long ct1;
3092 unsigned long ct2;
3093 unsigned short ip_pl;
3094 int n_c_ops;
3095 t1=netapi_timing_start();
3096 ct1 =Osal_cache_op_measure(&n_c_ops);
3097 for(i=0;i<n_pkts;i++)
3098 {
3099         tip = p_recv[i];
3100         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
3101         len = Pktlib_getPacketLen(tip)-4;//real length, subtract mac trailer
3102         stats.rx+=1;
3103         appid = ((unsigned int)meta[i].u.rx_meta->appId)&0xff000000;
3104         switch(appid)
3105         {
3106            case(NETAPI_NETCP_MATCH_IPSEC):
3107            case(NETAPI_NETCP_MATCH_IPSEC_POLICY):
3108            {
3109              int tailen=12+2;
3110              memcpy(&temp_head,&p_pkt[14],sizeof(HEAD_T));
3111              if (!check_header(&temp_head,&meta[i])) {
3112                 stats.n_bad+=1;
3113                 Pktlib_freePacket(tip);
3114                 continue;
3115              }
3116              tailen+=p_pkt[len-12-2]; //padding length  (12)should come from sec_ptr
3117              p_pkt = &p_pkt[8+16+20];   //16= iv len, should come from sec_ptr
3118              len -= (8+16+20+tailen);  //16= iv len should come from sec ptr
3119
3120              //now check inner headder.
3121              memcpy(&th,&p_pkt[14],20);
3122              if (!check_header(&temp_head,&meta[i])) {
3123                 stats.n_bad+=1;
3124                 Pktlib_freePacket(tip);
3125                 continue;
3126              }
3127              Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
3128              Pktlib_setPacketLen(tip,len);
3129
3130              if (route_pkt(our_router, tip, &th, p_pkt, &len,&sec_data)<0)
3131               {
3132                 stats.n_bad+=1;
3133                 Pktlib_freePacket(tip);
3134              }
3135              else
3136              {
3137                send_it(tip,len,sec_data);
3138              }
3139              break;
3140            }
3141            case(NETAPI_NETCP_MATCH_GENERIC_MAC):
3142               if((p_pkt[12]!=0x8)||(p_pkt[13]!=0x00))
3143               {
3144                 stats.n_new+=1;
3145                 Pktlib_freePacket(tip);
3146                 continue;
3147               }
3148               if (!check_header(&temp_head,&meta[i]))
3149               {
3150                 stats.n_bad+=1;
3151                 Pktlib_freePacket(tip);
3152                 continue;
3153               }
3154               memcpy(&th,&p_pkt[14],20);
3155               ip_pl= (((unsigned char *)&th.w1)[2]<<8) | ((unsigned char *)&th.w1)[3];
3156               if ((ip_pl+14)<60)
3157               {
3158                 len-= (60-(ip_pl+14));
3159                 stats.rx_min+=1;
3160               }
3161               Pktlib_setPacketLen(tip,len);
3162               if (route_pkt(our_router, tip, &th, p_pkt, &len,&sec_data)<0)
3163               {
3164                 stats.n_bad+=1;
3165                 Pktlib_freePacket(tip);
3166               }
3167               else
3168               {
3169                  send_it(tip,len,sec_data);
3170               }
3171               break;
3172            case(NETAPI_NETCP_MATCH_GENERIC_IP):
3173               Pktlib_freePacket(tip);
3174               stats.n_new=1;
3175               break;
3176            default:
3177               stats.n_new+=1;
3178               Pktlib_freePacket(tip);
3179               break;
3180        }
3181 }
3182 t2=netapi_timing_start();
3183 ct2 =Osal_cache_op_measure(&n_c_ops);
3184 stats.app_cycles +=  (unsigned long long) (t2-t1);
3185 stats.tx_cache_cycles += (unsigned long long) (ct2-ct1);
3186 return;
3187 }
3188 #endif