cbade343e2ff9e043d617db7dad2da3857660ab7
[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 /*-----------test driver: gen an input pkt------- */\r
551 //char buffer[sizeof(HEAD_T)+PKT_LEN];\r
552 Ti_Pkt * get_pkt(int n, unsigned int *p_len)\r
553 {\r
554    int ind;\r
555    long long temp;\r
556    Ti_Pkt * b;\r
557    char * buffer;\r
558    unsigned int len;\r
559 \r
560   if (pktloopback==0)\r
561   {\r
562         if (n>=4) return NULL;   //just gen pkts to warm swtich, so that it knows\r
563                                 //our mac is valid\r
564   }  \r
565   b=Pktlib_allocPacket(OurHeap,PKT_LEN);\r
566   if (!b) \r
567     {printf("net_test: get_pkt() heap empty!! %d pkts gen'd %d \n", n); return NULL;};\r
568 \r
569     //debug - way to validate descriptor\r
570     {Ti_Pkt* k= Pktlib_getNextPacket(b); \r
571          if(k != 0) {printf(" genpkt, nexpkt != NULL");}}\r
572 \r
573 \r
574    //get pointer to buffer area of packet\r
575    Pktlib_getDataBuffer(b,(uint8_t**)&buffer,&len);\r
576 \r
577 #if 0 \r
578 if (pktloopback==0)\r
579 {\r
580    temp = (long long) rand();\r
581    temp *= PKT_LEN;\r
582    temp /= RAND_MAX;\r
583    temp +=2;\r
584    *p_len = (int) temp; \r
585    *p_len = *p_len &0xfffffffe;\r
586    temp = (long long) rand();\r
587    temp *= n_pkt;\r
588    temp /= RAND_MAX;\r
589    ind = (int) temp;\r
590    update_header(&pkts[ind],*p_len);\r
591    //printf("get pkt:%d %d ind=%d len=%d\n",RAND_MAX, rand(),ind, *p_len);\r
592     memcpy(&buffer[0], &mac_header[0],14);\r
593     memcpy(&buffer[14],(char*)&pkts[ind],sizeof(HEAD_T)); \r
594 }\r
595 else\r
596 #endif\r
597 \r
598    //copy test packet into buffer\r
599 {\r
600     memcpy(&buffer[0], &testPkt[0],TEST_PKT_LEN);\r
601     *p_len = TEST_PKT_LEN;\r
602 }\r
603     return b; \r
604 }\r
605 \r
606 \r
607 /*--------------------------------------------------------------\r
608  *----------utility to flip a packet and send \r
609  *--------------------back to source----------------------------\r
610  *                   flag=1 => ipsec\r
611  *--------------------------------------------------------------*/\r
612 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag)\r
613 {\r
614 unsigned char mac_temp[6];\r
615 unsigned char ip_temp[4];\r
616 unsigned char new_dest_port[2]={0x75,0x30};  // 30000\r
617 uint16_t blah; \r
618 //mac\r
619 memcpy(&mac_temp,&p_pkt[0],6);\r
620 memcpy(&p_pkt[0],&p_pkt[6],6);\r
621 memcpy(&p_pkt[6],&mac_temp,6);\r
622 //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc\r
623 \r
624 //ip  (outer in case of ipsec)\r
625 memcpy(&ip_temp, &p_pkt[14+12],4);\r
626 memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);\r
627 memcpy(&p_pkt[14+12+4],&ip_temp,4);\r
628 \r
629 //outer checksum to 0\r
630 if (!flag) memset(&p_pkt[14+10],0,2);\r
631 \r
632 //inner ip &udp for ipsec\r
633 if (flag) \r
634 {\r
635 \r
636 //spi\r
637 //memset(&p_pkt[14+20],0x88,4); \r
638 //inner ip\r
639 memcpy(&ip_temp, &p_pkt[14+20+8+16+12],4);\r
640 memcpy(&p_pkt[14+20+8+16+12],&p_pkt[14+20+8+16+12+4],4);\r
641 memcpy(&p_pkt[14+20+8+16+12+4],&ip_temp,4);\r
642 \r
643 //udp\r
644 memcpy(&p_pkt[14+20+8+16+20+2],&new_dest_port[0],2);\r
645 memset(&p_pkt[14+20+8+16+20+6],0,2); //checksum\r
646 \r
647 #ifdef IPSEC_MODE_TX_SIDEBAND\r
648 \r
649 //inner ip checksum : leave alone\r
650 #if 0\r
651 blah=test_utilOnesCompChkSum (&p_pkt[14+20+8+16], 10);\r
652 p_pkt[14+20+8+16+10]= (blah&0xff00)>>8;\r
653 p_pkt[14+20+8+16+11]= blah&0xff;\r
654 #endif\r
655 \r
656 //tbd udp checksum (leave at 0)\r
657 \r
658 //outer ip, set to 0 (we will compute on way out\r
659 memset(&p_pkt[14+10],0,2);\r
660 \r
661 #else //inflow, don't touch outer , clear inner \r
662 memset(&p_pkt[14+20+8+16+10],0,2); //inner checksum, we will compute on way out\r
663 //outer ip checksum : leave alone\r
664 #if 0\r
665 blah = test_utilOnesCompChkSum (&p_pkt[14], 10);\r
666 p_pkt[14+10]= (blah&0xff00)>>8;\r
667 p_pkt[14+11]= blah&0xff;\r
668 #endif\r
669 #endif\r
670 }\r
671 else\r
672 {\r
673 memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out\r
674 memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);\r
675 }\r
676 \r
677 //IPSEC case, \r
678 if (flag)\r
679 {\r
680 #ifdef IPSEC_MODE_TX_SIDEBAND\r
681  //send to crypto for encryption\r
682 //12 byte auth tag\r
683         {\r
684            PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};\r
685            int err;\r
686            nwalDmTxPayloadInfo_t meta_tx={0};\r
687            meta.sa_handle=tx_data_mode_handle;  //use TX SA context\r
688            meta_tx.ploadLen = len;\r
689            meta_tx.encOffset = 14+20+8+16 ;\r
690            meta_tx.authOffset =14+20 ;\r
691            meta_tx.encSize=len - 14- 20-8-16-12;\r
692            meta_tx.authSize= len -14-20-12;\r
693            meta_tx.encIvSize=16;\r
694            meta_tx.pEncIV= &p_pkt[14+20+8];  //just use same IV..\r
695            meta_tx.authIvSize=0;\r
696            meta_tx.pAuthIV=NULL;\r
697            meta_tx.aadSize=0;\r
698            meta_tx.pAad=NULL;\r
699            /* post it to netcp sb tx channel*/\r
700            meta.u.tx_sb_meta=&meta_tx;\r
701            pktio_send(netcp_sb_tx_chan,tip,&meta,&err);\r
702        }\r
703 \r
704 #else\r
705  {\r
706   //inflow tx\r
707   //send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied\r
708            PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};\r
709            int err;\r
710            nwalTxPktInfo_t meta_tx={0};\r
711            meta.sa_handle=tx_inflow_mode_handle; //this tells netapi that inflow crypto needs to be applied\r
712            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
713            meta_tx.saOffBytes=14+20;  \r
714            meta_tx.saPayloadLen=len-14-20;   //don't include tag, mac and outer header\r
715            meta_tx.startOffset = 0;\r
716            meta_tx.ipOffBytes = 14+20+8+16;   //to inner header\r
717            meta_tx.l4OffBytes = 14+20+8+16+20; //to L4 \r
718            meta_tx.l4HdrLen = 8;\r
719            meta_tx.ploadLen = (unsigned) ((p_pkt[14+20+8+16+20+4]<<8)|p_pkt[14+20+8+16+20+4+1]) -8 ;\r
720            meta_tx.pseudoHdrChecksum =\r
721              test_utilGetIpv4PsudoChkSum(&p_pkt[14+20+8+16],8+ meta_tx.ploadLen);\r
722 \r
723            /* post it to netcp tx channel*/\r
724            meta.u.tx_meta=&meta_tx;\r
725            pktio_send(netcp_tx_chan,tip,&meta,&err);\r
726            stats.tx +=1;\r
727            stats.sec_tx +=1;\r
728      }\r
729 #endif\r
730 \r
731 \r
732 }\r
733 else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload\r
734 {\r
735            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};\r
736            int err;\r
737            nwalTxPktInfo_t meta_tx2={0};\r
738            meta2.sa_handle=nwal_HANDLE_INVALID;\r
739            meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM|NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );\r
740            meta_tx2.startOffset = 0;\r
741            meta_tx2.ipOffBytes = 14;\r
742            meta_tx2.l4OffBytes = 14+20;\r
743            meta_tx2.l4HdrLen = 8;\r
744            meta_tx2.ploadLen = (unsigned) ((p_pkt[14+20+4]<<8)|p_pkt[14+20+4+1]) -8 ;\r
745            meta_tx2.pseudoHdrChecksum =\r
746              test_utilGetIpv4PsudoChkSum(&p_pkt[14],8+ meta_tx2.ploadLen);\r
747 \r
748            /* post it to netcp tx channel*/\r
749            meta2.u.tx_meta=&meta_tx2;\r
750            pktio_send(netcp_tx_chan,tip,&meta2,&err);\r
751            stats.tx +=1;\r
752 }\r
753 }\r
754 \r
755 \r
756 \r
757 \r
758 \r
759 \r
760 \r
761 /****************************************************************************************/\r
762 /******************SB Accelerator Callback PKT RECEIVE HANDLER *************************/\r
763 /******************  Handles Decrypt and Encrypt operation callbacks ******************/\r
764 /******************************************************************************************/\r
765 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
766                          PKTIO_METADATA_T meta[], int n_pkts,\r
767                          uint64_t ts )\r
768 {\r
769 int i;\r
770 int len;\r
771 int p;\r
772 HEAD_T * p_res;\r
773 Ti_Pkt * tip;\r
774 unsigned int templen;\r
775 int err;\r
776 KEY_T key;\r
777 char * p_pkt;\r
778 HEAD_T * p_head;\r
779 HEAD_T temp_head;\r
780 int tag_cmp=0;\r
781 unsigned int hash[3];\r
782 \r
783  /* loop over received pkts */\r
784    for(i=0;i<n_pkts;i++)\r
785    {\r
786         tip = p_recv[i];\r
787         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen\r
788         len = Pktlib_getPacketLen(tip);//real length\r
789 \r
790         //is this a decrypt (rx_tunnel) complete\r
791         if (meta[i].u.rx_sb_meta->appId == rx_tunnel)\r
792         {\r
793            stats.sb_rx+=1;\r
794            //copy hash out of meta data (for some reason it needs endian conversion)\r
795            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);\r
796            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);\r
797            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);\r
798 \r
799            if(stats.sb_rx<=16)\r
800            {\r
801              char *tp = (char *) &hash[0];\r
802              dump_header((long*)p_pkt, stats.sb_rx, meta[i].u.rx_sb_meta->appId,0);\r
803              printf("tag in pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
804                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],\r
805                       p_pkt[len-7],p_pkt[len-6],\r
806                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);\r
807              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
808                        tp[0],tp[1],tp[2],tp[3],tp[4],tp[5],\r
809                        tp[6],tp[7],tp[8],tp[9],tp[10],tp[11]);\r
810            }\r
811            //check tag \r
812            tag_cmp = memcmp(&p_pkt[len-12],(char*) &hash[0],12); //todo, really use meta->authTagLen\r
813            stats.n_auth_ok += !(tag_cmp);\r
814            flip_and_send_pkt(tip, p_pkt, len,1);  //flip packet to echo back and send\r
815         }\r
816         //this is an encrypt (tx tunnel) complete\r
817         else if(meta[i].u.rx_sb_meta->appId== tx_tunnel )\r
818         {\r
819            hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);\r
820            hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);\r
821            hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);\r
822            stats.sb_tx+=1;\r
823            if(stats.sb_tx<=16)\r
824            {\r
825              char *tp1 = (char *) &hash[0];\r
826              dump_header((long*)p_pkt, stats.sb_tx, meta[i].u.rx_sb_meta->appId,0);\r
827              printf("tag in original rx pkt=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
828                       p_pkt[len-12],p_pkt[len-11],p_pkt[len-10],p_pkt[len-9], p_pkt[len-8],\r
829                       p_pkt[len-7],p_pkt[len-6],\r
830                       p_pkt[len-5],p_pkt[len-4],p_pkt[len-3],p_pkt[len-2],p_pkt[len-1]);\r
831 \r
832              printf("tag from SA=%x %x %x %x %x %x %x %x %x %x %x %x\n",\r
833                        tp1[0],tp1[1],tp1[2],tp1[3],tp1[4],tp1[5],\r
834                        tp1[6],tp1[7],tp1[8],tp1[9],tp1[10],tp1[11]);\r
835            }\r
836            //put the computed tag in the packet\r
837            memcpy(&p_pkt[len-12],(char*)&hash[0],12); //todo, really use meta->authTagLen\r
838            {\r
839            PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};\r
840            nwalTxPktInfo_t meta_tx={0};\r
841            // now send directly \r
842            meta2.sa_handle=nwal_HANDLE_INVALID;\r
843            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
844            meta_tx.startOffset = 0;\r
845            meta_tx.ipOffBytes = 14;\r
846            //not used\r
847            meta_tx.l4OffBytes = 0;\r
848            meta_tx.l4HdrLen = 0;\r
849            meta_tx.ploadLen = 0;\r
850 \r
851            /* post it to netcp tx channel*/\r
852            meta2.u.tx_meta=&meta_tx;\r
853            pktio_send(netcp_tx_chan,tip,&meta2,&err);\r
854            stats.tx +=1;\r
855            }\r
856         }\r
857         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );\r
858     }\r
859 }\r
860 \r
861 /******************************************************/\r
862 /******************PKT RECEIVE HANDLER *************************/\r
863 /******************************************************/\r
864 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],\r
865                          PKTIO_METADATA_T meta[], int n_pkts,\r
866                          uint64_t ts )\r
867 {\r
868 int i;\r
869 int len;\r
870 int p;\r
871 HEAD_T * p_res;\r
872 Ti_Pkt * tip;\r
873 unsigned int templen;\r
874 int err;\r
875 KEY_T key;\r
876 char * p_pkt;\r
877 HEAD_T * p_head;\r
878 HEAD_T temp_head;\r
879 \r
880     p_head=&temp_head;\r
881 \r
882     //debug\r
883 #if 0\r
884     if (n_pkts != TX_BURST) {\r
885       printf("recv_cb, txsofar=%d rxsofar=%d  np = %d, NOT %d\n", \r
886              stats.itx, stats.rx, n_pkts,TX_BURST);\r
887       our_stats_cb(netapi_handle,NULL);\r
888     }\r
889 #endif\r
890     //test_alloc_free(7);\r
891     //printf("recv start\n");\r
892 \r
893    /* loop over received pkts */\r
894    for(i=0;i<n_pkts;i++)\r
895    {\r
896         tip = p_recv[i];\r
897         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen\r
898         len = Pktlib_getPacketLen(tip)-4;//real length, subtract mac trailer\r
899 \r
900          //debug: validate descriptor */\r
901          if(Pktlib_getNextPacket(tip) != 0) {printf(" rcv_cb, nexpkt != NULL");}\r
902         //debug printf("recv pkt, len=%d %d\n", len, templen);\r
903         stats.rx+=1;\r
904 \r
905 #ifdef DEBUG_DESC\r
906    if (stats.rx<16){printf(">rx dmp.."); dump_descr((long *) tip, stats.rx);}\r
907    else if (stats.rx>99) {printf(">rx dmp.."); dump_descr((long *) tip,stats.rx);}\r
908 #endif\r
909     if(stats.rx<=16)\r
910     {\r
911         dump_header((long*)p_pkt, stats.rx, meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);\r
912     }\r
913         /* check header */\r
914         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));\r
915 \r
916         if ((p_head->ip[2]&0x0000ff00)==0x00003200)\r
917         {\r
918              if (!check_header(p_head,&meta[i])) {\r
919                 stats.n_bad+=1;Pktlib_freePacket(tip); continue;\r
920              }\r
921  \r
922              //process IP SEC PACKET\r
923 #ifdef IPSEC_MODE_RX_SIDEBAND\r
924         {\r
925            //ship to crypto for decrypt!!\r
926            //12 byte auth tag\r
927            PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};\r
928            nwalDmTxPayloadInfo_t meta_tx={0};\r
929            meta2.sa_handle=rx_data_mode_handle;\r
930            meta_tx.ploadLen = len;\r
931            meta_tx.encOffset = 14+20+8+16 ;\r
932            meta_tx.authOffset =14+20 ;\r
933            meta_tx.encSize=len - 14- 20-8-16-12;\r
934            meta_tx.authSize= len -14-20-12;\r
935            meta_tx.encIvSize=16;\r
936            meta_tx.pEncIV= &p_pkt[14+20+8];\r
937            meta_tx.authIvSize=0;\r
938            meta_tx.pAuthIV=NULL;\r
939            meta_tx.aadSize=0;\r
940            meta_tx.pAad=NULL;\r
941            /* post it to netcp sb tx channel*/\r
942            meta2.u.tx_sb_meta=&meta_tx;\r
943            pktio_send(netcp_sb_tx_chan,tip,&meta2,&err);\r
944            continue;\r
945         }\r
946 #else \r
947         //inflow mode.  flip and send\r
948         flip_and_send_pkt(tip,p_pkt,len,1);\r
949 #endif\r
950     }\r
951     else  //non ipsec\r
952     {\r
953         if (!check_header(p_head,&meta[i])) { \r
954                 stats.n_bad+=1;Pktlib_freePacket(tip); continue;\r
955         }\r
956 \r
957 #if 0\r
958         /* lookup flow */\r
959         key.src_ip = p_head->ip[3];\r
960         key.dst_ip = p_head->ip[4];\r
961         key.src_port= (p_head->udp[0]&0xffff0000)>>16;\r
962         key.dst_port= (p_head->udp[0]&0x0000ffff);\r
963         p_res= (HEAD_T *) trie_lookup(P_trie, (char *) &key, sizeof(key));\r
964         if (!p_res) { stats.n_new+=1;  slow_path(tip, len); continue;}\r
965 \r
966         /* copy header */\r
967         memcpy((char *) p_head, (char *) p_res, sizeof(HEAD_T));\r
968 \r
969         memcpy(&p_pkt[14],p_head,sizeof(HEAD_T));\r
970         /* update_mac(&p_pkt[0]);  */\r
971 \r
972         /* 'simulate' send pkt */\r
973         send_pkt(tip,len);\r
974 #endif\r
975         //just flip and send\r
976         flip_and_send_pkt(tip,p_pkt,len,0);\r
977     }\r
978   }\r
979     //printf("recv done\n");\r
980 }\r
981 \r
982 //timer callback \r
983 void our_timer_cb( NETAPI_TIMER_GROUP_HANDLE_T th,\r
984         int n_fired,     //# timers fired\r
985         NETAPI_TIMER_LIST_T fired_list,\r
986         uint64_t currentTime)\r
987 {\r
988 int i;\r
989 NETAPI_TIMER_T tx;\r
990 int cookie;\r
991 int err;\r
992 unsigned long long et;\r
993 //DEBUGprintf("TIMER CALLBACK @ %lld %d timers\n", currentTime, n_fired);\r
994 tx = netapi_TimerGetFirst(fired_list);\r
995 for(i=0;i<n_fired;i++)\r
996 {\r
997   cookie = (int) netapi_TimerGetCookie(tx);\r
998   et =  netapi_TimerGetTs(tx); //debug\r
999   //DEBUGprintf("   timer %d - cookie = %d expected ts=%lld (delta=%lld)\n", i, cookie, et, currentTime-et);\r
1000   if (cookie ==1)\r
1001   {  \r
1002      stats.n_t1+=1;\r
1003      t1 = netapi_TimerGroupStartTimer(\r
1004         th,\r
1005         (void *) 1,\r
1006         100LL,  //timer group tics\r
1007         &err);\r
1008   }\r
1009   else if (cookie ==2)\r
1010   {\r
1011       stats.n_t2+=1;\r
1012       t2 = netapi_TimerGroupStartTimer(\r
1013         th,\r
1014         (void *) 2,\r
1015         200LL,  //timer group ticks\r
1016         &err);\r
1017   }\r
1018   else\r
1019   {\r
1020     stats.n_t3+=1;\r
1021     t3 = netapi_TimerGroupStartTimer(\r
1022         th,\r
1023         (void *) 3,\r
1024         300LL,  //timer group ticks\r
1025         &err);\r
1026     //cancel 1 and restart 1\r
1027    netapi_TimerGroupCancel(th,t1,&err);\r
1028    t1 = netapi_TimerGroupStartTimer(\r
1029         th,\r
1030         (void *) 1,\r
1031         100LL,  //timer group ticks\r
1032         &err);\r
1033  }\r
1034   tx = netapi_TimerGetNext(fired_list,tx); \r
1035 }\r
1036 }\r
1037 \r
1038 \r
1039 static int np2process = NP;\r
1040 /******************************************************\r
1041  * stats callback\r
1042  *******************************************************/\r
1043 void our_stats_cb(NETAPI_T h, paSysStats_t* pPaStats)\r
1044 {\r
1045 uint32_t numFreeDataPackets;\r
1046 uint32_t numZeroBufferPackets;\r
1047 uint32_t numPacketsinGarbage;\r
1048 \r
1049 printf(">*****stats @ %lld\n", netapi_getTimestamp());\r
1050 //printf("netcp_tx_handle check %x\n", netcp_tx_chan->back);\r
1051 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
1052          stats.n_class0_rx, stats.n_class1_rx, \r
1053          stats.n_class2_rx, stats.sec_rx, stats.secp_rx, stats.sb_rx, stats.sb_tx, stats.n_auth_ok,\r
1054          stats.n_t1, stats.n_t2,stats.n_t3);\r
1055 \r
1056 if(pPaStats)\r
1057 {\r
1058        printf("C1 number of packets:           %d\n", pPaStats->classify1.nPackets);\r
1059        printf("C1 number IPv4 packets:         %d\n", pPaStats->classify1.nIpv4Packets);\r
1060        //printf("C1 number llc/snap fail:        %d\n", pPaStats->classify1.nLlcSnapFail);\r
1061        printf("C1 number table matched:        %d\n", pPaStats->classify1.nTableMatch);\r
1062        printf("C1 number failed table matched: %d\n", pPaStats->classify1.nNoTableMatch);\r
1063        printf ("C1 number of parse fail:        %d\n",pPaStats->classify1.nParseFail);\r
1064        printf("C1 number of command failures:  %d\n", pPaStats->classify1.nCommandFail);\r
1065        printf("C1 number invalid reply dests:  %d\n", pPaStats->classify1.nInvalidComReplyDest);\r
1066        printf ("C1 number of silent discard:    %d\n",pPaStats->classify1.nSilentDiscard);\r
1067        printf("C1 number of invalid control:   %d\n", pPaStats->classify1.nInvalidControl);\r
1068        printf ("C1 number of invalid states:    %d\n",pPaStats->classify1.nInvalidState);\r
1069        printf ("C1 number of system fails:      %d\n",pPaStats->classify1.nSystemFail);\r
1070        printf ("C2 number parse failed  :      %d\n",pPaStats->classify2.nParseFail);\r
1071        printf ("C2 number Invld Header  :      %d\n",pPaStats->classify2.nInvldHdr);\r
1072        printf ("C2 number udp           :      %d\n",pPaStats->classify2.nUdp);\r
1073        printf ("C2 number tcp           :      %d\n",pPaStats->classify2.nTcp);\r
1074        printf ("C2 number cmd fail      :      %d\n",pPaStats->classify2.nCommandFail);\r
1075        printf ("C2 number silent drop   :      %d\n",pPaStats->classify2.nSilentDiscard);\r
1076        printf ("C2 number invalid cntrl :      %d\n\n",pPaStats->classify2.nInvalidControl);\r
1077 }\r
1078 Pktlib_getHeapStats(OurHeap, &numFreeDataPackets,\r
1079                              &numZeroBufferPackets, &numPacketsinGarbage);\r
1080 printf("main heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
1081                                 numZeroBufferPackets, numPacketsinGarbage);\r
1082 Pktlib_getHeapStats(specialSmall, &numFreeDataPackets,\r
1083                              &numZeroBufferPackets, &numPacketsinGarbage);\r
1084 printf("specialSmall heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
1085                                 numZeroBufferPackets, numPacketsinGarbage);\r
1086 Pktlib_getHeapStats(specialLarge, &numFreeDataPackets,\r
1087                              &numZeroBufferPackets, &numPacketsinGarbage);\r
1088 printf("specialLarge heap stats>  #free=%d #zb=%d #garbage=%d\n", numFreeDataPackets,\r
1089                                 numZeroBufferPackets, numPacketsinGarbage);\r
1090 \r
1091 //debug = dump timer polling stats\r
1092 dump_poll_stats();\r
1093 \r
1094 \r
1095 }\r
1096 \r
1097 //******************************************************\r
1098 //use scheduling housekeeping callback to generate pkts\r
1099 //******************************************************\r
1100 void house(NETAPI_SCHED_HANDLE_T * s)\r
1101 {\r
1102 Ti_Pkt * tip;\r
1103 unsigned int len;\r
1104 nwalTxPktInfo_t meta_tx={0};\r
1105 PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};\r
1106 int err;\r
1107 static int house_pkts_gened=0;\r
1108 int p;\r
1109 unsigned char * pIpHdr,* pData;\r
1110 unsigned int vv1,vv2,vv3;\r
1111 \r
1112 for(p=0;p<TX_BURST;p++) {  \r
1113 //reguest stats \r
1114 if ((house_pkts_gened>0) && (! (house_pkts_gened%400)) )\r
1115 {\r
1116    printf("net_test> request stats at n=%d \n",house_pkts_gened);\r
1117    netcp_cfgReqStats(netapi_handle, our_stats_cb, 0,&err); \r
1118    if (err!=0) {printf("stats req failed\n");}\r
1119 }\r
1120 \r
1121 \r
1122   if (house_pkts_gened >= np2process+ 100)\r
1123   {\r
1124      //shutdown\r
1125      netapi_schedShutdown(s,NULL,&err);\r
1126      continue;\r
1127   }\r
1128 \r
1129   else if (house_pkts_gened >= np2process) { house_pkts_gened+=1;  continue;}\r
1130   \r
1131 \r
1132 /* manufacture a pkt to transmit */\r
1133    tip = get_pkt(house_pkts_gened, &len);\r
1134    if(!tip) { house_pkts_gened +=1; continue; }\r
1135 \r
1136 \r
1137    /* set the pkt length */\r
1138    vv1 = netapi_timing_start();\r
1139    Pktlib_setPacketLen(tip, len);\r
1140 \r
1141    /* set up meta data */\r
1142     meta.sa_handle=nwal_HANDLE_INVALID;\r
1143     meta_tx.txFlag1 = (NWAL_TX_FLAG1_DO_IPV4_CHKSUM | NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID);\r
1144     meta_tx.startOffset = 0;\r
1145     //GONE in V2 meta_tx.pktLen = len;\r
1146     meta_tx.ipOffBytes = TEST_PKT_IP_OFFSET_BYTES;\r
1147     meta_tx.l4OffBytes = TEST_PKT_UDP_OFFSET_BYTES;\r
1148     meta_tx.l4HdrLen = TEST_PKT_UDP_HDR_LEN;\r
1149     //GONE in V2 meta_tx.ploadOffBytes = TEST_PKT_PLOAD_OFFSET_BYTES;\r
1150     meta_tx.ploadLen = TEST_PAYLOAD_LEN;\r
1151 \r
1152     Pktlib_getDataBuffer(tip,&pData,&len);\r
1153     pIpHdr = pData + meta_tx.ipOffBytes;\r
1154     meta_tx.pseudoHdrChecksum =\r
1155         test_utilGetIpv4PsudoChkSum(pIpHdr,(TEST_PAYLOAD_LEN+TEST_PKT_UDP_HDR_LEN));\r
1156 \r
1157    /* post it to netcp tx channel*/\r
1158    meta.u.tx_meta=&meta_tx;\r
1159 #ifdef DEBUG_DESC\r
1160    if (house_pkts_gened<16) dump_descr((long *) tip, house_pkts_gened);\r
1161    else if (house_pkts_gened>99) dump_descr((long *) tip,house_pkts_gened);\r
1162 #endif\r
1163    vv2= netapi_timing_stop();\r
1164    pktio_send(netcp_tx_chan,tip,&meta,&err);\r
1165    vv3= netapi_timing_stop();\r
1166    printf("pktio send. full=%d metadata=%d pktio_send=%d\n", vv3-vv1,  vv2-vv1,  vv3-vv2);\r
1167    if (err == 0) stats.itx +=1;\r
1168 \r
1169    house_pkts_gened +=1;\r
1170  }\r
1171 }\r
1172 \r
1173 \r
1174 /***************************************\r
1175  ********** test driver*****************\r
1176  ***************************************/\r
1177 int main(int argc, char **argv)\r
1178 {\r
1179 int err;\r
1180 rlim_t oss,ss = 1024*1024;\r
1181 struct rlimit rl;\r
1182 \r
1183 err= getrlimit(RLIMIT_STACK,&rl);\r
1184 if (!err) printf(" stack limit = %d\n",rl.rlim_cur); else printf("getrlimit failed\n");\r
1185 #if 0\r
1186 rl.rlim_cur = ss;\r
1187 err=setrlimit(RLIMIT_STACK,&rl);\r
1188 if (!err) printf("set stack to %d\n",rl.rlim_cur); else printf("setrlimit failed\n");\r
1189 #endif\r
1190 \r
1191 if (argc>=2)  np2process = atoi(argv[1]);\r
1192 if (np2process<0) np2process = NP; /* default */\r
1193 if (argc==3)  perslow = atoi(argv[2]);\r
1194 if ((perslow<0)||(perslow>100)) perslow=PERSLOW;//default\r
1195 if (argc>3) {printf("net_test  <no of pkts to process> <percent slow path>\n"); exit(1);}\r
1196 \r
1197 \r
1198 //real mode, so update our test packet mac header and ip header\r
1199 if (pktloopback==0)\r
1200 {\r
1201 memcpy(&testPkt,&real_mac_header[0],14); //overwrite test pkt mac address\r
1202 memcpy(&testPkt[26],&real_ip_addr[0],8);//overrite test pkt ip addresses\r
1203 }\r
1204 \r
1205 /*******************************************/\r
1206 /*************NETAPI STARTUP****************/\r
1207 /*******************************************/\r
1208 \r
1209 /* create netapi */\r
1210 netapi_handle = netapi_init(NETAPI_SYS_MASTER);\r
1211 \r
1212 /* open the main heap */\r
1213 OurHeap = Pktlib_findHeapByName("netapi");\r
1214 if (!OurHeap) {printf("findheapbyname fail\n"); exit(1);}\r
1215 \r
1216 /* create two secondary heaps */\r
1217 specialSmall = Pktlib_createHeap("netapi-small", NETAPI_GLOBAL_REGION,\r
1218                                                 1,\r
1219                                                 256, //bytes\r
1220                                                 64,  //num buffs\r
1221                                                 0,\r
1222                                                 netapi_getPktlibIfTable());\r
1223 specialLarge = Pktlib_createHeap("netapi-small", NETAPI_GLOBAL_REGION,\r
1224                                                 1,\r
1225                                                 1600, //bytes\r
1226                                                 64,  //num buffs\r
1227                                                 0,\r
1228                                                 netapi_getPktlibIfTable());\r
1229 //register these heaps so poll routine will include their garbage queues.\r
1230 netapi_registerHeap(netapi_handle, specialSmall);\r
1231 netapi_registerHeap(netapi_handle, specialLarge);\r
1232 \r
1233 \r
1234 /* create a pktio channel */\r
1235 our_chan=pktio_create(netapi_handle,"our1stq",(PKTIO_CB) recv_cb, &our_chan_cfg,&err);\r
1236 if (!our_chan) {printf("pktio create failed err=%d\n",err); exit(1);}\r
1237 \r
1238 /* open netcp default tx, rx queues */\r
1239 netcp_tx_chan= pktio_open(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);\r
1240 if (!netcp_tx_chan) {printf("pktio open TX failed err=%d\n",err); exit(1);}\r
1241 netcp_rx_chan= pktio_open(netapi_handle, NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);\r
1242 if (!netcp_rx_chan) {printf("pktio open RX failed err=%d\n",err); exit(1);}\r
1243 \r
1244 /* create a pktio channel for specially classified pkts */\r
1245 netcp_rx_chan2= pktio_create(netapi_handle, "classq", (PKTIO_CB) recv_cb, &netcp_rx_cfg2,  &err);\r
1246 if (!netcp_rx_chan2) {printf("pktio create RX2 failed err=%d\n",err); exit(1);}\r
1247 \r
1248 /* open netcp default tx, rx queues for sideband crypto */\r
1249 netcp_sb_tx_chan= pktio_open(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);\r
1250 if (!netcp_sb_tx_chan) {printf("pktio open SB TX failed err=%d\n",err); exit(1);}\r
1251 netcp_sb_rx_chan= pktio_open(netapi_handle, NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);\r
1252 if (!netcp_sb_rx_chan) {printf("pktio open SB RX failed err=%d\n",err); exit(1);}\r
1253 \r
1254 \r
1255 /* create scheduler instance */\r
1256 our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);\r
1257 if (!our_sched) {printf("sched create failed\n"); exit(1);}\r
1258 \r
1259 /* add mac intefaces */\r
1260 netcp_cfgCreateMacInterface(\r
1261                   netapi_handle,\r
1262                   &mac0[0],\r
1263                   0,0,\r
1264                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,\r
1265                   (NETCP_CFG_VLAN_T ) NULL ,  //future\r
1266                   1, \r
1267                   &err);\r
1268 if (err) {printf("addmac0 failed %d\n",err); exit(1); } \r
1269 \r
1270 //attach an IP to this interface\r
1271 ip_rule0=netcp_addIp(\r
1272                   netapi_handle,\r
1273                   0,\r
1274                   nwal_IPV4,\r
1275                   &OurIp0,\r
1276                   NULL,  //all IP\r
1277                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,\r
1278                   &err\r
1279                   );\r
1280 if (err) {printf("addip0 failed %d\n",err); exit(1); } \r
1281 #if 1\r
1282 //create a 2nd mac instance\r
1283 netcp_cfgCreateMacInterface(\r
1284                   netapi_handle,\r
1285                   &mac1[0],\r
1286                   1,1,\r
1287                   (NETCP_CFG_ROUTE_HANDLE_T)  NULL,\r
1288                   (NETCP_CFG_VLAN_T ) NULL ,  //future\r
1289                   1,\r
1290                   &err);\r
1291 if (err) {printf("addmac1 failed %d\n",err); exit(1); }\r
1292 \r
1293 //attach an IP to this interface\r
1294 ip_rule1=netcp_addIp(\r
1295                   netapi_handle,\r
1296                   1,\r
1297                   nwal_IPV4,\r
1298                   &OurIp1,\r
1299                   NULL,  //all IP\r
1300                   (NETCP_CFG_ROUTE_HANDLE_T) NULL,\r
1301                   &err\r
1302                   );\r
1303 if (err) {printf("addip1 failed %d\n",err); exit(1); }\r
1304 \r
1305 //attach 2 classifiers to iface 0, ip0\r
1306 class_0_cfg.u.c_l4.ip = ip_rule0;\r
1307 class_0 =  netcp_cfgAddClass(netapi_handle,\r
1308                              &class_0_cfg,\r
1309                              NULL,\r
1310                              NETCP_CFG_ACTION_TO_SW,\r
1311                              &err);\r
1312 if (err) {printf("addclass0 failed %d\n",err); exit(1);}\r
1313 \r
1314 class_1_cfg.u.c_l4.ip = ip_rule0;\r
1315 class_1 =  netcp_cfgAddClass(netapi_handle,\r
1316                              &class_1_cfg,\r
1317                              NULL,\r
1318                              NETCP_CFG_ACTION_TO_SW,\r
1319                              &err);\r
1320 if (err) {printf("addclass1 failed %d\n",err); exit(1);}\r
1321 \r
1322 \r
1323 //3rd classifier has a different IP and route\r
1324 class_2_cfg.u.c_l3_l4.ip_addr = &OurIp2;\r
1325 \r
1326 //create specialFlow for this classifier\r
1327 {\r
1328 Pktlib_HeapHandle heaps[2];\r
1329 int sizes[2];\r
1330 heaps[0]= specialSmall;\r
1331 heaps[1]= specialLarge;\r
1332 sizes[0]=256;\r
1333 sizes[1]=1600;\r
1334 specialFlow = netcp_cfgAddFlow( netapi_handle,\r
1335                                 2,\r
1336                                 heaps,\r
1337                                 sizes,\r
1338                                 &err);\r
1339 if (err) {printf("add flow failed\n", err); exit(1);}\r
1340 }\r
1341 //special route for this classifier:  different flow + destination q\r
1342 class2_route.p_dest_q = netcp_rx_chan2;\r
1343 class2_route.p_flow = specialFlow;\r
1344 class_2 = netcp_cfgAddClass(netapi_handle,\r
1345                             &class_2_cfg,\r
1346                             (void*) &class2_route,\r
1347                             NETCP_CFG_ACTION_TO_SW,\r
1348                             &err);\r
1349 if (err) {printf("addclass2 failed %d\n",err); exit(1);}\r
1350 #endif\r
1351 \r
1352 //security stuff \r
1353 ourRXKeyParams.pEncKey = &ourEncrKey[0];\r
1354 ourRXKeyParams.pAuthKey = &ourAuthKey[0];\r
1355 memcpy(&rx_sa.src, &TheirIp4IPSEC,4);\r
1356 memcpy(&rx_sa.dst, &OurIp4IPSEC,4);\r
1357 \r
1358 #if 1\r
1359 rx_tunnel = netapi_secAddSA( netapi_handle,\r
1360                  0, //iface #0 \r
1361                 &rx_sa,\r
1362                 &ourRXKeyParams,\r
1363 #ifdef IPSEC_MODE_RX_SIDEBAND\r
1364                 NETAPI_SEC_SA_SIDEBAND,\r
1365 #else\r
1366                 NETAPI_SEC_SA_INFLOW,  //USE inflow mode\r
1367 #endif\r
1368                 NULL,  //use default route \r
1369                 &rx_data_mode_handle,\r
1370                 &rx_inflow_mode_handle,\r
1371                 &err);\r
1372 if (err) {printf("addRxSa failed %d\n",err); exit(1);}\r
1373 \r
1374 #ifdef IPSEC_MODE_RX_INFLOW\r
1375 //assume inner and outer ip is the same\r
1376 rx_policy= netapi_secAddRxPolicy( netapi_handle,\r
1377                          rx_tunnel,  //link to tunnel above\r
1378                          4,         //ipv4\r
1379                          &TheirIp4IPSEC, //src -> them\r
1380                          &OurIp4IPSEC,  //dst -> us\r
1381                          NULL,  // no qualifiers\r
1382                          NULL,  //default route\r
1383                          &err);\r
1384 if (err) {printf("addSaPolicy failed %d\n",err); exit(1);}\r
1385 #else \r
1386 rx_policy = 0;\r
1387 #endif\r
1388 #endif\r
1389 \r
1390 //tx SA\r
1391 //security stuff \r
1392 ourTXKeyParams.pEncKey = &ourEncrKey[0];\r
1393 ourTXKeyParams.pAuthKey = &ourAuthKey[0];\r
1394 memcpy(&tx_sa.src, &OurIp4IPSEC,4);\r
1395 memcpy(&tx_sa.dst, &TheirIp4IPSEC,4);\r
1396 tx_tunnel = netapi_secAddSA( netapi_handle,\r
1397                  0, //iface #0 \r
1398                 &tx_sa,\r
1399                 &ourTXKeyParams,\r
1400 #ifdef IPSEC_MODE_TX_SIDEBAND\r
1401                 NETAPI_SEC_SA_SIDEBAND,\r
1402 #else\r
1403                 NETAPI_SEC_SA_INFLOW,  //USE inflow mode\r
1404 #endif\r
1405                 NULL,  //use default route \r
1406                 &tx_data_mode_handle,\r
1407                 &tx_inflow_mode_handle,\r
1408                 &err);\r
1409 if (err) {printf("addTxSa failed %d\n",err); exit(1);}\r
1410 \r
1411 \r
1412 \r
1413 //timers\r
1414 ourTimerBlock = netapi_TimerGroupCreate(\r
1415         netapi_handle,\r
1416         "our1sttimer",\r
1417         our_timer_cb,\r
1418         0,    //1 if timers local to thread\r
1419         0,    //1 if expect to cancel\r
1420         netapi_getTicksPerSec()/1000,  /* 1 msc resolution for these timers */\r
1421         netapi_getTicksPerSec()/5000, /* would like .5 msc tolerence */\r
1422         10,  //small # of timers to test garbage collection\r
1423         &err);\r
1424 if (err) {printf("timergroupcreate failed %d\n",err); exit(1);}\r
1425 \r
1426 //start a couple of timers \r
1427 t1 = netapi_TimerGroupStartTimer(\r
1428         ourTimerBlock,\r
1429         (void *) 1,\r
1430         100LL,  //timer group ticks\r
1431         &err);\r
1432 if (err) {printf("timerstart failed %d\n");}\r
1433 t2 = netapi_TimerGroupStartTimer(\r
1434         ourTimerBlock,\r
1435         (void *) 2,\r
1436         200LL,  //timer group ticks\r
1437         &err);\r
1438 if (err) {printf("timerstart failed %d\n");}\r
1439 t3 = netapi_TimerGroupStartTimer(\r
1440         ourTimerBlock,\r
1441         (void *) 3,\r
1442         300LL,  //timer group ticks\r
1443         &err);\r
1444 if (err) {printf("timerstart failed %d\n");}\r
1445 \r
1446 netcp_cfgReqStats(netapi_handle, our_stats_cb, 1,&err);\r
1447 if (err!=0) {printf("stats req failed\n");}\r
1448 \r
1449 /*********************************************/\r
1450 /*****************end NETAPI STARTUP**********/\r
1451 /*********************************************/\r
1452 \r
1453 \r
1454 /********************************************\r
1455 * Basic pkt loopback test\r
1456 *********************************************/\r
1457 \r
1458 \r
1459 /* create TRIE */\r
1460 P_trie = trie_new();\r
1461 if (!P_trie) {printf("trie alloc failed\n"); exit(1);}\r
1462 \r
1463 nat = (HEAD_T *) malloc(NE * sizeof(HEAD_T));\r
1464 if (!nat) {printf("malloc of nat table failed\n"); exit(1);}\r
1465 \r
1466 //gen_pkts(np2process<NP ? np2process:NP);\r
1467 n_pkt= np2process;\r
1468 \r
1469 /* build table */\r
1470 build_table(P_trie);\r
1471 \r
1472 \r
1473 /* processing loop: get pkt, check it, look up in table, copy new header,\r
1474    send packet */\r
1475 srand((unsigned) np2process);\r
1476 \r
1477 \r
1478 /*********************************************/\r
1479 /**************Entry point into scheduler ****/\r
1480 /*********************************************/\r
1481 netapi_schedWaitForEvents(our_sched, &err);\r
1482 \r
1483 /* done */\r
1484 our_stats_cb(netapi_handle, NULL);\r
1485 \r
1486 /*************************************************\r
1487  ************CLEAN UP****************************\r
1488  ************************************************/\r
1489 \r
1490 //delete Classifiers\r
1491 netcp_cfgDelClass(netapi_handle, class_0, &err); \r
1492 netcp_cfgDelClass(netapi_handle, class_1, &err); \r
1493 netcp_cfgDelClass(netapi_handle, class_2, &err); \r
1494 \r
1495 //delete flow \r
1496 netcp_cfgDelFlow(netapi_handle, specialFlow, &err);\r
1497 \r
1498 #if 1\r
1499 //delete policy\r
1500 if (rx_policy)\r
1501         netapi_secDelRxPolicy(netapi_handle, rx_policy, &err);\r
1502 \r
1503 //delete tunnels\r
1504 netapi_secDelSA(netapi_handle, 0, rx_tunnel, &err);\r
1505 netapi_secDelSA(netapi_handle, 0, tx_tunnel, &err);\r
1506 #endif\r
1507 \r
1508 //delete IPs and MAC Interfacess\r
1509 netcp_cfgDelIp(netapi_handle, 0, 0, NULL, NULL, ip_rule0, &err);\r
1510 netcp_cfgDelIp(netapi_handle, 1, 0, NULL, NULL, ip_rule1, &err);\r
1511 netcp_cfgDelMac(netapi_handle,0,&err);\r
1512 netcp_cfgDelMac(netapi_handle,1,&err);\r
1513 \r
1514 \r
1515 //close pktio channels we opened\r
1516 pktio_close(netcp_tx_chan ,&err);\r
1517 pktio_close(netcp_rx_chan ,&err);\r
1518 pktio_close(netcp_sb_tx_chan ,&err);\r
1519 pktio_close(netcp_sb_rx_chan ,&err);\r
1520 \r
1521 //clear pktio channel we created\r
1522 pktio_control(our_chan, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);\r
1523 pktio_control(netcp_rx_chan2, (PKTIO_CB) NULL, (PKTIO_CFG_T *) NULL, &zap_channel_control, &err);\r
1524 \r
1525 //delete pktio channels we created\r
1526 pktio_delete(our_chan, &err);\r
1527 pktio_delete(netcp_rx_chan2,&err);\r
1528 \r
1529 netapi_shutdown(netapi_handle);\r
1530 \r
1531 }\r