Merge remote branch 'origin/master' into netapi-keystone2
[keystone-rtos/netapi.git] / 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.
42  *****************************************/
43 #define DAL_REVIEW
44 //#define NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
45 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
46 #define NWAL_ENABLE_SA
47 #endif
48 #define AH_SUPPORT
49 //#define NET_TEST_ENABLE_INFLOW_LOW_LEVEL_API
50 #ifdef NET_TEST_ENABLE_INFLOW_LOW_LEVEL_API
51 #define NWAL_ENABLE_SA
52 #endif
54 //define this for multi-thread
55 #define MULTI_THREAD
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <unistd.h>
59 #include <string.h>
60 #include <signal.h>
61 #include <pthread.h>
63 #include "trie.h"
64 #include "string.h"
65 #include "netapi.h"
66 #include "pktio.h"
67 #include <sys/resource.h>
68 #include "net_test.h"
69 #include <ti/drv/sa/salld.h>
70 //#define EXPERIMENTAL
71 #ifdef EXPERIMENTAL
72 #include "router.c"
73 Trie * our_router;
78 OUR_ROUTE_T routes[MAX_ROUTES]=
79 {
80 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
81 {0,{0x00,0x00,0x0,0x00,0x0,0x0, 0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00},0},
82 {0,{0xD4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x14,0x02,0x08,0x00},0},
83 {0,{0x00,0x15,0x60,0xa1,0xf7,0xbe, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0},
84 {0,{0xd4,0xbe,0xd9,0x00,0xd3,0x7e, 0x00,0x01,0x02,0x03,0x04,0x05,0x08,0x00},0}};
86 unsigned int ip[MAX_ROUTES]={BE(0x0a0100c8),BE(0x0a00000a),BE(0x0a02000a),BE(0xc0a8010a),BE(0x9eda6719)};
88 #endif
90 #ifdef MULTI_THREAD
91     //__thread int our_core;
93     cpu_set_t cpu_set;
94 #endif
97 hplib_spinLock_T stats_lock;
99 //#define TEST_TIMERS
100 static int scnt=0;
101 static int QUIT=0;
102 void mysig(int x)
104   QUIT=1;
105   scnt+=1;
106   printf(">net_test: recv'd signal %d cnt=%d\n",x,scnt);
107   if (scnt > 10) {printf(">net_test: WARNING EXITING WITH PROPER SHUTDOWN, LUTS LEFT ACTIVE\n");exit(1);}
111 static unsigned char all_mac[]={0,0,0,0,0,0};
113 /*************debug********************/
114 void dump_descr(unsigned long *p, int n)
116    printf("--------dump of descriptor %d %x\n", n, (int) p);
117    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]);
118    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]);
119    printf("-----------------------------\n");
121 void dump_header(unsigned long *p, int n, int a, int r)
123    printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);
124    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]);
125    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]);
126    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]);
127    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]);
128    printf("-----------------------------\n");
131 static void  netapi_dump_buf
133     unsigned long *                      buf,
134     uint32_t                      buf_length
137     uint8_t                       count = 0;
138     uint16_t                      dump_size;
139     uint8_t*                     tmp_buf;
140     uint8_t                       row_count;
141     static uint8_t                first = 0;
143     //if(first > 2) return;
145     //first++;
147     dump_size = buf_length ;
149     tmp_buf = (uint8_t *)(buf);
151     printf("netapi *:  - 8 bit word hex Length: %d Start \n",buf_length);
152     do
153     {
154         row_count = (dump_size - count);
156         if(row_count == 0)
157         {
158             break;
159         }
161         if(row_count > 4)
162         {
163             row_count = 4;
164         }
166         switch (row_count)
167         {
168             case 4:
169             {
170                 printf("netapi *:%02d : %02x    %02x    %02x    %02x \n",
171                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2],tmp_buf[3]);
172                 break;
173             }
174             case 3:
175             {
176                 printf("netapi *: %02d : %02x    %02x    %02x \n",
177                       count,tmp_buf[0],tmp_buf[1],tmp_buf[2]);
178                 break;
179             }
181             case 2:
182             {
183                 printf("netapi *: %02d : %02x    %02x \n",
184                       count,tmp_buf[0],tmp_buf[1]);
185                 break;
186             }
188             case 1:
189             {
190                 printf("netapi *: %02d : %02x \n",
191                       count,tmp_buf[0]);
192                 break;
193             }
195             default:
196             {
197                 /* Should never reach here */
198                 printf("netapi *: Internal Error in netapi_dump_buf().Row Count: %d \n",
199                     row_count);
200                 return;
201             }
202         }
204         tmp_buf = tmp_buf + row_count;
205         count = count +  row_count;
207     }while(count < dump_size);
209     printf("netapi *:  - Byte hex Dump End \n");
214 /*****************************************/
217 //************for multi pkt burst  xfer test in loopback mode
218 #define TX_BURST 700 
219 int pktloopback=TUNE_NETAPI_NWAL_ENABLE_PASS_LOOPBACK;
220 nwalTxPSCmdInfo_t   flowPSCmdInfo;
221 nwal_RetValue       nwalRetVal;
223 /* Local Per Process default resourcese maintained at NWAL */
224 nwalLocCxtInfo_t    nwalLocCxt;
226 //this device: 10.0.0.100, mac 0x,01,02,03,04,05  and .. 0x6
228 //test packet, setup for loopback (so dest is ourself)
229 static uint8_t testPkt[] = {
231   /* MAC header */
232   0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
233   0x00, 0xe0, 0xa6, 0x66, 0x57, 0x04,
234   0x08, 0x00,
236   /* IP header */
237   0x45, 0x00,
238   0x00, 0x6c,  /* Length (including this header) */
239   0x00, 0x00, 0x00, 0x00, 0x05, 0x11,
240   0x00, 0x00,  /* Header checksum */
241   0x0a, 0x00, 0x00, 0x0a, 0x0a, 0x00, 0x00, 0x64,
243   /* UDP header */
244   0x12, 0x34, 0x05, 0x55,
245   0x00, 0x58,  /* Length, including this header */
246   0x00, 0x00,  /* Header checksum */
248  /* Payload */
249   0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
250   0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41,
251   0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
252   0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
253   0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
254   0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61,
255   0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
256   0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71,
257   0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
258   0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81
260 };
262 char    input_file_name[] = "net_test_config.txt";
263 #define MAX_LINE_LENGTH 40
265 #define TEST_PAYLOAD_LEN            80
267 #define TEST_PKT_IP_OFFSET_BYTES        14
268 #define TEST_PKT_UDP_OFFSET_BYTES       34
269 #define TEST_PKT_PLOAD_OFFSET_BYTES     42
270 #define TEST_PKT_UDP_HDR_LEN            8
271 /* Offsets to length fields */
272 #define TEST_PKT_OFFSET_IP_LEN      16
273 #define TEST_PKT_OFFSET_UDP_LEN     38
275 #define TEST_PKT_LEN                122
277 /* The pseudo header checksum of the packet except for the 16 bit length */
278 #define TEST_PKT_PSEUDO_HDR_CHKSUM_SANS_LEN  0x0FFC
280 void example_fast_poll( PKTIO_HANDLE_T * p_pktio, int max_pkts);
281 void example_fast_pushpop(Pktlib_HeapHandle p_heap, int ntrials);
283 void recv_cb_router(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
284                          PKTIO_METADATA_T meta[], int n_pkts,
285                          uint64_t ts );
288 //#include "arpa/inet.h"
289 long htonl(long x)
291         long temp = (x&0xff000000)>>24 | (x&0xff0000)>>8 | (x&0xff00)<<8 |  (x&0xff)<<24 ;
292         return temp;
296 unsigned long peek(unsigned long * p)
298   return *p;
302 /********************************************************************
303  *  FUNCTION PURPOSE: Ones complement addition utility
304  ********************************************************************
305  ********************************************************************/
306 uint16_t test_utilOnesComplementAdd (uint16_t v1, uint16_t v2)
308   uint32_t result;
310   result = (uint32_t)v1 + (uint32_t)v2;
311   result = (result >> 16) + (result & 0xffff);
312   result = (result >> 16) + (result & 0xffff);
314   return ((uint16_t)result);
317 /********************************************************************
318  *  FUNCTION PURPOSE: Ones complement checksum utility
319  ********************************************************************
320  ********************************************************************/
321  uint16_t test_utilOnesCompChkSum (uint8_t *p, uint32_t nwords)
323   uint16_t chksum = 0;
324   uint16_t v;
325   uint32_t i;
326   uint32_t j;
328   for (i = j = 0; i < nwords; i++, j+=2)  {
329     v = (p[j] << 8) | p[j+1];
330     chksum = test_utilOnesComplementAdd (chksum, v);
331   }
332   return (chksum);
333 } /* utilOnesCompChkSum */
335 /**************************************************************************************
336  * FUNCTION PURPOSE: Compute ipv4 psudo checksum
337  **************************************************************************************
338  * DESCRIPTION: Compute ipv4 psudo checksum
339  **************************************************************************************/
340 uint16_t test_utilGetIpv4PsudoChkSum (uint8_t *data, uint16_t payloadLen)
342   uint16_t psudo_chksum;
344   psudo_chksum = test_utilOnesCompChkSum (&data[12], 4);
345   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, (uint16_t) data[9]);
346   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, payloadLen);
348   return (psudo_chksum);
350 } /* utilGetIpv4PsudoChkSum */
354 /* net test default configuration */
355 netTestConfig_t config =
357     {0x00,0x01,0x02,0x03,0x05,0x05},
358     {0x00,0x01,0x02,0x03,0x05,0x06},
359     {10, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
360     {10, 0, 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
361     {10, 0, 2, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
362     {192,168 , 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
363     {192,168 , 1, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
364     IPSEC_MODE_RX_SIDEBAND,
365     IPSEC_MODE_TX_SIDEBAND,
366     0
367 };
369 #if 1  //goes with real tx (to laptop) 
370 unsigned char real_mac_header[]={0xd4,0xbe,0xd9,0x00,0xd3,0x7e,
371                       0x00,0x01,0x02,0x03,0x04,0x05,
372                       0x08,0x00};
373 unsigned char real_ip_addr[]={0xa,0x00,0x00,0x64,0xa,0x0,0x0,0xa};
374 #endif
376 #if 0  //goes with loopback
377 unsigned char mac_header[]={0x00,0x01,0x02,0x03,0x04,0x05, 
378                       0x00,0x11,0x22,0x33,0x44,0x55,
379                       0x08,0x00};
380 #endif
381 #define NE 65536 
382 HEAD_T *nat;
384 #define NP 5000
385 int n_pkt = NP;
386 STATS_T stats[TUNE_NETAPI_NUM_CORES];
387 paSysStats_t netcp_stats;
389 Trie * P_trie;
390 Trie *p_trie_sa;
391 HEAD_T pkts[NP];
392 #define PERSLOW  10  //% of pkts that will not be fastpath'd 
393 int perslow= PERSLOW;
395 /*******************************************
396  *************NETAPI OBJECTS***************
397  *****************************************/
398 static NETAPI_CFG_T our_netapi_default_cfg=
400 TUNE_NETAPI_PERM_MEM_SZ,
401 128,  //start of packet offset for hw to place data on rx for default flow
402 TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
403 TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
404 TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
405 64, //#descriptors w/o buffers in default heap
406 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
407 128   ,  //tail room
408 256      //extra room 
409 };
411 Pktlib_HeapHandle ourHeap;
412 Pktlib_HeapHandle specialSmall;
413 Pktlib_HeapHandle specialLarge;
415 PKTIO_HANDLE_T *our_chan;
416 PKTIO_HANDLE_T *netcp_rx_chan;
417 PKTIO_HANDLE_T *netcp_rx_chan2;
418 PKTIO_HANDLE_T *netcp_tx_chan;
419 PKTIO_HANDLE_T *netcp_sb_tx_chan;
420 PKTIO_HANDLE_T *netcp_sb_rx_chan;
421 PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
422 PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
423 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
424 PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
425 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};
426 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};
428 void house(NETAPI_SCHED_HANDLE_T *s);
429 NETAPI_T netapi_handle;
430 NETAPI_SCHED_HANDLE_T * our_sched;
431 #ifdef MULTI_THREAD
432 NETAPI_SCHED_HANDLE_T * scheduler[TUNE_NETAPI_NUM_CORES];
433 #endif
434 NETAPI_SCHED_CONFIG_T our_sched_cfg={
435   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 5000000  //every 5000000 poll loops
436 };
437 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats);
438 void our_stats_cb_mt(NETAPI_T h, paSysStats_t* pPaStats);
441 #ifdef TEST_TIMERS
442 HPLIB_TIMER_GROUP_HANDLE_T ourTimerBlock; 
443 HPLIB_TIMER_T t1;
444 HPLIB_TIMER_T t2;
445 HPLIB_TIMER_T t3;
447 void our_timer_cb( HPLIB_TIMER_GROUP_HANDLE_T th,
448         int n_fired,     //# timers fired
449         HPLIB_TIMER_LIST_T fired_list,
450         uint64_t currentTime);
451 #endif
452 NETCP_CFG_IP_T ip_rule0;
453 NETCP_CFG_IP_T ip_rule1;
454 NETCP_CFG_CLASS_T class_0;
455 NETCP_CFG_CLASS_T class_1;
456 NETCP_CFG_CLASS_T class_2;
457 NETCP_CFG_FLOW_HANDLE_T specialFlow;
460 NETCP_CFG_CLASSIFIER_T class_0_cfg=
462    NETCP_CFG_CLASS_TYPE_L4,
463    {
464         .c_l4={0,0, NWAL_APP_PLOAD_PROTO_UDP, {2500}}
465    }
466 };
468 NETCP_CFG_CLASSIFIER_T class_1_cfg=
470     NETCP_CFG_CLASS_TYPE_L4,
471     {
472        .c_l4= {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2502}}
473    }
474 };
476 NETCP_CFG_ROUTE_T  class2_route=
478 NULL, NULL  //* to be filled in
479 };
480 NETCP_CFG_CLASSIFIER_T class_2_cfg=  
482    NETCP_CFG_CLASS_TYPE_L3_L4,
483    {
484         .c_l3_l4={0,  4 ,0/*fill in below*/ , NULL, NULL,          //L2/L3
485            NWAL_APP_PLOAD_PROTO_UDP, {2504}}   //L4
486    }
487 };
489 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};
491 /* security objects. (for loopback mode) */
492 netTestSA_t sa_info[7];
493 int netapi_algorithm_set = 0;
494 int netapi_sec_sa_mode = 2;
496 NETCP_CFG_IPSEC_POLICY_T rx_policy[7];
500 NETAPI_SEC_SA_INFO_T rx_sa [7] = {
502     NWAL_SA_DIR_INBOUND,
503     0x11111111,  //spi
504     nwal_IpSecProtoESP, //ESP mode
505     nwal_SA_MODE_TUNNEL,  //tunnel mode
506     nwal_IPV4, //v4
507     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
508     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
509     64,/* replayWindow */
510     NWAL_SA_AALG_HMAC_SHA1,
511     NWAL_SA_EALG_AES_CBC,
512     0,0  //na
513 },
515     NWAL_SA_DIR_INBOUND,
516     0x22222222,  //spi
517     nwal_IpSecProtoESP, //ESP mode
518     nwal_SA_MODE_TUNNEL,  //tunnel mode
519     nwal_IPV4, //v4
520     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
521     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
522     64,/* replayWindow */
523     NWAL_SA_AALG_HMAC_SHA2_256,
524     NWAL_SA_EALG_AES_CTR,
525     0,0  //na
526 },
528     NWAL_SA_DIR_INBOUND,
529     0x33333333,  //spi
530     nwal_IpSecProtoESP, //ESP mode
531     nwal_SA_MODE_TUNNEL,  //tunnel mode
532     nwal_IPV4, //v4
533     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
534     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
535     64,/* replayWindow */
536     NWAL_SA_AALG_HMAC_SHA2_256,
537     NWAL_SA_EALG_3DES_CBC,
538     0,0  //na
539 },
541     NWAL_SA_DIR_INBOUND,
542     0x44444444,  //spi
543     nwal_IpSecProtoAH, //ESP mode
544     nwal_SA_MODE_TUNNEL,  //tunnel mode
545     nwal_IPV4, //v4
546     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
547     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
548     64,/* replayWindow */
549     NWAL_SA_AALG_HMAC_MD5,
550     NWAL_SA_EALG_NULL,
551     0,0  //na
552 },
554     NWAL_SA_DIR_INBOUND,
555     0x55555555,  //spi
556     nwal_IpSecProtoESP, //ESP mode
557     nwal_SA_MODE_TUNNEL,  //tunnel mode
558     nwal_IPV4, //v4
559     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
560     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
561     64,/* replayWindow */
562     NWAL_SA_AALG_NULL,
563     NWAL_SA_EALG_AES_GCM,
564     0,0  //na
565 },
567     NWAL_SA_DIR_INBOUND,
568     0x66666666,  //spi
569     nwal_IpSecProtoESP, //ESP mode
570     nwal_SA_MODE_TUNNEL,  //tunnel mode
571     nwal_IPV4, //v4
572     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
573     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
574     64,/* replayWindow */
575     NWAL_SA_AALG_NULL,
576     NWAL_SA_EALG_AES_CCM,
577     0,0  //na
578 },
580     NWAL_SA_DIR_INBOUND,
581     0x77777777,  //spi
582     nwal_IpSecProtoESP, //ESP mode
583     nwal_SA_MODE_TUNNEL,  //tunnel mode
584     nwal_IPV4, //v4
585     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
586     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
587     64,/* replayWindow */
588     NWAL_SA_AALG_AES_XCBC,
589     NWAL_SA_EALG_NULL,
590     0,0  //na
592 };
594 /*tx */
595 NETAPI_SEC_SA_INFO_T tx_sa[7]= {
597     NWAL_SA_DIR_OUTBOUND,
598     0x11111111,  //spi
599     nwal_IpSecProtoESP, //ESP mode
600     nwal_SA_MODE_TUNNEL,  //tunnel mode
601     nwal_IPV4, //v4
602     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
603     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
604     64, /* NA replayWindow */
605     NWAL_SA_AALG_HMAC_SHA1,
606     NWAL_SA_EALG_AES_CBC,
607     0,0  //seq no
608 },
609     {
610     NWAL_SA_DIR_OUTBOUND,
611     0x22222222,  //spi
612     nwal_IpSecProtoESP, //ESP mode
613     nwal_SA_MODE_TUNNEL,  //tunnel mode
614     nwal_IPV4, //v4
615     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
616     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
617     64, /* NA replayWindow */
618     NWAL_SA_AALG_HMAC_SHA2_256,
619     NWAL_SA_EALG_AES_CTR,
620     0,0  //seq no
621 },
623     NWAL_SA_DIR_OUTBOUND,
624     0x33333333,  //spi
625     nwal_IpSecProtoESP, //ESP mode
626     nwal_SA_MODE_TUNNEL,  //tunnel mode
627     nwal_IPV4, //v4
628     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
629     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
630     64, /* NA replayWindow */
631     NWAL_SA_AALG_HMAC_SHA2_256,
632     NWAL_SA_EALG_3DES_CBC,
633     0,0  //seq no
634 },
636     NWAL_SA_DIR_OUTBOUND,
637     0x44444444,  //spi
638     nwal_IpSecProtoAH, //ESP mode
639     nwal_SA_MODE_TUNNEL,  //tunnel mode
640     nwal_IPV4, //v4
641     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */
642     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/
643     64, /* NA replayWindow */
644     NWAL_SA_AALG_HMAC_MD5,
645     NWAL_SA_EALG_NULL,
646 },
648     NWAL_SA_DIR_OUTBOUND,
649     0x55555555,  //spi
650     nwal_IpSecProtoESP, //ESP mode
651     nwal_SA_MODE_TUNNEL,  //tunnel mode
652     nwal_IPV4, //v4
653     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
654     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
655     64,/* replayWindow */
656     NWAL_SA_AALG_NULL,
657     NWAL_SA_EALG_AES_GCM,
658     0,0  //na
659 },
661     NWAL_SA_DIR_OUTBOUND,
662     0x66666666,  //spi
663     nwal_IpSecProtoESP, //ESP mode
664     nwal_SA_MODE_TUNNEL,  //tunnel mode
665     nwal_IPV4, //v4
666     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
667     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
668     64,/* replayWindow */
669     NWAL_SA_AALG_NULL,
670     NWAL_SA_EALG_AES_CCM,
671     0,0  //na
672 },
674     NWAL_SA_DIR_OUTBOUND,
675     0x77777777,  //spi
676     nwal_IpSecProtoESP, //ESP mode
677     nwal_SA_MODE_TUNNEL,  //tunnel mode
678     nwal_IPV4, //v4
679     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */
680     { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/
681     64,/* replayWindow */
682     NWAL_SA_AALG_AES_XCBC,
683     NWAL_SA_EALG_NULL,
684     0,0  //na
686 };
689 static nwalSecKeyParams_t ourTXKeyParams[7] ={
691     32, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
692     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
693     NULL, //set below
694     NULL, //set below
695 },
697     20, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
698     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
699     NULL, //set below
700     NULL, //set below
701 },
703     24, /* encKeySize: DES-CBC: 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
704     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
705     NULL, //set below
706     NULL, //set below
707 },
709     0, /* NULL*/
710     16, /* MD5, 16 bytes */
711     NULL, //set below
712     NULL, //set below
713 },
715     20, /* encKeySize: GCM 16 bytes Encryption Key and 4 bytes Salt */
716     0, /* macKeySize: 0*/
717     NULL, //set below
718     NULL, //set below
719 },
721     19, /* encKeySize: CTR 16 bytes Encryption Key and 3 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
722     0, /* macKeySize 0*/
723     NULL, //set below
724     NULL, //set below
725 },
727     0, /* encKeySize: CTR 16 bytes Encryption Key and 3 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
728     16, /* macKeySize 0*/
729     NULL, //set below
730     NULL, //set below
732 };
734 /* these keys are for aes-ctr and hmac sha2_256 */
735 static nwalSecKeyParams_t ourRXKeyParams[7] ={
737     32, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
738     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA1 */
739     NULL, //set below
740     NULL, //set below
741 },
743     20, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt */
744     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
745     NULL, //set below
746     NULL, //set below
747 },
749     24, /* encKeySize: DES-CBC: 24 bytes:NWAL_SA_EALG_3DES_CBC and 0 bytes Salt*/
750     32, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_SHA2_256 */
751     NULL, //set below
752     NULL, //set below
753 },
755     0, /* NWAL_SA_EALG_NULL*/
756     16, /* NWAL_SA_AALG_HMAC_MD5, 16 bytes */
757     NULL, //set below
758     NULL, //set below
759 },
761     20, /* encKeySize: GCM 16 bytes Encryption Key and 4 bytes Salt */
762     0, /* macKeySize: 0*/
763     NULL, //set below
764     NULL, //set below
765 },
767     19, /* encKeySize: CTR 16 bytes Encryption Key and 3 bytes Salt t*/
768     0, /* macKeySize 0*/
769     NULL, //set below
770     NULL, //set below
771 },
773     0, /* encKeySize: CTR 16 bytes Encryption Key and 3 bytes Salt : 24 bytes:NWAL_SA_EALG_AES_CTR and 0 bytes Salt*/
774     16, /* macKeySize 0*/
775     NULL, //set below
776     NULL, //set below
778 };
781 static uint8_t ourAuthKey[36] =
782         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
783          0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
784          0x20, 0x21, 0x22, 0x23 };
787 static uint8_t ourEncrKey[36] = 
788         {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
789          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
790          0x30, 0x31, 0x32, 0x33 }; 
793 /*************************END NETAPI OBJECTS***********************/
795 #define START_SRC_IP 0x0a00000a
796 #define DST_IP       0xc0a80001
797 #define NEW_START_SRC_IP 0x9eda000a
798 #define DST_PORT 0x555 
799 #define START_SRC_PORT 0x1234
800 #define NEW_START_SRC_PORT 100
801 void update_header(HEAD_T * p_head, int len)
803    unsigned char *p = (unsigned char *) &p_head->udp[1];
804    len -= (20+14);
805    /* update ip checksum */
806    /* update udp checksum */
807    /* update length */
808    *p= (len&0xff00)>>8;
809    *(p+1) = len&0xff;
812 #if 0
813 void gen_pkts(int np)
815 int i;
816 int ip = START_SRC_IP &0xff;
817 int port= START_SRC_PORT;
818 //HEAD_T temp={{0x25000200,0xdead0000,0x80110000,START_SRC_IP,DST_IP},
819 //             {START_SRC_PORT<<16|DST_PORT,0x01ec<<16|0x0000}};
820 HEAD_T temp;
821 memcpy(&temp,&testPkt[0],sizeof(HEAD_T));
823 for(i=0;(i<np) && (i<NP);i++)
824   {
825        memcpy(&pkts[i],&temp,sizeof(temp));
826        update_header(&pkts[i],512);      /* update checksums etc */
827        /* change template for new pkt */
828        ip+=1;
829        if(ip>254) {(ip=START_SRC_IP&0xff); port+=1; }
830        temp.ip[3] = htonl((START_SRC_IP&0xffffff00)| ip);
831        temp.udp[0] = htonl( (temp.udp[0]&0xffff0000)| port);
832        temp.udp[1] = htonl(temp.udp[1]);
833      
834   }
835   n_pkt=np;
837 #endif
839 void build_table(Trie * p_trie)
841 int i;
842 int sport=NEW_START_SRC_PORT; 
843 HEAD_T temp,temp2;
844 KEY_T key;
846 memcpy(&temp,&testPkt[14],sizeof(temp));
848  //insert entry into trie
849 key.src_ip = temp.ip[3];
850 key.dst_ip = temp.ip[4];
851 key.src_port= (temp.udp[0]&0xffff0000)>>16;
852 key.dst_port= (temp.udp[0]&0x0000ffff);
853 trie_insert(p_trie,(char *)&key,sizeof(key), (void *) &nat[0]); //asociate with nat entry 0
855 //build nat table
856 for(i=0;i<100;i++)
858    memcpy(&temp2,&testPkt[14],sizeof(temp));
859    temp2.udp[0] = (temp2.udp[0] & 0xffff0000) |  sport;
860    memcpy(&nat[i], &temp2, sizeof(temp2));
861    sport+= 1;
865 //===========stub transmitter==================
866 void send_pkt(Ti_Pkt *pkt, int len)
868 //just free pkt.  Don't send
869 Pktlib_freePacket((Ti_Pkt*)pkt);
870         return;
873 //==========stub slow path============
874 void slow_path(Ti_Pkt *pkt, int len)
876 // debug: check descriptor for validity by verifying that desciptor link field is null as expected\n");
877          {Ti_Pkt * k= Pktlib_getNextPacket(pkt); if(k != 0) {printf(" slowpath, nexpkt != NULL");}}
878 //just free pkt
879 Pktlib_freePacket((Ti_Pkt*)pkt);
880         return;
882 /* check header */
883 struct LastPktInfo
885 int iface;
886 int ipcsum;
887 int l4csum;
888 } ;
889 static struct LastPktInfo lpInfo;
891 int check_header(HEAD_T * p_head, PKTIO_METADATA_T * p_meta)
893 #ifdef MULTI_THREAD
894     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
895     //int coreid = our_core;
896 #else
897     int coreid=0;
898 #endif
899 if (NWAL_RX_FLAG1_META_DATA_VALID & p_meta->u.rx_meta->rxFlag1)
901     lpInfo.iface = ((unsigned int)p_meta->u.rx_meta->appId) &0xff; //last byte is interface num
902     lpInfo.ipcsum =(p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_MASK )== NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_ACK ? 1 : 0;
903     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; 
904     if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC)
905     {
906     stats[coreid].sec_rx++;
907     }
908     if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC_POLICY)
909     {
910     stats[coreid].secp_rx++;
911     }
913     if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_CLASS)
914     {
915         int c= ((unsigned int)p_meta->u.rx_meta->appId >>8)&0xffff;
916     if (c==0)  stats[coreid].n_class0_rx +=1;
917     else if (c==1) stats[coreid].n_class1_rx +=1;
918     else if (c==2) stats[coreid].n_class2_rx +=1;
919     else printf("**NET_TEST RX -unknown class: %x\n",  p_meta->u.rx_meta->appId);
923  return 1;
926 #define PKT_LEN 1400
927 void test_alloc_free(int n)
929 int i;
930 Ti_Pkt * b;
932 for(i=0;i<n;i++)
934   b=Pktlib_allocPacket(ourHeap,PKT_LEN);
935   Pktlib_freePacket(b);
939 //measurement test points
940 unsigned int vv1;
941 unsigned int vv2;
942 unsigned int vv3;
943 unsigned int vv4;
944 unsigned int vv5;
945 unsigned int vv6;
948 unsigned int vv11;
950 extern unsigned int nwal_prof1,nwal_prof2,nwal_prof3,nwal_prof4,nwal_prof5,nwal_prof6;
952 //#define REASSEMBLE_BENCH
953 #ifdef REASSEMBLE_BENCH
954 #include <ti/drv/pa/example/reassemLib/reassemLib.h>
955 /*--------------reassembly benchmark--------------------------------*/
956 void our_reassemble_bench(int nfrags)
958 paIPReassemblyConfig_t Config={5,128,10000 };
959 int i,j;
960 int len;
961 Ti_Pkt tip;
962 char *buffer;
963 unsigned long v1;
964 unsigned long v2;
965 unsigned long sum1=0;
966 unsigned long sum2=0;
967 paEx_reassemLibInit(&Config);
968 for(j=0;j<200/nfrags;j++)
970   for(i=0;i<nfrags;i++)
971   {
972     short temp;
973     tip=Pktlib_allocPacket(ourHeap,PKT_LEN);
974     Pktlib_getDataBuffer(tip,(uint8_t**)&buffer,&len);
975     memcpy(&buffer[0],&testPkt[14],20); //IP header
976     if (i < (nfrags-1)) buffer[6] = 0x20;
977     temp = i*40; 
978     buffer[6]|= (temp&0x1f00)>>8;
979     buffer[7]= (temp&0xff);
980     temp = 20+40*8; 
981     buffer[2]= (temp&0xff00)>>8;
982     buffer[3]= (temp&0xff);
983     Pktlib_setPacketLen(tip, temp);
984     v1= hplib_mUtilGetPmuCCNT();
985     paEx_reassemLibProc(tip, 0xffff);
986     v2= hplib_mUtilGetPmuCCNT();
987     sum1+= v2-v1;
988   }
989   sum2 += v2-v1;
991 printf("reasssembly test:  %d trials, %d frags/pkt  %d cycles/frag %d cycles/last frag\n",j,nfrags, sum1/(j*nfrags), sum2/(j));
993 #endif
995 /*--------------basic pktio send/recv benchmark----------------------*/
996 unsigned int timings[10];
997 void our_pktio_bench(int ntrials)
999 int i;
1000 #define NBATCH 8
1001 Ti_Pkt tip;
1002 unsigned char * pData;
1003 int len;
1004 int n;
1005 int err;
1006 int sum =0;
1008    Osal_cache_op_measure_reset();
1009    for(i=0;i<10;i++) timings[i]=0;
1010    printf("calibration loop .. ");
1011    for(i=0;i<1000;i++)
1012    {
1013    vv1= hplib_mUtilGetPmuCCNT();
1014    vv2= hplib_mUtilGetPmuCCNT();
1015    sum+=(vv2-vv1);
1016    }
1017    printf(" accuracy = +- %d cycles\n", sum/1000);
1018    sleep(1);
1019   
1020 PKTIO_METADATA_T meta[10]={0};
1021 //send single, recv single
1022 for(i=0;i<ntrials;i++)
1024    vv1= hplib_mUtilGetPmuCCNT();
1025    tip=Pktlib_allocPacket(ourHeap,PKT_LEN);
1026    vv2= hplib_mUtilGetPmuCCNT();
1027    Pktlib_getDataBuffer(tip,&pData,&len);
1028    vv3= hplib_mUtilGetPmuCCNT();
1029    pktio_send(our_chan,tip,&meta[0],&err);
1030    vv4= hplib_mUtilGetPmuCCNT();
1031    n=pktio_poll(our_chan,NULL , &err);
1032    vv5=   hplib_mUtilGetPmuCCNT();
1033    timings[0]+=(vv6-vv4);
1034    timings[1]+=(vv5-vv4);
1035    timings[3]+=(vv4-vv3); 
1036    timings[5]+=(vv3-vv1);
1037    timings[8]+=(vv11-vv6);
1039 #ifdef PKTIO_GET_BENCHMARK
1040    timings[2]+=(our_chan->vv7p-vv4);
1041    timings[4]+=(our_chan->vv8p-vv3);
1042    timings[6]+=(our_chan->vv9p-our_chan->vv8p);
1043    timings[7]+=(our_chan->vv10p-our_chan->vv7p);
1044 #endif
1047 #ifdef PKTIO_GET_BENCHMARK
1048    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,
1049            timings[1]/ntrials, timings[2]/ntrials,timings[3]/ntrials, timings[4]/ntrials,timings[5]/ntrials,
1050            timings[6]/ntrials,timings[7]/ntrials, timings[8]/ntrials );
1051    {
1052        unsigned long long ccycles;
1053        unsigned long long  n_c_ops;
1054        ccycles =Osal_cache_op_measure(&n_c_ops);
1055        printf("n_c_ops=%lld cache_op_time=%lld (total) = %lld (pp)\n", n_c_ops, ccycles,  n_c_ops? (ccycles/(n_c_ops)) : 0);
1056    }
1057 #endif
1060 /*-----------test driver: gen an input pkt------- */
1061 //char buffer[sizeof(HEAD_T)+PKT_LEN];
1062 Ti_Pkt * get_pkt(int n, unsigned int *p_len, Pktlib_HeapHandle heap2use, int size, unsigned char * buf2cpy, int copy_size)
1064    int ind;
1065    long long temp;
1066    Ti_Pkt * b;
1067    char * buffer;
1068    unsigned int len;
1070   if (pktloopback==0)
1071   {
1072         if (n>=TX_BURST) return NULL;   //just gen pkts to warm swtich, so that it knows
1073                                 //our mac is valid
1074   }  
1075   b=Pktlib_allocPacket(heap2use,size);
1076   if (!b) 
1077     {printf("net_test: get_pkt() heap empty!! %d pkts gen'd %d \n", n); return NULL;};
1079     //debug - way to validate descriptor
1080     {Ti_Pkt* k= Pktlib_getNextPacket(b); 
1081          if(k != 0) {printf(" genpkt, nexpkt != NULL");}}
1084    //get pointer to buffer area of packet
1085    Pktlib_getDataBuffer(b,(uint8_t**)&buffer,&len);
1086    if (!buffer) 
1087     {printf("net_test: get_pkt() heap returned empty buffer %d \n", n); return NULL;};
1089 #if 0 
1090 if (pktloopback==0)
1092    temp = (long long) rand();
1093    temp *= PKT_LEN;
1094    temp /= RAND_MAX;
1095    temp +=2;
1096    *p_len = (int) temp; 
1097    *p_len = *p_len &0xfffffffe;
1098    temp = (long long) rand();
1099    temp *= n_pkt;
1100    temp /= RAND_MAX;
1101    ind = (int) temp;
1102    update_header(&pkts[ind],*p_len);
1103    //printf("get pkt:%d %d ind=%d len=%d\n",RAND_MAX, rand(),ind, *p_len);
1104     memcpy(&buffer[0], &mac_header[0],14);
1105     memcpy(&buffer[14],(char*)&pkts[ind],sizeof(HEAD_T)); 
1107 else
1108 #endif
1110    //copy test packet into buffer
1112     memcpy(&buffer[0], buf2cpy, copy_size);
1113     *p_len = copy_size;
1115     return b; 
1118 static int eof=0;
1119 /*--------------------------------------------------------------
1120  *----------utility to flip a packet and send 
1121  *--------------------back to source----------------------------
1122  *                   flag=1 => ipsec
1123  *--------------------------------------------------------------*/
1124 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag, uint16_t enet_port)
1126     unsigned char mac_temp[6];
1127     unsigned char ip_temp[4];
1128     unsigned char new_dest_port[2]={0x75,0x30};  // 30000
1129     uint16_t blah; 
1130     uint16_t i=1;   /* for testing only */
1132     uint8_t *p_spi; 
1133     netTestSA_t * p_sa_info;
1134     uint8_t p_iv[16];
1135     uint8_t p_add[8];
1136     Cppi_HostDesc*          pPloadDesc;
1137     uint8_t ah_len;
1138 #ifdef AH_SUPPORT
1139     HEAD_T * p_head;
1140     HEAD_T temp_head;
1141     int pkt_type;
1142 #endif
1144 #ifdef MULTI_THREAD
1145     int coreid=Osal_nwalGetProcId(); //who we are(thread local)
1146         //int coreid = our_core;
1147 #else
1148 int coreid=0;
1149 #endif
1150               //netapi_dump_buf((long*)p_pkt,len);
1151     Pktlib_setPacketLen(tip,len);
1152     //flip the mac address
1153     memcpy(&mac_temp,&p_pkt[0],6);
1154     memcpy(&p_pkt[0],&p_pkt[6],6);
1155     memcpy(&p_pkt[6],&mac_temp,6);
1156     //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
1158     //flip the ip  (outer in case of ipsec)
1159     memcpy(&ip_temp, &p_pkt[14+12],4);
1160     memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);
1161     memcpy(&p_pkt[14+12+4],&ip_temp,4);
1163 #ifdef AH_SUPPORT
1164     p_head=&temp_head;
1165 #endif
1166     //outer checksum to 0
1167     if (!flag) 
1168     {
1169         memset(&p_pkt[14+10],0,2);
1170     }
1172     //inner ip &udp for ipsec
1173     if (flag) 
1174     {
1175 #ifdef AH_SUPPORT
1176         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));
1178         if ((p_head->ip[2]&0x0000ff00)==0x00003300)
1179         {
1180             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN + 4]);
1181             pkt_type = IPSEC_AH_PKT;
1182             printf("flip_and_send_pkt: IPSEC AH packet received\n");
1183         }
1184         else if ((p_head->ip[2]&0x0000ff00)==0x00003200)
1185         {
1186             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1187             pkt_type = IPSEC_ESP_PKT;
1189             printf("flip_and_send_pkt: IPSEC ESP packet received\n");
1191         }
1192 #endif
1194         //p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN + 4]);
1195         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1196         if (p_sa_info == NULL)
1197         {
1198             printf("flip_and_send_pkt(): trie_lookup() failed\n");
1199             return;
1200         }
1201         //just drop non-udp packet
1202         if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
1203         {
1204             stats[coreid].n_new+=1;Pktlib_freePacket(tip); return;
1205         }
1207         /* flip inner IP */
1208         printf("flip_and_send_pkt: encOffSet %d\n", p_sa_info->tx_payload_info.encOffset);
1209         memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
1210         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
1211         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
1212         /* setting udp ports */
1213         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+2],&new_dest_port[0],2);
1214         memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+6],0,2); //checksum
1216         if (config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
1217         {
1218             /* inner ip checksum : leave alone */
1219             /* outer ip, set to 0 (we will compute on way out */
1220             memset(&p_pkt[14+10],0,2);
1221         }
1222         else
1223         {
1224             //#else //inflow, don't touch outer , clear inner 
1225             //DALmemset(&p_pkt[14+20+8+16+10],0,2); //inner checksum, we will compute on way out
1226             //outer ip checksum : leave alone
1227         }
1228     }
1229     else
1230     {
1231         memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out
1232         memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);
1233     }
1235     /*IPSEC case */ 
1236     if (flag)
1237     {
1238         if (config.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
1239         //send to crypto for encryption
1240         //12 byte auth tag
1241         {
1242             PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
1243             int err;
1244             nwalDmTxPayloadInfo_t meta_tx={0};
1245             meta.sa_handle=p_sa_info->tx_data_mode_handle;  //use TX SA context
1247             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
1249  
1250                 meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
1251                 meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
1253 #if 0
1254             printf("flip_and_send_pkt(): encOffset %d\n", meta_tx.encOffset);
1255             printf("flip_and_send_pkt():authOffset %d\n", meta_tx.authOffset);
1256             printf("flip_and_send_pkt(): encSize %d\n", meta_tx.encSize);
1257             printf("flip_and_send_pkt(): authSize %d\n", meta_tx.authSize);
1258 #endif
1260             meta_tx.pAuthIV=NULL;
1261             meta_tx.aadSize=0;
1262             meta_tx.pAad=NULL;
1263             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
1264             {
1265                 memcpy(&p_iv[0], &ourEncrKey[16], 4);
1266                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1267                 p_iv[12] = 0;
1268                 p_iv[13] = 0;
1269                 p_iv[14] = 0;
1270                 p_iv[15] = 1;
1271                 meta_tx.pEncIV = &p_iv[0];
1272             }
1273             else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
1274                 (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
1275                 {
1276                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1277                         meta_tx.pEncIV = &p_iv[0];
1278                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
1279                         meta_tx.pAad= &p_add[0];
1280                         meta_tx.aadSize = 8;
1281                 }
1282             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
1283             {
1284                 meta_tx.pEncIV = NULL;
1285             }
1286             else
1287             {
1288                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
1289             }
1290             //meta_tx.authIvSize=0;
1292             /* post it to netcp sb tx channel*/
1293             meta_tx.appCtxId = (nwal_AppId)hplib_mUtilGetPmuCCNT();
1294             meta.u.tx_sb_meta=&meta_tx;
1296 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
1297             /* Use the command label which was cached during create time
1298             * Update the Queue to receive output packet from SA to the local 
1299             * core Queue. Below information can be saved by application in 
1300             * per process context to avoid API overhead per packet
1301             * Application can use below rxSbSaQ for polling packets back from
1302             * SA
1303             */
1304             nwalRetVal =  
1305             nwal_getLocCxtInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
1306                                                       &nwalLocCxt);
1307             if(nwalRetVal == nwal_OK)
1308             {
1309                 p_sa_info->tx_dmPSCmdInfo.rxSbSaQ = nwalLocCxt.rxSbSaQ;
1310             }
1311             nwal_mCmdDMUpdate(tip,
1312                               &p_sa_info->tx_dmPSCmdInfo,
1313                               meta_tx.appCtxId,
1314                               meta_tx.encOffset,
1315                               meta_tx.encSize,
1316                               meta_tx.pEncIV,
1317                               meta_tx.authOffset,
1318                               meta_tx.authSize,
1319                               meta_tx.pAuthIV,
1320                               meta_tx.aadSize,
1321                               meta_tx.pAad);
1322             pPloadDesc = Pktlib_getDescFromPacket(tip);
1323             pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
1324             Qmss_queuePushDescSizeRaw(p_sa_info->tx_dmPSCmdInfo.txQueue,
1325                                        pPloadDesc,
1326                                        NWAL_DESC_SIZE);
1328 #else
1329            pktio_send(netcp_sb_tx_chan,tip,&meta,&err);
1330 #endif
1331         }
1332         else
1333         {
1334             //INFLOW TX *******************
1335             //send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
1336             PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
1337             int err;
1338             nwalTxPktInfo_t meta_tx={0};
1339 #define USE_COPY
1340 #ifdef USE_COPY
1341 //debug:  see if re-using RX descriptor for TX is causing our SA lockup
1342             {
1343             int new_len=0;
1344             Ti_Pkt new_tip =  get_pkt(0, &new_len, specialLarge , len+10 , &p_pkt[0]   , len);
1345             if (!new_tip)
1346             {
1347                 printf("net_test> new_tip NULL\n");
1348             }
1349             else
1350             {
1351                 Pktlib_setPacketLen(new_tip,new_len);
1352                 Pktlib_freePacket(tip);
1353                 tip=new_tip;  
1354                 Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&new_len);  //reset p_pkt to point to new buffer as its used below
1355 //                Cppi_setTimeStamp (Cppi_DescType_HOST, (Cppi_Desc *) tip,stats[coreid].sec_tx); 
1356             }
1357             }
1358             if (len <1500)  
1359             {
1360                 eof+=1;
1361             }
1362 #endif
1364             meta.sa_handle=p_sa_info->tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied
1365             meta_tx.startOffset = p_sa_info->tx_pkt_info.startOffset;
1366             meta_tx.ipOffBytes =p_sa_info->tx_payload_info.encOffset; 
1367             meta_tx.l4OffBytes = p_sa_info->tx_pkt_info.l4OffBytes;
1368             meta_tx.l4HdrLen = p_sa_info->tx_pkt_info.l4HdrLen;
1369             meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
1370             meta_tx.saOffBytes=  p_sa_info->tx_pkt_info.saOffBytes;
1371             if (pkt_type == IPSEC_AH_PKT)
1372             {
1373                  memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+netTest_IPSEC_AH_FIXED_HDR_SIZE],0,netTest_IPSEC_AH_FIXED_HDR_SIZE);
1374                 meta_tx.txFlag1 = p_sa_info->tx_pkt_info.txFlag1;
1375                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN;   //don't inlcude mac 
1376                 meta_tx.saAhMacSize = 12;
1377                 meta_tx.saAhIcvOffBytes = netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE;
1378                 printf("flip_and_send_pkt: enet_port %d\n", enet_port);
1379                 meta_tx.enetPort = enet_port;
1380             }
1381             else if (pkt_type == IPSEC_ESP_PKT)
1382             {
1383                 meta_tx.txFlag1 = p_sa_info->tx_pkt_info.txFlag1;
1384                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN-netTest_IP_HEADER_LEN;   //don't include mac and ip outer header
1385                 meta_tx.enetPort = 0;
1386             }
1387             else
1388             {
1389                 printf("flip_and_send_pkt: invalid ESP protocol\n");
1390                 return;
1391             }
1393             meta_tx.pseudoHdrChecksum =
1394             test_utilGetIpv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
1397             /* post it to netcp tx channel*/
1398             meta.u.tx_meta=&meta_tx;
1399             if (stats[coreid].sec_tx<20) dump_descr((long *) tip, stats[coreid].sec_tx);
1400 #ifdef NET_TEST_ENABLE_INFLOW_LOW_LEVEL_API
1401 #if 0
1402         nwal_mCmdSetCrypPort (tip,
1403                                           &p_sa_info->tx_psCmdInfo,
1404                                          p_sa_info->tx_pkt_info.saOffBytes,
1405                                          meta_tx.saPayloadLen,
1406                 p_sa_info->swInfo0, 
1407                 p_sa_info->swInfo1, 
1408                 NWAL_ENET_PORT_UNKNOWN);
1409 #endif
1410                 nwal_mCmdSetL4CkSumCrypPort(tip,
1411                  &p_sa_info->tx_psCmdInfo,
1412                 meta_tx.l4OffBytes, 
1413                 meta_tx.ploadLen + meta_tx.l4HdrLen, 
1414                 meta_tx.pseudoHdrChecksum, 
1415                 p_sa_info->tx_pkt_info.saOffBytes, 
1416                 meta_tx.saPayloadLen, 
1417                 p_sa_info->swInfo0, 
1418                 p_sa_info->swInfo1, 
1419                 enet_port);
1421                 pPloadDesc = Pktlib_getDescFromPacket(tip);
1422                 pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
1423                 Qmss_queuePushDescSizeRaw(p_sa_info->tx_psCmdInfo.txQueue,
1424                                            pPloadDesc,
1425                                            NWAL_DESC_SIZE);
1426 #else
1427                pktio_send(netcp_tx_chan,tip,&meta,&err);
1428 #endif
1429             stats[coreid].tx +=1;
1430             stats[coreid].sec_tx +=1;
1431         }
1432     }
1433     else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
1434     {
1435         PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
1436         int err;
1437         nwalTxPktInfo_t meta_tx2={0};
1438         meta2.sa_handle=nwal_HANDLE_INVALID;
1439         meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
1440         meta_tx2.startOffset = 0;
1441         meta_tx2.ipOffBytes = 14;
1442         meta_tx2.l4OffBytes = 14+20;
1443         meta_tx2.l4HdrLen = 8;
1444         meta_tx2.ploadLen = (unsigned) ((p_pkt[14+20+4]<<8)|p_pkt[14+20+4+1]) -8 ;
1445         meta_tx2.pseudoHdrChecksum =
1446         test_utilGetIpv4PsudoChkSum(&p_pkt[14],8+ meta_tx2.ploadLen);
1448         /* post it to netcp tx channel*/
1449         meta2.u.tx_meta=&meta_tx2;
1450         pktio_send(netcp_tx_chan,tip,&meta2,&err);
1451         stats[coreid].tx +=1;
1452     }
1458 /***************************************
1459  benchmark receive handler
1460 ****************************************/
1461 void recv_cb_bench(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1462                          PKTIO_METADATA_T meta[], int n_pkts,
1463                          uint64_t ts )
1465    int i;
1466    vv6=   hplib_mUtilGetPmuCCNT();
1467    for (i=0;i<n_pkts; i++) 
1468    {
1469      Pktlib_freePacket(p_recv[i]);
1470    }
1471    vv11 = hplib_mUtilGetPmuCCNT();
1474 /****************************************************************************************/
1475 /******************SB Accelerator Callback PKT RECEIVE HANDLER *************************/
1476 /******************  Handles Decrypt and Encrypt operation callbacks ******************/
1477 /******************************************************************************************/
1478 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1479                          PKTIO_METADATA_T meta[], int n_pkts,
1480                          uint64_t ts )
1482 int i;
1483 int len;
1484 int p;
1485 HEAD_T * p_res;
1486 Ti_Pkt * tip;
1487 unsigned int templen;
1488 int err;
1489 KEY_T key;
1490 char * p_pkt;
1491 HEAD_T * p_head;
1492 HEAD_T temp_head;
1493 int tag_cmp=0;
1494 unsigned int hash[4];
1495 uint8_t *p_spi;
1496 netTestSA_t *p_sa_info;
1498 #ifdef MULTI_THREAD
1499     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
1500     //int coreid = our_core;
1501 #else
1502 int coreid=0;
1503 #endif
1504 //nwal_AppId time;
1505 unsigned long time, delta_time;
1506  /* loop over received pkts */
1507    for(i=0;i<n_pkts;i++)
1508    {
1509         tip = p_recv[i];
1510         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
1511         len = Pktlib_getPacketLen(tip);//real length
1514          p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1516         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1517         if (p_sa_info == NULL)
1518         {
1519             printf("recv_sb_cb(): trie_lookup failed\n");
1520             continue;
1521         }
1524         //is this a decrypt (rx_tunnel) complete
1525         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
1526         {
1527            
1528             time = hplib_mUtilGetPmuCCNT();
1529            delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
1530             stats[coreid].total_decrypt_time += delta_time;
1531             stats[coreid].sb_rx+=1;
1532            //copy hash out of meta data (for some reason it needs endian conversion)
1533            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
1534            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
1535            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
1536            hash[3]= htonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
1537            if(stats[coreid].sb_rx<=16)
1538            {
1539              char *tp = (char *) &hash[0];
1540              //dump_header((long*)p_pkt, stats[coreid].sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
1541 #if 0
1542              printf("decrypt complete: tag in pkt= %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \n",
1543                       p_pkt[len-16],p_pkt[len-15],p_pkt[len-14],p_pkt[len-13],
1544                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],
1545                       p_pkt[len-7],p_pkt[len-6],
1546                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);
1547              printf("decrypt complete: tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \n",
1548                        tp[0],tp[1],tp[2],tp[3],tp[4],tp[5],
1549                        tp[6],tp[7],tp[8],tp[9],tp[10],tp[11],tp[12],tp[13],tp[14],tp[15]);
1551             // netapi_dump_buf((long*)p_pkt,len);
1552 #endif
1553            }
1554            //check tag 
1555            //printf("recv_sb_cb(); auth tag size %d\n", p_sa_info->auth_tag_size);
1556            tag_cmp = memcmp(&p_pkt[len-p_sa_info->auth_tag_size],(char*) &hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
1557            stats[coreid].n_auth_ok += !(tag_cmp);
1558            
1559             flip_and_send_pkt(tip, p_pkt, len,1, 0);  //flip packet to echo back and send
1560         }
1561         //this is an encrypt (tx tunnel) complete
1562         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
1563         {
1564            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
1565            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
1566            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
1567            hash[3]= htonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
1568            stats[coreid].sb_tx+=1;
1569            if(stats[coreid].sb_tx<=16)
1570            {
1571              char *tp1 = (char *) &hash[0];
1572              //dump_header((long*)p_pkt, stats[coreid].sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
1573 #if 0
1574             printf("encrypt complete: tag in pkt=  %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \n",
1575                       p_pkt[len-16],p_pkt[len-15],p_pkt[len-14],p_pkt[len-13],
1576                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],
1577                       p_pkt[len-7],p_pkt[len-6],
1578                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);
1579              printf("encrypt complete: tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x \n",
1580                        tp1[0],tp1[1],tp1[2],tp1[3],tp1[4],tp1[5],
1581                        tp1[6],tp1[7],tp1[8],tp1[9],tp1[10],tp1[11],tp1[12],tp1[13],tp1[14],tp1[15]);
1582              //netapi_dump_buf((long*)p_pkt,len);
1583 #endif
1584            }
1585            //put the computed tag in the packet
1586            memcpy(&p_pkt[len-p_sa_info->auth_tag_size],(char*)&hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
1587 //          printf("recv_sb_cb(): dumping pkt after updating computed tag, len %d, auth tag size %d\n", len, p_sa_info->auth_tag_size);
1588            //netapi_dump_buf(p_pkt, len);
1589            {
1590            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
1591            nwalTxPktInfo_t meta_tx={0};
1592            // now send directly 
1593            meta2.sa_handle=nwal_HANDLE_INVALID;
1594            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
1595            meta_tx.startOffset = 0;
1596            meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
1597            //not used
1598            meta_tx.l4OffBytes = 0;
1599            meta_tx.l4HdrLen = 0;
1600            meta_tx.ploadLen = 0;
1601             time = hplib_mUtilGetPmuCCNT();
1602             delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
1603            stats[coreid].total_encrypt_time += delta_time;
1604         
1606            /* post it to netcp tx channel*/
1607            meta2.u.tx_meta=&meta_tx;
1608 //           printf("recv_sb_cb(): calling pktio send to send it to network\n");
1609            pktio_send(netcp_tx_chan,tip,&meta2,&err);
1610            hplib_cacheWbInv(p_pkt,len);
1611            stats[coreid].tx +=1;
1612            }
1613         }
1614         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
1615     }
1618 /******************************************************/
1619 /******************PKT RECEIVE HANDLER *************************/
1620 /******************************************************/
1621 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
1622                          PKTIO_METADATA_T meta[], int n_pkts,
1623                          uint64_t ts )
1625     int i;
1626     int len;
1627     int p;
1628     HEAD_T * p_res;
1629     Ti_Pkt * tip;
1630     unsigned int templen;
1631     int err = 0;
1632     KEY_T key;
1633     char * p_pkt;
1634     HEAD_T * p_head;
1635     HEAD_T temp_head;
1636     netTestSA_t *p_sa_info;
1637     uint8_t *p_spi;
1638     uint8_t p_iv[16];
1639     uint8_t p_add[8];
1640     uint8_t p_add1[1500];
1641     int16_t       retVal;
1642                     nwalGlobCxtInfo_t   nwalGlobCxt;
1643                     nwalLocCxtInfo_t    nwalLocCxt;
1645     Cppi_HostDesc*          pPloadDesc;
1646     int ifno;
1647     uint16_t enet_port = 0;
1649 #ifdef MULTI_THREAD
1650     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
1651     //int coreid = our_core;
1652 #else
1653     int coreid=0;
1654 #endif
1655     p_head=&temp_head;
1657     /* loop over received pkts */
1658     for(i=0;i<n_pkts;i++)
1659     {
1660         ifno = ((unsigned int)meta[i].u.rx_meta->appId)&0xff;
1661         enet_port = meta[i].u.rx_meta->enetPort;
1662         tip = p_recv[i];
1663         
1664         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);/*ignore templen */
1665         len = Pktlib_getPacketLen(tip)-4;   /*real length, subtract mac trailer */
1666         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
1667         Pktlib_setPacketLen(tip,len);
1668         //printf("recv_cb() packet len %d\n", len);
1670         //debug: validate descriptor */
1671         if(Pktlib_getNextPacket(tip) != 0) 
1672         {
1673             printf(" rcv_cb, nexpkt != NULL");
1674         }
1676         if(coreid<TUNE_NETAPI_NUM_CORES)
1677             stats[coreid].rx+=1;
1678         if (ifno < TUNE_NETAPI_MAX_NUM_MAC)
1679             stats[coreid].if_rx[ifno]+=1;
1682 #ifdef DEBUG_DESC
1683         if (stats[coreid].rx<16)
1684         {
1685             printf(">rx dmp.."); 
1686             dump_descr((long *) tip, stats[coreid].rx);
1687         }
1688         else if (stats[coreid].rx>99) 
1689         {
1690             printf(">rx dmp.."); 
1691             dump_descr((long *) tip,stats[coreid].rx);
1692         }
1693 #endif
1694 #if 0
1695         if(stats[coreid].rx<=16)
1696         {
1697             dump_header((long*)p_pkt,stats[coreid].rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
1698              netapi_dump_buf((long*)p_pkt,len);
1699         }
1700 #endif
1701         /* check header */
1702         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));
1704         /* check for IPSEC ESP or AH packet, 0x32 is ESP tunnel mode, 0x33 is AH tunnel mode*/
1705        if (((p_head->ip[2]&0x0000ff00)==0x00003200) || ((p_head->ip[2]&0x0000ff00)==0x00003300))
1706         {
1707             if (!check_header(p_head,&meta[i]))
1708             {
1709                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
1710                 continue;
1711             }
1713             //process IP SEC PACKET
1714             if (config.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
1715             {
1716                 
1717                 p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
1718                  p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa, (char *)p_spi ,4);
1719                 if (p_sa_info == NULL)
1720                 {
1721                     printf("recv_cb(): trie_lookup() failed\n");
1722                     continue;
1723                 }
1725                 //ship to crypto for decrypt!!
1726                 //12 byte auth tag
1727                 PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
1728                 nwalDmTxPayloadInfo_t meta_tx={0};
1729                 meta2.sa_handle=p_sa_info->rx_data_mode_handle;
1731                 memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
1733                 //meta_tx.ploadLen = len;
1737                     meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
1738                     meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
1742 #if 0
1743                 printf("recv_cb(): packet length %d\n", len);
1744                 printf("recv_cb(): encOffset %d\n", meta_tx.encOffset);
1745                 printf("recv_cb():authOffset %d\n", meta_tx.authOffset);
1746                 printf("recv_cb(): encSize %d\n", meta_tx.encSize);
1747                 printf("recv_cb(): authSize %d\n", meta_tx.authSize);
1748 #endif
1750                 if (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CTR)
1751                 {
1752                     memcpy(&p_iv[0], &ourEncrKey[16], 4);
1753                     memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1754                     p_iv[12] = 0;
1755                     p_iv[13] = 0;
1756                     p_iv[14] = 0;
1757                     p_iv[15] = 1;
1758                     meta_tx.pEncIV = &p_iv[0];
1759                  
1760                 }
1761                 else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM)  ||
1762                             (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
1763                 {
1764                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
1765                         meta_tx.pEncIV = &p_iv[0];
1766                         /* aad is the ESP header which is 8 bytes */
1767                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
1768                         meta_tx.pAad= &p_add[0];
1769                         meta_tx.aadSize = 8;
1770                 }
1771                 else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
1772                 {
1773                     meta_tx.pEncIV = NULL;
1774                 }
1775                 else
1776                 {
1777                     meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
1778                 }
1779                
1780                 meta_tx.appCtxId = (nwal_AppId)hplib_mUtilGetPmuCCNT();
1781                 //printf("recv_cb appCtxId: %lu\n", meta_tx.appCtxId);
1783                 /* post it to netcp sb tx channel*/
1784             meta2.u.tx_sb_meta=&meta_tx;
1786 /* TODO: Move the following ifdef code into ptkio_sendDM */
1787 #ifdef NET_TEST_ENABLE_SIDE_BAND_LOW_LEVEL_API
1788             /* Use the command label which was cached during create time
1789             * Update the Queue to receive output packet from SA to the local 
1790             * core Queue. Below information can be saved by application in 
1791             * per process context to avoid API overhead per packet
1792             * Application can use below rxSbSaQ for polling packets back from
1793             * SA
1794             */
1795             nwalRetVal =  
1796             nwal_getLocCxtInfo(PKTIO_GET_NWAL_INSTANCE(netcp_sb_tx_chan),
1797                                                       &nwalLocCxt);
1798             if(nwalRetVal == nwal_OK)
1799             {
1800                 p_sa_info->rx_dmPSCmdInfo.rxSbSaQ = nwalLocCxt.rxSbSaQ;
1801             }
1802             nwal_mCmdDMUpdate(tip,
1803                               &p_sa_info->rx_dmPSCmdInfo,
1804                               meta_tx.appCtxId,
1805                               meta_tx.encOffset,
1806                               meta_tx.encSize,
1807                               meta_tx.pEncIV,
1808                               meta_tx.authOffset,
1809                               meta_tx.authSize,
1810                               meta_tx.pAuthIV,
1811                               meta_tx.aadSize,
1812                               meta_tx.pAad);
1813             pPloadDesc = Pktlib_getDescFromPacket(tip);
1814             pPloadDesc = Qmss_osalConvertDescVirtToPhy(pPloadDesc);
1815             Qmss_queuePushDescSizeRaw(p_sa_info->rx_dmPSCmdInfo.txQueue,
1816                                        pPloadDesc,
1817                                        NWAL_DESC_SIZE);
1819 #else
1820             pktio_send(netcp_sb_tx_chan,tip,&meta2,&err);
1821 #endif
1822             continue;
1823         }
1824         else
1825         {
1826             //inflow mode.  flip and send
1827             flip_and_send_pkt(tip,p_pkt,len,1, enet_port);
1828         }
1829     }
1830     else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
1831     {
1832         stats[coreid].n_new+=1;Pktlib_freePacket(tip); continue;
1833     }
1834     else  //non ipsec
1835     {
1836         if (!check_header(p_head,&meta[i]))
1837         {
1838             stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
1839             continue;
1840         }
1842 #if 0
1843         /* lookup flow */
1844         key.src_ip = p_head->ip[3];
1845         key.dst_ip = p_head->ip[4];
1846         key.src_port= (p_head->udp[0]&0xffff0000)>>16;
1847         key.dst_port= (p_head->udp[0]&0x0000ffff);
1848         p_res= (HEAD_T *) trie_lookup(P_trie, (char *) &key, sizeof(key));
1849         if (!p_res) { stats[coreid].n_new+=1;  slow_path(tip, len); continue;}
1851         /* copy header */
1852         memcpy((char *) p_head, (char *) p_res, sizeof(HEAD_T));
1854         memcpy(&p_pkt[14],p_head,sizeof(HEAD_T));
1855         /* update_mac(&p_pkt[0]);  */
1857         /* 'simulate' send pkt */
1858         send_pkt(tip,len);
1859 #endif
1860              //just flip and send
1861             flip_and_send_pkt(tip,p_pkt,len,0, enet_port);
1862         }
1863     }
1864     //printf("recv done\n");
1867 #ifdef TEST_TIMERS
1868 //timer callback 
1869 void our_timer_cb( HPLIB_TIMER_GROUP_HANDLE_T th,
1870         int n_fired,     //# timers fired
1871         HPLIB_TIMER_LIST_T fired_list,
1872         uint64_t currentTime)
1874 int i;
1875 HPLIB_TIMER_T tx;
1876 int cookie;
1877 int err;
1878 unsigned long long et;
1879 #ifdef MULTI_THREAD
1880     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
1881     //int coreid = our_core;
1882 #else
1883     int coreid=0;
1884 #endif
1885 //DEBUGprintf("TIMER CALLBACK @ %lld %d timers\n", currentTime, n_fired);
1886 tx = hplib_Timer_GetFirst(fired_list);
1887 for(i=0;i<n_fired;i++)
1889   cookie = (int) hplib_Time_rGetCookie(tx);
1890   et =  hplib_Timer_GetTs(tx); //debug
1891   //DEBUGprintf("   timer %d - cookie = %d expected ts=%lld (delta=%lld)\n", i, cookie, et, currentTime-et);
1892   if (cookie ==1)
1893   {  
1894      stats[coreid].n_t1+=1;
1895      t1 = hplib_Timer_Start(
1896         th,
1897         (void *) 1,
1898         100LL,  //timer group tics
1899         &err);
1900   }
1901   else if (cookie ==2)
1902   {
1903       stats[coreid].n_t2+=1;
1904       t2 = hplib_Timer_Start(
1905         th,
1906         (void *) 2,
1907         200LL,  //timer group ticks
1908         &err);
1909   }
1910   else
1911   {
1912     stats[coreid].n_t3+=1;
1913     t3 = hplib_Timer_Start(
1914         th,
1915         (void *) 3,
1916         300LL,  //timer group ticks
1917         &err);
1918     //cancel 1 and restart 1
1919    hplib_Timer_Cancel(th,t1,&err);
1920    t1 = hplib_Timer_Start(
1921         th,
1922         (void *) 1,
1923         100LL,  //timer group ticks
1924         &err);
1925  }
1926   tx = hplib_Timer_GetNext(fired_list,tx); 
1929 #endif
1930 void print_ipsec_stats(Sa_IpsecStats_t     *p_saIpsecStats, nwal_saAALG auth, nwal_saEALG cipher)
1932 #if 0
1933     if(retVal != nwal_OK)
1934     {
1935         System_printf("CORE: %d Error getting IP Sec Stats: Ret Status: %d \n",
1936                        retVal);
1937         return(nwal_FALSE);
1938     }
1939     if((p_saIpsecStats->pktEncHi) ||(p_saIpsecStats->pktEncLo))
1940     {
1941         printf("------------- IPSec TX (Encryption Channel) Stats BEGIN --\n");
1942     }
1943     else
1944     {
1945         printf("------------- IPSec RX (Decryption Channel) Stats BEGIN --\n");
1946     }
1947 #endif
1948     printf("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
1949     printf("IPSec replayOld:0x%x,replayDup:0x%x,authFail:0x%x \n",
1950                    p_saIpsecStats->replayOld,p_saIpsecStats->replayDup,p_saIpsecStats->authFail);
1951     printf("IPSec txESN:0x%x,rxESN:0x%x,pktEncHi:0x%x,pktEncLo:0x%x,pktDecHi:0x%x,pktDecLo:0x%x \n",
1952                    p_saIpsecStats->txESN,p_saIpsecStats->rxESN,p_saIpsecStats->pktEncHi,
1953                    p_saIpsecStats->pktEncLo,p_saIpsecStats->pktDecHi,p_saIpsecStats->pktDecLo);
1956 void print_datamode_stats(Sa_DataModeStats_t     *p_saDataModeStats, nwal_saAALG auth, nwal_saEALG cipher)
1959     printf("\nAutentication mode: %d, Encryption Mode: %d\n", auth, cipher);
1960     printf(" Packets processedHi: 0x%x, Packets processed Lo:0x%x\n",
1961             p_saDataModeStats->pktHi, p_saDataModeStats->pktLo);
1967 static int np2process = NP;
1968 /******************************************************
1969  * stats callback
1970  *******************************************************/
1971 void our_stats_cb_mt(NETAPI_T h, paSysStats_t* pPaStats)
1974 #ifdef MULTI_THREAD
1975     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
1976     //int coreid = our_core;
1977 #else
1978 int coreid=0;
1979 #endif
1981   stats[coreid].n_stats_cb +=1;
1982   if(pPaStats) memcpy(&netcp_stats,pPaStats, sizeof(paSysStats_t));
1984 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats)
1986 uint32_t numFreeDataPackets;
1987 uint32_t            numZeroBufferPackets;
1988 uint32_t            numPacketsinGarbage;
1989 Pktlib_HeapStats    pktLibHeapStats;
1990 int i;
1991 unsigned long long bcpp;
1992 unsigned long long bcpp_noc;
1993 unsigned long long bcpp_app;
1994 unsigned long long bcpp_tx;
1995 unsigned long long npL;
1996 unsigned long long cyclesL;
1997 unsigned long long ccyclesL; //cache cycles
1998 unsigned long long tmp_npL[TUNE_NETAPI_NUM_CORES];
1999 unsigned long long tmp_cyclesL[TUNE_NETAPI_NUM_CORES];
2000 unsigned long long tmp_ccyclesL[TUNE_NETAPI_NUM_CORES]; //cache cycles
2001 NETAPI_SA_STATS_T netapi_sa_stats;
2003     for (i=0;i < TUNE_NETAPI_NUM_CORES;i++)
2004     {
2005         printf("Per Core Statistics for CORE %d\n", i);
2006         printf(">*****stats @ %lld (#cbs%d) \n", hplib_mUtilGetTimestamp(),stats[i].n_stats_cb);
2007         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  min_rx=%d min_tx=%d\n",
2008          stats[i].itx, stats[i].rx, stats[i].tx, stats[i].n_bad, stats[i].n_new, 
2009          stats[i].n_class0_rx, stats[i].n_class1_rx, 
2010          stats[i].n_class2_rx, stats[i].sec_rx, stats[i].secp_rx, stats[i].sb_rx, stats[i].sb_tx, stats[i].n_auth_ok,
2011          stats[i].sec_tx, stats[i].rx_min, stats[i].tx_min);
2012         printf(">if rx stats:  %d %d %d\n",stats[i].if_rx[0],stats[i].if_rx[1],stats[i].if_rx[2]);
2013         printf(">core rx stats:  %d \n",stats[i].core_rx);
2015         if (stats[i].rx && stats[i].tx)
2016             printf("decrypt time per packet(avg): %lu, encrypt  time per packet(avg): %lu\n", 
2017             (unsigned long) stats[i].total_decrypt_time/stats[i].rx, (unsigned long) stats[i].total_encrypt_time/stats[i].tx);
2020         if (npL && stats[i].rx)
2021         {
2022             bcpp = cyclesL/npL; 
2023             bcpp_noc = (cyclesL-ccyclesL)/npL; 
2024             bcpp_app = (stats[i].app_cycles-stats[i].tx_cache_cycles)/stats[i].rx;
2025         }
2026         else
2027         {
2028             bcpp = bcpp_noc=bcpp_app=0L;
2029         }
2030         if (stats[i].tx)
2031         {
2032             bcpp_tx = (stats[i].send_cycles-stats[i].tx_cache_cycles)/stats[i].tx;
2033         }
2034         else
2035         {
2036             bcpp_tx = 0L;
2037         }
2038         printf(">         ++ busy cycles pp=%lld (%lld wo cache ops) (app+tx= %lld) (tx= %lld) ++\n",
2039          bcpp,bcpp_noc,bcpp_app, bcpp_tx);
2040         printf("\n");
2041     }
2043 #ifdef MULTI_THREAD
2044     netapi_sched_get_stats(scheduler[0],&tmp_npL[0],&tmp_cyclesL[0],&tmp_ccyclesL[0]);
2045     netapi_sched_get_stats(scheduler[1],&tmp_npL[1],&tmp_cyclesL[1],&tmp_ccyclesL[1]);
2046 npL = tmp_npL[0]+tmp_npL[1];
2047 cyclesL = tmp_cyclesL[0]+tmp_cyclesL[1];
2048 ccyclesL = tmp_ccyclesL[0]+tmp_ccyclesL[1];
2049 #else
2050 netapi_sched_get_stats(our_sched, &npL,&cyclesL,&ccyclesL);
2051 #endif
2053 if(pPaStats)
2055        printf("C1 number of packets:           %d\n", pPaStats->classify1.nPackets);
2056        printf("C1 number IPv4 packets:         %d\n", pPaStats->classify1.nIpv4Packets);
2057        printf("C1 number IPv6 packets:        %d\n", pPaStats->classify1.nIpv6Packets);
2058        printf("C1 number Custom packets:        %d\n", pPaStats->classify1.nCustomPackets);
2059        printf("C1 number SRIO packets:        %d\n", pPaStats->classify1.nSrioPackets);
2060        printf("C1 number LLC/SNAP Fail packets:        %d\n", pPaStats->classify1.nLlcSnapFail);
2061        printf("C1 number table matched:        %d\n", pPaStats->classify1.nTableMatch);
2062        printf("C1 number failed table matched: %d\n", pPaStats->classify1.nNoTableMatch);
2063        printf("C1 number IP Fragmented packets: %d\n", pPaStats->classify1.nIpFrag);
2064        printf("C1 number IP Depth Overflow: %d\n", pPaStats->classify1.nIpDepthOverflow);
2065        printf("C1 number VLAN Depth Overflow: %d\n", pPaStats->classify1.nVlanDepthOverflow);
2066        printf("C1 number GRE Depth Overflow: %d\n", pPaStats->classify1.nGreDepthOverflow);
2067        printf("C1 number MPLS Packets: %d\n", pPaStats->classify1.nMplsPackets);
2068        printf ("C1 number of parse fail:        %d\n",pPaStats->classify1.nParseFail);
2069        printf("C1 number of Invalid IPv6 Opt:  %d\n", pPaStats->classify1.nInvalidIPv6Opt);
2070        printf("C1 number of TX IP Fragments:  %d\n", pPaStats->classify1.nTxIpFrag);
2071        printf ("C1 number of silent discard:    %d\n",pPaStats->classify1.nSilentDiscard);
2072        printf("C1 number of invalid control:   %d\n", pPaStats->classify1.nInvalidControl);
2073        printf ("C1 number of invalid states:    %d\n",pPaStats->classify1.nInvalidState);
2074        printf ("C1 number of system fails:      %d\n",pPaStats->classify1.nSystemFail);
2075        printf ("C2 number Packets  :           %d\n",pPaStats->classify2.nPackets);
2076        printf ("C2 number udp           :      %d\n",pPaStats->classify2.nUdp);
2077        printf ("C2 number tcp           :      %d\n",pPaStats->classify2.nTcp);
2078        printf ("C2 number Custom       :      %d\n",pPaStats->classify2.nCustom);
2079        printf ("C2 number silent drop   :      %d\n",pPaStats->classify2.nSilentDiscard);
2080        printf ("C2 number invalid cntrl :      %d\n\n",pPaStats->classify2.nInvalidControl);
2081        printf ("C2 number Modify Stats Cmd Fail :      %d\n\n",pPaStats->modify.nCommandFail);
2083 Pktlib_getHeapStats(ourHeap, &pktLibHeapStats);
2084 printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
2085                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
2086 printf("               >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
2087                         pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
2088                         pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
2090 Pktlib_getHeapStats(specialSmall, &pktLibHeapStats);
2091 printf("specialSmall heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
2092                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
2093 printf("                       >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
2094                                 pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
2095                                 pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
2098 Pktlib_getHeapStats(specialLarge, &pktLibHeapStats);
2099 printf("specialLarge heap stats>  #free=%d #zb=%d #garbage=%d\n", pktLibHeapStats.numFreeDataPackets,
2100                                 pktLibHeapStats.numZeroBufferPackets, pktLibHeapStats.numPacketsinGarbage);
2101 printf("                       >  #dataBufThreshStatus=%d #dataBufStarvCounter=%d #zBufThreshStatus=%d #zBufStarvCounter=%d \n", 
2102                                 pktLibHeapStats.dataBufferThresholdStatus,pktLibHeapStats.dataBufferStarvationCounter,
2103                                 pktLibHeapStats.zeroDataBufferThresholdStatus, pktLibHeapStats.zeroDataBufferStarvationCounter);
2106 #if 0
2107 printf("pa2sa descriptor area dump\n");
2108 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_PA_TO_SA_DESC;i++)
2110    extern long * pa2sa_descr_base;
2111    long * tip= &pa2sa_descr_base[32*i]; 
2112    dump_descr(tip, i);
2114 printf("sa2pa descriptor area dump\n");
2115 for(i=0;i<TUNE_NETAPI_CONFIG_MAX_SA_TO_PA_DESC;i++)
2117    extern long * sa2pa_descr_base;
2118    long * tip= &sa2pa_descr_base[32*i]; 
2119    dump_descr(tip, i);
2121 #endif
2122 #ifdef TEST_TIMERS
2123 //debug = dump timer polling stats
2124 dump_poll_stats();
2125 //debug = dump timer polling stats
2126 //dump_poll_stats();
2127 #endif
2128 #ifndef EXPERIMENTAL
2129     for (i = 0; i < MAX_SEC_INDEX; i++)
2130 #else
2131     for (i=0; i < 1;i++)
2132 #endif
2133     {
2134         /* Statistics for RX Tunnel */
2135         memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
2136         netapi_getSaStats(netapi_handle, sa_info[i].rx_tunnel, &netapi_sa_stats);
2137         if (netapi_sa_stats.validParams & NETAPI_IPSEC_STAT_VALID)
2138         {
2139              print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), 
2140                                  rx_sa[i].authMode, 
2141                                  rx_sa[i].cipherMode);
2142         }
2143         if (netapi_sa_stats.validParams & NETAPI_SIDEBAND_DATA_MODE_STAT_VALID)
2144         {
2145             print_datamode_stats(&(netapi_sa_stats.dataModeStats),
2146                                    rx_sa[i].authMode, 
2147                                    rx_sa[i].cipherMode);
2148         }
2149         
2150         /* Statistics for TX Tunnel */
2151         memset(&netapi_sa_stats, 0, sizeof(netapi_sa_stats));
2152         netapi_getSaStats(netapi_handle, sa_info[i].tx_tunnel, &netapi_sa_stats);
2153         if (netapi_sa_stats.validParams & NETAPI_IPSEC_STAT_VALID)
2154         {
2155              print_ipsec_stats(&(netapi_sa_stats.saIpsecStats), 
2156                                  tx_sa[i].authMode, 
2157                                  tx_sa[i].cipherMode);
2158         }
2159         if (netapi_sa_stats.validParams & NETAPI_SIDEBAND_DATA_MODE_STAT_VALID)
2160         {
2161             print_datamode_stats(&(netapi_sa_stats.dataModeStats),
2162                                    tx_sa[i].authMode, 
2163                                    tx_sa[i].cipherMode);
2164         }
2165     }
2166     netapi_dump_internal_heap_stats();
2169 //******************************************************
2170 //use scheduling housekeeping callback to generate pkts
2171 //******************************************************
2172 static int done_burst=0;
2173 void house(NETAPI_SCHED_HANDLE_T * s)
2175 Ti_Pkt * tip;
2176 unsigned int len;
2177 nwalTxPktInfo_t meta_tx = {0};
2178 PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
2179 int err;
2180 static int house_pkts_gened=0;
2181 int p;
2182 unsigned char * pIpHdr,* pData;
2183 unsigned int vv1,vv2,vv3;
2184 unsigned int sum_vv1=0;
2185 unsigned int sum_vv2=0;
2186 unsigned int sum_vv3=0;
2187 unsigned int sum_vv4=0;
2188 unsigned int sum_vv5=0;
2190 unsigned int nwal_flow_vv1,nwal_flow_vv2;
2191 unsigned int nwal_sum_vv1=0;
2192 unsigned int nwal_sum_vv2=0;
2193 unsigned int nwal_sum_vv3=0;
2194 unsigned int nwal_sum_vv4=0;
2195 unsigned int nwal_sum_vv5=0;
2196 unsigned int nwal_sum_vv6=0;
2198 unsigned int nwal_sum_flow_vv1=0;
2199 unsigned int nwal_sum_flow_vv2=0;
2200 unsigned long long cache_op_b1;
2201 unsigned long long  cache_op_b2;
2202 unsigned long long  n_c_ops;
2203 static int first =0;
2204 Cppi_HostDesc*      pPktDesc;
2206 int coreid = 0;  //who we are
2207 #ifdef MULTI_THREAD
2208 NETAPI_T nh= netapi_schedGetNetapiHandle(s);
2209 coreid=(int) netapi_getCookie(nh);
2211 if (QUIT) {netapi_schedShutdown(s,NULL,&err); return;}
2213 if (coreid==0) //slave
2215    netcp_cfgReqStats(nh, our_stats_cb_mt, 0,&err); 
2217 #else
2218 if(done_burst)
2220   house_pkts_gened+=TX_BURST;
2221   printf("net_test> request stats at n=%d \n",house_pkts_gened);
2222   netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err);
2223   if (err!=0) {printf("stats req failed\n");}
2224   if (house_pkts_gened >= np2process+ 100)
2225   {
2226      netapi_schedShutdown(s,NULL,&err);
2227   }
2228   return;
2230 done_burst=1;
2231 Osal_cache_op_measure_reset();
2232 memset(&meta_tx,0,sizeof(meta_tx));
2233 for(p=0;p<TX_BURST;p++) {  
2234 //reguest stats 
2235 if ((house_pkts_gened>0) && (! (house_pkts_gened%1000)) )
2237    printf("net_test> request stats at n=%d \n",house_pkts_gened);
2238    netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err); 
2239    if (err!=0) {printf("stats req failed\n");}
2243   if (house_pkts_gened >= np2process+ 100)
2244   {
2245      //shutdown
2246      netapi_schedShutdown(s,NULL,&err);
2247      continue;
2248   }
2250   else if (house_pkts_gened >= np2process) { house_pkts_gened+=1;  continue;}
2251   
2253 /* manufacture a pkt to transmit */
2254    tip = get_pkt(house_pkts_gened, &len, ourHeap, PKT_LEN,&testPkt[0]  , TEST_PKT_LEN);
2255    if(!tip) { house_pkts_gened +=1; continue; }
2258    /* set the pkt length */
2259    vv1 = hplib_mUtilGetPmuCCNT();
2260    Pktlib_setPacketLen(tip, len);
2262    /* set up meta data */
2263     meta.sa_handle=nwal_HANDLE_INVALID;
2264     /* #define BENCH_UDP_SEND */
2265 #ifdef BEND_UDP_SEND
2266     meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM | NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);
2267     meta_tx.startOffset = 0;
2268     /* GONE in V2 meta_tx.pktLen = len; */
2269     meta_tx.ipOffBytes = TEST_PKT_IP_OFFSET_BYTES;
2270     meta_tx.l4OffBytes = TEST_PKT_UDP_OFFSET_BYTES;
2271     meta_tx.l4HdrLen = TEST_PKT_UDP_HDR_LEN;
2272     //GONE in V2 meta_tx.ploadOffBytes = TEST_PKT_PLOAD_OFFSET_BYTES;
2273     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
2275     Pktlib_getDataBuffer(tip,&pData,&len);
2276    if(house_pkts_gened &0x1)
2277    {
2278         memcpy(&pData[6],&config.mac1[0] ,6);
2279    }
2280     pIpHdr = pData + meta_tx.ipOffBytes;
2281     meta_tx.pseudoHdrChecksum =
2282         test_utilGetIpv4PsudoChkSum(pIpHdr,(TEST_PAYLOAD_LEN+TEST_PKT_UDP_HDR_LEN));
2283 #else
2284    Pktlib_getDataBuffer(tip,&pData,&len);
2285    if(house_pkts_gened &0x1)
2286    {
2287         memcpy(&pData[6],&config.mac1[0] ,6);
2288    }
2289     meta_tx.txFlag1 = NWAL_TX_FLAG1_META_DATA_VALID;
2290     meta_tx.startOffset = 0;
2291     meta_tx.ploadLen = TEST_PAYLOAD_LEN;
2292 #endif
2293    /* post it to netcp tx channel*/
2294    meta.u.tx_meta=&meta_tx;
2295 #ifdef DEBUG_DESC
2296    if (house_pkts_gened<16) dump_descr((long *) tip, house_pkts_gened);
2297    else if (house_pkts_gened>99) dump_descr((long *) tip,house_pkts_gened);
2298 #endif
2300    if(!first)
2301    {
2302        first++;
2303        nwal_flow_vv1= hplib_mUtilGetPmuCCNT();
2304        if(nwal_initPSCmdInfo(PKTIO_GET_NWAL_INSTANCE(netcp_tx_chan),
2305                              &meta_tx,
2306                              &flowPSCmdInfo) != nwal_OK)
2307        {
2308            printf("nwal_initPSCmdInfo() ERROR \n");
2309        }
2310        nwal_flow_vv2= hplib_mUtilGetPmuCCNT();
2311        nwal_sum_flow_vv1 += (nwal_flow_vv1-vv1); 
2312        nwal_sum_flow_vv2 += (nwal_flow_vv2-nwal_flow_vv1); 
2313    }
2314        
2315    cache_op_b1= Osal_cache_op_measure(&n_c_ops);
2316    vv2= hplib_mUtilGetPmuCCNT();
2317 #ifdef BEND_UDP_SEND
2318    nwal_mCmdSetL4CkSumPort(  tip,
2319                              &flowPSCmdInfo,
2320                              TEST_PKT_UDP_OFFSET_BYTES,
2321                              (TEST_PKT_UDP_HDR_LEN + TEST_PAYLOAD_LEN),
2322                              meta_tx.pseudoHdrChecksum,
2323                              meta_tx.enetPort);
2324 #else
2325    nwal_mCmdSetPort  (tip,
2326                       &flowPSCmdInfo,  //could be NULL
2327                       0);  //port 0 -> switch decides
2329 #endif
2331    pPktDesc = Pktlib_getDescFromPacket(tip);
2332    /* Send the packet out to transmit Q*/
2333    Qmss_queuePushDescSize (flowPSCmdInfo.txQueue, 
2334                         pPktDesc, 
2335                         NWAL_DESC_SIZE);
2336    vv3= hplib_mUtilGetPmuCCNT();
2337    cache_op_b2= Osal_cache_op_measure(&n_c_ops);
2339    sum_vv1 += (vv2-vv1);
2340    if(!house_pkts_gened)
2341    {
2342        /* first packet. Take out the PS command label creation cost */
2343        sum_vv1 = sum_vv1 - nwal_sum_flow_vv2;
2344    }
2346    sum_vv3 += (vv3-vv2)-(long) (cache_op_b2-cache_op_b1); //sub out cache op cost
2348    // printf("pktio send. full=%d metadata=%d pktio_send=%d\n", vv3-vv1,  vv2-vv1,  vv3-vv2);
2349    
2351    stats[coreid].itx +=1;
2352    house_pkts_gened +=1;
2353  }
2355    unsigned long long  ccycles;
2356    ccycles =Osal_cache_op_measure(&n_c_ops);
2357    if (sum_vv1) 
2358    {
2359       printf("BURST NWAL Fast send %d pkts.  metadata=%d Cmd Label Creation Cost=%d  nwal Fast Send Cost (less cacheop)= %d n_c_ops=%lld cache_op_time=%lld (pp-> %d)\n", 
2360               stats[coreid].itx, sum_vv1/stats[coreid].itx,  nwal_sum_flow_vv2, sum_vv3/stats[coreid].itx, 
2361               n_c_ops, ccycles, n_c_ops? (ccycles/(n_c_ops/2L)) : 0);
2362 #if 0
2363       printf("NWAL Profile Cycles: Prof1= %d,Prof2=%d,Prof3=%d,Prof4=%d,Prof5=%d ,Prof6=%d \n",
2364               nwal_sum_vv1/stats[coreid].itx,nwal_sum_vv2/stats[coreid].itx,nwal_sum_vv3/stats[coreid].itx,
2365               nwal_sum_vv4/stats[coreid].itx,nwal_sum_vv5/stats[coreid].itx,nwal_sum_vv6/stats[coreid].itx);
2366   
2367 #endif  
2369       if(stats[core_id].itx2)
2370       {
2371           printf("nwal_flowSend Profile Cycles: Prof1= %d,Prof2=%d \n",
2372               nwal_sum_flow_vv1/stats[coreid].itx2,nwal_sum_flow_vv2/stats[coreid].itx2);
2373       }
2375    }
2377 #endif
2380 void  build_sa_db(int i)
2382     long tmp_spi;
2383     if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA1) && (tx_sa[i].cipherMode == NWAL_SA_EALG_AES_CBC))
2384     {
2385         /* static configuration, will not change */
2386         sa_info[i].tx_payload_info.aadSize = 0;
2387         sa_info[i].tx_payload_info.pAad = NULL;
2388         sa_info[i].tx_payload_info.pAuthIV = NULL;
2389         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */         
2390         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
2391                                                                      netTest_IP_HEADER_LEN +
2392                                                                     netTest_ESP_HEADER_LEN +
2393                                                                     netTest_AES_CBC_IV_LEN;
2395         /* dynamic configuration, will  be calculated on the fly */
2396         sa_info[i].tx_payload_info.authSize = 0; /* pkt len - mac - ip -icv (12) */
2397         sa_info[i].tx_payload_info.encSize = 0;   /* authSize - esp header size (always 8 bytes) */
2398         sa_info[i].tx_payload_info.pEncIV = 0;
2399         sa_info[i].tx_payload_info.pPkt = 0;     /* not being referenced in net_test */
2401         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CBC;
2402         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2403         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2404 #ifdef EXPERIMENTAL
2405         sa_info[i].iv_len=16;
2406         sa_info[i].bl=16;
2407         sa_info[i].spi = tx_sa[i].spi;
2408         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2409         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2410 #endif
2411         sa_info[i].tx_pkt_info.enetPort = 0;
2412         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2413         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2414         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2415         sa_info[i].tx_pkt_info.startOffset = 0;
2416         sa_info[i].tx_pkt_info.lpbackPass = 0;
2417         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2418         sa_info[i].tx_pkt_info.pPkt = NULL;
2419         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2420         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2421         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2422        
2423         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2425         tmp_spi = htonl((long)(tx_sa[i].spi));
2426          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2427          
2428          
2429     }
2430     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA2_256) && (tx_sa[i].cipherMode == NWAL_SA_EALG_AES_CTR))
2431     {
2432         /* static configuration, will not change */
2433         sa_info[i].tx_payload_info.aadSize = 0;
2434         sa_info[i].tx_payload_info.pAad = NULL;
2435         sa_info[i].tx_payload_info.pAuthIV = NULL;
2436         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2437         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
2438                                                                      netTest_IP_HEADER_LEN +
2439                                                                     netTest_ESP_HEADER_LEN +
2440                                                                     netTest_AES_CTR_IV_LEN;
2445         /* dynamic configuration, will  be calculated on the fly */
2446         sa_info[i].tx_payload_info.authSize = 0;
2447         sa_info[i].tx_payload_info.encSize = 0;
2448         sa_info[i].tx_payload_info.pEncIV = 0;
2449         sa_info[i].tx_payload_info.pPkt = 0;
2451         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CTR;
2452         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2453         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2454 #ifdef EXPERIMENTAL
2455         sa_info[i].iv_len=8;
2456         sa_info[i].bl=8;
2457         sa_info[i].spi = tx_sa[i].spi;
2458         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2459         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2460 #endif
2462         sa_info[i].tx_pkt_info.enetPort = 0;
2463         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2464         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2465         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2466         sa_info[i].tx_pkt_info.startOffset = 0;
2467         sa_info[i].tx_pkt_info.lpbackPass = 0;
2468         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2469         sa_info[i].tx_pkt_info.pPkt = NULL;
2470         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2471         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2472         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2473        
2474         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2475         tmp_spi = htonl((long)(tx_sa[i].spi));
2476          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2477     }
2478     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_SHA2_256) && (tx_sa[i].cipherMode == NWAL_SA_EALG_3DES_CBC))
2479     {
2480         /* static configuration, will not change */
2481         sa_info[i].tx_payload_info.aadSize = 0;
2482         sa_info[i].tx_payload_info.pAad = NULL;
2483         sa_info[i].tx_payload_info.pAuthIV = NULL;
2484         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2485         sa_info[i].tx_payload_info.encOffset = netTest_MAC_HEADER_LEN +
2486                                                                      netTest_IP_HEADER_LEN +
2487                                                                     netTest_ESP_HEADER_LEN +
2488                                                                     netTest_3DES_CBC_IV_LEN;
2490         /* dynamic configuration, will  be calculated on the fly */
2491         sa_info[i].tx_payload_info.authSize = 0;
2492         sa_info[i].tx_payload_info.encSize = 0;
2493         sa_info[i].tx_payload_info.pEncIV = 0;
2494         sa_info[i].tx_payload_info.pPkt = 0;
2496         sa_info[i].cipherMode = NWAL_SA_EALG_3DES_CBC;
2497         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2498         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2499 #ifdef EXPERIMENTAL
2500         sa_info[i].iv_len=8;
2501         sa_info[i].bl=8;
2502         sa_info[i].spi = tx_sa[i].spi;
2503         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2504         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2505 #endif
2507         sa_info[i].tx_pkt_info.enetPort = 0;
2508         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2509         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2510         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2511         sa_info[i].tx_pkt_info.startOffset = 0;
2512         sa_info[i].tx_pkt_info.lpbackPass = 0;
2513         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2514         sa_info[i].tx_pkt_info.pPkt = NULL;
2515         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2516         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2517         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2518        
2519         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2521         tmp_spi = htonl((long)(tx_sa[i].spi));
2522          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2523     }
2524     else if ((tx_sa[i].authMode == NWAL_SA_AALG_HMAC_MD5) && (rx_sa[i].cipherMode == NWAL_SA_EALG_NULL))
2525     {
2526         /* static configuration, will not change */
2527         sa_info[i].tx_payload_info.aadSize = 0;
2528         sa_info[i].tx_payload_info.pAad = NULL;
2529         sa_info[i].tx_payload_info.pAuthIV = NULL;
2530         //sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN + 24;        /*done: same for all cipher suites */
2531         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN;
2533         sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
2534                                                                      netTest_IP_HEADER_LEN +
2535                                                                     netTest_NULL_ESP_HEADER_LEN +
2536                                                                     netTest_NULL_IV_LEN +
2537                                                                     24;
2539         
2540 #ifdef EXPERIMENTAL
2541         sa_info[i].iv_len=0;
2542         sa_info[i].bl=4;
2543         sa_info[i].spi = tx_sa[i].spi;
2544         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2545         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2546 #endif
2549         /* dynamic configuration, will  be calculated on the fly */
2550         sa_info[i].tx_payload_info.authSize = 0;
2551         sa_info[i].tx_payload_info.encSize = 0;
2552         sa_info[i].tx_payload_info.pEncIV = 0;
2553         sa_info[i].tx_payload_info.pPkt = 0;
2555         sa_info[i].cipherMode = NWAL_SA_EALG_NULL;
2556         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2557         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2559         sa_info[i].tx_pkt_info.enetPort = 0;
2560         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2561         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2562         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2563         sa_info[i].tx_pkt_info.startOffset = 0;
2564         sa_info[i].tx_pkt_info.lpbackPass = 0;
2565         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2566         sa_info[i].tx_pkt_info.pPkt = NULL;
2567         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN;
2568         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2569         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2570         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_AH_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM | NWAL_TX_FLAG1_META_DATA_VALID ;
2571         tmp_spi = htonl((long)(tx_sa[i].spi));
2572          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2573     }
2574     else if ((tx_sa[i].authMode == NWAL_SA_AALG_NULL) && (rx_sa[i].cipherMode == NWAL_SA_EALG_AES_GCM))
2575     {
2576         /* static configuration, will not change */
2577         sa_info[i].tx_payload_info.aadSize = 0;
2578         sa_info[i].tx_payload_info.pAad = NULL;
2579         sa_info[i].tx_payload_info.pAuthIV = NULL;
2580         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2581         //sa_info[i].tx_payload_info.encIvSize = netTest_AES_GCM_IV_LEN;
2583         sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
2584                                                                      netTest_IP_HEADER_LEN +
2585                                                                     netTest_ESP_HEADER_LEN +
2586                                                                     netTest_AES_GCM_IV_LEN;
2587 #ifdef EXPERIMENTAL
2588         sa_info[i].iv_len=0;
2589         sa_info[i].bl=4;
2590         sa_info[i].spi = tx_sa[i].spi;
2591         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2592         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2593 #endif
2596         /* dynamic configuration, will  be calculated on the fly */
2597         sa_info[i].tx_payload_info.authSize = 0;
2598         sa_info[i].tx_payload_info.encSize = 0;
2599         //sa_info[i].tx_payload_info.ploadLen = 0;
2600         sa_info[i].tx_payload_info.pEncIV = 0;
2601         sa_info[i].tx_payload_info.pPkt = 0;
2603         sa_info[i].cipherMode = NWAL_SA_EALG_AES_GCM;
2604         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2605         sa_info[i].auth_tag_size = netTest_AES_GCM_CCM_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2607         sa_info[i].tx_pkt_info.enetPort = 0;
2608         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2609         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2610         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2611         sa_info[i].tx_pkt_info.startOffset = 0;
2612         sa_info[i].tx_pkt_info.lpbackPass = 0;
2613         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2614         sa_info[i].tx_pkt_info.pPkt = NULL;
2615         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2616         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2617         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2618        
2619         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2621         tmp_spi = htonl((long)(tx_sa[i].spi));
2622          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2623     }
2624     else if ((tx_sa[i].authMode == NWAL_SA_AALG_NULL) && (rx_sa[i].cipherMode == NWAL_SA_EALG_AES_CCM))
2625     {
2626         /* static configuration, will not change */
2627         sa_info[i].tx_payload_info.aadSize = 0;
2628         sa_info[i].tx_payload_info.pAad = NULL;
2629         //sa_info[i].tx_payload_info.authIvSize = 0;
2630         sa_info[i].tx_payload_info.pAuthIV = NULL;
2631         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;        /*done: same for all cipher suites */
2633         sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
2634                                                                      netTest_IP_HEADER_LEN +
2635                                                                     netTest_ESP_HEADER_LEN +
2636                                                                     netTest_AES_CCM_IV_LEN;
2637 #ifdef EXPERIMENTAL
2638         sa_info[i].iv_len=0;
2639         sa_info[i].bl=4;
2640         sa_info[i].spi = tx_sa[i].spi;
2641         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2642         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2643 #endif
2646         /* dynamic configuration, will  be calculated on the fly */
2647         sa_info[i].tx_payload_info.authSize = 0;
2648         sa_info[i].tx_payload_info.encSize = 0;
2649         //sa_info[i].tx_payload_info.ploadLen = 0;
2650         sa_info[i].tx_payload_info.pEncIV = 0;
2651         sa_info[i].tx_payload_info.pPkt = 0;
2653         sa_info[i].cipherMode = NWAL_SA_EALG_AES_CCM;
2654         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2655         sa_info[i].auth_tag_size = netTest_AES_GCM_CCM_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM */
2657         sa_info[i].tx_pkt_info.enetPort = 0;
2658         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2659         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2660         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2661         sa_info[i].tx_pkt_info.startOffset = 0;
2662         sa_info[i].tx_pkt_info.lpbackPass = 0;
2663         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2664         sa_info[i].tx_pkt_info.pPkt = NULL;
2665         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2666         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2667         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2668        
2669         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2670         
2671         tmp_spi = htonl((long)(tx_sa[i].spi));
2672          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2673     }
2674     else if ((tx_sa[i].authMode == NWAL_SA_AALG_AES_XCBC) && (rx_sa[i].cipherMode == NWAL_SA_EALG_NULL))
2675     {
2676         /* static configuration, will not change */
2677         sa_info[i].tx_payload_info.aadSize = 0;
2678         sa_info[i].tx_payload_info.pAad = NULL;
2679         sa_info[i].tx_payload_info.pAuthIV = NULL;
2680         sa_info[i].tx_payload_info.authOffset = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2683         sa_info[i].tx_payload_info.encOffset =         netTest_MAC_HEADER_LEN +
2684                                                                      netTest_IP_HEADER_LEN +
2685                                                                     netTest_ESP_HEADER_LEN +
2686                                                                     netTest_NULL_IV_LEN;
2687 #ifdef EXPERIMENTAL
2688         sa_info[i].iv_len=0;
2689         sa_info[i].bl=4;
2690         sa_info[i].spi = tx_sa[i].spi;
2691         sa_info[i].src =*((unsigned int *)(&config.local_ipsec_ip.ipv4[0]));
2692         sa_info[i].dst =*((unsigned int *)(&config.remote_ipsec_ip.ipv4[0]));
2693 #endif
2696         /* dynamic configuration, will  be calculated on the fly */
2697         sa_info[i].tx_payload_info.authSize = 0;
2698         sa_info[i].tx_payload_info.encSize = 0;
2699         //sa_info[i].tx_payload_info.ploadLen = 0;
2700         sa_info[i].tx_payload_info.pEncIV = 0;
2701         sa_info[i].tx_payload_info.pPkt = 0;
2703         sa_info[i].cipherMode = NWAL_SA_EALG_NULL;
2704         sa_info[i].authMode = NWAL_SA_AALG_AES_XCBC;
2705         sa_info[i].inner_ip_offset = sa_info[i].tx_payload_info.encOffset;
2706         sa_info[i].auth_tag_size = netTest_ICV_LEN;  /* icv or mac size,. always 12 except for AES_CCM/AES_GCM , GMAC*/
2708         sa_info[i].tx_pkt_info.enetPort = 0;
2709         sa_info[i].tx_pkt_info.ipOffBytes = sa_info[i].tx_payload_info.encOffset;
2710         sa_info[i].tx_pkt_info.l4HdrLen = netTest_UDP_HEADER_LEN; /*UDP header len */
2711         sa_info[i].tx_pkt_info.l4OffBytes = sa_info[i].inner_ip_offset + netTest_IP_HEADER_LEN;
2712         sa_info[i].tx_pkt_info.startOffset = 0;
2713         sa_info[i].tx_pkt_info.lpbackPass = 0;
2714         sa_info[i].tx_pkt_info.ploadLen = 0; /*sa_info[i].tx_pkt_info.l4OffBytes + 4 */
2715         sa_info[i].tx_pkt_info.pPkt = NULL;
2716         sa_info[i].tx_pkt_info.saOffBytes = netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN;
2717         sa_info[i].tx_pkt_info.saPayloadLen = 0;
2718         sa_info[i].tx_pkt_info.pseudoHdrChecksum =0;
2719        
2720         sa_info[i].tx_pkt_info.txFlag1 = NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID ;
2721         
2722         tmp_spi = htonl((long)(tx_sa[i].spi));
2723          trie_insert(p_trie_sa,(char *)&tmp_spi,4, (void *) &sa_info[i]); //asociate with tx sa SPI
2724     }
2725     else
2726         printf("build_sa_db(): invalid encryption/authentication combination selected\n");
2728     //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);
2729     
2730     
2735 #define CHECK_SET_PARAM(ARG1, ARG2)     \
2736     do { \
2737         if(strcmp(key, ARG1) == 0) { \
2738         if(data)strncpy(ARG2,data,CONFIG_STRING_LEN); \
2739         printf("CHECK_SET_PARM, match found, input cong string %s\n", ARG2); \
2740         continue; \
2741         } \
2742     } while(0)
2744 #define CHECK_SET_PARAM2(ARG1, ARG2,  ARG3)     \
2745     do { \
2746         if(strcmp(key, ARG1) == 0) { \
2747         if(data) strncpy(ARG2,data,CONFIG_STRING_LEN); \
2748         if(data2) strncpy(ARG3,data2,CONFIG_STRING_LEN); \
2749         printf("CHECK_SET_PARM2, match found, input cong string %s %s\n", ARG2, ARG3); \
2750         continue; \
2751         } \
2752     } while(0)
2754 unsigned char hex2dec(char *p_s)
2756   int val;
2757   sscanf(p_s,"%x",&val); 
2758  return val&0xff;
2760 void parse_one_mac(char * p_mac_str, unsigned char *p_mac)
2762     int index = 0;
2763     int i;
2764     char *pch = strtok (&(p_mac_str[0]),"-");
2766     while (pch != NULL)
2767     {
2768          printf ("%s\n",pch);
2769          p_mac[index] = hex2dec(pch);
2770          index++;
2771          pch = strtok (NULL,"-");
2772     }
2773      printf("index value : %d\n", index);
2774     for (i=0; i<6;i++)
2775          printf("************mac0[%d]: 0x%x\n",i,  p_mac[i]);
2778 void parse_one_ip(char * p_ip_addr_str, unsigned char * p_ip)
2780     int index = 0;
2781     int i;
2782     char * pch = strtok (&p_ip_addr_str[0],".");
2784      while (pch != NULL)
2785      {
2786         printf ("xxxxx: %s\n",pch);
2787         p_ip[index] = atoi(pch);
2788         index++;
2789         pch = strtok (NULL,".");
2790     }
2791     printf("index value : %d\n", index);
2792     for (i=0; i<4;i++)
2793         printf("************ip[%d]: 0x%x\n",i, p_ip[i]);
2798 void parse_mac_address(netTestConfigFile_t *pConfig)
2800     if (strlen(&pConfig->mac0[0]))
2801         parse_one_mac(&pConfig->mac0[0],&config.mac0[0]);
2802     if (strlen(&pConfig->mac1[0]))
2803         parse_one_mac(&pConfig->mac1[0],&config.mac1[0]);
2805 void parse_ip_address(netTestConfigFile_t *pConfig)
2807     if (strlen(&pConfig->ip0[0]))
2808         parse_one_ip(&pConfig->ip0[0],&config.ip0.ipv4[0]);
2809     if (strlen(&pConfig->ip1[0]))
2810         parse_one_ip(&pConfig->ip1[0],&config.ip1.ipv4[0]);
2811     if (strlen(&pConfig->ip2[0]))
2812         parse_one_ip(&pConfig->ip2[0],&config.ip2.ipv4[0]);
2813     if (strlen(&pConfig->local_ipsec_ip[0]))
2814         parse_one_ip(&pConfig->local_ipsec_ip[0],&config.local_ipsec_ip.ipv4[0]);
2815     if (strlen(&pConfig->remote_ipsec_ip[0]))
2816     parse_one_ip(&pConfig->remote_ipsec_ip[0],&config.remote_ipsec_ip.ipv4[0]);
2820 void parse_ipsec_mode(netTestConfigFile_t *pConfig)
2823     if (strlen(&pConfig->ipsec_mode_rx[0]))
2824     {
2825         if (strcmp(pConfig->ipsec_mode_rx, "SIDEBAND") == 0)
2826         {
2827             config.ipsec_mode_rx = IPSEC_MODE_RX_SIDEBAND;
2828         }
2829         else if (strcmp(pConfig->ipsec_mode_rx, "INFLOW") == 0)
2830         {
2831             config.ipsec_mode_rx = IPSEC_MODE_RX_INFLOW;
2832         }
2833         else
2834             printf("parse_ipsec_mode(), invalid RX ipsec mode in config file \n");
2835     }
2837     if (strlen(&pConfig->ipsec_mode_tx[0]))
2838     {
2839         if (strcmp(pConfig->ipsec_mode_tx, "SIDEBAND") == 0)
2840         {
2841             config.ipsec_mode_tx = IPSEC_MODE_TX_SIDEBAND;
2842         }
2843         else if (strcmp(pConfig->ipsec_mode_tx, "INFLOW") == 0)
2844         {
2845             config.ipsec_mode_tx = IPSEC_MODE_TX_INFLOW;
2846         }
2847     else
2848         printf("parse_ipsec_mode(), invalid TX ipsec mode in config file \n");
2849     }
2851     printf("parse_ipsec_mode(): RX mode %d\n", config.ipsec_mode_rx);
2852     printf("parse_ipsec_mode(): TX mode %d\n", config.ipsec_mode_tx);
2854     
2857 #ifdef EXPERIMENTAL
2858 int n_routes=0;
2859 int n_dst_ips=0;
2860 void parse_routes(netTestConfigFile_t *pConfig)
2862 int i;
2863 int said=0;
2864 for(i=0;i<MAX_ROUTES;i++)
2866    int port;
2867    if (pConfig->routes[i][0])
2868    {
2869       port=atoi(&pConfig->ports[i][0]);
2870       if((port<1)||(port>2)) continue; //bad port #: only 1 or 2 valid
2871       if(strncmp(&pConfig->routes[i][0],"MAC",3)==0)
2872       {
2873          routes[i].out_port = port;
2874          parse_one_mac(&pConfig->routes[i][3],&routes[i].out_mac[0]);
2875          memcpy(&routes[i].out_mac[6], ((port==1) ?&config.mac0[0]: &config.mac1[0] ),6); 
2876          routes[i].out_mac[12]=0x08;
2877          routes[i].out_mac[13]=0x00;
2878          routes[i].sec_ptr=NULL;
2879          n_routes+=1;
2880       }
2881       else if (strncmp(&pConfig->routes[i][0],"SA",2)==0)
2882       {      
2883          said=atoi(&pConfig->routes[i][2]) ;
2884          routes[i].sec_ptr=&sa_info[said];
2885          n_routes+=1;
2886       }
2887    }
2889 our_router = route_init();
2890 for (i=0;i<MAX_ROUTES;i++)
2892   unsigned long ip_be;
2893   int route_index;
2894   if (pConfig->dst_ips[i][0])
2895   {
2896      parse_one_ip(&pConfig->dst_ips[i][0],(unsigned char *)&ip_be);
2897      sscanf(&pConfig->paths[i][0],"route%d",&route_index);
2898      route_add(our_router,&ip_be,&routes[route_index]);
2899      n_dst_ips+=1;
2900   }
2902 printf(">Route DB built.  %d entries\n",n_dst_ips);
2904 #endif
2905 static void parse_config_file(FILE * fpr, netTestConfigFile_t *pConfig)
2907     char line[MAX_LINE_LENGTH + 1];
2908     int i;
2909  
2910     char *key, *data, *ep, *data2;
2911     char tokens[] = " :=;\n";
2912     char temp_str[50];
2913     memset(line, 0, MAX_LINE_LENGTH + 1);
2914     memset(pConfig, 0, sizeof(netTestConfigFile_t));
2915     while (fgets(line, MAX_LINE_LENGTH + 1, fpr)) 
2916     {
2917         if(line[0]=='#') continue; //skip comment
2918         key  = (char *)strtok(line, tokens);
2919         data = (char *)strtok(NULL, tokens);
2920         data2 = (char *)strtok(NULL, tokens);
2921         if (!key) continue;
2922         if (!data) continue;
2924         if(strlen(data) == 0) 
2925         {
2926             continue;
2927         }
2929          CHECK_SET_PARAM(INIT_CONFIG_MAC0,&(pConfig->mac0[0]));
2930          CHECK_SET_PARAM(INIT_CONFIG_MAC1,&(pConfig->mac1[0]));
2931          CHECK_SET_PARAM(INIT_CONFIG_IP0,&(pConfig->ip0[0]));
2932          CHECK_SET_PARAM(INIT_CONFIG_IP1,&(pConfig->ip1[0]));
2933          CHECK_SET_PARAM(INIT_CONFIG_IP2,&(pConfig->ip2[0]));
2934          CHECK_SET_PARAM(INIT_CONFIG_LOCAL_IPSEC_IP,&(pConfig->local_ipsec_ip[0]));
2935          CHECK_SET_PARAM(INIT_CONFIG_REMOTE_IPSEC_IP,&(pConfig->remote_ipsec_ip[0]));
2936          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_RX,&(pConfig->ipsec_mode_rx[0]));
2937          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_MODE_TX,&(pConfig->ipsec_mode_tx[0]));
2938          CHECK_SET_PARAM(INIT_CONFIG_IPSEC_IF_NO,&(pConfig->ipsec_if_no[0]));
2939 #ifdef EXPERIMENTAL
2940     for(i=0;i<MAX_ROUTES;i++)
2941     {
2942         sprintf(temp_str,"route%d",i);
2943         CHECK_SET_PARAM2(temp_str,&pConfig->routes[i][0],&pConfig->ports[i][0] );
2944     }
2945     for(i=0;i<MAX_ROUTES;i++)
2946     {
2947         sprintf(temp_str,"dstip%d",i);
2948         CHECK_SET_PARAM2(temp_str,&pConfig->dst_ips[i][0],&pConfig->paths[i][0] );
2949     }
2950 #endif
2951          
2952     }
2953     parse_mac_address(pConfig);
2955     parse_ip_address(pConfig);
2957     parse_ipsec_mode(pConfig);
2958 #ifdef EXPERIMENTAL
2959      if (strlen(&pConfig->ipsec_if_no[0]))
2960         config.ipsec_if_no = atoi(&pConfig->ipsec_if_no[0]);
2961     parse_routes(pConfig);
2962 #endif
2966 #ifdef MULTI_THREAD
2967 NETAPI_T worker_nh[TUNE_NETAPI_NUM_CORES];
2968 void slow_path_thread(int coreid)
2970     int err;
2972     PKTIO_HANDLE_T *our_chan;
2973     PKTIO_HANDLE_T *rx_chan;
2974     PKTIO_HANDLE_T *tx_chan;
2975     PKTIO_HANDLE_T *sb_tx_chan;
2976     PKTIO_HANDLE_T *sb_rx_chan;
2978     
2980     printf("slow_path_thread, mypid: %d, core_id %d\n", gettid(), coreid);
2982     CPU_ZERO( &cpu_set);
2983 #ifdef CORTEX_A15
2984     CPU_SET( coreid, &cpu_set);
2985     hplib_utilSetupCore(coreid, &cpu_set);
2986 #else
2987       CPU_SET( 0, &cpu_set);
2988     hplib_utilSetupCore(coreid+1, &cpu_set);
2989 #endif
2990     worker_nh[coreid]=netapi_init(NETAPI_CORE_MASTER,NULL);
2992 #ifdef DAL_REVIEW
2993     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) worker_nh[coreid];
2995    /* open netcp default tx, rx queues */
2996     tx_chan = pktio_open(worker_nh[coreid], NETCP_TX, NULL, &netcp_tx_cfg,  &err);
2997     
2998     
2999 #ifdef EXPERIMENTAL
3000     rx_chan = pktio_open(worker_nh[coreid], NETCP_RX, (PKTIO_CB) recv_cb_router, &netcp_rx_cfg,  &err);
3001 #else
3002     rx_chan = pktio_open(worker_nh[coreid], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
3003 #endif
3004     
3005 #ifndef EXPERIMENTAL
3006     /* create a pktio channel for specially classified pkts */
3007     /* open netcp default tx, rx queues for sideband crypto */
3008      sb_tx_chan = pktio_open(worker_nh[coreid], NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
3009     
3010     sb_rx_chan = pktio_open(worker_nh[coreid], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
3011 #endif
3013 #endif
3017     netapi_setCookie(worker_nh[coreid],coreid);
3018     //our_core = coreid;
3019       
3020     scheduler[coreid] =netapi_schedOpen(worker_nh[coreid],&our_sched_cfg, &err);
3021     if (!scheduler[coreid]) 
3022     {
3023         printf("sched create failed for core%d\n",coreid); 
3024         exit(1);
3025     }
3026       scheduler[coreid]->config.yield = FALSE;
3027        scheduler[coreid]->config.pollGarbageQ = TRUE;
3028         scheduler[coreid]->config.pollCtrlQ = TRUE;
3029             /*********************************************/
3030     /**************Entry point into scheduler ****/
3031     /*********************************************/
3032     netapi_schedWaitForEvents(scheduler[coreid], &err);
3033     printf(">net_test: core %d worker thread done\n",coreid);
3034     pktio_close(tx_chan, &err);
3035     pktio_close(rx_chan, &err);
3036     pktio_close(sb_tx_chan, &err);
3037     pktio_close(sb_tx_chan, &err);
3038     netapi_shutdown(worker_nh[coreid]);
3041 void fast_path_thread(int coreid)
3043     int err;
3044         PKTIO_HANDLE_T *our_chan;
3045     PKTIO_HANDLE_T *rx_chan;
3046     PKTIO_HANDLE_T *tx_chan;
3047     PKTIO_HANDLE_T *sb_tx_chan;
3048     PKTIO_HANDLE_T *sb_rx_chan;
3050 #ifdef CORTEX_A15
3051     CPU_SET( coreid, &cpu_set);
3052         hplib_utilSetupCore(coreid, &cpu_set);
3053 #else
3054       CPU_SET( 0, &cpu_set);
3055     hplib_utilSetupCore(coreid + 1, &cpu_set);
3056 #endif
3057     worker_nh[coreid]=netapi_init(NETAPI_CORE_MASTER,NULL);
3059 #ifdef DAL_REVIEW
3060     NETAPI_HANDLE_T * n = (NETAPI_HANDLE_T *) worker_nh[coreid];
3062    /* open netcp default tx, rx queues */
3063     tx_chan = pktio_open(worker_nh[coreid], NETCP_TX, NULL, &netcp_tx_cfg,  &err);
3064     
3065     
3066 #ifdef EXPERIMENTAL
3067     rx_chan = pktio_open(worker_nh[coreid], NETCP_RX, (PKTIO_CB) recv_cb_router, &netcp_rx_cfg,  &err);
3068 #else
3069     rx_chan = pktio_open(worker_nh[coreid], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
3070 #endif
3071     
3072 #ifndef EXPERIMENTAL
3073     /* create a pktio channel for specially classified pkts */
3074     /* open netcp default tx, rx queues for sideband crypto */
3075      sb_tx_chan = pktio_open(worker_nh[coreid], NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
3076     
3077     sb_rx_chan = pktio_open(worker_nh[coreid], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
3078 #endif
3080 #endif
3082     
3083     netapi_setCookie(worker_nh[coreid],coreid);
3084     //our_core = coreid;
3085     scheduler[coreid] =netapi_schedOpen(worker_nh[coreid],&our_sched_cfg, &err);
3086     if (!scheduler[coreid]) 
3087         {
3088         printf("sched create failed for core%d\n",coreid); 
3089         exit(1);
3090     }
3092     /*********************************************/
3093     /**************Entry point into scheduler ****/
3094     /*********************************************/
3095     scheduler[coreid]->config.yield = FALSE;
3096      scheduler[coreid]->config.pollGarbageQ = FALSE;
3097      scheduler[coreid]->config.pollCtrlQ = FALSE;
3098      //sleep(100000);
3099     netapi_schedWaitForEvents(scheduler[coreid], &err);
3100     printf(">net_test: core %d worker thread done\n",coreid);
3101     pktio_close(tx_chan, &err);
3102     pktio_close(rx_chan, &err);
3103     pktio_close(sb_tx_chan, &err);
3104     pktio_close(sb_tx_chan, &err);
3105     netapi_shutdown(worker_nh[coreid]);
3108 #endif
3109 static  netTestConfigFile_t config_file;
3110 /***************************************
3111  ********** test driver*****************
3112  ***************************************/
3113 int main(int argc, char **argv)
3115     int err,i;
3116     Pktlib_HeapCfg      heapCfg;
3117     rlim_t oss,ss = 1024*1024;
3118     struct rlimit rl;
3119     int32_t             errCode;
3120     Pktlib_HeapIfTable*  pPktifTable;
3122     FILE * fpr = NULL;
3124     nwalSaIpSecId_t  nwalSaIpSecId;
3126     err= getrlimit(RLIMIT_STACK,&rl);
3127     if (!err) printf(" stack limit = %d\n",rl.rlim_cur); else printf("getrlimit failed\n");
3129     if (argc>=2)  np2process = atoi(argv[1]);
3130         printf("*************** np2process %d\n", np2process);
3131     if (np2process<0) np2process = NP; /* default */
3132     if (argc==3)  perslow = atoi(argv[2]);
3133     if ((perslow<0)||(perslow>100)) perslow=PERSLOW;//default
3134     if (argc>3) {printf("net_test  <no of pkts to process> <percent slow path>\n"); exit(1);}
3136      /* install signal handler for ^c */
3137     signal(SIGINT,mysig);
3139     fpr = fopen(input_file_name, "r");
3140     if (fpr == NULL) 
3141     {
3142         printf("Error in opening %s input file\n", input_file_name);
3143         exit(1);
3144     }
3145     else
3146     {
3147         parse_config_file(fpr,&config_file);
3148     }
3150     memset(&sa_info, 0, sizeof(sa_info));
3153     //real mode, so update our test packet mac header and ip header
3154     if (pktloopback==0)
3155     {
3156         memcpy(&testPkt,&real_mac_header[0],14); //overwrite test pkt mac address
3157         memcpy(&testPkt[26],&real_ip_addr[0],8);//overrite test pkt ip addresses
3158     }
3160 #ifdef MULTI_THREAD
3161     /* assign main net_test thread to run on core 0 */
3162     CPU_ZERO( &cpu_set);
3163     CPU_SET( 0, &cpu_set);
3164     hplib_utilSetupCore(0, &cpu_set);
3165 #endif
3166     /* create netapi */
3167     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
3169     /* open the main heap */
3170     ourHeap = Pktlib_findHeapByName("netapi");
3171     if (!ourHeap)
3172     {
3173         printf("Pktlib_findHeapByName()  fail\n");
3174         exit(1);
3175     }
3177     /* create two secondary heaps */
3178     /* Initialize the heap configuration. */
3179     memset ((void *)&heapCfg, 0, sizeof(Pktlib_HeapCfg));
3181     pPktifTable = netapi_getPktlibIfTable();
3182     /* Populate the heap configuration */
3183     heapCfg.name                = "netapi-small";
3184     heapCfg.memRegion           = NETAPI_GLOBAL_REGION;
3185     heapCfg.sharedHeap          = 1;
3186     heapCfg.useStarvationQueue  = 0;
3187     heapCfg.dataBufferSize      = 512;
3188     heapCfg.numPkts             = 64;
3189     heapCfg.numZeroBufferPackets= 0;
3190     heapCfg.heapInterfaceTable.data_malloc  = pPktifTable->data_malloc;
3191     heapCfg.heapInterfaceTable.data_free    = pPktifTable->data_free;
3192     heapCfg.dataBufferPktThreshold   = 0;
3193     heapCfg.zeroBufferPktThreshold   = 0;
3195     specialSmall = Pktlib_createHeap(&heapCfg, &errCode);
3196     heapCfg.name                = "netapi-big";
3197     heapCfg.dataBufferSize      = 1600;
3198     specialLarge = Pktlib_createHeap(&heapCfg, &errCode);
3199     //register these heaps so poll routine will include their garbage queues.
3200     netapi_registerHeap(netapi_handle, specialSmall);
3201     netapi_registerHeap(netapi_handle, specialLarge);
3203 #ifdef REASSEMBLE_BENCH
3204     our_reassemble_bench(2);
3205 exit(1);
3206 #endif
3208 #ifndef EXPERIMENTAL
3209     /* create a pktio channel */
3210     our_chan=pktio_create(netapi_handle,"our1stq",(PKTIO_CB) recv_cb_bench, &our_chan_cfg,&err);
3211     if (!our_chan)
3212     {
3213         printf("pktio create failed err=%d\n",err);
3214         exit(1);
3215     }
3216 #endif
3218     /* open netcp default tx, rx queues */
3219     netcp_tx_chan= pktio_open(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
3220     if (!netcp_tx_chan)
3221     {
3222         printf("pktio open TX failed err=%d\n",err);
3223         exit(1);
3224     }
3225 #ifdef EXPERIMENTAL
3226     netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb_router, &netcp_rx_cfg,  &err);
3227 #else
3228     netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
3229 #endif
3230     if (!netcp_rx_chan)
3231     {
3232         printf("pktio open RX failed err=%d\n",err);
3233         exit(1);
3234     }
3236 #ifndef EXPERIMENTAL
3237     /* create a pktio channel for specially classified pkts */
3238     netcp_rx_chan2= pktio_create(netapi_handle, "classq", (PKTIO_CB) recv_cb, &netcp_rx_cfg2,  &err);
3239     if (!netcp_rx_chan2) {printf("pktio create RX2 failed err=%d\n",err); exit(1);}
3241     /* open netcp default tx, rx queues for sideband crypto */
3242     netcp_sb_tx_chan= pktio_open(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
3243     if (!netcp_sb_tx_chan)
3244     {
3245         printf("pktio open SB TX failed err=%d\n",err);
3246         exit(1);
3247     }
3248     netcp_sb_rx_chan= pktio_open(netapi_handle, NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
3249     if (!netcp_sb_rx_chan)
3250     {
3251         printf("pktio open SB RX failed err=%d\n",err);
3252         exit(1);
3253     }
3254 #endif
3256     printf("net_test> %d bytes left in our CMA area\n", netapi_getBufMemRemainder());
3257     /* create scheduler instance */
3258     our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
3259     if (!our_sched) {printf("sched create failed\n"); exit(1);}
3261 #if 0
3262     /********************************************
3263     * Basic pkt loopback test
3264     *********************************************/
3265     printf("...running pure push/pop benchmark\n");
3266     our_pktio_bench(1000);
3267     our_pktio_bench(1000);
3268     our_pktio_bench(1000);
3269     our_pktio_bench(1000);
3270     our_pktio_bench(1000);
3271     /*********************************************/
3272 #endif
3273     //#define PROMISCUOUS
3274 #ifdef PROMISCUOUS
3275 #define ETH0 1
3276 #define ETH1 2
3277     printf(">net_test: WARNING, ADDING RULE FOR PROMISCUOUS THAT WILL BREAK LINUX STACK\n");
3278     netcp_cfgCreateMacInterface(
3279                       netapi_handle,
3280                       &all_mac[0],
3281                       0,0,
3282                       (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
3283                       (NETCP_CFG_VLAN_T ) NULL ,  //future
3284                       1,
3285                       &err);
3286     if (err) {printf("addmac0 failed %d\n",err); exit(1); }
3288 #else
3289 #define ETH0 0
3290 #define ETH1 1
3291 #endif
3293     /* add mac intefaces */
3294     netcp_cfgCreateMacInterface(
3295                       netapi_handle,
3296                       &config.mac0[0],
3297                       ETH0,0,
3298                       (NETCP_CFG_ROUTE_HANDLE_T)  NULL,
3299                       (NETC