79f8c608e223ffa1d79f6efce5b237fc79dfc5e7
[keystone-rtos/netapi.git] / ti / runtime / netapi / test / net_test.c
1 /******************************************
2  * File: net_test.c
3  * Purpose: test app for netapi
4  **************************************************************
5  * FILE:  net_test.c
6  * 
7  * DESCRIPTION:  netapi user space transport
8  *               library  test application
9  * 
10  * REVISION HISTORY:
11  *
12  *  Copyright (c) Texas Instruments Incorporated 2010-2011
13  * 
14  *  Redistribution and use in source and binary forms, with or without 
15  *  modification, are permitted provided that the following conditions 
16  *  are met:
17  *
18  *    Redistributions of source code must retain the above copyright 
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  *    Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the 
23  *    documentation and/or other materials provided with the   
24  *    distribution.
25  *
26  *    Neither the name of Texas Instruments Incorporated nor the names of
27  *    its contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  *****************************************/
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <unistd.h>
47 #include <string.h>
48 #include <signal.h>
49 #include <pthread.h>
51 #include "net_test.h"
52 #include "trie.h"
53 #include "string.h"
55 #include <sys/resource.h>
57 #include <ti/drv/sa/salld.h>
58 #include <ti/drv/pa/pa.h>
60 #include "net_test_utils.h"
61 #include "router.h"
63 extern int QUIT;
64 extern STATS_T stats[TUNE_NETAPI_NUM_CORES];
65 extern paSysStats_t netcp_stats;
66 /* Global definitions */
67 #ifdef MULTI_THREAD
68     cpu_set_t cpu_set;
69 #endif
71 netTestConfig_t netTestCfg;
72 static  netTestConfigFile_t config_file;
74 char    input_file_name[] = "net_test_config.txt";
76 nwal_RetValue       nwalRetVal;
77 Pktlib_HeapHandle ourHeap;
79 PKTIO_HANDLE_T *netcp_rx_chan;
80 PKTIO_HANDLE_T *netcp_tx_chan_no_crypto;
81 PKTIO_HANDLE_T *netcp_tx_chan_esp;
82 PKTIO_HANDLE_T *netcp_tx_chan_ah;
83 PKTIO_HANDLE_T *netcp_sb_tx_chan;
84 PKTIO_HANDLE_T *netcp_sb_rx_chan;
86 PKTIO_CFG_T our_chan_cfg={PKTIO_RX_TX, PKTIO_LOCAL, PKTIO_Q_ANY, 8};
87 PKTIO_CFG_T netcp_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
88 PKTIO_CFG_T netcp_rx_cfg2={PKTIO_RX, (PKTIO_GLOBAL|PKTIO_PKT), PKTIO_Q_ANY, 8};
89 PKTIO_CFG_T netcp_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
90 PKTIO_CFG_T netcp_sb_rx_cfg={PKTIO_RX, PKTIO_NA, PKTIO_NA, 8};
91 PKTIO_CFG_T netcp_sb_tx_cfg={PKTIO_TX, PKTIO_NA, PKTIO_NA, 8};
94 NETCP_CFG_EXCEPTION_PKT_T expPkt_appid;
96 Trie *p_trie_sa_rx;
97 Trie *p_trie_sa_tx;
100 /*******************************************
101  *************NETAPI OBJECTS***************
102  *****************************************/
103 static NETAPI_CFG_T our_netapi_default_cfg=
105 TUNE_NETAPI_PERM_MEM_SZ,
106 128,  //start of packet offset for hw to place data on rx for default flow
107 TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
108 TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
109 TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
110 64, //#descriptors w/o buffers in default heap
111 TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
112 128   ,  //tail room
113 256      //extra room 
114 };
116 NETAPI_T netapi_handle;
117 NETAPI_SCHED_HANDLE_T * our_sched;
118 #ifdef MULTI_THREAD
119 NETAPI_SCHED_HANDLE_T * scheduler[TUNE_NETAPI_NUM_CORES];
120 #endif
121 NETAPI_SCHED_CONFIG_T our_sched_cfg={
122   NETAPI_SCHED_DURATION|NETAPI_SCHED_CBV, 0, house, 5000000  //every 5000000 poll loops
123 };
125 NETCP_CFG_IP_T ip_rule[NET_TEST_MAX_IP];
126 NETCP_CFG_MACIF_T mac[NET_TEST_MAX_MAC];
130 /* security objects. (for loopback mode) */
131 netTestSA_t sa_info[MAX_SEC_INDEX];
133 NETCP_CFG_IPSEC_POLICY_T rx_policy[MAX_SEC_INDEX];
137 /*--------------------------------------------------------------
138  *----------utility to flip a packet and send 
139  *--------------------back to source----------------------------
140  *                   flag=1 => ipsec
141  *--------------------------------------------------------------*/
142 void flip_and_send_pkt(Ti_Pkt *tip,  unsigned char * p_pkt, int len, int flag, uint16_t enet_port)
144     unsigned char mac_temp[6];
145     unsigned char ip_temp[4];
146     unsigned char new_dest_port[2]={0x75,0x30};  // 30000
147     uint16_t blah; 
148     uint16_t i=1;   /* for testing only */
150     uint8_t *p_spi; 
151     netTestSA_t * p_sa_info;
152     netTestSA_t *p_sa_info_tx;
153     uint8_t p_iv[16];
154     uint8_t p_add[8];
155     Cppi_HostDesc*          pPloadDesc;
156     uint8_t ah_len;
157     uint32_t tunnel_id;
158     nwalLocCxtInfo_t    nwalLocCxt;
159     HEAD_T * p_head;
160     HEAD_T temp_head;
161     int pkt_type;
163 #ifdef MULTI_THREAD
164     int coreid=Osal_nwalGetProcId(); //who we are(thread local)
165         //int coreid = our_core;
166 #else
167 int coreid=0;
168 #endif
169               //netapi_dump_buf((long*)p_pkt,len);
170     Pktlib_setPacketLen(tip,len);
171     //flip the mac address
172     memcpy(&mac_temp,&p_pkt[0],6);
173     memcpy(&p_pkt[0],&p_pkt[6],6);
174     memcpy(&p_pkt[6],&mac_temp,6);
175     //memcpy(&p_pkt[0],real_mac_header,6); //for testing to wireshark pc
177     //flip the ip  (outer in case of ipsec)
178     memcpy(&ip_temp, &p_pkt[14+12],4);
179     memcpy(&p_pkt[14+12],&p_pkt[14+12+4],4);
180     memcpy(&p_pkt[14+12+4],&ip_temp,4);
182     p_head=&temp_head;
184     //inner ip &udp for ipsec
185     if (flag) 
186     {
187         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));
189         if ((p_head->ip[2]&0x0000ff00)==0x00003300)
190         {
191             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN + 4]);
192             pkt_type = IPSEC_AH_PKT;
193             printf("flip_and_send_pkt: AH packet received\n");
194         }
195         else if ((p_head->ip[2]&0x0000ff00)==0x00003200)
196         {
197             p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
198             pkt_type = IPSEC_ESP_PKT;
199         }
200         else
201         {
202             printf("flip_and_send_pkt: un-supported IPSEC protocol\n");
203             Pktlib_freePacket(tip);
204             return;
205         }
207         p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
208         if (p_sa_info == NULL)
209         {
210             printf("flip_and_send_pkt(): trie_lookup() failed\n");
211             Pktlib_freePacket(tip);
212             return;
213         }
214         tunnel_id = p_sa_info->tunnel_id;
215         p_sa_info_tx = (netTestSA_t *) trie_lookup(p_trie_sa_tx, (char *)&tunnel_id ,4);
216         if (p_sa_info_tx == NULL)
217         {
218             printf("flip_and_send_pkt(): trie_lookup() failed\n");
219             Pktlib_freePacket(tip);
220             return;
221         }
222         //just drop non-udp packet
223         if (p_pkt[p_sa_info->tx_payload_info.encOffset+9]!=0x11)
224         {
225             stats[coreid].n_new+=1;Pktlib_freePacket(tip); return;
226         }
228         /* flip inner IP */
229         memcpy(&ip_temp, &p_pkt[p_sa_info->tx_payload_info.encOffset+12],4);
230         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12],&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],4);
231         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+12+4],&ip_temp,4);
232         /* setting udp ports */
233         memcpy(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+2],&new_dest_port[0],2);
234         memset(&p_pkt[p_sa_info->tx_payload_info.encOffset+20+6],0,2); //checksum
236         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
237         {
238             /* inner ip checksum : leave alone, outer ip, set to 0 (we will compute on way out */
239             memset(&p_pkt[14+10],0,2);
240         }
241     }
242     else
243     {
244         memset(&p_pkt[14+20+6],0,2);//0 udp checksum (we will compute on way out)
245         memcpy(&p_pkt[14+20+2],&new_dest_port[0],2);
246     }
248     /*IPSEC case */ 
249     if (flag)
250     {
251         if (netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_SIDEBAND)
252         //send to crypto for encryption
253         //12 byte auth tag
254         {
255             PKTIO_METADATA_T meta = {PKTIO_META_SB_TX,{0},0};
256             int err;
257             nwalDmTxPayloadInfo_t meta_tx={0};
258             
259             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
261             memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
262             meta_tx.appCtxId = (nwal_AppId)p_sa_info_tx;
263             meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
264             meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
265             meta_tx.pAuthIV=NULL;
266             meta_tx.aadSize=0;
267             meta_tx.pAad=NULL;
268             if (p_sa_info->cipherMode ==  NWAL_SA_EALG_AES_CTR)
269             {
270                 memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
271                 memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
272                 p_iv[12] = 0;
273                 p_iv[13] = 0;
274                 p_iv[14] = 0;
275                 p_iv[15] = 1;
276                 meta_tx.pEncIV = &p_iv[0];
277             }
278             else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) || (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
279             {
280                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
281                 meta_tx.pEncIV = &p_iv[0];
282                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
283                 meta_tx.pAad= &p_add[0];
284                 meta_tx.aadSize = 8;
285             }
286             else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
287             {
288                 memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
289                 meta_tx.pAuthIV= &p_iv[0];
290                 memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
291                 meta_tx.pAad= &p_add[0];
292                 meta_tx.aadSize = 8;
293             }
294             else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
295             {
296                 meta_tx.pEncIV = NULL;
297             }
298             else
299             {
300                 meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
301             }
302             /* post it to netcp sb tx channel*/
303             meta.u.tx_sb_meta=&meta_tx;
305             pktio_send(netcp_sb_tx_chan,tip,&meta,&err);
306         }
307         else
308         {
309             //INFLOW TX, send pkt directly, asking for IP and UDP checksum offloads AND IPSEC to be applied
310             PKTIO_METADATA_T meta = {PKTIO_META_TX,{0},0};
311             int err;
312             nwalTxPktInfo_t meta_tx={0};
314             meta.sa_handle = (void*)p_sa_info_tx->tx_tunnel;  //use TX SA APPID
316             meta_tx.startOffset = p_sa_info_tx->tx_pkt_info.startOffset;
317             meta_tx.ipOffBytes =p_sa_info_tx->tx_payload_info.encOffset; 
318             meta_tx.l4OffBytes = p_sa_info_tx->tx_pkt_info.l4OffBytes;
319             meta_tx.l4HdrLen = p_sa_info_tx->tx_pkt_info.l4HdrLen;
320             meta_tx.ploadLen = (unsigned) ((p_pkt[meta_tx.l4OffBytes+4]<<8)|p_pkt[meta_tx.l4OffBytes+4+1]) -8 ;
321             meta_tx.saOffBytes=  p_sa_info_tx->tx_pkt_info.saOffBytes;
322             if (pkt_type == IPSEC_AH_PKT)
323             {
324                 memset(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+netTest_IPSEC_AH_FIXED_HDR_SIZE],0,netTest_IPSEC_AH_FIXED_HDR_SIZE);
325                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
326                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN;   //don't inlcude mac 
327                 meta_tx.saAhMacSize = 12;
328                 meta_tx.saAhIcvOffBytes = netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE;
329                 
330                 meta_tx.enetPort = enet_port;
331                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4],&p_sa_info_tx->spi,4);
332             }
333             else if (pkt_type == IPSEC_ESP_PKT)
334             {
335                 meta_tx.txFlag1 = p_sa_info_tx->tx_pkt_info.txFlag1;
336                 meta_tx.saPayloadLen=len-netTest_MAC_HEADER_LEN-netTest_IP_HEADER_LEN;   //don't include mac and ip outer header
337                 meta_tx.enetPort = 0;
338                  memcpy(&p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN],&p_sa_info_tx->spi,4);
339             }
340             else
341             {
342                 printf("flip_and_send_pkt: invalid ESP protocol\n");
343                 return;
344             }
346             meta_tx.pseudoHdrChecksum =
347             test_utilGetIpv4PsudoChkSum(&p_pkt[meta_tx.ipOffBytes],8+ meta_tx.ploadLen);
350             /* post it to netcp tx channel*/
351             meta.u.tx_meta=&meta_tx;
352             if (stats[coreid].sec_tx<20) dump_descr((long *) tip, stats[coreid].sec_tx);
354             if ( pkt_type == IPSEC_ESP_PKT)
355                 pktio_send(netcp_tx_chan_esp,tip,&meta,&err);
356             else if ( pkt_type == IPSEC_AH_PKT)
357                  pktio_send(netcp_tx_chan_ah,tip,&meta,&err);
358             stats[coreid].tx +=1;
359             stats[coreid].sec_tx +=1;
360         }
361     }
362     else  //non ipsec send pkt directly, asking for IP and UDP checksum ofload
363     {
364         PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
365         int err;
366         nwalTxPktInfo_t meta_tx2={0};
367         meta2.sa_handle=nwal_HANDLE_INVALID;
368         meta_tx2.txFlag1 = (NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID );
369         meta_tx2.startOffset = 0;
370         meta_tx2.ipOffBytes = netTest_MAC_HEADER_LEN;
371         meta_tx2.l4OffBytes = netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN;
372         meta_tx2.l4HdrLen = netTest_UDP_HEADER_LEN;
373         meta_tx2.ploadLen = (unsigned) ((p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4]<<8)|
374                                         p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN+4+1]) -8 ;
375         meta_tx2.pseudoHdrChecksum =
376         test_utilGetIpv4PsudoChkSum(&p_pkt[netTest_MAC_HEADER_LEN],8+ meta_tx2.ploadLen);
378         /* post it to netcp tx channel*/
379         meta2.u.tx_meta=&meta_tx2;
380         printf("flip_and_send_pkt: non-ipsec packet received\n");
381         pktio_send(netcp_tx_chan_no_crypto,tip,&meta2,&err);
382         stats[coreid].tx +=1;
383     }
387 /****************************************************************************************/
388 /******************SB Accelerator Callback PKT RECEIVE HANDLER *************************/
389 /******************  Handles Decrypt and Encrypt operation callbacks ******************/
390 /******************************************************************************************/
391 void recv_sb_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
392                          PKTIO_METADATA_T meta[], int n_pkts,
393                          uint64_t ts )
395     int i;
396     int len;
397     int p;
398     HEAD_T * p_res;
399     Ti_Pkt * tip;
400     unsigned int templen;
401     int err;
402     KEY_T key;
403     char * p_pkt;
404     HEAD_T * p_head;
405     HEAD_T temp_head;
406     int tag_cmp=0;
407     unsigned int hash[4];
408     uint8_t *p_spi;
409     netTestSA_t *p_sa_info;
411 #ifdef MULTI_THREAD
412     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
413 #else
414     int coreid=0;
415 #endif
416     //nwal_AppId time;
417     unsigned long time, delta_time;
418     /* loop over received pkts */
419     for(i=0;i<n_pkts;i++)
420    {
421         tip = p_recv[i];
422         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);//ignore templen
423         len = Pktlib_getPacketLen(tip);//real length
425         /*p_sa_info is for rx context */
426         p_sa_info = (netTestSA_t*)meta[i].u.rx_sb_meta->appCtxId;
427         if (p_sa_info == NULL)
428         {
429             printf("recv_sb_cb(): trie_lookup failed\n");
430             continue;
431         }
433         //is this a decrypt (rx_tunnel) complete
434         if ((int)meta[i].u.rx_sb_meta->appId == p_sa_info->rx_tunnel)
435         {
436             //time = hplib_mUtilGetPmuCCNT();
437             //delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
438             stats[coreid].total_decrypt_time += delta_time;
439             stats[coreid].sb_rx+=1;
440             //copy hash out of meta data (for some reason it needs endian conversion)
441             hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
442             hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
443             hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
444             hash[3]= htonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
445             if(stats[coreid].sb_rx<=16)
446             {
447                 char *tp = (char *) &hash[0];
448                 //dump_header((long*)p_pkt, stats[coreid].sb_rx, (int)meta[i].u.rx_sb_meta->appId,0);
449             }
450             tag_cmp = memcmp(&p_pkt[len-p_sa_info->auth_tag_size],(char*) &hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
451             stats[coreid].n_auth_ok += !(tag_cmp);
452             flip_and_send_pkt(tip, p_pkt, len,1, 0);  //flip packet to echo back and send
453         }
454         //this is an encrypt (tx tunnel) complete
455         else if((int)meta[i].u.rx_sb_meta->appId== p_sa_info->tx_tunnel )
456         {
457             hash[0]= htonl( meta[i].u.rx_sb_meta->pAuthTag[0]);
458             hash[1]= htonl( meta[i].u.rx_sb_meta->pAuthTag[1]);
459             hash[2]= htonl( meta[i].u.rx_sb_meta->pAuthTag[2]);
460             hash[3]= htonl( meta[i].u.rx_sb_meta->pAuthTag[3]);
461             stats[coreid].sb_tx+=1;
462             if(stats[coreid].sb_tx<=16)
463             {
464                 //dump_header((long*)p_pkt, stats[coreid].sb_tx, (int)meta[i].u.rx_sb_meta->appId,0);
465             }
466             //put the computed tag in the packet
467              memcpy(&p_pkt[len-p_sa_info->auth_tag_size],(char*)&hash[0],p_sa_info->auth_tag_size); //todo, really use meta->authTagLen
468             {
469                 PKTIO_METADATA_T meta2 = {PKTIO_META_TX,{0},0};
470                 nwalTxPktInfo_t meta_tx={0};
471                 // now send directly 
472                 meta2.sa_handle=nwal_HANDLE_INVALID;
473                 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
474                 meta_tx.startOffset = 0;
475                 meta_tx.ipOffBytes = netTest_MAC_HEADER_LEN;
476                 meta_tx.l4OffBytes = 0;
477                 meta_tx.l4HdrLen = 0;
478                 meta_tx.ploadLen = 0;
479                 time = hplib_mUtilGetPmuCCNT();
480                 delta_time = time -(unsigned long) meta[i].u.rx_sb_meta->appCtxId;
481                 stats[coreid].total_encrypt_time += delta_time;
483                 /* post it to netcp tx channel*/
484                 meta2.u.tx_meta=&meta_tx;
485                 pktio_send(netcp_tx_chan_esp,tip,&meta2,&err);
486                 hplib_cacheWbInv(p_pkt,len);
487                 stats[coreid].tx +=1;
488             }
489         }
490         else printf("netapi recv_sb_cb: unknown appiD %x \n",meta[i].u.rx_sb_meta->appId );
491     }
494 /******************************************************/
495 /******************PKT RECEIVE HANDLER *************************/
496 /******************************************************/
498 void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
499                          PKTIO_METADATA_T meta[], int n_pkts,
500                          uint64_t ts )
502     int i;
503     int len;
504     int p;
505     HEAD_T * p_res;
506     Ti_Pkt * tip;
507     unsigned int templen;
508     int err = 0;
509     KEY_T key;
510     char * p_pkt;
511     HEAD_T * p_head;
512     HEAD_T temp_head;
513     netTestSA_t *p_sa_info;
514     uint8_t *p_spi;
515     uint8_t p_iv[16];
516     uint8_t p_add[8];
517     uint8_t p_add1[1500];
518     int16_t       retVal;
520     nwalGlobCxtInfo_t   nwalGlobCxt;
521     nwalLocCxtInfo_t    nwalLocCxt;
523     Cppi_HostDesc*          pPloadDesc;
524     int ifno;
525     uint16_t enet_port = 0;
527 #ifdef MULTI_THREAD
528     int coreid=Osal_nwalGetProcId();  //who we are(thread local)
529     //int coreid = our_core;
530 #else
531     int coreid=0;
532 #endif
533     p_head=&temp_head;
536     /* loop over received pkts */
537     for(i=0;i<n_pkts;i++)
538     {
539         ifno = ((unsigned int)meta[i].u.rx_meta->appId)&0xff;
540         
541         enet_port = meta[i].u.rx_meta->enetPort;
542         tip = p_recv[i];
544         Pktlib_getDataBuffer(tip,(uint8_t**)&p_pkt,&templen);/*ignore templen */
545         len = Pktlib_getPacketLen(tip)-4;   /*real length, subtract mac trailer */
546         Cppi_setData (Cppi_DescType_HOST, (Cppi_Desc *) tip, p_pkt,len);
547         Pktlib_setPacketLen(tip,len);
549         if(((unsigned int)meta[i].u.rx_meta->appId) == expPkt_appid)
550         {
551             netapi_Log("recv_cb: received exception packet\n");
552             Pktlib_freePacket(tip);
553             if(((unsigned int)meta[i].u.rx_meta->rxFlag1  & NWAL_RX_IP_FRAGMENT_PKT) ==
554                                              NWAL_RX_IP_FRAGMENT_PKT)
555             {
556                 stats[coreid].exceptionPktsFrag+=1;
557             }
558             else
559             {
560                 stats[coreid].exceptionPktsOther+=1;
561             }
562             continue;
563         }
564         //debug: validate descriptor */
565         if(Pktlib_getNextPacket(tip) != 0) 
566         {
567             printf(" rcv_cb, nexpkt != NULL");
568         }
570         if(coreid<TUNE_NETAPI_NUM_CORES)
571             stats[coreid].rx+=1;
572         if (ifno < TUNE_NETAPI_MAX_NUM_MAC)
573             stats[coreid].if_rx[ifno]+=1;
576 #ifdef DEBUG_DESC
577         if (stats[coreid].rx<16)
578         {
579             netapi_Log(">rx dmp.."); 
580             dump_descr((long *) tip, stats[coreid].rx);
581         }
582         else if (stats[coreid].rx>99) 
583         {
584             netapi_Log(">rx dmp.."); 
585             dump_descr((long *) tip,stats[coreid].rx);
586         }
587 #endif
588 #if 0
589         if(stats[coreid].rx<=16)
590         {
591             dump_header((long*)p_pkt,stats[coreid].rx, (int)meta[i].u.rx_meta->appId,meta[i].u.rx_meta->rxFlag1);
592              netapi_dump_buf((long*)p_pkt,len);
593         }
594 #endif
595         /* check header */
596         memcpy(p_head,&p_pkt[14],sizeof(HEAD_T));
598         /* check for IPSEC ESP or AH packet, 0x32 is ESP tunnel mode, 0x33 is AH tunnel mode*/
599         if (((p_head->ip[2]&0x0000ff00)==0x00003200) || ((p_head->ip[2]&0x0000ff00)==0x00003300))
600         {
601             if (!check_header(p_head,&meta[i]))
602             {
603                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
604                 continue;
605             }
607             //process IP SEC PACKET
608             if (netTestCfg.ipsec_mode_rx == IPSEC_MODE_RX_SIDEBAND)
609             {
610                 p_spi = &(p_pkt[netTest_MAC_HEADER_LEN+netTest_IP_HEADER_LEN]);
611                 p_sa_info = (netTestSA_t *) trie_lookup(p_trie_sa_rx, (char *)p_spi ,4);
612                 if (p_sa_info == NULL)
613                 {
614                     printf("recv_cb(): trie_lookup() failed\n");
615                     continue;
616                 }
618                 //ship to crypto for decrypt!!
619                 //12 byte auth tag
620                 PKTIO_METADATA_T meta2 = {PKTIO_META_SB_TX,{0},0};
621                 nwalDmTxPayloadInfo_t meta_tx={0};
623                 meta2.sa_handle = (void*) p_sa_info->rx_tunnel;
625                 memcpy(&meta_tx, &(p_sa_info->tx_payload_info), sizeof(nwalDmTxPayloadInfo_t));
627                 meta_tx.encSize = len - p_sa_info->tx_payload_info.encOffset -p_sa_info->auth_tag_size;
628                 meta_tx.authSize = len - meta_tx.authOffset - p_sa_info->auth_tag_size;
630                 if (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CTR)
631                 {
632                     memcpy(&p_iv[0], &p_sa_info->key_params->pEncKey[16], 4);
633                     memcpy(&p_iv[4], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
634                     p_iv[12] = 0;
635                     p_iv[13] = 0;
636                     p_iv[14] = 0;
637                     p_iv[15] = 1;
638                     meta_tx.pEncIV = &p_iv[0];
639                  
640                 }
641                 else if ((p_sa_info->cipherMode == NWAL_SA_EALG_AES_GCM) ||
642                             (p_sa_info->cipherMode == NWAL_SA_EALG_AES_CCM))
643                 {
644                         memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
645                         meta_tx.pEncIV = &p_iv[0];
646                         /* aad is the ESP header which is 8 bytes */
647                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
648                         meta_tx.pAad= &p_add[0];
649                         meta_tx.aadSize = 8;
650                 }
651                 else if (p_sa_info->authMode == NWAL_SA_AALG_GMAC)
652                 {
653                     memcpy(&p_iv[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN], 8);
654                         meta_tx.pAuthIV= &p_iv[0];
655                         /* aad is the ESP header which is 8 bytes */
656                         memcpy(&p_add[0], &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN], 8);
657                         meta_tx.pAad= &p_add[0];
658                         meta_tx.aadSize = 8;
659                 }
660                 else if (p_sa_info->cipherMode ==  NWAL_SA_EALG_NULL)
661                 {
662                     meta_tx.pEncIV = NULL;
663                 }
664                 else
665                 {
666                     meta_tx.pEncIV = &p_pkt[netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN + netTest_ESP_HEADER_LEN ];
667                 }
668                
669                 meta_tx.appCtxId = (nwal_AppId)p_sa_info;
670                 //printf("recv_cb appCtxId: %lu\n", meta_tx.appCtxId);
672                 /* post it to netcp sb tx channel*/
673             meta2.u.tx_sb_meta=&meta_tx;
675                 pktio_send(netcp_sb_tx_chan,tip,&meta2,&err);
676                 continue;
677             }
678             else
679             {
680                 //inflow mode.  flip and send
681                 flip_and_send_pkt(tip,p_pkt,len,1, enet_port);
682             }
683         }
684         else if ((p_head->ip[2]&0x0000ff00)!=0x00001100)
685         {
686             stats[coreid].n_new+=1;Pktlib_freePacket(tip); continue;
687         }
688         else  //non ipsec
689         {
690             if (!check_header(p_head,&meta[i]))
691             {
692                 stats[coreid].n_bad+=1;Pktlib_freePacket(tip); 
693                 continue;
694             }
695             //just flip and send
696             flip_and_send_pkt(tip,p_pkt,len,0, enet_port);
697         }
698     }
701 /* Templates to build command labels at startup up time, required by open_pktio_tx_channels() */
702 nwalTxPktInfo_t txPktInfoESP = 
704     NULL,                                                                                               /* p_pkt */
705     NWAL_TX_FLAG1_DO_IPSEC_ESP_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
706     0,                                                                                                  /* lpbackPass */
707     0,                                                                                                  /* enetport */
708     0,                                                                                                  /* msuSize */
709     0,                                                                                                   /* startOffset */
710     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
711     0,                                                                                                  /* saPayLoadLen */
712     0               ,                                                                                    /* saAhIcvOffBytes */
713     0,                                                                                                 /* saAhMacSize */
714     0,                                                                                                  /* etherLenOffBytes */
715     0,                                                                                                  /* ipOffBytes */
716     0,                                                                                                  /* l4OffBytes */
717     netTest_UDP_HEADER_LEN,                                                                             /* l4HdrLen */
718     0,                                                                                                  /* pseudoHdrChecksum */
719     0                                                                                                   /* pLoadLen */
720 };
723 nwalTxPktInfo_t txPktInfoAH = 
725     NULL,                                                                                               /* p_pkt */
726     NWAL_TX_FLAG1_DO_IPSEC_AH_CRYPTO| NWAL_TX_FLAG1_DO_UDP_CHKSUM | NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
727     0,                                                                                                  /* lpbackPass */
728     0,                                                                                                  /* enetport */
729     0,                                                                                                  /* msuSize */
730     0,                                                                                                   /* startOffset */
731     netTest_MAC_HEADER_LEN  + netTest_IP_HEADER_LEN,                                                    /* saOffBytes */
732     0,                                                                                                  /* saPayLoadLen */
733     netTest_MAC_HEADER_LEN + netTest_IP_HEADER_LEN + netTest_IPSEC_AH_FIXED_HDR_SIZE,                    /* saAhIcvOffBytes */
734     12,                                                                                                 /* saAhMacSize */
735     0,                                                                                                  /* etherLenOffBytes */
736     0,                                             /* ipOffBytes */
737     0,                                                                                                  /* l4OffBytes */
738     netTest_UDP_HEADER_LEN,                                                                            /* l4HdrLen */
739     0,                                                                                                  /* pseudoHdrChecksum */
740     0                                                                                                   /* pLoadLen */
741 };
743 nwalTxPktInfo_t txPktInfoNoCrypto = 
745     NULL,                                                                                               /* p_pkt */
746     NWAL_TX_FLAG1_DO_UDP_CHKSUM| NWAL_TX_FLAG1_META_DATA_VALID,      /* txFlags */
747     0,                                                                                                  /* lpbackPass */
748     0,                                                                                                  /* enetport */
749     0,                                                                                                  /* msuSize */
750     0,                                                                                                   /* startOffset */
751     0,                                                    /* saOffBytes */
752     0,                                                                                                  /* saPayLoadLen */
753     0               ,                                                                                    /* saAhIcvOffBytes */
754     0,                                                                                                 /* saAhMacSize */
755     0,                                                                                                  /* etherLenOffBytes */
756     0,                                                                                                  /* ipOffBytes */
757     netTest_MAC_HEADER_LEN +netTest_IP_HEADER_LEN,                                        /* l4OffBytes */
758     netTest_UDP_HEADER_LEN,                                                             /* l4HdrLen */
759     0,                                                                         /* pseudoHdrChecksum */
760     0                                                                                                   /* pLoadLen */
761 };
764 void close_pktio_channels(void)
766     int err;
767     netapi_pktioClose(netcp_tx_chan_esp ,&err);
768     netapi_pktioClose(netcp_tx_chan_ah ,&err);
769     netapi_pktioClose(netcp_sb_tx_chan ,&err);
770     netapi_pktioClose(netcp_tx_chan_no_crypto,&err);
773 void open_pktio_tx_channels(void)
775     int err;
776     /* open netcp default  TX for ESP packets */
777     netcp_tx_chan_esp= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
778     if (!netcp_tx_chan_esp)
779     {
780         printf("pktio open TX failed err=%d\n",err);
781         exit(1);
782     }
783     else
784     {
785         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
786         {
787             PKTIO_CONTROL_T control;
788             control.op = PKTIO_UPDATE_FAST_PATH;
789             PKTIO_CFG_T cfg;
790             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_ESP_L4CKSUM_PORT;
791             cfg.fast_path_cfg.txPktInfo= &txPktInfoESP;
792             netapi_pktioControl(netcp_tx_chan_esp, NULL, &cfg, &control, &err);
793         }
794     }
796     /*/* open netcp default  TX for AH packets */
797     netcp_tx_chan_ah= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
798     if (!netcp_tx_chan_ah)
799     {
800         printf("pktio open TX failed err=%d\n",err);
801         exit(1);
802     }
803     else
804     {
805         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
806         {
807             PKTIO_CONTROL_T control;
808             control.op = PKTIO_UPDATE_FAST_PATH;
809             PKTIO_CFG_T cfg;
810             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_AH_L4CKSUM_PORT;
811             cfg.fast_path_cfg.txPktInfo= &txPktInfoAH;
812             netapi_pktioControl(netcp_tx_chan_ah, NULL, &cfg, &control, &err);
813         }
814     }
816     /* open netcp default  TX channels for non-Crypto packets */
817     netcp_tx_chan_no_crypto= netapi_pktioOpen(netapi_handle, NETCP_TX, NULL, &netcp_tx_cfg,  &err);
818     if (!netcp_tx_chan_no_crypto)
819     {
820         printf("pktio open TX failed err=%d\n",err);
821         exit(1);
822     }
823     else
824     {
825         if(netTestCfg.ipsec_mode_tx == IPSEC_MODE_TX_INFLOW)
826         {
827             PKTIO_CONTROL_T control;
828             control.op = PKTIO_UPDATE_FAST_PATH;
829             PKTIO_CFG_T cfg;
830             cfg.fast_path_cfg.fp_send_option = PKTIO_FP_L4CKSUM_PORT;
831             cfg.fast_path_cfg.txPktInfo= &txPktInfoNoCrypto;
832             netapi_pktioControl(netcp_tx_chan_no_crypto, NULL, &cfg, &control, &err);
833         }
834     }
836     /* open netcp default  TX channels for SB crypto */
837     netcp_sb_tx_chan= netapi_pktioOpen(netapi_handle, NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
838     if (!netcp_sb_tx_chan)
839     {
840         printf("pktio open SB TX failed err=%d\n",err);
841         exit(1);
842     }
846 #ifdef MULTI_THREAD
847 NETAPI_T worker_nh[TUNE_NETAPI_NUM_CORES];
849 void slow_path_thread(uint32_t thread_num)
851     int err, i;;
853     PKTIO_HANDLE_T *rx_chan;
854     PKTIO_HANDLE_T *sb_rx_chan;
856     printf("slow_path_thread, mypid: %d, core_id %d\n", gettid(), thread_num);
858     CPU_ZERO( &cpu_set);
859     printf("slow_path_thread: settting up for thread number %d\n", thread_num);
860 #ifdef CORTEX_A15
861     for (i = netTestCfg.sp_proc_start[thread_num]; i <= netTestCfg.sp_proc_end[thread_num];i++)
862     {
863         printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
864         CPU_SET( i, &cpu_set);
865     }
866     hplib_utilSetupCore(thread_num, &cpu_set);
867 #else
868     for (i = netTestCfg.sp_proc_start[thread_num]; i <= netTestCfg.sp_proc_end[thread_num];i++)
869     {
870         printf("slow_path_thread: setting cpu %d to cpu_set\n", i);
871         CPU_SET( i, &cpu_set);
872     }
873     hplib_utilSetupCore(thread_num, &cpu_set);
874 #endif
875     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
877    /* open netcp default RX channels*/
878     
879     rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
880     
881     sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
883     netapi_setCookie(worker_nh[thread_num],(void*)(thread_num | NET_TEST_SP_THREAD_MASK));
885     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
886     if (!scheduler[thread_num]) 
887     {
888         printf("sched create failed for core%d\n",thread_num);
889         exit(1);
890     }
891     scheduler[thread_num]->config.yield = TRUE;
892     scheduler[thread_num]->config.pollGarbageQ = TRUE;
893     scheduler[thread_num]->config.pollCtrlQ = TRUE;
895     /* Entry point to scheduler */
896     netapi_schedRun(scheduler[thread_num], &err);
897     printf(">net_test: core %d worker thread done\n",thread_num);
899     netapi_pktioClose(rx_chan, &err);
900     netapi_pktioClose(sb_rx_chan, &err);
901     netapi_shutdown(worker_nh[thread_num]);
904 void fast_path_thread(uint32_t thread_num)
906     int err, i;
907     PKTIO_HANDLE_T *rx_chan;
908     PKTIO_HANDLE_T *sb_rx_chan;
910     CPU_ZERO( &cpu_set);
911     printf("fast_path_thread: settting up for thread number %d\n", thread_num);
912 #ifdef CORTEX_A15
913     for (i = netTestCfg.fp_proc_start[thread_num]; i <= netTestCfg.fp_proc_end[thread_num];i++)
914     {
915         printf("fast_path_thread: setting cpu %d to cpu_set\n", i);
916         CPU_SET( i, &cpu_set);
917     }
918     hplib_utilSetupCore(thread_num, &cpu_set);
919 #else
920     for (i = netTestCfg.fp_proc_start[thread_num]; i <= netTestCfg.fp_proc_end[thread_num];i++)
921     {
922         printf("fast_path_thread: setting cpu %d to cpu_set\n", i);
923         CPU_SET( i, &cpu_set);
924     }
925     hplib_utilSetupCore(thread_num, &cpu_set);
926 #endif
927     worker_nh[thread_num]=netapi_init(NETAPI_CORE_MASTER,NULL);
929    /* open netcp default RX channels*/
930     rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_RX, (PKTIO_CB) recv_cb, &netcp_rx_cfg,  &err);
932     /* create a pktio channel for specially classified pkts */
933     /* open netcp default tx, rx queues for sideband crypto */
934      //sb_tx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_TX, NULL, &netcp_sb_tx_cfg,  &err);
935      sb_rx_chan = netapi_pktioOpen(worker_nh[thread_num], NETCP_SB_RX, (PKTIO_CB) recv_sb_cb, &netcp_sb_rx_cfg,  &err);
938     
939     netapi_setCookie(worker_nh[thread_num],(void*)thread_num);
940     
941     scheduler[thread_num] =netapi_schedOpen(worker_nh[thread_num],&our_sched_cfg, &err);
942     if (!scheduler[thread_num]) 
943         {
944         printf("sched create failed for core%d\n",thread_num); 
945         exit(1);
946     }
948  
949     scheduler[thread_num]->config.yield = FALSE;
950     scheduler[thread_num]->config.pollGarbageQ = FALSE;
951     scheduler[thread_num]->config.pollCtrlQ = FALSE;
952      //sleep(100000);
953    /* Entry point to scheduler */
954      netapi_schedRun(scheduler[thread_num], &err);
955     printf(">net_test: core %d worker thread done\n",thread_num);
957     netapi_pktioClose(rx_chan, &err);
959     netapi_pktioClose(sb_rx_chan, &err);
960     netapi_shutdown(worker_nh[thread_num]);
963 #endif
964 /***************************************
965  ********** test driver*****************
966  ***************************************/
967 int main(int argc, char **argv)
969     int err,i;
970     Pktlib_HeapCfg      heapCfg;
971     rlim_t oss,ss = 1024*1024;
972     struct rlimit rl;
973     int32_t             errCode;
974     Pktlib_HeapIfTable*  pPktifTable;
975     /* Local Per Process default resourcese maintained at NWAL */
976     nwalLocCxtInfo_t    nwalLocCxt;
977     //nwalSaIpSecId_t  nwalSaIpSecId;
978     FILE * fpr = NULL;
980     err= getrlimit(RLIMIT_STACK,&rl);
981     if (!err) printf(" stack limit = %d\n",rl.rlim_cur); else printf("getrlimit failed\n");
984      /* install signal handler for ^c */
985     signal(SIGINT,mysig);
987     if (argc == 2)
988     {
989         printf("main: filename1 %s\n", argv[1]);
990         fpr = fopen(argv[1], "r");
991     }
992     else
993     {
994         fpr = fopen(input_file_name, "r");
995     }
996     if (fpr == NULL)
997     {
998         exit(1);
999     }
1000     else
1001     {
1002         memset(&config_file, 0, sizeof(netTestConfigFile_t));
1003         memset(&netTestCfg, 0, sizeof(netTestConfig_t));
1004         parse_config_file(fpr,&config_file);
1005     }
1007     memset(&sa_info, 0, sizeof(sa_info));
1010 #ifdef MULTI_THREAD
1011     /* assign main net_test thread to run on core 0 */
1012     CPU_ZERO( &cpu_set);
1013     CPU_SET( 0, &cpu_set);
1014     hplib_utilSetupCore(0, &cpu_set);
1015 #endif
1017     /* create netapi */
1018     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
1020     /* configure expection packet handling with netapi */
1021     netapi_netcpCfgExceptions(netapi_handle, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_DISCARD, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1022     expPkt_appid = netapi_netcpCfgExceptions(netapi_handle, 7, NETCP_CFG_ACTION_TO_SW, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
1024     /* open the main heap */
1025     ourHeap = Pktlib_findHeapByName("netapi");
1026     if (!ourHeap)
1027     {
1028         printf("Pktlib_findHeapByName()  fail\n");
1029         exit(1);
1030     }
1032     open_pktio_tx_channels();
1035     printf("net_test: %d bytes left in our CMA area\n", netapi_getBufMemRemainder());
1036     /* create scheduler instance */
1037     our_sched =netapi_schedOpen(netapi_handle,&our_sched_cfg, &err);
1038     if (!our_sched) {printf("sched create failed\n"); exit(1);}
1041     /*create net_test MAC interfaces, attach IP to created MAC interfaces */
1042     create_interfaces();
1044     /* lookup Database for SA context, this is used by packet processing routines to get RX and TX SA information*/
1045     p_trie_sa_rx = trie_new();
1046     p_trie_sa_tx = trie_new();
1047     if (!p_trie_sa_rx || !p_trie_sa_tx)
1048         {printf("trie alloc for SA  failed\n"); exit(1);}
1052     /* Create RX SA's, RX Policy and TX SA's, all SA configuration parameters are read from net_test_config.txt file */
1053     create_sec_associations();
1055 #ifdef MULTI_THREAD
1057     char c;
1058     /* create and set affinity of slow path and fast path threads to
1059     * specific CPU cores as specified in the net_test_config.txt file */
1060     create_sp_fp_threads();
1062         //this thread of execution (main) now just waits on user input
1063         for(;;)
1064         {
1065            printf(">");
1066            c=getchar();
1067            if (c=='q') {QUIT=1;break;}
1068            else if (c=='s') our_stats_cb(netapi_handle, &netcp_stats);
1069            else if (c=='h') printf("'q' to quit,  's' for stats, 'h' for help\n");
1070         }
1072         sp_fp_thread_cleanup();
1075 #else
1076     /*********************************************/
1077     /**************Entry point into scheduler ****/
1078     /*********************************************/
1079     //create_sec_associations(netcp_sb_rx_chan, netcp_sb_tx_chan,netcp_tx_chan);
1080     netapi_schedRun(our_sched, &err);
1081 #endif
1083     /* done */
1084     our_stats_cb(netapi_handle, NULL);
1087     /* cleanup*/
1088      delete_sec_associations();
1090     delete_interfaces();
1092     /* close pktio channels we opened via open_pktio_tx_channels() */
1093     close_pktio_channels();
1094     
1095     netapi_shutdown(netapi_handle);
1099 /* Stub functions */
1100 Trie * route_init(void)
1103 void route_add(Trie * Pt, unsigned long * Pdest_ipBE, void * Pour_route)