NETAPI integration with ipsecmgr
[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 globalCfg;
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 };
85 /* stub functions */
86 static void recv_cb(struct PKTIO_HANDLE_Tag * channel, Ti_Pkt* p_recv[],
87                          PKTIO_METADATA_T meta[], int n_pkts,
88                          uint64_t ts )
89 {
90     return;
91 }
93 /* byte swap routine */
94 static unsigned int swap32 (unsigned int x)
95 {
96     unsigned int y;
98     y = (((x >> 24) & 0xff) <<  0) |
99         (((x >> 16) & 0xff) <<  8) |
100         (((x >>  8) & 0xff) << 16) |
101         (((x >>  0) & 0xff) << 24) ;
103     return (y);
108 static void* snoop_run_thread (void* arg)
110     ipsecmgr_syslog_msg(SYSLOG_LEVEL_INFO,
111         "snoop_run_thread: daemon entering forever event loop\n");
113     while (1)
114     {
115         /* Poll for message from user application */
116         ipsecmgr_ipc_poll();
118         /* Poll for message from Kernel */
119         ipsecmgr_snoop_run();
120     }
122     return;
125 /**
126  *  @b Description
127  *  @n  
128  *      SIGTERM handler.
129  *
130  *  @param[in]  lock_file
131  *      Lock file to be used by the daemon
132  */
133 static void sig_term_handler(int signum)
136     /* Cleanup and exit */        
137     ipsecmgr_snoop_shutdown ();
139     netapi_shutdown(netapi_handle);
140     exit (0);
143 /**
144  *  @b Description
145  *  @n  
146  *      Function to implement task sleep functionality 
147  *      for IPSecMgr
148  *
149  *  @param[in]  time_in_msec
150  *      Time in milliseconds to sleep
151  *
152  *  @retval
153  *      Not Applicable.
154  */
155 static void task_sleep(uint32_t time_in_msec)
157     pthread_mutex_t fake_mutex = PTHREAD_MUTEX_INITIALIZER;
158     pthread_cond_t fake_cond = PTHREAD_COND_INITIALIZER;
159     struct timespec ts;
160     int rt;
161     unsigned int sec, nsec;
163     sec = time_in_msec/1000;
164     nsec = (time_in_msec - (sec*1000)) * 1000000;
166     /* Use the wall-clock time */
167     clock_gettime(CLOCK_REALTIME, &ts);
169     ts.tv_sec += sec;
170     ts.tv_nsec += nsec;
172     pthread_mutex_lock(&fake_mutex);
173     rt = pthread_cond_timedwait(&fake_cond, &fake_mutex, &ts);
174     pthread_mutex_unlock(&fake_mutex);
178 /**
179  *  @b Description
180  *  @n  
181  *      NETAPI Proxy's IPSecMgr Start Offload Response 
182  *      message handler.
183  *
184  *      This function is called by the IPSecMgr library
185  *      when it has a response ready corresponding to an
186  *      Start Offload SP request issued by the user application.
187  *
188  *  @param[in]  rsp
189  *      IPSecMgr's Start Offload SP response
190  *  @param[in]  addr
191  *      Destination address (user application) to send 
192  *      the response to
193  *  @param[in]  addr_size
194  *      Size of destination address passed
195  *
196  *  @retval
197  *      Success -   0
198  *  @retval
199  *      ERROR   -   <0
200  */
201 static int offload_sp_rsp_send
203     ipsecmgr_snoop_offload_sp_rsp_param_t *rsp,
204     void                                  *addr,
205     uint32_t                              addr_size
208     ipsecmgr_ipc_offload_sp_rsp_param_t offload_sp_rsp;
210     offload_sp_rsp.type = rsp->type;
211     offload_sp_rsp.result = rsp->result;
212     offload_sp_rsp.trans_id = rsp->trans_id;
213     offload_sp_rsp.err_code = rsp->err_code;
214     offload_sp_rsp.sp_handle = rsp->sp_handle;
215     offload_sp_rsp.sa_handle = rsp->sa_handle;
217     if (addr_size != sizeof(ipsecmgr_ipc_addr_t)) {
218         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR,
219             "offload_sp_rsp_send: addr size not correct\n");
220         return -1;
221     }
223     return send_iface->offload_sp_rsp(&offload_sp_rsp,
224                                       (ipsecmgr_ipc_addr_t *)addr);
226 static void offload_sp_req_recv
228     ipsecmgr_ipc_offload_sp_req_param_t *req,
229     ipsecmgr_ipc_addr_t                 *src_addr
232     ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,"offload_sp_req_recv called for policy id\n",
233     req->policy_id);
234     ipsecmgr_snoop_offload_sp_rsp_param_t rsp;
235     uint32_t addr_size = sizeof(ipsecmgr_ipc_addr_t);
236     ipsecmgr_snoop_offload_sp_req_param_t offload_sp_req;
238     offload_sp_req.trans_id = req->trans_id;
239     offload_sp_req.policy_id = req->policy_id;
240     offload_sp_req.sa_flags = req->sa_flags;
241     offload_sp_req.if_name = req->if_name;
242     offload_sp_req.dscp_cfg = req->dscp_cfg;
243     offload_sp_req.l5_selector = req->l5_selector;
245     memset(&rsp, 0, sizeof(rsp));
246     rsp.trans_id = req->trans_id;
248     if (ipsecmgr_snoop_offload_sp_req(&offload_sp_req, (void*)src_addr,
249                                       addr_size)) {
250         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
251             "offload_sp_req_recv: snoop_offload_sp_req failed\n");
252         rsp.result = RESULT_FAILURE;
253         rsp.type = RSP_TYPE_ACK | RSP_TYPE_DONE;
254     }
255     else
256     {
257         rsp.result = RESULT_SUCCESS;
258         rsp.type = RSP_TYPE_ACK;
259     }
260     
261     if (offload_sp_rsp_send(&rsp, (void *)src_addr, addr_size))
262     {
263         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
264             "offload_sp_req_recv: failed to send ACK for offload_sp\n");
265     }
266     return;
270 /**
271  *  @b Description
272  *  @n  
273  *      NETAPI Proxy's IPSecMgr Stop Offload response message 
274  *      handler.
275  *
276  *      This function is called by the IPSecMgr library
277  *      when it has a response ready corresponding to an
278  *      Stop Offload SP request issued by the user application.
279  *
280  *  @param[in]  rsp
281  *      IPSecMgr's Stop Offload SP response
282  *  @param[in]  addr
283  *      Destination address (user application) to send 
284  *      the response to
285  *  @param[in]  addr_size
286  *      Size of destination address passed
287  *
288  *  @retval
289  *      Success -   0
290  *  @retval
291  *      ERROR   -   <0
292  */
293 static int stop_offload_rsp_send
295     ipsecmgr_snoop_stop_offload_rsp_param_t *rsp,
296     void                                    *addr,
297     uint32_t                                addr_size
300     ipsecmgr_ipc_stop_offload_rsp_param_t stop_offload_rsp;
302     stop_offload_rsp.type = rsp->type;
303     stop_offload_rsp.result = rsp->result;
304     stop_offload_rsp.trans_id = rsp->trans_id;
306     if (addr_size != sizeof(ipsecmgr_ipc_addr_t)) {
307         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR,
308             "stop_offload_rsp_send: addr size not correct\n");
309         return -1;
310     }
312     return send_iface->stop_offload_rsp(&stop_offload_rsp,
313                                       (ipsecmgr_ipc_addr_t *)addr);
316 static void stop_offload_req_recv
318     ipsecmgr_ipc_stop_offload_req_param_t   *req,
319     ipsecmgr_ipc_addr_t                     *src_addr
322     ipsecmgr_snoop_stop_offload_req_param_t stop_offload_req;
323     uint32_t addr_size = sizeof(ipsecmgr_ipc_addr_t);
324     ipsecmgr_snoop_stop_offload_rsp_param_t rsp;
326     stop_offload_req.trans_id = req->trans_id;
327     stop_offload_req.policy_id = req->policy_id;
329     memset(&rsp, 0, sizeof(rsp));
330     rsp.trans_id = req->trans_id;
332     if (ipsecmgr_snoop_stop_offload(&stop_offload_req, (void*)src_addr,
333                                       addr_size)) {
334         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
335             "stop_offload_req_recv: snoop_stop_offload failed\n");
336         rsp.result = RESULT_FAILURE;
337         rsp.type = RSP_TYPE_ACK | RSP_TYPE_DONE;
338     }
339     else
340     {
341         rsp.result = RESULT_SUCCESS;
342         rsp.type = RSP_TYPE_ACK;
343     }
345     if (stop_offload_rsp_send(&rsp, (void *)src_addr, addr_size))
346     {
347         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
348             "stop_offload_req_recv: failed to send ACK for stop_offload\n");
349     }
350     return;
353 /**
354  *  @b Description
355  *  @n  
356  *      Function to initialize IPSec Manager library.
357  *
358  *  @retval
359  *      Success -   0
360  *  @retval
361  *      ERROR   -   >0
362  */
363 static int32_t init_ipsecmgr (void)
365     struct ipsecmgr_snoop_fp_cfg_cb     fp_cfg_cb;
366     struct ipsecmgr_snoop_mgnt_cb       mgnt_cb;
367     struct ipsecmgr_snoop_platform_cb   plat_cb;
368     ipsecmgr_ipc_daemon_recv_if_t       recv_if;
369     ipsecmgr_ipc_cfg_t                  ipc_cfg;
370     int32_t                             status;
371     pthread_attr_t threadAttr;
373     /* Initializations */
374     ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO, 
375                         "DEBUG: init_ipsecmgr() starting initialization\n");
376     memset(&fp_cfg_cb, 0, sizeof(fp_cfg_cb));
377     memset(&mgnt_cb, 0, sizeof(mgnt_cb));
378     memset(&plat_cb, 0, sizeof(plat_cb));
379     memset(&recv_if, 0, sizeof(recv_if));
380     memset(&ipc_cfg, 0, sizeof(ipc_cfg));
382     /* Initialize IPC library */
383     ipc_cfg.mode = IPC_MODE_SNOOP_DAEMON;
384     if (ipsecmgr_ipc_init(&ipc_cfg)) {
385         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
386             "init_ipsecmgr: ipc_init failed\n");
387         return -1;
388     }
389     else
390         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
391             "init_ipsecmgr: ipc_init sucess\n");
393     if (ipsecmgr_ipc_get_daemon_send_iface(&send_iface)) {
394         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
395             "init_ipsecmgr: ipc_get_daemon_send_iface failed\n");
396         return -1;
397     }
398     recv_if.offload_sp_req = offload_sp_req_recv;
399     recv_if.stop_offload_req = stop_offload_req_recv;
400     /* Register ipsecmgr daemon recieve i/f */
401     if (ipsecmgr_ipc_register_daemon_recv_iface(&recv_if)) {
402         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
403             "snoop_run: ipc_register_daemon_recv_iface failed\n");
404         return -1;
405     }
407     /* Initialize the IPSec Manager Snoop library */
408     fp_cfg_cb.add_sa        =   netapilib_ifAddSA;
409     fp_cfg_cb.add_sp        =   netapilib_ifAddSP;
410     fp_cfg_cb.del_sa        =   netapilib_ifDeleteSA;
411     fp_cfg_cb.del_sp        =   netapilib_ifDeleteSP;
412     fp_cfg_cb.get_sa_ctx    =   netapilib_ifGetSACtx;
414     plat_cb.log_msg  = (ipsecmgr_snoop_log_msg_t)ipsecmgr_syslog_msg;
415     plat_cb.sleep           =   task_sleep;
417     mgnt_cb.offload_sp_rsp  =   offload_sp_rsp_send;
418     mgnt_cb.stop_offload_rsp=   stop_offload_rsp_send;
419     mgnt_cb.rekey_event     =   NULL; // No explicit notifications needed on Rekey completion
421     if ((status = ipsecmgr_snoop_init (&fp_cfg_cb, &mgnt_cb, &plat_cb))) 
422     {
423         ipsecmgr_syslog_msg (SYSLOG_LEVEL_INFO,
424                             "DEBUG: init_ipsecmgr() ipsecmgr_snoop_init failed (%d)\n", status);
425         return -1;
426     }
428     /* Create the task context for snoop library */
429     pthread_attr_init(&threadAttr);
430     pthread_attr_setstacksize(&threadAttr, 0x8000);
431     if (pthread_create(&snoop_run_th, (void*) NULL, snoop_run_thread, NULL))
432     {
433         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
434             "ERROR: NETAPI Proxy Poll Thread failed to start, error code\n"); 
436         /* Cleanup the plugin and exit */
437         //netapiIPSecMgrMcb.pluginMcb.exit ();
438         return -1;
439     }
441     /* Setup signal handler for SIGTERM */
442     if (signal(SIGTERM, sig_term_handler) == SIG_ERR) {
443         ipsecmgr_syslog_msg(SYSLOG_LEVEL_WARN,
444             "snoop_run: cannot handle SIGTERM\n");
445     }
446     /* Wait for the NETAPI Proxy task to finish its processing and exit. */
447     pthread_join (snoop_run_th, NULL);
449     return 0;
452 /**
453  *  @b Description
454  *  @n  
455  *      Utility function to daemonize the current
456  *      application.
457  *
458  *  @param[in]  lock_file
459  *      Lock file to be used by the daemon
460  */
461 static void daemonize (const char *lock_file)
463     pid_t       pid, sid;
464     int32_t     lock_fp = -1;
465     char        str[10];
467     /* already a daemon */
468     if (getppid () == 1)
469         return;
471     /* Fork off the parent process */
472     if ((pid = fork ()) < 0) 
473     {
474         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR, 
475                             "ERROR: daemonize() unable to fork daemon, code=%d (%s)",
476                             errno, 
477                             strerror(errno));
478         exit (-1);
479     }
481     /* If we got a PID, then exit the parent process. */
482     if (pid > 0)
483         exit (0);
485     /* At this point we are executing as the child process */
487     /* Create a new SID for the child process */
488     if ((sid = setsid ()) < 0) 
489     {
490         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR, 
491                             "ERROR: daemonize() unable to create a new session, code %d (%s)",
492                             errno, 
493                             strerror(errno));
494         exit (-1);
495     }
497     /* Change the file mode mask */
498     umask (027);
500     /* Change the current working directory.  This prevents the current
501      * directory from being locked; hence not being able to remove it. */
502     if ((chdir("/")) < 0) 
503     {
504         ipsecmgr_syslog_msg(SYSLOG_LEVEL_ERROR, 
505                             "ERROR: daemonize() unable to change directory to %s, code %d (%s)",
506                             "/", 
507                             errno, 
508                             strerror(errno));
509         exit (-1);
510     }
512     /* Create the lock file */
513     if (lock_file) 
514     {
515         if ((lock_fp = open(lock_file, O_RDWR|O_CREAT, 0640)) < 0 ) 
516         {
517             ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR, 
518                                 "ERROR: daemonize() unable to create lock file %s, code=%d (%s)",
519                                 lock_file, 
520                                 errno, 
521                                 strerror(errno));
522             exit (-1);
523         }
524     }
526     if (lockf (lock_fp, F_TLOCK, 0) < 0) 
527         exit(-1); /* can not lock */
529     /* Record pid to lockfile */
530     sprintf (str, "%d\n", getpid());
531     write (lock_fp, str, strlen(str)); 
533     /* Cancel certain signals */
534     signal (SIGCHLD, SIG_DFL); /* A child process dies */
535     signal (SIGTSTP, SIG_IGN); /* Various TTY signals */
536     signal (SIGTTOU, SIG_IGN);
537     signal (SIGTTIN, SIG_IGN);
538     signal (SIGHUP, SIG_IGN); /* Ignore hangup signal */
539     signal (SIGTERM, sig_term_handler); /* catch SIGTERM */
541     /* Redirect standard files to /dev/null */
542     freopen( "/dev/null", "r", stdin);
543     freopen( "/dev/null", "w", stdout);
544     freopen( "/dev/null", "w", stderr);
546     /* Done setting up the daemon */
547     return;
550 /* FUNCTION PURPOSE:validate and process inputs to the application */
551 int32_t parse_cmd_line_args(int argc, char** argv)
553     int32_t             i;
555     /* Valid command line options */
556     if (argc == 1)
557     {
558         printf("netapi_proxyParseCommandLineArgs, argc =1\n");
559         return 0;
560     }
561     else
562     {
563            printf("netapi_proxyParseCommandLineArgs, argc=%d\n", argc);
564      
565     }
567     /* Scan and parse the command line options */
568     for (i = 1; i < argc; i ++)
569     {
570         if (argv[i][0] == '-' && argv[i][1] == 'f')
571         {
572             /* Log file name */                
573             if (i+1 >= argc || argv[i+1] == NULL)
574                 return -1;
576 #if 0
577             /* Close the default log file if we opened it already */
578             if (netapiIPSecMgrMcb.logFd)
579                 fclose (netapiIPSecMgrMcb.logFd);                    
581             /* Open the log file specified at command line */
582             if ((netapiIPSecMgrMcb.logFd  = fopen(argv[i+1], "a")) == NULL)
583             {
584                 printf ("Error opening log file %s\n", argv[i+1]);
585                 return -1;
586             }
587 #endif
588             i++;
589         }
591         else
592         {
593             /* Invalid options */                
594             return -1;
595         }
596     }
598     /* Success */
599     return 0;
602 int get_kernel_config()
604     uint32_t temp=0;
605     char name[] = "offload_chan";
606     FILE *pDts = NULL;
608     pDts = fopen(DTS_LOG_FILE_QUEUE, "rb");
610     if(pDts)
611     {
612         fread((void*)&temp, sizeof(uint32_t), 1, pDts);
613         globalCfg.qNum= (int)swap32(temp);
614         fclose(pDts);
615     }
616     else
617     {
618         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
619             "main: error opening device tree file: %s\n",DTS_LOG_FILE_QUEUE);
620         return -1;
621     }
623     pDts = NULL;
624     pDts = fopen(DTS_LOG_FILE_FLOW, "rb");
626     if(pDts)
627     {
628         fread((void*)&temp, sizeof(uint32_t), 1, pDts);
629         globalCfg.flowId = (int)swap32(temp);
630         fclose(pDts);
631     }
632     else
633     {
634         printf("main: error opening %s\n",DTS_LOG_FILE_FLOW);
635         return -1;
636     }
637     
638     return 0;
641 int create_pktio_channel()
643     int error = 0;
644     char name[] = "offload_chan";
645     PKTIO_HANDLE_T *pktio_channel;
646     PKTIO_CFG_T pktio_cfg;
648     pktio_cfg.qnum = globalCfg.qNum;
649     pktio_cfg.flags1 = PKTIO_RX;
650     pktio_cfg.flags2 = PKTIO_GLOBAL | PKTIO_PKT;
651     pktio_cfg.max_n = 8;
653     globalCfg.pktio_channel = netapi_pktioCreate(netapi_handle,
654                                                &name[0],
655                                                (PKTIO_CB)recv_cb,
656                                                &pktio_cfg,
657                                                &error);
658     if (!globalCfg.pktio_channel)
659     {
660         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
661             "create_pktio_channel: failed\n");
662         return -1;
663     }
665     return 0;
667 /**
668  *  @b Description
669  *  @n  
670  *      Entry point for the NETAPI Proxy application.
671  *
672  *  @param[in]  argc
673  *      Number of arguments passed to the application
674  *  @param[in]  argv
675  *      Arguments passed to the application.
676  *
677  *  @retval
678  *      Success -   0
679  *  @retval
680  *      ERROR   -   >0
681  */
682 int32_t main (int argc, char* argv[])
684     int32_t             retVal;
685     ipsecmgr_syslog_init();
687     /* create netapi */
688     netapi_handle = netapi_init(NETAPI_SYS_MASTER, &our_netapi_default_cfg);
690     if(netapi_handle == NULL)
691     {
692         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR, "ERROR: netapi_init failed\n");
693         printf("main: netapi_init failed\n");
694         return -1;
695     }
696     else
697         printf("main: netapi_init passed\n");
699     if (get_kernel_config())
700     {
701         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
702                             "ERROR: main: get_kernel_config() failed\n");
703         return -1;
704     }
706         if (create_pktio_channel())
707     {
708         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
709                             "ERROR: main: create_pktio_channel() failed\n");
710         return -1;
711     }
713 #if 1
714     /* Read and parse command line options */
715     if (parse_cmd_line_args (argc, argv) < 0)
716     {
717         printf ("Usage format: netfpproxy.out [-f <log_file>]\n");
718         return -1;
719     }
720 #endif
721     printf("main: calling daemonize\n");
722     /* Create the proxy daemon. */
723     //daemonize (LOCK_FILE);
725     /* Initialize and start the IPSec Mgr Snoop functionality */
726     if ((retVal = init_ipsecmgr ()) < 0)
727     {
728         ipsecmgr_syslog_msg (SYSLOG_LEVEL_ERROR,
729                             "ERROR: IPSec Mgr init failed, error code %d \n",
730                             retVal);
731         return -1;
732     }
733     else
734         printf("main: init_ipsecmgr passed\n");