dd0d2022da5140e9b78948aa52ff74a54bbb86dc
[keystone-rtos/netapi.git] / ti / runtime / netapi / applications / ipsec_offload / ipsecmgr / src / netapi_ipsecmgr.c
1 /*
2  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
3  *
4  *
5  *  Redistribution and use in source and binary forms, with or without
6  *  modification, are permitted provided that the following conditions
7  *  are met:
8  *
9  *    Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  *    Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the
15  *    distribution.
16  *
17  *    Neither the name of Texas Instruments Incorporated nor the names of
18  *    its contributors may be used to endorse or promote products derived
19  *    from this software without specific prior written permission.
20  *
21  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33 */
36 /* IPSec Manager Include Files */
37 #include "ipsecmgr_snoop.h"
38 #include "ipsecmgr_ipc.h"
39 #include "ipsecmgr_syslog.h"
41 /* Local include */
42 #include "netapilib_interface.h"
44 /* Standard includes */
45 #include <dlfcn.h>
46 #include <stdlib.h>
47 #include <signal.h>
48 #include <stdarg.h>
49 /**********************************************************************
50  ************************** Local Definitions *************************
51  **********************************************************************/
52 #define DTS_LOG_FILE_QUEUE "/proc/device-tree/soc/pktdma@2004000/channels/netrx0/complete-queue"
53 #define DTS_LOG_FILE_FLOW  "/proc/device-tree/soc/pktdma@2004000/channels/netrx0/flow"
56 /**********************************************************************
57  ************************** Global Variables **************************
58  **********************************************************************/
60 static ipsecmgr_ipc_daemon_send_if_t *send_iface;
61 NETAPI_T netapi_handle;
63 //paSysStats_t netcp_stats;
64 ipsecMgrMcb_t globalDB;
66 /* Lock file for the daemon */
67 #define LOCK_FILE   "/var/lock/ipsecmgr_daemon"
69 /* snoop task */
70 static pthread_t    snoop_run_th;
72 static NETAPI_CFG_T our_netapi_default_cfg=
73 {
74     TUNE_NETAPI_PERM_MEM_SZ,
75     128,  //start of packet offset for hw to place data on rx for default flow
76     TUNE_NETAPI_QM_CONFIG_MAX_DESC_NUM, //max number of descriptors in system
77     TUNE_NETAPI_NUM_GLOBAL_DESC,        //total we will use
78     TUNE_NETAPI_DEFAULT_NUM_BUFFERS,   //#descriptors+buffers in default heap
79     64, //#descriptors w/o buffers in default heap
80     TUNE_NETAPI_DEFAULT_BUFFER_SIZE+128+128,  //size of buffers in default heap
81     128   ,  //tail room
82     256      //extra room
83 };
86 static int QUIT = 0;
88 /* stub functions */
89 static void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
90                          PKTIO_METADATA_T meta[], int n_pkts,
91                          uint64_t ts )
92 {
93     return;
94 }
96 /* byte swap routine */
97 static unsigned int swap32 (unsigned int x)
98 {
99     unsigned int y;
101     y = (((x >> 24) & 0xff) <<  0) |
102         (((x >> 16) & 0xff) <<  8) |
103         (((x >>  8) & 0xff) << 16) |
104         (((x >>  0) & 0xff) << 24) ;
106     return (y);
110 void cleanup_sa_sp()
112     int slot, error=0;;
113     /* delete any offloaded rx SA's and policies */
114     /* and delete any offloaded tx SA's */
115     for (slot = 0;slot < 64;slot++)
116     {
117         if(globalDB.rx_sa[slot].in_use)
118         {
119             globalDB.rx_sa[slot].in_use = 0;
120             if(globalDB.rx_sa[slot].spAppId)
121             {
122                 netapi_secDelRxPolicy(netapi_handle,
123                               (NETCP_CFG_IPSEC_POLICY_T) globalDB.rx_sa[slot].spAppId,
124                               &error);
125                 ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,
126                 "cleanup_sa_sp: SP deleted: sp_app_id: 0x%x, slot: %d, error: %d\n", 
127                 globalDB.rx_sa[slot].spAppId, slot, error);
128             }
129             netapi_secDelSA(netapi_handle,
130                         NETCP_CFG_NO_INTERFACE,
131                         (NETCP_CFG_SA_T) globalDB.rx_sa[slot].saAppId,
132                         &error);
133             ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,
134                 "cleanup_sa_sp: SA deleted: sa_app_id: 0x%x, slot: %d, error: %d\n", 
135                 globalDB.rx_sa[slot].saAppId, slot, error);
136             
137         }
138         if(globalDB.tx_sa[slot].in_use)
139         {
140             globalDB.tx_sa[slot].in_use = 0;
141             netapi_secDelSA(netapi_handle,
142                             NETCP_CFG_NO_INTERFACE,
143                            (NETCP_CFG_SA_T) globalDB.tx_sa[slot].saAppId,
144                             &error);
145             ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,
146                 "cleanup_sa_sp: SA deleted: sa_app_id: 0x%x, slot: %d, error: %d\n", 
147                 globalDB.tx_sa[slot].saAppId, slot, error);
148         }
149     }
153 static void* snoop_run_thread (void* arg)
155     ipsecmgr_syslog_msg(SYSLOG_LEVEL_INFO,
156         "snoop_run_thread: daemon entering forever event loop\n");
158     while (1)
159     {
160         /* Poll for message from user application */
161         ipsecmgr_ipc_poll();
163         /* Poll for message from Kernel */
164         ipsecmgr_snoop_run();
166         if (QUIT == 1)
167             break;
168     }
169     printf("snoop_run_thread: calling shutdowns\n");
170     ipsecmgr_snoop_shutdown ();
171     cleanup_sa_sp();
172     netapi_shutdown(netapi_handle);
174     return;
177 /**
178  *  @b Description
179  *  @n  
180  *      SIGTERM handler.
181  *
182  *  @param[in]  signum
183  *      signal number to terminate deamon.
184  */
185 static void sig_term_handler(int signum)
188     QUIT = 1;
189     /* Cleanup and exit */        
190     //ipsecmgr_snoop_shutdown ();
191     //netapi_shutdown(netapi_handle);
192     //exit (0);
195 /**
196  *  @b Description
197  *  @n  
198  *      Function to implement task sleep functionality 
199  *      for IPSecMgr
200  *
201  *  @param[in]  time_in_msec
202  *      Time in milliseconds to sleep
203  *
204  *  @retval
205  *      Not Applicable.
206  */
207 static void task_sleep(uint32_t time_in_msec)
209     pthread_mutex_t fake_mutex = PTHREAD_MUTEX_INITIALIZER;
210     pthread_cond_t fake_cond = PTHREAD_COND_INITIALIZER;
211     struct timespec ts;
212     int rt;
213     unsigned int sec, nsec;
215     sec = time_in_msec/1000;
216     nsec = (time_in_msec - (sec*1000)) * 1000000;
218     /* Use the wall-clock time */
219     clock_gettime(CLOCK_REALTIME, &ts);
221     ts.tv_sec += sec;
222     ts.tv_nsec += nsec;
224     pthread_mutex_lock(&fake_mutex);
225     rt = pthread_cond_timedwait(&fake_cond, &fake_mutex, &ts);
226     pthread_mutex_unlock(&fake_mutex);
230 /**
231  *  @b Description
232  *  @n  
233  *      NETAPI Proxy's IPSecMgr Start Offload Response 
234  *      message handler.
235  *
236  *      This function is called by the IPSecMgr library
237  *      when it has a response ready corresponding to an
238  *      Start Offload SP request issued by the user application.
239  *
240  *  @param[in]  rsp
241  *      IPSecMgr's Start Offload SP response
242  *  @param[in]  addr
243  *      Destination address (user application) to send 
244  *      the response to
245  *  @param[in]  addr_size
246  *      Size of destination address passed
247  *
248  *  @retval
249  *      Success -   0
250  *  @retval
251  *      ERROR   -   <0
252  */
253 static int offload_sp_rsp_send
255     ipsecmgr_snoop_offload_sp_rsp_param_t *rsp,
256     void                                  *addr,
257     uint32_t                              addr_size
260     ipsecmgr_ipc_offload_sp_rsp_param_t offload_sp_rsp;
262     offload_sp_rsp.type = rsp->type;
263     offload_sp_rsp.result = rsp->result;
264     offload_sp_rsp.trans_id = rsp->trans_id;
265     offload_sp_rsp.err_code = rsp->err_code;
266     offload_sp_rsp.sp_handle = rsp->sp_handle;
267     offload_sp_rsp.sa_handle = rsp->sa_handle;
269     if (addr_size != sizeof(ipsecmgr_ipc_addr_t)) {
270         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR,
271             "offload_sp_rsp_send: addr size not correct\n");
272         return -1;
273     }
275     return send_iface->offload_sp_rsp(&offload_sp_rsp,
276                                       (ipsecmgr_ipc_addr_t *)addr);
278 static void offload_sp_req_recv
280     ipsecmgr_ipc_offload_sp_req_param_t *req,
281     ipsecmgr_ipc_addr_t                 *src_addr
284     ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,"offload_sp_req_recv called for policy id\n",
285     req->policy_id);
286     ipsecmgr_snoop_offload_sp_rsp_param_t rsp;
287     uint32_t addr_size = sizeof(ipsecmgr_ipc_addr_t);
288     ipsecmgr_snoop_offload_sp_req_param_t offload_sp_req;
290     offload_sp_req.trans_id = req->trans_id;
291     offload_sp_req.policy_id = req->policy_id;
292     offload_sp_req.sa_flags = req->sa_flags;
293     offload_sp_req.if_name = req->if_name;
294     offload_sp_req.dscp_cfg = req->dscp_cfg;
295     offload_sp_req.l5_selector = req->l5_selector;
297     memset(&rsp, 0, sizeof(rsp));
298     rsp.trans_id = req->trans_id;
300     if (ipsecmgr_snoop_offload_sp_req(&offload_sp_req, (void*)src_addr,
301                                       addr_size)) {
302         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
303             "offload_sp_req_recv: snoop_offload_sp_req failed\n");
304         rsp.result = RESULT_FAILURE;
305         rsp.type = RSP_TYPE_ACK | RSP_TYPE_DONE;
306     }
307     else
308     {
309         rsp.result = RESULT_SUCCESS;
310         rsp.type = RSP_TYPE_ACK;
311     }
312     
313     if (offload_sp_rsp_send(&rsp, (void *)src_addr, addr_size))
314     {
315         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
316             "offload_sp_req_recv: failed to send ACK for offload_sp\n");
317     }
318     return;
322 /**
323  *  @b Description
324  *  @n  
325  *      NETAPI Proxy's IPSecMgr Stop Offload response message 
326  *      handler.
327  *
328  *      This function is called by the IPSecMgr library
329  *      when it has a response ready corresponding to an
330  *      Stop Offload SP request issued by the user application.
331  *
332  *  @param[in]  rsp
333  *      IPSecMgr's Stop Offload SP response
334  *  @param[in]  addr
335  *      Destination address (user application) to send 
336  *      the response to
337  *  @param[in]  addr_size
338  *      Size of destination address passed
339  *
340  *  @retval
341  *      Success -   0
342  *  @retval
343  *      ERROR   -   <0
344  */
345 static int stop_offload_rsp_send
347     ipsecmgr_snoop_stop_offload_rsp_param_t *rsp,
348     void                                    *addr,
349     uint32_t                                addr_size
352     ipsecmgr_ipc_stop_offload_rsp_param_t stop_offload_rsp;
354     stop_offload_rsp.type = rsp->type;
355     stop_offload_rsp.result = rsp->result;
356     stop_offload_rsp.trans_id = rsp->trans_id;
358     if (addr_size != sizeof(ipsecmgr_ipc_addr_t)) {
359         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR,
360             "stop_offload_rsp_send: addr size not correct\n");
361         return -1;
362     }
364     return send_iface->stop_offload_rsp(&stop_offload_rsp,
365                                       (ipsecmgr_ipc_addr_t *)addr);
368 static void stop_offload_req_recv
370     ipsecmgr_ipc_stop_offload_req_param_t   *req,
371     ipsecmgr_ipc_addr_t                     *src_addr
374     ipsecmgr_snoop_stop_offload_req_param_t stop_offload_req;
375     uint32_t addr_size = sizeof(ipsecmgr_ipc_addr_t);
376     ipsecmgr_snoop_stop_offload_rsp_param_t rsp;
378     stop_offload_req.trans_id = req->trans_id;
379     stop_offload_req.policy_id = req->policy_id;
381     memset(&rsp, 0, sizeof(rsp));
382     rsp.trans_id = req->trans_id;
384     if (ipsecmgr_snoop_stop_offload(&stop_offload_req, (void*)src_addr,
385                                       addr_size)) {
386         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
387             "stop_offload_req_recv: snoop_stop_offload failed\n");
388         rsp.result = RESULT_FAILURE;
389         rsp.type = RSP_TYPE_ACK | RSP_TYPE_DONE;
390     }
391     else
392     {
393         rsp.result = RESULT_SUCCESS;
394         rsp.type = RSP_TYPE_ACK;
395     }
397     if (stop_offload_rsp_send(&rsp, (void *)src_addr, addr_size))
398     {
399         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
400             "stop_offload_req_recv: failed to send ACK for stop_offload\n");
401     }
402     return;
405 /**
406  *  @b Description
407  *  @n  
408  *      Function to initialize IPSec Manager library.
409  *
410  *  @retval
411  *      Success -   0
412  *  @retval
413  *      ERROR   -   >0
414  */
415 static int32_t init_ipsecmgr (void)
417     struct ipsecmgr_snoop_fp_cfg_cb     fp_cfg_cb;
418     struct ipsecmgr_snoop_mgnt_cb       mgnt_cb;
419     struct ipsecmgr_snoop_platform_cb   plat_cb;
420     ipsecmgr_ipc_daemon_recv_if_t       recv_if;
421     ipsecmgr_ipc_cfg_t                  ipc_cfg;
422     int32_t                             status;
423     pthread_attr_t threadAttr;
425     /* Initializations */
426     ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO, 
427                         "DEBUG: init_ipsecmgr() starting initialization\n");
428     memset(&fp_cfg_cb, 0, sizeof(fp_cfg_cb));
429     memset(&mgnt_cb, 0, sizeof(mgnt_cb));
430     memset(&plat_cb, 0, sizeof(plat_cb));
431     memset(&recv_if, 0, sizeof(recv_if));
432     memset(&ipc_cfg, 0, sizeof(ipc_cfg));
434     /* Initialize IPC library */
435     ipc_cfg.mode = IPC_MODE_SNOOP_DAEMON;
436     if (ipsecmgr_ipc_init(&ipc_cfg)) {
437         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
438             "init_ipsecmgr: ipc_init failed\n");
439         return -1;
440     }
441     else
442         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
443             "init_ipsecmgr: ipc_init sucess\n");
445     if (ipsecmgr_ipc_get_daemon_send_iface(&send_iface)) {
446         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
447             "init_ipsecmgr: ipc_get_daemon_send_iface failed\n");
448         return -1;
449     }
450     recv_if.offload_sp_req = offload_sp_req_recv;
451     recv_if.stop_offload_req = stop_offload_req_recv;
452     /* Register ipsecmgr daemon recieve i/f */
453     if (ipsecmgr_ipc_register_daemon_recv_iface(&recv_if)) {
454         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
455             "snoop_run: ipc_register_daemon_recv_iface failed\n");
456         return -1;
457     }
459     /* Initialize the IPSec Manager Snoop library */
460     fp_cfg_cb.add_sa        =   netapilib_ifAddSA;
461     fp_cfg_cb.add_sp        =   netapilib_ifAddSP;
462     fp_cfg_cb.del_sa        =   netapilib_ifDeleteSA;
463     fp_cfg_cb.del_sp        =   netapilib_ifDeleteSP;
464     fp_cfg_cb.get_sa_ctx    =   netapilib_ifGetSACtx;
466     plat_cb.log_msg  = (ipsecmgr_snoop_log_msg_t)ipsecmgr_syslog_msg;
467     plat_cb.sleep           =   task_sleep;
469     mgnt_cb.offload_sp_rsp  =   offload_sp_rsp_send;
470     mgnt_cb.stop_offload_rsp=   stop_offload_rsp_send;
471     mgnt_cb.rekey_event     =   NULL; // No explicit notifications needed on Rekey completion
473     if ((status = ipsecmgr_snoop_init (&fp_cfg_cb, &mgnt_cb, &plat_cb))) 
474     {
475         ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,
476                             "DEBUG: init_ipsecmgr() ipsecmgr_snoop_init failed (%d)\n", status);
477         return -1;
478     }
480     /* Create the task context for snoop library */
481     pthread_attr_init(&threadAttr);
482     pthread_attr_setstacksize(&threadAttr, 0x8000);
483     if (pthread_create(&snoop_run_th, (void*) NULL, snoop_run_thread, NULL))
484     {
485         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
486             "ERROR: snoop run thread failed to start, error code\n"); 
487         return -1;
488     }
490     /* Setup signal handler for SIGTERM */
491     if (signal(SIGTERM, sig_term_handler) == SIG_ERR) {
492         ipsecmgr_syslog_msg(SYSLOG_LEVEL_WARN,
493             "init_ipsecmgr: cannot handle SIGTERM\n");
494     }
495     /* Wait for the NETAPI Proxy task to finish its processing and exit. */
496     pthread_join (snoop_run_th, NULL);
498     return 0;
501 /**
502  *  @b Description
503  *  @n  
504  *      Utility function to daemonize the current
505  *      application.
506  *
507  *  @param[in]  lock_file
508  *      Lock file to be used by the daemon
509  */
510 static void daemonize (const char *lock_file)
512     pid_t       pid, sid;
513     int32_t     lock_fp = -1;
514     char        str[10];
516     /* already a daemon */
517     if (getppid () == 1)
518         return;
520     /* Fork off the parent process */
521     if ((pid = fork ()) < 0) 
522     {
523         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR, 
524                             "ERROR: daemonize() unable to fork daemon, code=%d (%s)",
525                             errno, 
526                             strerror(errno));
527         exit (-1);
528     }
530     /* If we got a PID, then exit the parent process. */
531     if (pid > 0)
532         exit (0);
534     /* At this point we are executing as the child process */
536     /* Create a new SID for the child process */
537     if ((sid = setsid ()) < 0) 
538     {
539         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR, 
540                             "ERROR: daemonize() unable to create a new session, code %d (%s)",
541                             errno, 
542                             strerror(errno));
543         exit (-1);
544     }
546     /* Change the file mode mask */
547     umask (027);
549     /* Change the current working directory.  This prevents the current
550      * directory from being locked; hence not being able to remove it. */
551     if ((chdir("/")) < 0) 
552     {
553         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR, 
554                             "ERROR: daemonize() unable to change directory to %s, code %d (%s)",
555                             "/", 
556                             errno, 
557                             strerror(errno));
558         exit (-1);
559     }
561     /* Create the lock file */
562     if (lock_file) 
563     {
564         if ((lock_fp = open(lock_file, O_RDWR|O_CREAT, 0640)) < 0 ) 
565         {
566             ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR, 
567                                 "ERROR: daemonize() unable to create lock file %s, code=%d (%s)",
568                                 lock_file, 
569                                 errno, 
570                                 strerror(errno));
571             exit (-1);
572         }
573     }
575     if (lockf (lock_fp, F_TLOCK, 0) < 0) 
576         exit(-1); /* can not lock */
578     /* Record pid to lockfile */
579     sprintf (str, "%d\n", getpid());
580     write (lock_fp, str, strlen(str)); 
582     /* Cancel certain signals */
583     signal (SIGCHLD, SIG_DFL); /* A child process dies */
584     signal (SIGTSTP, SIG_IGN); /* Various TTY signals */
585     signal (SIGTTOU, SIG_IGN);
586     signal (SIGTTIN, SIG_IGN);
587     signal (SIGHUP, SIG_IGN); /* Ignore hangup signal */
588     signal (SIGTERM, sig_term_handler); /* catch SIGTERM */
590     /* Redirect standard files to /dev/null */
591     freopen( "/dev/null", "r", stdin);
592     freopen( "/dev/null", "w", stdout);
593     freopen( "/dev/null", "w", stderr);
595     /* Done setting up the daemon */
596     return;
599 /* FUNCTION PURPOSE:validate and process inputs to the application */
600 int32_t parse_cmd_line_args(int argc, char** argv)
602     int32_t             i;
604     /* Valid command line options */
605     if (argc == 1)
606     {
607         printf("netapi_proxyParseCommandLineArgs, argc =1\n");
608         return 0;
609     }
610     else
611     {
612            printf("netapi_proxyParseCommandLineArgs, argc=%d\n", argc);
613      
614     }
616     /* Scan and parse the command line options */
617     for (i = 1; i < argc; i ++)
618     {
619         if (argv[i][0] == '-' && argv[i][1] == 'f')
620         {
621             /* Log file name */                
622             if (i+1 >= argc || argv[i+1] == NULL)
623                 return -1;
625 #if 0
626             /* Close the default log file if we opened it already */
627             if (netapiIPSecMgrMcb.logFd)
628                 fclose (netapiIPSecMgrMcb.logFd);                    
630             /* Open the log file specified at command line */
631             if ((netapiIPSecMgrMcb.logFd  = fopen(argv[i+1], "a")) == NULL)
632             {
633                 printf ("Error opening log file %s\n", argv[i+1]);
634                 return -1;
635             }
636 #endif
637             i++;
638         }
640         else
641         {
642             /* Invalid options */                
643             return -1;
644         }
645     }
647     /* Success */
648     return 0;
651 int get_kernel_config()
653     uint32_t temp=0;
654     char name[] = "offload_chan";
655     FILE *pDts = NULL;
657     pDts = fopen(DTS_LOG_FILE_QUEUE, "rb");
659     if(pDts)
660     {
661         fread((void*)&temp, sizeof(uint32_t), 1, pDts);
662         globalDB.qNum= (int)swap32(temp);
663         fclose(pDts);
664     }
665     else
666     {
667         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
668             "main: error opening device tree file: %s\n",DTS_LOG_FILE_QUEUE);
669         return -1;
670     }
672     pDts = NULL;
673     pDts = fopen(DTS_LOG_FILE_FLOW, "rb");
675     if(pDts)
676     {
677         fread((void*)&temp, sizeof(uint32_t), 1, pDts);
678         globalDB.flowId = (int)swap32(temp);
679         fclose(pDts);
680     }
681     else
682     {
683         printf("main: error opening %s\n",DTS_LOG_FILE_FLOW);
684         return -1;
685     }
686     
687     return 0;
690 int create_pktio_channel()
692     int error = 0;
693     char name[] = "offload_chan";
694     PKTIO_HANDLE_T *pktio_channel;
695     PKTIO_CFG_T pktio_cfg;
697     pktio_cfg.qnum = globalDB.qNum;
698     pktio_cfg.flags1 = PKTIO_RX;
699     pktio_cfg.flags2 = PKTIO_GLOBAL | PKTIO_PKT;
700     pktio_cfg.max_n = 8;
702     globalDB.pktio_channel = netapi_pktioCreate(netapi_handle,
703                                                &name[0],
704                                                (PKTIO_CB)recv_cb,
705                                                &pktio_cfg,
706                                                &error);
707     if (!globalDB.pktio_channel)
708     {
709         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
710             "create_pktio_channel: failed\n");
711         return -1;
712     }
714     return 0;
716 /**
717  *  @b Description
718  *  @n  
719  *      Entry point for the NETAPI Proxy application.
720  *
721  *  @param[in]  argc
722  *      Number of arguments passed to the application
723  *  @param[in]  argv
724  *      Arguments passed to the application.
725  *
726  *  @retval
727  *      Success -   0
728  *  @retval
729  *      ERROR   -   >0
730  */
731 int32_t main (int argc, char* argv[])
733     int32_t             retVal;
734     ipsecmgr_syslog_init();
736     memset(&globalDB, 0, sizeof(globalDB));
738     /* create netapi */
739     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
741     if(netapi_handle == NULL)
742     {
743         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR, "ERROR: netapi_init failed\n");
744         printf("main: netapi_init failed\n");
745         return -1;
746     }
747     else
748         netapi_netcpCfgExceptions(netapi_handle, NETCP_CFG_ALL_EXCEPTIONS, NETCP_CFG_ACTION_DISCARD, (NETCP_CFG_ROUTE_HANDLE_T) NULL);
750         printf("main: netapi_init passed\n");
752     if (get_kernel_config())
753     {
754         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
755                             "ERROR: main: get_kernel_config() failed\n");
756         return -1;
757     }
759         if (create_pktio_channel())
760     {
761         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
762                             "ERROR: main: create_pktio_channel() failed\n");
763         return -1;
764     }
766 #if 1
767     /* Read and parse command line options */
768     if (parse_cmd_line_args (argc, argv) < 0)
769     {
770         printf ("Usage format: netfpproxy.out [-f <log_file>]\n");
771         return -1;
772     }
773 #endif
774     printf("main: calling daemonize\n");
775     /* Create the proxy daemon. */
776     daemonize (LOCK_FILE);
778     /* Initialize and start the IPSec Mgr Snoop functionality */
779     if ((retVal = init_ipsecmgr ()) < 0)
780     {
781         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
782                             "ERROR: IPSec Mgr init failed, error code %d \n",
783                             retVal);
784         return -1;
785     }
786     else
787         printf("main: ipsecmgr daemon shutdonw complete\n");