. changes for ddr cache
[keystone-rtos/netapi.git] / ti / runtime / netapi / test / net_test.c
1 /******************************************\r
2  * File: net_test.c\r
3  * Purpose: test app for netapi\r
4  **************************************************************\r
5  * FILE:  net_test.c\r
6  * \r
7  * DESCRIPTION:  netapi user space transport\r
8  *               library  test application\r
9  * \r
10  * REVISION HISTORY:  rev 0.0.1 \r
11  *\r
12  *  Copyright (c) Texas Instruments Incorporated 2010-2011\r
13  * \r
14  *  Redistribution and use in source and binary forms, with or without \r
15  *  modification, are permitted provided that the following conditions \r
16  *  are met:\r
17  *\r
18  *    Redistributions of source code must retain the above copyright \r
19  *    notice, this list of conditions and the following disclaimer.\r
20  *\r
21  *    Redistributions in binary form must reproduce the above copyright\r
22  *    notice, this list of conditions and the following disclaimer in the \r
23  *    documentation and/or other materials provided with the   \r
24  *    distribution.\r
25  *\r
26  *    Neither the name of Texas Instruments Incorporated nor the names of\r
27  *    its contributors may be used to endorse or promote products derived\r
28  *    from this software without specific prior written permission.\r
29  *\r
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \r
31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT \r
32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\r
33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT \r
34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, \r
35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT \r
36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \r
40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
41 \r
42  *****************************************/\r
43 \r
44 #include <stdio.h>\r
45 #include <stdlib.h>\r
46 #include <unistd.h>\r
47 #include <string.h>\r
48 \r
49 \r
50 #include "trie.h"\r
51 #include "string.h"\r
52 #include "netapi.h"\r
53 #include "pktio.h"\r
54 #include <sys/resource.h>\r
55 \r
56 //IPSEC MODE(only choose one rx and one tx)\r
57 #define IPSEC_MODE_RX_INFLOW\r
58 #define IPSEC_MODE_TX_INFLOW\r
59 //#define IPSEC_MODE_RX_SIDEBAND\r
60 //#define IPSEC_MODE_TX_SIDEBAND\r
61 \r
62 /*************debug********************/\r
63 void dump_descr(unsigned long *p, int n)\r
64 {\r
65    printf("--------dump of descriptor %d %x\n", n, (int) p);\r
66    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]);\r
67    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]);\r
68    printf("-----------------------------\n");\r
69 }\r
70 void dump_header(unsigned long *p, int n, int a, int r)\r
71 {\r
72    printf("--------dump of header %d %x appID=%x flag1=%x\n", n, (int) p,a,r);\r
73    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]);\r
74    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]);\r
75    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]);\r
76    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]);\r
77    printf("-----------------------------\n");\r
78 }\r
79 \r
80 /*****************************************/\r
81 \r
82 \r
83 //************for multi pkt burst  xfer test in loopback mode\r
84 #define TX_BURST 4\r
85 int pktloopback=TUNE_NETAPI_NWAL_ENABLE_PASS_LOOPBACK;\r
86 \r
87 //this device: 10.0.0.100, mac 0x,01,02,03,04,05  and .. 0x6\r
88 \r
89 //test packet, setup for loopback (so dest is ourself)\r
90 static uint8_t testPkt[] = {\r
91 \r
92   /* MAC header */\r
93   0x00, 0x01, 0x02, 0x03, 0x04, 0x05,\r
94   0x00, 0xe0, 0xa6, 0x66, 0x57, 0x04,\r
95   0x08, 0x00,\r
96 \r
97   /* IP header */\r
98   0x45, 0x00,\r
99   0x00, 0x6c,  /* Length (including this header) */\r
100   0x00, 0x00, 0x00, 0x00, 0x05, 0x11,\r
101   0x00, 0x00,  /* Header checksum */\r
102   0x0a, 0x00, 0x00, 0x0a, 0x0a, 0x00, 0x00, 0x64,\r
103 \r
104   /* UDP header */\r
105   0x12, 0x34, 0x05, 0x55,\r
106   0x00, 0x58,  /* Length, including this header */\r
107   0x00, 0x00,  /* Header checksum */\r
108 \r
109  /* Payload */\r
110   0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,\r
111   0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41,\r
112   0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,\r
113   0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51,\r
114   0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,\r
115   0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61,\r
116   0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,\r
117   0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71,\r
118   0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,\r
119   0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81\r
120 \r
121 };\r
122 \r
123 #define TEST_PAYLOAD_LEN            80\r
124 \r
125 #define TEST_PKT_IP_OFFSET_BYTES        14\r
126 #define TEST_PKT_UDP_OFFSET_BYTES       34\r
127 #define TEST_PKT_PLOAD_OFFSET_BYTES     42\r
128 #define TEST_PKT_UDP_HDR_LEN            8\r
129 /* Offsets to length fields */\r
130 #define TEST_PKT_OFFSET_IP_LEN      16\r
131 #define TEST_PKT_OFFSET_UDP_LEN     38\r
132 \r
133 #define TEST_PKT_LEN                122\r
134 \r
135 /* The pseudo header checksum of the packet except for the 16 bit length */\r
136 #define TEST_PKT_PSEUDO_HDR_CHKSUM_SANS_LEN  0x0FFC\r
137 \r
138 \r
139 \r
140 #if 1\r
141 //#include "arpa/inet.h"\r
142 long htonl(long x)\r
143 {\r
144         long temp = (x&0xff000000)>>24 | (x&0xff0000)>>8 | (x&0xff00)<<8 |  (x&0xff)<<24 ;\r
145         return temp;\r
146 }\r
147 \r
148 /********************************************************************\r
149  *  FUNCTION PURPOSE: Ones complement addition utility\r
150  ********************************************************************\r
151  ********************************************************************/\r
152 uint16_t test_utilOnesComplementAdd (uint16_t v1, uint16_t v2)\r
153 {\r
154   uint32_t result;\r
155 \r
156   result = (uint32_t)v1 + (uint32_t)v2;\r
157   result = (result >> 16) + (result & 0xffff);\r
158   result = (result >> 16) + (result & 0xffff);\r
159 \r
160   return ((uint16_t)result);\r
161 }\r
162 \r
163 /********************************************************************\r
164  *  FUNCTION PURPOSE: Ones complement checksum utility\r
165  ********************************************************************\r
166  ********************************************************************/\r
167  uint16_t test_utilOnesCompChkSum (uint8_t *p, uint32_t nwords)\r
168 {\r
169   uint16_t chksum = 0;\r
170   uint16_t v;\r
171   uint32_t i;\r
172   uint32_t j;\r
173 \r
174   for (i = j = 0; i < nwords; i++, j+=2)  {\r
175     v = (p[j] << 8) | p[j+1];\r
176     chksum = test_utilOnesComplementAdd (chksum, v);\r
177   }\r
178   return (chksum);\r
179 } /* utilOnesCompChkSum */\r
180 \r
181 /**************************************************************************************\r
182  * FUNCTION PURPOSE: Compute ipv4 psudo checksum\r
183  **************************************************************************************\r
184  * DESCRIPTION: Compute ipv4 psudo checksum\r
185  **************************************************************************************/\r
186 uint16_t test_utilGetIpv4PsudoChkSum (uint8_t *data, uint16_t payloadLen)\r
187 {\r
188   uint16_t psudo_chksum;\r
189 \r
190   psudo_chksum = test_utilOnesCompChkSum (&data[12], 4);\r
191   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, (uint16_t) data[9]);\r
192   psudo_chksum = test_utilOnesComplementAdd(psudo_chksum, payloadLen);\r
193 \r
194   return (psudo_chksum);\r
195 \r
196 } /* utilGetIpv4PsudoChkSum */\r
197 \r
198 \r
199 \r
200 #endif\r
201 typedef struct stats_t\r
202 {\r
203         long itx;  //initially generated\r
204         long rx;\r
205         long tx;\r
206         long n_bad;\r
207         long n_new;\r
208         long n_class0_rx;   //count of pkts classified \r
209         long n_class1_rx;   //count of pkts classified \r
210         long n_class2_rx;   //count of pkts classified \r
211         long n_t1;\r
212         long n_t2;\r
213         long n_t3;\r
214         long sec_tx;\r
215         long sec_rx;\r
216         long sb_tx;\r
217         long sb_rx;\r
218         long secp_rx;\r
219         long n_auth_ok;\r
220 } STATS_T;\r
221 \r
222 typedef struct head_t\r
223 {\r
224         long ip[5];\r
225         long udp[2];\r
226 } HEAD_T;\r
227 \r
228 typedef struct key_t\r
229 {\r
230   long src_ip;\r
231   long dst_ip;\r
232   short src_port;\r
233   short dst_port;\r
234 } KEY_T;\r
235 \r
236 unsigned char mac0[]={0x00,0x01,0x02,0x03,0x04,0x05}; //interface 0\r
237 unsigned char mac1[]={0x00,0x01,0x02,0x03,0x04,0x06}; //interface 1\r
238 nwalIpAddr_t OurIp0={ 10, 0, 0, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\r
239 nwalIpAddr_t OurIp1={ 10, 0, 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\r
240 nwalIpAddr_t OurIp2={ 10, 0, 2, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\r
241 nwalIpAddr_t OurIp4IPSEC={ 192,168 , 1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\r
242 nwalIpAddr_t TheirIp4IPSEC={ 192,168 , 1, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };\r
243 \r
244 \r
245 #if 1  //goes with real tx (to laptop) \r
246 unsigned char real_mac_header[]={0xd4,0xbe,0xd9,0x00,0xd3,0x7e,\r
247                       0x00,0x01,0x02,0x03,0x04,0x05,\r
248                       0x08,0x00};\r
249 unsigned char real_ip_addr[]={0xa,0x00,0x00,0x64,0xa,0x0,0x0,0xa};\r
250 #endif\r
251 \r
252 #if 0  //goes with loopback\r
253 unsigned char mac_header[]={0x00,0x01,0x02,0x03,0x04,0x05, \r
254                       0x00,0x11,0x22,0x33,0x44,0x55,\r
255                       0x08,0x00};\r
256 #endif\r
257 #define NE 65536 \r
258 HEAD_T *nat;\r
259 \r
260 #define NP 5000\r
261 int n_pkt = NP;\r
262 STATS_T stats;\r
263 \r
264 Trie * P_trie;\r
265 HEAD_T pkts[NP];\r
266 #define PERSLOW  10  //% of pkts that will not be fastpath'd \r
267 int perslow= PERSLOW;\r
268 \r
269 /*******************************************\r
270  *************NETAPI OBJECTS***************\r
271  *****************************************/\r
272 Pktlib_HeapHandle OurHeap;\r
273 Pktlib_HeapHandle specialSmall;\r
274 Pktlib_HeapHandle specialLarge;\r
275 \r
276 PKTIO_HANDLE_T *our_chan;\r
277 PKTIO_HANDLE_T *netcp_rx_chan;\r
278 PKTIO_HANDLE_T *netcp_rx_chan2;\r
279 PKTIO_HANDLE_T *netcp_tx_chan;\r
280 PKTIO_HANDLE_T *netcp_sb_tx_chan;\r
281 PKTIO_HANDLE_T *netcp_sb_rx_chan;\r
282 PKTIO_CFG_T our_chan_cfg={PKTIO_RW, PKTIO_LOCAL, PKTIO_Q_ANY, 8};\r
283 PKTIO_CFG_T netcp_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};\r
284 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_R, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};\r
285 PKTIO_CFG_T netcp_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};\r
286 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_R, PKTIO_NA, PKTIO_NA, 8};\r
287 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_W, PKTIO_NA, PKTIO_NA, 8};\r
288 \r
289 void house(NETAPI_SCHED_HANDLE_T *s);\r
290 NETAPI_T netapi_handle;\r
291 NETAPI_SCHED_HANDLE_T * our_sched;\r
292 NETAPI_SCHED_CONFIG_T our_sched_cfg={\r
293   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 500  //every 500 poll loops\r
294 };\r
295 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats);\r
296 NETAPI_TIMER_GROUP_HANDLE_T ourTimerBlock; \r
297 NETAPI_TIMER_T t1;\r
298 NETAPI_TIMER_T t2;\r
299 NETAPI_TIMER_T t3;\r
300 \r
301 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,\r
302         int n_fired,     //# timers fired\r
303         NETAPI_TIMER_LIST_T fired_list,\r
304         uint64_t currentTime);\r
305 \r
306 NETCP_CFG_IP_T ip_rule0;\r
307 NETCP_CFG_IP_T ip_rule1;\r
308 NETCP_CFG_CLASS_T class_0;\r
309 NETCP_CFG_CLASS_T class_1;\r
310 NETCP_CFG_CLASS_T class_2;\r
311 NETCP_CFG_FLOW_HANDLE_T specialFlow;\r
312 \r
313 NETCP_CFG_CLASSIFIER_T class_0_cfg=\r
314 {\r
315    NETCP_CFG_CLASS_TYPE_L4,\r
316    {\r
317         {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2500}}\r
318    }\r
319 };\r
320 \r
321 NETCP_CFG_CLASSIFIER_T class_1_cfg=\r
322 {\r
323    NETCP_CFG_CLASS_TYPE_L4,\r
324    {\r
325         {0,0, NWAL_APP_PLOAD_PROTO_UDP, {2502}}\r
326    }\r
327 };\r
328 \r
329 NETCP_CFG_ROUTE_T  class2_route=\r
330 {\r
331 NULL, NULL  //* to be filled in\r
332 };\r
333 NETCP_CFG_CLASSIFIER_T class_2_cfg=  \r
334 {\r
335    NETCP_CFG_CLASS_TYPE_L3_L4,\r
336    {\r
337         {0,  4 ,0/*fill in below*/ , NULL, NULL,          //L2/L3\r
338            NWAL_APP_PLOAD_PROTO_UDP, {2504}}   //L4\r
339    }\r
340 };\r
341 \r
342 PKTIO_CONTROL_T zap_channel_control={PKTIO_CLEAR, NULL};\r
343 \r
344 /* security objects. (for loopback mode) */\r
345 NETCP_CFG_SA_T rx_tunnel;\r
346 NETCP_CFG_SA_T tx_tunnel;\r
347 NETCP_CFG_IPSEC_POLICY_T rx_policy;\r
348 void * rx_data_mode_handle;\r
349 void * tx_data_mode_handle;\r
350 void * rx_inflow_mode_handle;\r
351 void * tx_inflow_mode_handle;\r
352 /* rx */\r
353 NETAPI_SEC_SA_INFO_T rx_sa=\r
354 {\r
355         NWAL_SA_DIR_INBOUND,\r
356         0x44444444,  //spi\r
357         nwal_IpSecProtoESP, //ESP mode\r
358         nwal_SA_MODE_TUNNEL,  //tunnel mode\r
359         nwal_IPV4, //v4\r
360         { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (them) -> set below */\r
361         { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (us)-> set below*/\r
362         64,/* replayWindow */\r
363         NWAL_SA_AALG_HMAC_SHA1,\r
364         NWAL_SA_EALG_AES_CBC,\r
365         0,0  //na\r
366 };\r
367 \r
368 /*tx */\r
369 NETAPI_SEC_SA_INFO_T tx_sa=\r
370 {\r
371        NWAL_SA_DIR_OUTBOUND,\r
372         0x44444444,  //spi\r
373         nwal_IpSecProtoESP, //ESP mode\r
374         nwal_SA_MODE_TUNNEL,  //tunnel mode\r
375         nwal_IPV4, //v4\r
376         { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* Src IP (us) -> set below */\r
377         { 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* dst IP (them) -> set below*/\r
378         64, /* NA replayWindow */\r
379         NWAL_SA_AALG_HMAC_SHA1,\r
380         NWAL_SA_EALG_AES_CBC,\r
381         0,0  //seq no\r
382 };\r
383 \r
384 //since we are doing loopback, the rx key params = tx key params\r
385 static nwalSecKeyParams_t ourTXKeyParams =\r
386 {\r
387     16, /* encKeySize: CTR 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_DES_CBC and 0 bytes Salt*/\r
388     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_MD5 */\r
389     NULL, //set below\r
390     NULL, //set below\r
391 };\r
392 \r
393 static nwalSecKeyParams_t ourRXKeyParams ={\r
394     16, /* encKeySize: 16 bytes Encryption Key and 4 bytes Salt : 24 bytes:NWAL_SA_EALG_DES_CBC and 0 bytes Salt*/\r
395     20, /* macKeySize: 16 bytes NWAL_SA_AALG_HMAC_MD5 */\r
396     NULL, //set below\r
397     NULL, //set below\r
398 };\r
399 \r
400 //keys\r
401 static uint8_t ourAuthKey[36] =\r
402         {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,\r
403          0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,\r
404          0x20, 0x21, 0x22, 0x23 };\r
405 static uint8_t ourEncrKey[36] =\r
406         {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,\r
407          0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,\r
408          0x30, 0x31, 0x32, 0x33 };\r
409 \r
410 \r
411 /*************************END NETAPI OBJECTS***********************/\r
412 \r
413 #define START_SRC_IP 0x0a00000a\r
414 #define DST_IP       0xc0a80001\r
415 #define NEW_START_SRC_IP 0x9eda000a\r
416 #define DST_PORT 0x555 \r
417 #define START_SRC_PORT 0x1234\r
418 #define NEW_START_SRC_PORT 100\r
419 void update_header(HEAD_T * p_head, int len)\r
420 {\r
421    unsigned char *p = (unsigned char *) &p_head->udp[1];\r
422    len -= (20+14);\r
423    /* update ip checksum */\r
424    /* update udp checksum */\r
425    /* update length */\r
426    *p= (len&0xff00)>>8;\r
427    *(p+1) = len&0xff;\r
428 }\r
429 \r
430 #if 0\r
431 void gen_pkts(int np)\r
432 {\r
433 int i;\r
434 int ip = START_SRC_IP &0xff;\r
435 int port= START_SRC_PORT;\r
436 //HEAD_T temp={{0x25000200,0xdead0000,0x80110000,START_SRC_IP,DST_IP},\r
437 //             {START_SRC_PORT<<16|DST_PORT,0x01ec<<16|0x0000}};\r
438 HEAD_T temp;\r
439 memcpy(&temp,&testPkt[0],sizeof(HEAD_T));\r
440 \r
441 for(i=0;(i<np) && (i<NP);i++)\r
442   {\r
443        memcpy(&pkts[i],&temp,sizeof(temp));\r
444        update_header(&pkts[i],512);      /* update checksums etc */\r
445        /* change template for new pkt */\r
446        ip+=1;\r
447        if(ip>254) {(ip=START_SRC_IP&0xff); port+=1; }\r
448        temp.ip[3] = htonl((START_SRC_IP&0xffffff00)| ip);\r
449        temp.udp[0] = htonl( (temp.udp[0]&0xffff0000)| port);\r
450        temp.udp[1] = htonl(temp.udp[1]);\r
451      \r
452   }\r
453   n_pkt=np;\r
454 }\r
455 #endif\r
456 \r
457 void build_table(Trie * p_trie)\r
458 {\r
459 int i;\r
460 int sport=NEW_START_SRC_PORT; \r
461 HEAD_T temp,temp2;\r
462 KEY_T key;\r
463 \r
464 memcpy(&temp,&testPkt[14],sizeof(temp));\r
465 \r
466  //insert entry into trie\r
467 key.src_ip = temp.ip[3];\r
468 key.dst_ip = temp.ip[4];\r
469 key.src_port= (temp.udp[0]&0xffff0000)>>16;\r
470 key.dst_port= (temp.udp[0]&0x0000ffff);\r
471 trie_insert(p_trie,(char *)&key,sizeof(key), (void *) &nat[0]); //asociate with nat entry 0\r
472 \r
473 //build nat table\r
474 for(i=0;i<100;i++)\r
475 {\r
476    memcpy(&temp2,&testPkt[14],sizeof(temp));\r
477    temp2.udp[0] = (temp2.udp[0] & 0xffff0000) |  sport;\r
478    memcpy(&nat[i], &temp2, sizeof(temp2));\r
479    sport+= 1;\r
480 }\r
481 }\r
482 \r
483 //===========stub transmitter==================\r
484 void send_pkt(Ti_Pkt *pkt, int len)\r
485 {\r
486 //just free pkt.  Don't send\r
487 Pktlib_freePacket((Ti_Pkt*)pkt);\r
488         return;\r
489 }\r
490 \r
491 //==========stub slow path============\r
492 void slow_path(Ti_Pkt *pkt, int len)\r
493 {\r
494 // debug: check descriptor for validity by verifying that desciptor link field is null as expected\n");\r
495          {Ti_Pkt * k= Pktlib_getNextPacket(pkt); if(k != 0) {printf(" slowpath, nexpkt != NULL");}}\r
496 //just free pkt\r
497 Pktlib_freePacket((Ti_Pkt*)pkt);\r
498         return;\r
499 }\r
500 /* check header */\r
501 struct LastPktInfo\r
502 {\r
503 int iface;\r
504 int ipcsum;\r
505 int l4csum;\r
506 } ;\r
507 static struct LastPktInfo lpInfo;\r
508 \r
509 int check_header(HEAD_T * p_head, PKTIO_METADATA_T * p_meta)\r
510 {\r
511 if (NWAL_RX_FLAG1_META_DATA_VALID & p_meta->u.rx_meta->rxFlag1)\r
512 {\r
513 lpInfo.iface = ((unsigned int)p_meta->u.rx_meta->appId) &0xff; //last byte is interface num\r
514 lpInfo.ipcsum =(p_meta->u.rx_meta->rxFlag1 & NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_MASK )== NWAL_RX_FLAG1_IPV4_CHKSUM_VERIFY_ACK ? 1 : 0;\r
515 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; \r
516 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC)\r
517 {\r
518    stats.sec_rx++;\r
519 }\r
520 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_IPSEC_POLICY)\r
521 {\r
522    stats.secp_rx++;\r
523 }\r
524 \r
525 if ((unsigned int)p_meta->u.rx_meta->appId & NETAPI_NETCP_MATCH_CLASS)\r
526 {\r
527   int c= ((unsigned int)p_meta->u.rx_meta->appId >>8)&0xffff;\r
528   if (c==0)  stats.n_class0_rx +=1;\r
529   else if (c==1) stats.n_class1_rx +=1;\r
530   else if (c==2) stats.n_class2_rx +=1;\r
531   else printf("**NET_TEST RX -unknown class: %x\n",  p_meta->u.rx_meta->appId);\r
532 }\r
533 }\r
534 \r
535  return 1;\r
536 }\r
537 \r
538 #define PKT_LEN 1400\r
539 void test_alloc_free(int n)\r
540 {\r
541 int i;\r
542 Ti_Pkt * b;\r
543 \r
544 for(i=0;i<n;i++)\r
545 {\r
546   b=Pktlib_allocPacket(OurHeap,PKT_LEN);\r
547   Pktlib_freePacket(b);\r
548 }\r
549 }\r
550 \r
551 unsigned int vv1;\r
552 unsigned int vv2;\r
553 unsigned int vv3;\r
554 unsigned int vv4;\r
555 unsigned int vv5;\r
556 unsigned int vv6;\r
557 unsigned int vv7p;\r
558 unsigned int vv8p;\r
559 \r
560 /*--------------basic pktio send/recv benchmark----------------------*/\r
561 void our_pktio_bench(int ntrials)\r
562 {\r
563 int i;\r
564 #define NBATCH 8\r
565 Ti_Pkt tip;\r
566 unsigned char * pData;\r
567 int len;\r
568 int n;\r
569 int err;\r
570 PKTIO_METADATA_T meta[10]={0};\r
571 //send single, recv single\r
572 for(i=0;i<ntrials;i++)\r
573 {\r
574    vv1= netapi_timing_stop();\r
575    tip=Pktlib_allocPacket(OurHeap,PKT_LEN);\r
576    vv2= netapi_timing_stop();\r
577    Pktlib_getDataBuffer(tip,&pData,&len);\r
578    vv3= netapi_timing_stop();\r
579    pktio_send(our_chan,tip,&meta[0],&err);\r
580    vv4= netapi_timing_stop();\r
581    n=pktio_poll(our_chan,NULL , &err);\r
582    vv5=   netapi_timing_stop();\r
583    printf("pktio send. rx=%d (wcb%d) (toqm%d) tx=%d (toqm%d) alloc=%d\n", vv6-vv4,vv5-vv4,vv7p-vv4,  vv4-vv3, vv8p-vv4,  vv3-vv1);\r
584    \r
585 }\r
586 \r
587 //send multiple, rec multiple\r
588 for(i=0;i<ntrials;i++)\r
589 {\r
590 }\r
591 \r
592 }\r
593 /*-----------test driver: gen an input pkt------- */\r
594 //char buffer[sizeof(HEAD_T)+PKT_LEN];\r
595 Ti_Pkt * get_pkt(int n, unsigned int *p_len)\r
596 {\r
597    int ind;\r
598    long long temp;\r
599    Ti_Pkt * b;\r
600    char * buffer;\r
601    unsigned int len;\r
602 \r
603   if (pktloopback==0)\r
604   {\r
605         if (n>=4) return NULL;   //just gen pkts to warm swtich, so that it knows\r
606                                 //our mac is valid\r
607   }  \r
608   b=Pktlib_allocPacket(OurHeap,PKT_LEN);\r
609   if (!b) \r
610     {printf("net_test: get_pkt() heap empty!! %d pkts gen'd %d \n", n); return NULL;};\r
611 \r
612     //debug - way to validate descriptor\r
613     {Ti_Pkt* k= Pktlib_getNextPacket(b); \r
614          if(k != 0) {printf(" genpkt, nexpkt != NULL");}}\r
615 \r
616 \r
617    //get pointer to buffer area of packet\r
618    Pktlib_getDataBuffer(b,(uint8_t**)&buffer,&len);\r
619 \r
620 #if 0 \r
621 if (pktloopback==0)\r
622 {\r
623    temp = (long long) rand();\r
624    temp *= PKT_LEN;\r
625    temp /= RAND_MAX;\r
626    temp +=2;\r
627    *p_len = (int) temp; \r
628    *p_len = *p_len &0xfffffffe;\r
629    temp = (long long) rand();\r
630    temp *= n_pkt;\r
631    temp /= RAND_MAX;\r
632    ind = (int) temp;\r
633    update_header(&pkts[ind],*p_len);\r
634    //printf("get pkt:%d %d ind=%d len=%d\n",RAND_MAX, rand(),ind, *p_len);\r
635     memcpy(&buffer[0], &mac_header[0],14);\r
636     memcpy(&buffer[14],(char*)&pkts[ind],sizeof(HEAD_T)); \r
637 }\r
638 else\r
639 #endif\r
640 \r
641    //copy test packet into buffer\r
642 {\r
643     memcpy(&buffer[0], &testPkt[0],TEST_PKT_LEN);\r
644     *p_len = TEST_PKT_LEN;\r
645 }\r
646     return b; \r
647 }\r
648 \r
649 \r
650 /*--------------------------------------------------------------\r
651  *----------utility to flip a packet and send \r
652  *--------------------back to source----------------------------\r
653  *                   flag=1 => ipsec\r
654  *--------------------------------------------------------------*/\r
655 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag)\r
656 {\r
657 unsigned char mac_temp[6];\r
658 unsigned char ip_temp[4];\r
659 unsigned char new_dest_port[2]={0x75,0x30};  // 30000\r
660 uint16_t blah; \r
661 //mac\r
662 memcpy(&mac_temp,&p_pkt[0],6);\r
663 memcpy(&p_pkt[0],&p_pkt[6],6);\r
664 memcpy(&p_pkt[6],&mac_temp,6);\r
665 //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc\r
666 \r
667 //ip  (outer in case of ipsec)\r
668 memcpy(&ip_temp, &p_pkt[14+12],4);\r
669 memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);\r
670 memcpy(&p_pkt[14+12+4],&ip_temp,4);\r
671 \r
672 //outer checksum to 0\r
673 if (!flag) memset(&p_pkt[14+10],0,2);\r
674 \r
675 //inner ip &udp for ipsec\r
676 if (flag) \r
677 {\r
678     //just drop non-udp packet\r
679     if (p_pkt[14+20+8+16+9]!=0x11)\r
680     {\r
681         stats.n_new+=1;Pktlib_freePacket(tip); return;\r
682     }\r
683 \r
684 //spi\r
685 //memset(&p_pkt[14+20],0x88,4); \r
686 //inner ip\r
687 memcpy(&ip_temp, &p_pkt[14+20+8+16+12],4);\r
688 memcpy(&p_pkt[14+20+8+16+12],&p_pkt[14+20+8+16+12+4],4);\r
689 memcpy(&p_pkt[14+20+8+16+12+4],&ip_temp,4);\r
690 \r
691 //udp\r
692 memcpy(&p_pkt[14+20+8+16+20+2],&new_dest_port[0],2);\r
693 memset(&p_pkt[14+20+8+16+20+6],0,2); //checksum\r
694 \r
695 #ifdef IPSEC_MODE_TX_SIDEBAND\r
696 \r
697 //inner ip checksum : leave alone\r
698 #if 0\r
699 blah=test_utilOnesCompChkSum (&p_pkt[14+20+8+16], 10);\r
700 p_pkt[14+20+8+16+10]= (blah&0xff00)>>8;\r
701 p_pkt[14+20+8+16+11]= blah&0xff;\r
702 #endif\r
703 \r
704 //tbd udp checksum (leave at 0)\r
705 \r
706 //outer ip, set to 0 (we will compute on way out\r
707 memset(&p_pkt[14+10],0,2);\r
708 \r
709 #else //inflow, don't touch outer , clear inner \r
710 memset(&p_pkt[14+20+8+16+10],0,2); //inner checksum, we will compute on way out\r
711 //outer ip checksum : leave alone\r
712 #if 0\r
713 blah = test_utilOnesCompChkSum (&p_pkt[14], 10);\r
714 p_pkt[14+10]= (blah&0xff00)>>8;\r
715 p_pkt[14+11]= blah&0xff;\r
716 #endif\r
717 #endif\r
718 }\r
719 else\r
720 {\r
721 memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out\r
722 memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);\r
723 }\r
724 \r
725 //IPSEC case, \r
726 if (flag)\r
727 {\r
728 #ifdef IPSEC_MODE_TX_SIDEBAND\r
729  //send to crypto for encryption\r
730 //12 byte auth tag\r
731         {\r
732            PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};\r
733            int err;\r
734            nwalDmTxPayloadInfo_t meta_tx={0};\r
735            meta.sa_handle=tx_data_mode_handle;  //use TX SA context\r
736            meta_tx.ploadLen = len;\r
737            meta_tx.encOffset = 14+20+8+16 ;\r
738            meta_tx.authOffset =14+20 ;\r
739            meta_tx.encSize=len - 14- 20-8-16-12;\r
740            meta_tx.authSize= len -14-20-12;\r
741            meta_tx.encIvSize=16;\r
742            meta_tx.pEncIV= &p_pkt[14+20+8];  //just use same IV..\r
743            meta_tx.authIvSize=0;\r
744            meta_tx.pAuthIV=NULL;\r
745            meta_tx.aadSize=0;\r
746            meta_tx.pAad=NULL;\r
747            /* post it to netcp sb tx channel*/\r
748            meta.u.tx_sb_meta=&meta_tx;\r
749            pktio_send(netcp_sb_tx_chan,tip,&meta,&err);\r
750        }\r
751 \r
752 #else\r
753  {\r
754   //inflow tx\r
755   //send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied\r
756            PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};\r
757            int err;\r
758            nwalTxPktInfo_t meta_tx={0};\r
759            meta.sa_handle=tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied\r
760            meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_DO_IPSEC_CRYPTO| NWAL_TX_FLAG1_META_DATA_VALID );\r
761            meta_tx.saOffBytes=14+20;  \r
762            meta_tx.saPayloadLen=len-14-20;   //don't include tag, mac and outer header\r
763            meta_tx.startOffset = 0;\r
764            meta_tx.ipOffBytes = 14+20+8+16;   //to inner header\r
765            meta_tx.l4OffBytes = 14+20+8+16+20; //to L4 \r
766            meta_tx.l4HdrLen = 8;\r
767            meta_tx.ploadLen = (unsigned) ((p_pkt[14+20+8+16+20+4]<<8)|p_pkt[14+20+8+16+20+4+1]) -8 ;\r
768            meta_tx.pseudoHdrChecksum =\r
769              test_utilGetIpv4PsudoChkSum(&p_pkt[14+20+8+16],8+ meta_tx.ploadLen);\r
770 \r
771            /* post it to netcp tx channel*/\r
772            meta.u.tx_meta=&meta_tx;\r
773            pktio_send(netcp_tx_chan,tip,&meta,&err);\r
774            stats.tx +=1;\r
775            stats.sec_tx +=1;\r
776      }\r
777 #endif\r
778 \r
779 \r
780 }\r
781 else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload\r
782 {\r
783            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};\r
784            int err;\r
785            nwalTxPktInfo_t meta_tx2={0};\r
786            meta2.sa_handle=nwal_HANDLE_INVALID;\r
787            meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );\r
788            meta_tx2.startOffset = 0;\r
789            meta_tx2.ipOffBytes = 14;\r
790            meta_tx2.l4OffBytes = 14+20;\r
791            meta_tx2.l4HdrLen = 8;\r
792            meta_tx2.ploadLen = (unsigned) ((p_pkt[14+20+4]<<8)|p_pkt[14+20+4+1]) -8 ;\r
793            meta_tx2.pseudoHdrChecksum =\r
794              test_utilGetIpv4PsudoChkSum(&p_pkt[14],8+ meta_tx2.ploadLen);\r
795 \r
796            /* post it to netcp tx channel*/\r
797            meta2.u.tx_meta=&meta_tx2;\r
798            pktio_send(netcp_tx_chan,tip,&meta2,&err);\r
799            stats.tx +=1;\r
800 }\r
801 }\r
802 \r
803 \r
804 \r
805 \r
806 /***************************************\r
807  benchmark receive handler\r
808 ****************************************/\r
809 void recv_cb_bench(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
810                          PKTIO_METADATA_T meta[], int n_pkts,\r
811                          uint64_t ts )\r
812 {\r
813    int i;\r
814    vv6=   netapi_timing_stop();\r
815    for (i=0;i<n_pkts; i++) Pktlib_freePacket(p_recv[i]);\r
816 }\r
817 \r
818 /****************************************************************************************/\r
819 /******************SB Accelerator Callback PKT RECEIVE HANDLER *************************/\r
820 /******************  Handles Decrypt and Encrypt operation callbacks ******************/\r
821 /******************************************************************************************/\r
822 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
823                          PKTIO_METADATA_T meta[], int n_pkts,\r
824                          uint64_t ts )\r
825 {\r
826 int i;\r
827 int len;\r
828 int p;\r
829 HEAD_T * p_res;\r
830 Ti_Pkt * tip;\r
831 unsigned int templen;\r
832 int err;\r
833 KEY_T key;\r
834 char * p_pkt;\r
835 HEAD_T * p_head;\r
836 HEAD_T temp_head;\r
837 int tag_cmp=0;\r
838 unsigned int hash[3];\r
839 \r
840  /* loop over received pkts */\r
841    for(i=0;i<n_pkts;i++)\r
842    {\r
843         tip = p_recv[i];\r
844         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen\r
845         len = Pktlib_getPacketLen(tip);//real length\r
846 \r
847         //is this a decrypt (rx_tunnel) complete\r
848         if (meta[i].u.rx_sb_meta->appId == rx_tunnel)\r
849         {\r
850            stats.sb_rx+=1;\r
851            //copy hash out of meta data (for some reason it needs endian conversion)\r
852            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);\r
853            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);\r
854            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);\r
855 \r
856            if(stats.sb_rx<=16)\r
857            {\r
858              char *tp = (char *) &hash[0];\r
859              dump_header((long*)p_pkt, stats.sb_rx, meta[i].u.rx_sb_meta->appId,0);\r
860              printf("tag in pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
861                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],\r
862                       p_pkt[len-7],p_pkt[len-6],\r
863                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);\r
864              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
865                        tp[0],tp[1],tp[2],tp[3],tp[4],tp[5],\r
866                        tp[6],tp[7],tp[8],tp[9],tp[10],tp[11]);\r
867            }\r
868            //check tag \r
869            tag_cmp = memcmp(&p_pkt[len-12],(char*) &hash[0],12); //todo, really use meta->authTagLen\r
870            stats.n_auth_ok += !(tag_cmp);\r
871            flip_and_send_pkt(tip, p_pkt, len,1);  //flip packet to echo back and send\r
872         }\r
873         //this is an encrypt (tx tunnel) complete\r
874         else if(meta[i].u.rx_sb_meta->appId== tx_tunnel )\r
875         {\r
876            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);\r
877            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);\r
878            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);\r
879            stats.sb_tx+=1;\r
880            if(stats.sb_tx<=16)\r
881            {\r
882              char *tp1 = (char *) &hash[0];\r
883              dump_header((long*)p_pkt, stats.sb_tx, meta[i].u.rx_sb_meta->appId,0);\r
884              printf("tag in original rx pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
885                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],\r
886                       p_pkt[len-7],p_pkt[len-6],\r
887                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);\r
888 \r
889              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
890                        tp1[0],tp1[1],tp1[2],tp1[3],tp1[4],tp1[5],\r
891                        tp1[6],tp1[7],tp1[8],tp1[9],tp1[10],tp1[11]);\r
892            }\r
893            //put the computed tag in the packet\r
894            memcpy(&p_pkt[len-12],(char*)&hash[0],12); //todo, really use meta->authTagLen\r
895            {\r
896            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};\r
897            nwalTxPktInfo_t meta_tx={0};\r
898            // now send directly \r
899            meta2.sa_handle=nwal_HANDLE_INVALID;\r
900            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\r
901            meta_tx.startOffset = 0;\r
902            meta_tx.ipOffBytes = 14;\r
903            //not used\r
904            meta_tx.l4OffBytes = 0;\r
905            meta_tx.l4HdrLen = 0;\r
906            meta_tx.ploadLen = 0;\r
907 \r
908            /* post it to netcp tx channel*/\r
909            meta2.u.tx_meta=&meta_tx;\r
910            pktio_send(netcp_tx_chan,tip,&meta2,&err);\r
911            stats.tx +=1;\r
912            }\r
913         }\r
914         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );\r
915     }\r
916 }\r
917 \r
918 /******************************************************/\r
919 /******************PKT RECEIVE HANDLER *************************/\r
920 /******************************************************/\r
921 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
922                          PKTIO_METADATA_T meta[], int n_pkts,\r
923                          uint64_t ts )\r
924 {\r
925 int i;\r
926 int len;\r
927 int p;\r
928 HEAD_T * p_res;\r
929 Ti_Pkt * tip;\r
930 unsigned int templen;\r
931 int err;\r
932 KEY_T key;\r
933 char * p_pkt;\r
934 HEAD_T * p_head;\r
935 HEAD_T temp_head;\r
936 \r
937     p_head=&temp_head;\r
938 \r
939     //debug\r
940 #if 0\r
941     if (n_pkts != TX_BURST) {\r
942       printf("recv_cb, txsofar=%d rxsofar=%d  np = %d, NOT %d\n", \r
943              stats.itx, stats.rx, n_pkts,TX_BURST);\r
944       our_stats_cb(netapi_handle,NULL);\r
945     }\r
946 #endif\r
947     //test_alloc_free(7);\r
948     //printf("recv start\n");\r
949 \r
950    /* loop over received pkts */\r
951    for(i=0;i<n_pkts;i++)\r
952    {\r
953         tip = p_recv[i];\r
954         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen\r
955         len = Pktlib_getPacketLen(tip)-4;//real length, subtract mac trailer\r
956 \r
957          //debug: validate descriptor */\r
958          if(Pktlib_getNextPacket(tip) != 0) {printf(" rcv_cb, nexpkt != NULL");}\r
959         //debug printf("recv pkt, len=%d %d\n", len, templen);\r
960         stats.rx+=1;\r
961 \r
962 #ifdef DEBUG_DESC\r
963    if (stats.rx<16){printf(">rx dmp.."); dump_descr((long *) tip, stats.rx);}\r
964    else if (stats.rx>99) {printf(">rx dmp.."); dump_descr((long *) tip,stats.rx);}\r
965 #endif\r
966     if(stats.rx<=16)\r
967     {\r
968         dump_header((long*)p_pkt, stats.rx, meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);\r
969     }\r
970         /* check header */\r
971         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));\r
972 \r
973         if ((p_head->ip[2]&0x0000ff00)==0x00003200)\r
974         {\r
975              if (!check_header(p_head,&meta[i])) {\r
976                 stats.n_bad+=1;Pktlib_freePacket(tip); continue;\r
977              }\r
978  \r
979              //process IP SEC PACKET\r
980 #ifdef IPSEC_MODE_RX_SIDEBAND\r
981         {\r
982            //ship to crypto for decrypt!!\r
983            //12 byte auth tag\r
984            PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};\r
985            nwalDmTxPayloadInfo_t meta_tx={0};\r
986            meta2.sa_handle=rx_data_mode_handle;\r
987            meta_tx.ploadLen = len;\r
988            meta_tx.encOffset = 14+20+8+16 ;\r
989            meta_tx.authOffset =14+20 ;\r
990            meta_tx.encSize=len - 14- 20-8-16-12;\r
991            meta_tx.authSize= len -14-20-12;\r
992            meta_tx.encIvSize=16;\r
993            meta_tx.pEncIV= &p_pkt[14+20+8];\r
994            meta_tx.authIvSize=0;\r
995            meta_tx.pAuthIV=NULL;\r
996            meta_tx.aadSize=0;\r
997            meta_tx.pAad=NULL;\r
998            /* post it to netcp sb tx channel*/\r
999            meta2.u.tx_sb_meta=&meta_tx;\r
1000            pktio_send(netcp_sb_tx_chan,tip,&meta2,&err);\r
1001            continue;\r
1002         }\r
1003 #else \r
1004         //inflow mode.  flip and send\r
1005         flip_and_send_pkt(tip,p_pkt,len,1);\r
1006 #endif\r
1007     }\r
1008     else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)\r
1009     {\r
1010                 stats.n_new+=1;Pktlib_freePacket(tip); continue;\r
1011     }\r
1012     else  //non ipsec\r
1013     {\r
1014         if (!check_header(p_head,&meta[i])) { \r
1015                 stats.n_bad+=1;Pktlib_freePacket(tip); continue;\r
1016         }\r
1017 \r
1018 #if 0\r
1019         /* lookup flow */\r
1020         key.src_ip = p_head->ip[3];\r
1021         key.dst_ip = p_head->ip[4];\r
1022         key.src_port= (p_head->udp[0]&0xffff0000)>>16;\r
1023         key.dst_port= (p_head->udp[0]&0x0000ffff);\r
1024         p_res= (HEAD_T *) trie_lookup(P_trie, (char *) &key, sizeof(key));\r
1025         if (!p_res) { stats.n_new+=1;  slow_path(tip, len); continue;}\r
1026 \r
1027         /* copy header */\r
1028         memcpy((char *) p_head, (char *) p_res, sizeof(HEAD_T));\r
1029 \r
1030         memcpy(&p_pkt[14],p_head,sizeof(HEAD_T));\r
1031         /* update_mac(&p_pkt[0]);  */\r
1032 \r
1033         /* 'simulate' send pkt */\r
1034         send_pkt(tip,len);\r
1035 #endif\r
1036         //just flip and send\r
1037         flip_and_send_pkt(tip,p_pkt,len,0);\r
1038     }\r
1039   }\r
1040     //printf("recv done\n");\r
1041 }\r
1042 \r
1043 //timer callback \r
1044 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,\r
1045         int n_fired,     //# timers fired\r
1046         NETAPI_TIMER_LIST_T fired_list,\r
1047         uint64_t currentTime)\r
1048 {\r
1049 int i;\r
1050 NETAPI_TIMER_T tx;\r
1051 int cookie;\r
1052 int err;\r
1053 unsigned long long et;\r
1054 //DEBUGprintf("TIMER CALLBACK @ %lld %d timers\n", currentTime, n_fired);\r
1055 tx = netapi_TimerGetFirst(fired_list);\r
1056 for(i=0;i<n_fired;i++)\r
1057 {\r
1058   cookie = (int) netapi_TimerGetCookie(tx);\r
1059   et =  netapi_TimerGetTs(tx); //debug\r
1060   //DEBUGprintf("   timer %d - cookie = %d expected ts=%lld (delta=%lld)\n", i, cookie, et, currentTime-et);\r
1061   if (cookie ==1)\r
1062   {  \r
1063      stats.n_t1+=1;\r
1064      t1 = netapi_TimerGroupStartTimer(\r
1065         th,\r
1066         (void *) 1,\r
1067         100LL,  //timer group tics\r
1068         &err);\r
1069   }\r
1070   else if (cookie ==2)\r
1071   {\r
1072       stats.n_t2+=1;\r
1073       t2 = netapi_TimerGroupStartTimer(\r
1074         th,\r
1075         (void *) 2,\r
1076         200LL,  //timer group ticks\r
1077         &err);\r
1078   }\r
1079   else\r
1080   {\r
1081     stats.n_t3+=1;\r
1082     t3 = netapi_TimerGroupStartTimer(\r
1083         th,\r
1084         (void *) 3,\r
1085         300LL,  //timer group ticks\r
1086         &err);\r
1087     //cancel 1 and restart 1\r
1088    netapi_TimerGroupCancel(th,t1,&err);\r
1089    t1 = netapi_TimerGroupStartTimer(\r
1090         th,\r
1091         (void *) 1,\r
1092         100LL,  //timer group ticks\r
1093         &err);\r
1094  }\r
1095   tx = netapi_TimerGetNext(fired_list,tx); \r
1096 }\r
1097 }\r
1098 \r
1099 \r
1100 static int np2process = NP;\r
1101 /******************************************************\r
1102  * stats callback\r
1103  *******************************************************/\r
1104 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats)\r
1105 {\r
1106 uint32_t numFreeDataPackets;\r
1107 uint32_t numZeroBufferPackets;\r
1108 uint32_t numPacketsinGarbage;\r
1109 \r
1110 printf(">*****stats @ %lld\n", netapi_getTimestamp());\r
1111 //printf("netcp_tx_handle check %x\n", netcp_tx_chan->back);\r
1112 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\n  n_t1=%d n_t2=%d n_t3=%d\n",stats.itx, stats.rx, stats.tx, stats.n_bad, stats.n_new, \r
1113          stats.n_class0_rx, stats.n_class1_rx, \r
1114          stats.n_class2_rx, stats.sec_rx, stats.secp_rx, stats.sb_rx, stats.sb_tx, stats.n_auth_ok,\r
1115          stats.n_t1, stats.n_t2,stats.n_t3);\r
1116 \r
1117 if(pPaStats)\r
1118 {\r
1119        printf("C1 number of packets:           %d\n", pPaStats->classify1.nPackets);\r
1120        printf("C1 number IPv4 packets:         %d\n", pPaStats->classify1.nIpv4Packets);\r
1121        //printf("C1 number llc/snap fail:        %d\n", pPaStats->classify1.nLlcSnapFail);\r
1122        printf("C1 number table matched:        %d\n", pPaStats->classify1.nTableMatch);\r
1123        printf("C1 number failed table matched: %d\n", pPaStats->classify1.nNoTableMatch);\r
1124        printf ("C1 number of parse fail:        %d\n",pPaStats->classify1.nParseFail);\r
1125        printf("C1 number of command failures:  %d\n", pPaStats->classify1.nCommandFail);\r
1126        printf("C1 number invalid reply dests:  %d\n", pPaStats->classify1.nInvalidComReplyDest);\r
1127        printf ("C1 number of silent discard:    %d\n",pPaStats->classify1.nSilentDiscard);\r
1128        printf("C1 number of invalid control:   %d\n", pPaStats->classify1.nInvalidControl);\r
1129        printf ("C1 number of invalid states:    %d\n",pPaStats->classify1.nInvalidState);\r
1130        printf ("C1 number of system fails:      %d\n",pPaStats->classify1.nSystemFail);\r
1131        printf ("C2 number parse failed  :      %d\n",pPaStats->classify2.nParseFail);\r
1132        printf ("C2 number Invld Header  :      %d\n",pPaStats->classify2.nInvldHdr);\r
1133        printf ("C2 number udp           :      %d\n",pPaStats->classify2.nUdp);\r
1134        printf ("C2 number tcp           :      %d\n",pPaStats->classify2.nTcp);\r
1135        printf ("C2 number cmd fail      :      %d\n",pPaStats->classify2.nCommandFail);\r
1136        printf ("C2 number silent drop   :      %d\n",pPaStats->classify2.nSilentDiscard);\r
1137        printf ("C2 number invalid cntrl :      %d\n\n",pPaStats->classify2.nInvalidControl);\r
1138 }\r
1139 Pktlib_getHeapStats(OurHeap, &numFreeDataPackets,\r
1140                              &numZeroBufferPackets, &numPacketsinGarbage);\r
1141 printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
1142                                 numZeroBufferPackets, numPacketsinGarbage);\r
1143 Pktlib_getHeapStats(specialSmall, &numFreeDataPackets,\r
1144                              &numZeroBufferPackets, &numPacketsinGarbage);\r
1145 printf("specialSmall heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
1146                                 numZeroBufferPackets, numPacketsinGarbage);\r
1147 Pktlib_getHeapStats(specialLarge, &numFreeDataPackets,\r
1148                              &numZeroBufferPackets, &numPacketsinGarbage);\r
1149 printf("specialLarge heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
1150                                 numZeroBufferPackets, numPacketsinGarbage);\r
1151 \r
1152 //debug = dump timer polling stats\r
1153 dump_poll_stats();\r
1154 \r
1155 \r
1156 }\r
1157 \r
1158 //******************************************************\r
1159 //use scheduling housekeeping callback to generate pkts\r
1160 //******************************************************\r
1161 void house(NETAPI_SCHED_HANDLE_T * s)\r
1162 {\r
1163 Ti_Pkt * tip;\r
1164 unsigned int len;\r
1165 nwalTxPktInfo_t meta_tx;\r
1166 PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};\r
1167 int err;\r
1168 static int house_pkts_gened=0;\r
1169 int p;\r
1170 unsigned char * pIpHdr,* pData;\r
1171 unsigned int vv1,vv2,vv3;\r
1172 \r
1173 memset(&meta_tx,0,sizeof(meta_tx));\r
1174 for(p=0;p<TX_BURST;p++) {  \r
1175 //reguest stats \r
1176 if ((house_pkts_gened>0) && (! (house_pkts_gened%400)) )\r
1177 {\r
1178    printf("net_test> request stats at n=%d \n",house_pkts_gened);\r
1179    netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err); \r
1180    if (err!=0) {printf("stats req failed\n");}\r
1181 }\r
1182 \r
1183 \r
1184   if (house_pkts_gened >= np2process+ 100)\r
1185   {\r
1186      //shutdown\r
1187      netapi_schedShutdown(s,NULL,&err);\r
1188      continue;\r
1189   }\r
1190 \r
1191   else if (house_pkts_gened >= np2process) { house_pkts_gened+=1;  continue;}\r
1192   \r
1193 \r
1194 /* manufacture a pkt to transmit */\r
1195    tip = get_pkt(house_pkts_gened, &len);\r
1196    if(!tip) { house_pkts_gened +=1; continue; }\r
1197 \r
1198 \r
1199    /* set the pkt length */\r
1200    vv1 = netapi_timing_start();\r
1201    Pktlib_setPacketLen(tip, len);\r
1202 \r
1203    /* set up meta data */\r
1204     meta.sa_handle=nwal_HANDLE_INVALID;\r
1205     meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM | NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);\r
1206     meta_tx.startOffset = 0;\r
1207     //GONE in V2 meta_tx.pktLen = len;\r
1208     meta_tx.ipOffBytes = TEST_PKT_IP_OFFSET_BYTES;\r
1209     meta_tx.l4OffBytes = TEST_PKT_UDP_OFFSET_BYTES;\r
1210     meta_tx.l4HdrLen = TEST_PKT_UDP_HDR_LEN;\r
1211     //GONE in V2 meta_tx.ploadOffBytes = TEST_PKT_PLOAD_OFFSET_BYTES;\r
1212     meta_tx.ploadLen = TEST_PAYLOAD_LEN;\r
1213 \r
1214     Pktlib_getDataBuffer(tip,&pData,&len);\r
1215     pIpHdr = pData + meta_tx.ipOffBytes;\r
1216     meta_tx.pseudoHdrChecksum =\r
1217         test_utilGetIpv4PsudoChkSum(pIpHdr,(TEST_PAYLOAD_LEN+TEST_PKT_UDP_HDR_LEN));\r
1218 \r
1219    /* post it to netcp tx channel*/\r
1220    meta.u.tx_meta=&meta_tx;\r
1221 #ifdef DEBUG_DESC\r
1222    if (house_pkts_gened<16) dump_descr((long *) tip, house_pkts_gened);\r
1223    else if (house_pkts_gened>99) dump_descr((long *) tip,house_pkts_gened);\r
1224 #endif\r
1225    vv2= netapi_timing_stop();\r
1226    pktio_send(netcp_tx_chan,tip,&meta,&err);\r
1227    vv3= netapi_timing_stop();\r
1228    printf("pktio send. full=%d metadata=%d pktio_send=%d\n", vv3-vv1,  vv2-vv1,  vv3-vv2);\r
1229    if (err == 0) stats.itx +=1;\r
1230 \r
1231    house_pkts_gened +=1;\r
1232  }\r
1233 }\r
1234 \r
1235 \r
1236 /***************************************\r
1237  ********** test driver*****************\r
1238  ***************************************/\r
1239 int main(int argc, char **argv)\r
1240 {\r
1241 int err;\r
1242 rlim_t oss,ss = 1024*1024;\r
1243 struct rlimit rl;\r
1244 \r
1245 err= getrlimit(RLIMIT_STACK,&rl);\r
1246 if (!err) printf(" stack limit = %d\n",rl.rlim_cur); else printf("getrlimit failed\n");\r
1247 #if 0\r
1248 rl.rlim_cur = ss;\r
1249 err=setrlimit(RLIMIT_STACK,&rl);\r
1250 if (!err) printf("set stack to %d\n",rl.rlim_cur); else printf("setrlimit failed\n");\r
1251 #endif\r
1252 \r
1253 if (argc>=2)  np2process = atoi(argv[1]);\r
1254 if (np2process<0) np2process = NP; /* default */\r
1255 if (argc==3)  perslow = atoi(argv[2]);\r
1256 if ((perslow<0)||(perslow>100)) perslow=PERSLOW;//default\r
1257 if (argc>3) {printf("net_test  <no of pkts to process> <percent slow path>\n"); exit(1);}\r
1258 \r
1259 \r
1260 //real mode, so update our test packet mac header and ip header\r
1261 if (pktloopback==0)\r
1262 {\r
1263 memcpy(&testPkt,&real_mac_header[0],14); //overwrite test pkt mac address\r
1264 memcpy(&testPkt[26],&real_ip_addr[0],8);//overrite test pkt ip addresses\r
1265 }\r
1266 \r
1267 /*******************************************/\r
1268 /*************NETAPI STARTUP****************/\r
1269 /*******************************************/\r
1270 \r
1271 /* create netapi */\r
1272 netapi_handle = netapi_init(NETAPI_SYS_MASTER);\r
1273 \r
1274 /* open the main heap */\r
1275 OurHeap = Pktlib_findHeapByName("netapi");\r
1276 if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}\r
1277 \r
1278 /* create two secondary heaps */\r
1279 specialSmall = Pktlib_createHeap("netapi-small", NETAPI_GLOBAL_REGION,\r
1280                                                 1,\r
1281                                                 256, //bytes\r
1282                                                 64,  //num buffs\r
1283                                                 0,\r
1284                                                 netapi_getPktlibIfTable());\r
1285 specialLarge = Pktlib_createHeap("netapi-small", NETAPI_GLOBAL_REGION,\r
1286                                                 1,\r
1287                                                 1600, //bytes\r
1288                                                 64,  //num buffs\r
1289                                                 0,\r
1290                                                 netapi_getPktlibIfTable());\r
1291 //register these heaps so poll routine will include their garbage queues.\r
1292 netapi_registerHeap(netapi_handle, specialSmall);\r
1293 netapi_registerHeap(netapi_handle, specialLarge);\r
1294 \r
1295 \r
1296 /* create a pktio channel */\r
1297 our_chan=pktio_create(netapi_handle,"our1stq",(PKTIO_CB) recv_cb_bench, &our_chan_cfg,&err);\r
1298 if (!our_chan) {printf("pktio create failed err=%d\n",err); exit(1);}\r
1299 \r
1300 /* open netcp default tx, rx queues */\r
1301 netcp_tx_chan= pktio_open(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);\r
1302 if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}\r
1303 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);\r
1304 if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}\r
1305 \r
1306 /* create a pktio channel for specially classified pkts */\r
1307 netcp_rx_chan2= pktio_create(netapi_handle, "classq", (PKTIO_CB) recv_cb, &netcp_rx_cfg2,  &err);\r
1308 if (!netcp_rx_chan2) {printf("pktio create RX2 failed err=%d\n",err); exit(1);}\r
1309 \r
1310 /* open netcp default tx, rx queues for sideband crypto */\r
1311 netcp_sb_tx_chan= pktio_open(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);\r
1312 if (!netcp_sb_tx_chan) {printf("pktio open SB TX failed err=%d\n",err); exit(1);}\r
1313 netcp_sb_rx_chan= pktio_open(netapi_handle, NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);\r
1314 if (!netcp_sb_rx_chan) {printf("pktio open SB RX failed err=%d\n",err); exit(1);}\r
1315 \r
1316 \r
1317 /* create scheduler instance */\r
1318 our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);\r
1319 if (!our_sched) {printf("sched create failed\n"); exit(1);}\r
1320 \r
1321 /* add mac intefaces */\r
1322 netcp_cfgCreateMacInterface(\r
1323                   netapi_handle,\r
1324                   &mac0[0],\r
1325                   0,0,\r
1326                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,\r
1327                   (NETCP_CFG_VLAN_T ) NULL ,  //future\r
1328                   1, \r
1329                   &err);\r
1330 if (err) {printf("addmac0 failed %d\n",err); exit(1); } \r
1331 \r
1332 //attach an IP to this interface\r
1333 ip_rule0=netcp_addIp(\r
1334                   netapi_handle,\r
1335                   0,\r
1336                   nwal_IPV4,\r
1337                   &OurIp0,\r
1338                   NULL,  //all IP\r
1339                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,\r
1340                   &err\r
1341                   );\r
1342 if (err) {printf("addip0 failed %d\n",err); exit(1); } \r
1343 #if 1\r
1344 //create a 2nd mac instance\r
1345 netcp_cfgCreateMacInterface(\r
1346                   netapi_handle,\r
1347                   &mac1[0],\r
1348                   1,1,\r
1349                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,\r
1350                   (NETCP_CFG_VLAN_T ) NULL ,  //future\r
1351                   1,\r
1352                   &err);\r
1353 if (err) {printf("addmac1 failed %d\n",err); exit(1); }\r
1354 \r
1355 //attach an IP to this interface\r
1356 ip_rule1=netcp_addIp(\r
1357                   netapi_handle,\r
1358                   1,\r
1359                   nwal_IPV4,\r
1360                   &OurIp1,\r
1361                   NULL,  //all IP\r
1362                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,\r
1363                   &err\r
1364                   );\r
1365 if (err) {printf("addip1 failed %d\n",err); exit(1); }\r
1366 \r
1367 //attach 2 classifiers to iface 0, ip0\r
1368 class_0_cfg.u.c_l4.ip = ip_rule0;\r
1369 class_0 =  netcp_cfgAddClass(netapi_handle,\r
1370                              &class_0_cfg,\r
1371                              NULL,\r
1372                              NETCP_CFG_ACTION_TO_SW,\r
1373                              &err);\r
1374 if (err) {printf("addclass0 failed %d\n",err); exit(1);}\r
1375 \r
1376 class_1_cfg.u.c_l4.ip = ip_rule0;\r
1377 class_1 =  netcp_cfgAddClass(netapi_handle,\r
1378                              &class_1_cfg,\r
1379                              NULL,\r
1380                              NETCP_CFG_ACTION_TO_SW,\r
1381                              &err);\r
1382 if (err) {printf("addclass1 failed %d\n",err); exit(1);}\r
1383 \r
1384 \r
1385 //3rd classifier has a different IP and route\r
1386 class_2_cfg.u.c_l3_l4.ip_addr = &OurIp2;\r
1387 \r
1388 //create specialFlow for this classifier\r
1389 {\r
1390 Pktlib_HeapHandle heaps[2];\r
1391 int sizes[2];\r
1392 heaps[0]= specialSmall;\r
1393 heaps[1]= specialLarge;\r
1394 sizes[0]=256;\r
1395 sizes[1]=1600;\r
1396 specialFlow = netcp_cfgAddFlow( netapi_handle,\r
1397                                 2,\r
1398                                 heaps,\r
1399                                 sizes,\r
1400                                 &err);\r
1401 if (err) {printf("add flow failed\n", err); exit(1);}\r
1402 }\r
1403 //special route for this classifier:  different flow + destination q\r
1404 class2_route.p_dest_q = netcp_rx_chan2;\r
1405 class2_route.p_flow = specialFlow;\r
1406 class_2 = netcp_cfgAddClass(netapi_handle,\r
1407                             &class_2_cfg,\r
1408                             (void*) &class2_route,\r
1409                             NETCP_CFG_ACTION_TO_SW,\r
1410                             &err);\r
1411 if (err) {printf("addclass2 failed %d\n",err); exit(1);}\r
1412 #endif\r
1413 \r
1414 //security stuff \r
1415 ourRXKeyParams.pEncKey = &ourEncrKey[0];\r
1416 ourRXKeyParams.pAuthKey = &ourAuthKey[0];\r
1417 memcpy(&rx_sa.src, &TheirIp4IPSEC,4);\r
1418 memcpy(&rx_sa.dst, &OurIp4IPSEC,4);\r
1419 \r
1420 #if 1\r
1421 rx_tunnel = netapi_secAddSA( netapi_handle,\r
1422                  0, //iface #0 \r
1423                 &rx_sa,\r
1424                 &ourRXKeyParams,\r
1425 #ifdef IPSEC_MODE_RX_SIDEBAND\r
1426                 NETAPI_SEC_SA_SIDEBAND,\r
1427 #else\r
1428                 NETAPI_SEC_SA_INFLOW,  //USE inflow mode\r
1429 #endif\r
1430                 NULL,  //use default route \r
1431                 &rx_data_mode_handle,\r
1432                 &rx_inflow_mode_handle,\r
1433                 &err);\r
1434 if (err) {printf("addRxSa failed %d\n",err); exit(1);}\r
1435 \r
1436 #ifdef IPSEC_MODE_RX_INFLOW\r
1437 //assume inner and outer ip is the same\r
1438 rx_policy= netapi_secAddRxPolicy( netapi_handle,\r
1439                          rx_tunnel,  //link to tunnel above\r
1440                          4,         //ipv4\r
1441                          &TheirIp4IPSEC, //src -> them\r
1442                          &OurIp4IPSEC,  //dst -> us\r
1443                          NULL,  // no qualifiers\r
1444                          NULL,  //default route\r
1445                          &err);\r
1446 if (err) {printf("addSaPolicy failed %d\n",err); exit(1);}\r
1447 #else \r
1448 rx_policy = 0;\r
1449 #endif\r
1450 #endif\r
1451 \r
1452 //tx SA\r
1453 //security stuff \r
1454 ourTXKeyParams.pEncKey = &ourEncrKey[0];\r
1455 ourTXKeyParams.pAuthKey = &ourAuthKey[0];\r
1456 memcpy(&tx_sa.src, &OurIp4IPSEC,4);\r
1457 memcpy(&tx_sa.dst, &TheirIp4IPSEC,4);\r
1458 tx_tunnel = netapi_secAddSA( netapi_handle,\r
1459                  0, //iface #0 \r
1460                 &tx_sa,\r
1461                 &ourTXKeyParams,\r
1462 #ifdef IPSEC_MODE_TX_SIDEBAND\r
1463                 NETAPI_SEC_SA_SIDEBAND,\r
1464 #else\r
1465                 NETAPI_SEC_SA_INFLOW,  //USE inflow mode\r
1466 #endif\r
1467                 NULL,  //use default route \r
1468                 &tx_data_mode_handle,\r
1469                 &tx_inflow_mode_handle,\r
1470                 &err);\r
1471 if (err) {printf("addTxSa failed %d\n",err); exit(1);}\r
1472 \r
1473 \r
1474 \r
1475 //timers\r
1476 ourTimerBlock = netapi_TimerGroupCreate(\r
1477         netapi_handle,\r
1478         "our1sttimer",\r
1479         our_timer_cb,\r
1480         0,    //1 if timers local to thread\r
1481         0,    //1 if expect to cancel\r
1482         netapi_getTicksPerSec()/1000,  /* 1 msc resolution for these timers */\r
1483         netapi_getTicksPerSec()/5000, /* would like .5 msc tolerence */\r
1484         10,  //small # of timers to test garbage collection\r
1485         &err);\r
1486 if (err) {printf("timergroupcreate failed %d\n",err); exit(1);}\r
1487 \r
1488 //start a couple of timers \r
1489 t1 = netapi_TimerGroupStartTimer(\r
1490         ourTimerBlock,\r
1491         (void *) 1,\r
1492         100LL,  //timer group ticks\r
1493         &err);\r
1494 if (err) {printf("timerstart failed %d\n");}\r
1495 t2 = netapi_TimerGroupStartTimer(\r
1496         ourTimerBlock,\r
1497         (void *) 2,\r
1498         200LL,  //timer group ticks\r
1499         &err);\r
1500 if (err) {printf("timerstart failed %d\n");}\r
1501 t3 = netapi_TimerGroupStartTimer(\r
1502         ourTimerBlock,\r
1503         (void *) 3,\r
1504         300LL,  //timer group ticks\r
1505         &err);\r
1506 if (err) {printf("timerstart failed %d\n");}\r
1507 \r
1508 netcp_cfgReqStats(netapi_handle, our_stats_cb, 1,&err);\r
1509 if (err!=0) {printf("stats req failed\n");}\r
1510 \r
1511 /*********************************************/\r
1512 /*****************end NETAPI STARTUP**********/\r
1513 /*********************************************/\r
1514 \r
1515 \r
1516 /********************************************\r
1517 * Basic pkt loopback test\r
1518 *********************************************/\r
1519 printf("...runnining pure push/pop benchmark\n");\r
1520 our_pktio_bench(100);\r
1521 \r
1522 \r
1523 \r
1524 \r
1525 \r
1526 /**************unused stuff******************/\r
1527 /* create TRIE */\r
1528 P_trie = trie_new();\r
1529 if (!P_trie) {printf("trie alloc failed\n"); exit(1);}\r
1530 \r
1531 nat = (HEAD_T *) malloc(NE * sizeof(HEAD_T));\r
1532 if (!nat) {printf("malloc of nat table failed\n"); exit(1);}\r
1533 \r
1534 //gen_pkts(np2process<NP ? np2process:NP);\r
1535 n_pkt= np2process;\r
1536 \r
1537 /* build table */\r
1538 build_table(P_trie);\r
1539 \r
1540 \r
1541 /* processing loop: get pkt, check it, look up in table, copy new header,\r
1542    send packet */\r
1543 srand((unsigned) np2process);\r
1544 \r
1545 \r
1546 /*********************************************/\r
1547 /**************Entry point into scheduler ****/\r
1548 /*********************************************/\r
1549 netapi_schedWaitForEvents(our_sched, &err);\r
1550 \r
1551 /* done */\r
1552 our_stats_cb(netapi_handle, NULL);\r
1553 \r
1554 /*************************************************\r
1555  ************CLEAN UP****************************\r
1556  ************************************************/\r
1557 \r
1558 //delete Classifiers\r
1559 netcp_cfgDelClass(netapi_handle, class_0, &err); \r
1560 netcp_cfgDelClass(netapi_handle, class_1, &err); \r
1561 netcp_cfgDelClass(netapi_handle, class_2, &err); \r
1562 \r
1563 //delete flow \r
1564 netcp_cfgDelFlow(netapi_handle, specialFlow, &err);\r
1565 \r
1566 #if 1\r
1567 //delete policy\r
1568 if (rx_policy)\r
1569         netapi_secDelRxPolicy(netapi_handle, rx_policy, &err);\r
1570 \r
1571 //delete tunnels\r
1572 netapi_secDelSA(netapi_handle, 0, rx_tunnel, &err);\r
1573 netapi_secDelSA(netapi_handle, 0, tx_tunnel, &err);\r
1574 #endif\r
1575 \r
1576 //delete IPs and MAC Interfacess\r
1577 netcp_cfgDelIp(netapi_handle, 0, 0, NULL, NULL, ip_rule0, &err);\r
1578 netcp_cfgDelIp(netapi_handle, 1, 0, NULL, NULL, ip_rule1, &err);\r
1579 netcp_cfgDelMac(netapi_handle,0,&err);\r
1580 netcp_cfgDelMac(netapi_handle,1,&err);\r
1581 \r
1582 \r
1583 //close pktio channels we opened\r
1584 pktio_close(netcp_tx_chan ,&err);\r
1585 pktio_close(netcp_rx_chan ,&err);\r
1586 pktio_close(netcp_sb_tx_chan ,&err);\r
1587 pktio_close(netcp_sb_rx_chan ,&err);\r
1588 \r
1589 //clear pktio channel we created\r
1590 pktio_control(our_chan, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);\r
1591 pktio_control(netcp_rx_chan2, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);\r
1592 \r
1593 //delete pktio channels we created\r
1594 pktio_delete(our_chan, &err);\r
1595 pktio_delete(netcp_rx_chan2,&err);\r
1596 \r
1597 netapi_shutdown(netapi_handle);\r
1598 \r
1599 }\r