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