exit 1
fi
- # napatech-3gd
- AC_ARG_ENABLE(napatech-3gd,
- [ --enable-napatech-3gd Enabled Napatech 3GD Devices],
- [ enable_napatech_3gd=yes ],
- [ enable_napatech_3gd=no])
- AC_ARG_WITH(napatech_3gd_includes,
- [ --with-napatech-3gd-includes=DIR napatech 3gd include directory],
- [with_napatech_3gd_includes="$withval"],[with_napatech_3gd_includes="/opt/napatech3/include"])
- AC_ARG_WITH(napatech_3gd_libraries,
- [ --with-napatech-3gd-libraries=DIR napatech 3gd library directory],
- [with_napatech_3gd_libraries="$withval"],[with_napatech_3gd_libraries="/opt/napatech3/lib"])
-
- if test "$enable_napatech_3gd" = "yes"; then
- CPPFLAGS="${CPPFLAGS} -I${with_napatech_3gd_includes}"
- LDFLAGS="${LDFLAGS} -L${with_napatech_3gd_libraries} -lntapi"
- AC_CHECK_HEADER(nt.h,NAPATECH_3GD="yes",NAPATECH_3GD="no")
- if test "$NAPATECH_3GD" != "no"; then
- NAPATECH_3GD=""
- AC_CHECK_LIB(ntapi, NT_Init,NAPATECH_3GD="yes",NAPATECH_3GD="no")
+ # Napatech - Using the 3GD API
+ AC_ARG_ENABLE(napatech,
+ [ --enable-napatech Enabled Napatech Devices],
+ [ enable_napatech=yes ],
+ [ enable_napatech=no])
+ AC_ARG_WITH(napatech_includes,
+ [ --with-napatech-includes=DIR napatech include directory],
+ [with_napatech_includes="$withval"],[with_napatech_includes="/opt/napatech3/include"])
+ AC_ARG_WITH(napatech_libraries,
+ [ --with-napatech-libraries=DIR napatech library directory],
+ [with_napatech_libraries="$withval"],[with_napatech_libraries="/opt/napatech3/lib"])
+
+ if test "$enable_napatech" = "yes"; then
+ CPPFLAGS="${CPPFLAGS} -I${with_napatech_includes}"
+ LDFLAGS="${LDFLAGS} -L${with_napatech_libraries} -lntapi"
+ AC_CHECK_HEADER(nt.h,NAPATECH="yes",NAPATECH="no")
+ if test "$NAPATECH" != "no"; then
+ NAPATECH=""
+ AC_CHECK_LIB(ntapi, NT_Init,NAPATECH="yes",NAPATECH="no")
fi
- if test "$NAPATECH_3GD" != "no"; then
- CFLAGS="${CFLAGS} -DHAVE_NAPATECH_3GD"
+ if test "$NAPATECH" != "no"; then
+ CFLAGS="${CFLAGS} -DHAVE_NAPATECH"
fi
- if test "$NAPATECH_3GD" = "no"; then
+ if test "$NAPATECH" = "no"; then
echo
echo " ERROR! libntapi library not found"
echo
NFQueue support: ${enable_nfqueue}
IPFW support: ${enable_ipfw}
DAG enabled: ${enable_dag}
- Napatech 3GD enabled: ${enable_napatech_3gd}
+ Napatech enabled: ${enable_napatech}
libnss support: ${enable_nss}
libnspr support: ${enable_nspr}
runmode-ipfw.c runmode-ipfw.h \
runmode-erf-file.c runmode-erf-file.h \
runmode-erf-dag.c runmode-erf-dag.h \
-runmode-napatech-3gd.c runmode-napatech-3gd.h \
+runmode-napatech.c runmode-napatech.h \
runmode-af-packet.c runmode-af-packet.h \
packet-queue.c packet-queue.h \
data-queue.c data-queue.h \
source-ipfw.c source-ipfw.h \
source-erf-file.c source-erf-file.h \
source-erf-dag.c source-erf-dag.h \
-source-napatech-3gd.c source-napatech-3gd.h \
+source-napatech.c source-napatech.h \
source-af-packet.c source-af-packet.h \
decode.c decode.h \
decode-ethernet.c decode-ethernet.h \
+++ /dev/null
-/* Copyright (C) 2012 Open Information Security Foundation
- *
- * You can copy, redistribute or modify this Program under the terms of
- * the GNU General Public License version 2 as published by the Free
- * Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 2 along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-/**
- * \file
- *
- * \author nPulse Technologies, LLC.
- * \author Matt Keeler <mk@npulsetech.com>
- */
-
-#include "suricata-common.h"
-#include "tm-threads.h"
-#include "conf.h"
-#include "runmodes.h"
-#include "log-httplog.h"
-#include "output.h"
-
-#include "alert-fastlog.h"
-#include "alert-prelude.h"
-#include "alert-unified2-alert.h"
-#include "alert-debuglog.h"
-
-#include "util-debug.h"
-#include "util-time.h"
-#include "util-cpu.h"
-#include "util-affinity.h"
-#include "util-runmodes.h"
-#include "util-device.h"
-
-#include "runmode-napatech-3gd.h"
-
-// need Napatech3GDStreamDevConf structure
-#include "source-napatech-3gd.h"
-
-#define NT3GD_RUNMODE_AUTO 1
-#define NT3GD_RUNMODE_AUTOFP 2
-#define NT3GD_RUNMODE_WORKERS 4
-
-static const char *default_mode = NULL;
-#ifdef HAVE_NAPATECH_3GD
-static int num_configured_streams = 0;
-#endif
-
-const char *RunModeNapatech3GDGetDefaultMode(void)
-{
- return default_mode;
-}
-
-void RunModeNapatech3GDRegister(void)
-{
-#ifdef HAVE_NAPATECH_3GD
- default_mode = "autofp";
- RunModeRegisterNewRunMode(RUNMODE_NAPATECH_3GD, "auto",
- "Multi threaded Napatech 3GD mode",
- RunModeNapatech3GDAuto);
- RunModeRegisterNewRunMode(RUNMODE_NAPATECH_3GD, "autofp",
- "Multi threaded Napatech 3GD mode. Packets from "
- "each flow are assigned to a single detect "
- "thread instead of any detect thread",
- RunModeNapatech3GDAutoFp);
- RunModeRegisterNewRunMode(RUNMODE_NAPATECH_3GD, "workers",
- "Workers Napatech 3GD mode, each thread does all"
- " tasks from acquisition to logging",
- RunModeNapatech3GDWorkers);
- return;
-#endif
-}
-
-#ifdef HAVE_NAPATECH_3GD
-int Napatech3GDRegisterDeviceStreams()
-{
- NtInfoStream_t info_stream;
- NtInfo_t info;
- char error_buf[100];
- int status;
- int i;
- char live_dev_buf[9];
-
- if ((status = NT_InfoOpen(&info_stream, "Test")) != NT_SUCCESS)
- {
- NT_ExplainError(status, error_buf, sizeof(error_buf) -1);
- SCLogError(SC_ERR_NAPATECH_3GD_STREAMS_REGISTER_FAILED, "NT_InfoOpen failed: %s", error_buf);
- return -1;
- }
-
-
- info.cmd = NT_INFO_CMD_READ_STREAM;
- if ((status = NT_InfoRead(info_stream, &info)) != NT_SUCCESS)
- {
- NT_ExplainError(status, error_buf, sizeof(error_buf) -1);
- SCLogError(SC_ERR_NAPATECH_3GD_STREAMS_REGISTER_FAILED, "NT_InfoRead failed: %s", error_buf);
- return -1;
- }
-
- num_configured_streams = info.u.stream.data.count;
- for (i = 0; i < num_configured_streams; i++)
- {
- // The Stream IDs do not have to be sequential
- snprintf(live_dev_buf, sizeof(live_dev_buf), "nt3gd%d", info.u.stream.data.streamIDList[i]);
- LiveRegisterDevice(live_dev_buf);
- }
-
- if ((status = NT_InfoClose(info_stream)) != NT_SUCCESS)
- {
- NT_ExplainError(status, error_buf, sizeof(error_buf) -1);
- SCLogError(SC_ERR_NAPATECH_3GD_STREAMS_REGISTER_FAILED, "NT_InfoClose failed: %s", error_buf);
- return -1;
- }
- return 0;
-}
-
-void *Napatech3GDConfigParser(const char *device) {
- // Expect device to be of the form nt3gd%d where %d is the stream id to use
- int dev_len = strlen(device);
- struct Napatech3GDStreamDevConf *conf = SCMalloc(sizeof(struct Napatech3GDStreamDevConf));
- if (dev_len < 6 || dev_len > 8)
- {
- SCLogError(SC_ERR_NAPATECH_3GD_PARSE_CONFIG, "Could not parse config for device: %s - invalid length", device);
- return NULL;
- }
-
- // device+5 is a pointer to the beginning of the stream id after the constant nt3gd portion
- conf->stream_id = atoi(device+5);
- return (void *) conf;
-}
-
-int Napatech3GDGetThreadsCount(void *conf __attribute__((unused))) {
- // No matter which live device it is there is no reason to ever use more than 1 thread
- // 2 or more thread would cause packet duplication
- return 1;
-}
-
-int Napatech3GDInit(DetectEngineCtx *de_ctx, int runmode) {
- int ret;
- char errbuf[100];
-
- RunModeInitialize();
- TimeModeSetLive();
-
- /* Initialize the 3GD API and check version compatibility */
- if ((ret = NT_Init(NTAPI_VERSION)) != NT_SUCCESS) {
- NT_ExplainError(ret, errbuf, sizeof(errbuf));
- SCLogError(SC_ERR_NAPATECH_3GD_INIT_FAILED ,"NT_Init failed. Code 0x%X = %s", ret, errbuf);
- exit(EXIT_FAILURE);
- }
-
- ret = Napatech3GDRegisterDeviceStreams();
- if (ret < 0 || num_configured_streams <= 0) {
- SCLogError(SC_ERR_NAPATECH_3GD_STREAMS_REGISTER_FAILED, "Unable to setup up Napatech 3GD Streams");
- exit(EXIT_FAILURE);
- }
-
- switch(runmode) {
- case NT3GD_RUNMODE_AUTO:
- ret = RunModeSetLiveCaptureAuto(de_ctx, Napatech3GDConfigParser, Napatech3GDGetThreadsCount,
- "Napatech3GDStream", "Napatech3GDDecode",
- "RxNT3GD", NULL);
- break;
- case NT3GD_RUNMODE_AUTOFP:
- ret = RunModeSetLiveCaptureAutoFp(de_ctx, Napatech3GDConfigParser, Napatech3GDGetThreadsCount,
- "Napatech3GDStream", "Napatech3GDDecode",
- "RxNT3GD", NULL);
- break;
- case NT3GD_RUNMODE_WORKERS:
- ret = RunModeSetLiveCaptureWorkers(de_ctx, Napatech3GDConfigParser, Napatech3GDGetThreadsCount,
- "Napatech3GDStream", "Napatech3GDDecode",
- "RxNT3GD", NULL);
- break;
- default:
- ret = -1;
- }
-
- if (ret != 0) {
- SCLogError(SC_ERR_RUNMODE, "Runmode start failed");
- exit(EXIT_FAILURE);
- }
- return 0;
-}
-
-int RunModeNapatech3GDAuto(DetectEngineCtx *de_ctx) {
- return Napatech3GDInit(de_ctx, NT3GD_RUNMODE_AUTO);
-}
-
-int RunModeNapatech3GDAutoFp(DetectEngineCtx *de_ctx) {
- return Napatech3GDInit(de_ctx, NT3GD_RUNMODE_AUTOFP);
-}
-
-int RunModeNapatech3GDWorkers(DetectEngineCtx *de_ctx) {
- return Napatech3GDInit(de_ctx, NT3GD_RUNMODE_WORKERS);
-}
-
-#endif
-
--- /dev/null
+/* Copyright (C) 2012 Open Information Security Foundation
+ *
+ * You can copy, redistribute or modify this Program under the terms of
+ * the GNU General Public License version 2 as published by the Free
+ * Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * \file
+ *
+ * \author nPulse Technologies, LLC.
+ * \author Matt Keeler <mk@npulsetech.com>
+ */
+
+#include "suricata-common.h"
+#include "tm-threads.h"
+#include "conf.h"
+#include "runmodes.h"
+#include "log-httplog.h"
+#include "output.h"
+
+#include "alert-fastlog.h"
+#include "alert-prelude.h"
+#include "alert-unified2-alert.h"
+#include "alert-debuglog.h"
+
+#include "util-debug.h"
+#include "util-time.h"
+#include "util-cpu.h"
+#include "util-affinity.h"
+#include "util-runmodes.h"
+#include "util-device.h"
+
+#include "runmode-napatech.h"
+
+// need NapatechStreamDevConf structure
+#include "source-napatech.h"
+
+#define NT_RUNMODE_AUTO 1
+#define NT_RUNMODE_AUTOFP 2
+#define NT_RUNMODE_WORKERS 4
+
+static const char *default_mode = NULL;
+#ifdef HAVE_NAPATECH
+static int num_configured_streams = 0;
+#endif
+
+const char *RunModeNapatechGetDefaultMode(void)
+{
+ return default_mode;
+}
+
+void RunModeNapatechRegister(void)
+{
+#ifdef HAVE_NAPATECH
+ default_mode = "autofp";
+ RunModeRegisterNewRunMode(RUNMODE_NAPATECH, "auto",
+ "Multi threaded Napatech mode",
+ RunModeNapatechAuto);
+ RunModeRegisterNewRunMode(RUNMODE_NAPATECH, "autofp",
+ "Multi threaded Napatech mode. Packets from "
+ "each flow are assigned to a single detect "
+ "thread instead of any detect thread",
+ RunModeNapatechAutoFp);
+ RunModeRegisterNewRunMode(RUNMODE_NAPATECH, "workers",
+ "Workers Napatech mode, each thread does all"
+ " tasks from acquisition to logging",
+ RunModeNapatechWorkers);
+ return;
+#endif
+}
+
+#ifdef HAVE_NAPATECH
+int NapatechRegisterDeviceStreams()
+{
+ NtInfoStream_t info_stream;
+ NtInfo_t info;
+ char error_buf[100];
+ int status;
+ int i;
+ char live_dev_buf[9];
+
+ if ((status = NT_InfoOpen(&info_stream, "Test")) != NT_SUCCESS)
+ {
+ NT_ExplainError(status, error_buf, sizeof(error_buf) -1);
+ SCLogError(SC_ERR_NAPATECH_STREAMS_REGISTER_FAILED, "NT_InfoOpen failed: %s", error_buf);
+ return -1;
+ }
+
+
+ info.cmd = NT_INFO_CMD_READ_STREAM;
+ if ((status = NT_InfoRead(info_stream, &info)) != NT_SUCCESS)
+ {
+ NT_ExplainError(status, error_buf, sizeof(error_buf) -1);
+ SCLogError(SC_ERR_NAPATECH_STREAMS_REGISTER_FAILED, "NT_InfoRead failed: %s", error_buf);
+ return -1;
+ }
+
+ num_configured_streams = info.u.stream.data.count;
+ for (i = 0; i < num_configured_streams; i++)
+ {
+ // The Stream IDs do not have to be sequential
+ snprintf(live_dev_buf, sizeof(live_dev_buf), "nt%d", info.u.stream.data.streamIDList[i]);
+ LiveRegisterDevice(live_dev_buf);
+ }
+
+ if ((status = NT_InfoClose(info_stream)) != NT_SUCCESS)
+ {
+ NT_ExplainError(status, error_buf, sizeof(error_buf) -1);
+ SCLogError(SC_ERR_NAPATECH_STREAMS_REGISTER_FAILED, "NT_InfoClose failed: %s", error_buf);
+ return -1;
+ }
+ return 0;
+}
+
+void *NapatechConfigParser(const char *device) {
+ // Expect device to be of the form nt%d where %d is the stream id to use
+ int dev_len = strlen(device);
+ struct NapatechStreamDevConf *conf = SCMalloc(sizeof(struct NapatechStreamDevConf));
+ if (dev_len < 3 || dev_len > 5)
+ {
+ SCLogError(SC_ERR_NAPATECH_PARSE_CONFIG, "Could not parse config for device: %s - invalid length", device);
+ return NULL;
+ }
+
+ // device+5 is a pointer to the beginning of the stream id after the constant nt portion
+ conf->stream_id = atoi(device+2);
+ return (void *) conf;
+}
+
+int NapatechGetThreadsCount(void *conf __attribute__((unused))) {
+ // No matter which live device it is there is no reason to ever use more than 1 thread
+ // 2 or more thread would cause packet duplication
+ return 1;
+}
+
+int NapatechInit(DetectEngineCtx *de_ctx, int runmode) {
+ int ret;
+ char errbuf[100];
+
+ RunModeInitialize();
+ TimeModeSetLive();
+
+ /* Initialize the API and check version compatibility */
+ if ((ret = NT_Init(NTAPI_VERSION)) != NT_SUCCESS) {
+ NT_ExplainError(ret, errbuf, sizeof(errbuf));
+ SCLogError(SC_ERR_NAPATECH_INIT_FAILED ,"NT_Init failed. Code 0x%X = %s", ret, errbuf);
+ exit(EXIT_FAILURE);
+ }
+
+ ret = NapatechRegisterDeviceStreams();
+ if (ret < 0 || num_configured_streams <= 0) {
+ SCLogError(SC_ERR_NAPATECH_STREAMS_REGISTER_FAILED, "Unable to setup up Napatech Streams");
+ exit(EXIT_FAILURE);
+ }
+
+ switch(runmode) {
+ case NT_RUNMODE_AUTO:
+ ret = RunModeSetLiveCaptureAuto(de_ctx, NapatechConfigParser, NapatechGetThreadsCount,
+ "NapatechStream", "NapatechDecode",
+ "RxNT", NULL);
+ break;
+ case NT_RUNMODE_AUTOFP:
+ ret = RunModeSetLiveCaptureAutoFp(de_ctx, NapatechConfigParser, NapatechGetThreadsCount,
+ "NapatechStream", "NapatechDecode",
+ "RxNT", NULL);
+ break;
+ case NT_RUNMODE_WORKERS:
+ ret = RunModeSetLiveCaptureWorkers(de_ctx, NapatechConfigParser, NapatechGetThreadsCount,
+ "NapatechStream", "NapatechDecode",
+ "RxNT", NULL);
+ break;
+ default:
+ ret = -1;
+ }
+
+ if (ret != 0) {
+ SCLogError(SC_ERR_RUNMODE, "Runmode start failed");
+ exit(EXIT_FAILURE);
+ }
+ return 0;
+}
+
+int RunModeNapatechAuto(DetectEngineCtx *de_ctx) {
+ return NapatechInit(de_ctx, NT_RUNMODE_AUTO);
+}
+
+int RunModeNapatechAutoFp(DetectEngineCtx *de_ctx) {
+ return NapatechInit(de_ctx, NT_RUNMODE_AUTOFP);
+}
+
+int RunModeNapatechWorkers(DetectEngineCtx *de_ctx) {
+ return NapatechInit(de_ctx, NT_RUNMODE_WORKERS);
+}
+
+#endif
* \author Matt Keeler <mk@npulsetech.com>
*/
-#ifndef __RUNMODE_NAPATECH_3GD_H__
-#define __RUNMODE_NAPATECH_3GD_H__
+#ifndef __RUNMODE_NAPATECH_H__
+#define __RUNMODE_NAPATECH_H__
-#ifdef HAVE_NAPATECH_3GD
+#ifdef HAVE_NAPATECH
#include <nt.h>
#endif
-int RunModeNapatech3GDAuto(DetectEngineCtx *);
-int RunModeNapatech3GDAutoFp(DetectEngineCtx *);
-int RunModeNapatech3GDWorkers(DetectEngineCtx *);
-void RunModeNapatech3GDRegister(void);
-const char *RunModeNapatech3GDGetDefaultMode(void);
+int RunModeNapatechAuto(DetectEngineCtx *);
+int RunModeNapatechAutoFp(DetectEngineCtx *);
+int RunModeNapatechWorkers(DetectEngineCtx *);
+void RunModeNapatechRegister(void);
+const char *RunModeNapatechGetDefaultMode(void);
-#endif /* __RUNMODE_NAPATECH_3GD_H__ */
+#endif /* __RUNMODE_NAPATECH_H__ */
return "ERF_FILE";
case RUNMODE_DAG:
return "ERF_DAG";
- case RUNMODE_NAPATECH_3GD:
- return "NAPATECH_3GD";
+ case RUNMODE_NAPATECH:
+ return "NAPATECH";
case RUNMODE_UNITTEST:
return "UNITTEST";
case RUNMODE_AFP_DEV:
RunModeIpsIPFWRegister();
RunModeErfFileRegister();
RunModeErfDagRegister();
- RunModeNapatech3GDRegister();
+ RunModeNapatechRegister();
RunModeIdsAFPRegister();
#ifdef UNITTESTS
UtRunModeRegister();
case RUNMODE_DAG:
custom_mode = RunModeErfDagGetDefaultMode();
break;
- case RUNMODE_NAPATECH_3GD:
- custom_mode = RunModeNapatech3GDGetDefaultMode();
+ case RUNMODE_NAPATECH:
+ custom_mode = RunModeNapatechGetDefaultMode();
break;
case RUNMODE_AFP_DEV:
custom_mode = RunModeAFPGetDefaultMode();
RUNMODE_DAG,
RUNMODE_AFP_DEV,
RUNMODE_UNITTEST,
- RUNMODE_NAPATECH_3GD,
+ RUNMODE_NAPATECH,
RUNMODE_MAX,
};
#include "runmode-ipfw.h"
#include "runmode-erf-file.h"
#include "runmode-erf-dag.h"
-#include "runmode-napatech-3gd.h"
+#include "runmode-napatech.h"
#include "runmode-af-packet.h"
int threading_set_cpu_affinity;
#include "util-privs.h"
#include "tmqh-packetpool.h"
-#ifndef HAVE_NAPATECH_3GD
+#ifndef HAVE_NAPATECH
-TmEcode NoNapatech3GDSupportExit(ThreadVars *, void *, void **);
+TmEcode NoNapatechSupportExit(ThreadVars *, void *, void **);
-void TmModuleNapatech3GDStreamRegister (void) {
- tmm_modules[TMM_RECEIVENAPATECH3GD].name = "Napatech3GDStream";
- tmm_modules[TMM_RECEIVENAPATECH3GD].ThreadInit = NoNapatech3GDSupportExit;
- tmm_modules[TMM_RECEIVENAPATECH3GD].Func = NULL;
- tmm_modules[TMM_RECEIVENAPATECH3GD].ThreadExitPrintStats = NULL;
- tmm_modules[TMM_RECEIVENAPATECH3GD].ThreadDeinit = NULL;
- tmm_modules[TMM_RECEIVENAPATECH3GD].RegisterTests = NULL;
- tmm_modules[TMM_RECEIVENAPATECH3GD].cap_flags = SC_CAP_NET_ADMIN;
+void TmModuleNapatechStreamRegister (void) {
+ tmm_modules[TMM_RECEIVENAPATECH].name = "NapatechStream";
+ tmm_modules[TMM_RECEIVENAPATECH].ThreadInit = NoNapatechSupportExit;
+ tmm_modules[TMM_RECEIVENAPATECH].Func = NULL;
+ tmm_modules[TMM_RECEIVENAPATECH].ThreadExitPrintStats = NULL;
+ tmm_modules[TMM_RECEIVENAPATECH].ThreadDeinit = NULL;
+ tmm_modules[TMM_RECEIVENAPATECH].RegisterTests = NULL;
+ tmm_modules[TMM_RECEIVENAPATECH].cap_flags = SC_CAP_NET_ADMIN;
}
-void TmModuleNapatech3GDDecodeRegister (void) {
- tmm_modules[TMM_DECODENAPATECH3GD].name = "Napatech3GDDecode";
- tmm_modules[TMM_DECODENAPATECH3GD].ThreadInit = NoNapatech3GDSupportExit;
- tmm_modules[TMM_DECODENAPATECH3GD].Func = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].ThreadExitPrintStats = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].ThreadDeinit = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].RegisterTests = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].cap_flags = 0;
- tmm_modules[TMM_DECODENAPATECH3GD].flags = TM_FLAG_DECODE_TM;
+void TmModuleNapatechDecodeRegister (void) {
+ tmm_modules[TMM_DECODENAPATECH].name = "NapatechDecode";
+ tmm_modules[TMM_DECODENAPATECH].ThreadInit = NoNapatechSupportExit;
+ tmm_modules[TMM_DECODENAPATECH].Func = NULL;
+ tmm_modules[TMM_DECODENAPATECH].ThreadExitPrintStats = NULL;
+ tmm_modules[TMM_DECODENAPATECH].ThreadDeinit = NULL;
+ tmm_modules[TMM_DECODENAPATECH].RegisterTests = NULL;
+ tmm_modules[TMM_DECODENAPATECH].cap_flags = 0;
+ tmm_modules[TMM_DECODENAPATECH].flags = TM_FLAG_DECODE_TM;
}
-TmEcode NoNapatech3GDSupportExit(ThreadVars *tv, void *initdata, void **data)
+TmEcode NoNapatechSupportExit(ThreadVars *tv, void *initdata, void **data)
{
- SCLogError(SC_ERR_NAPATECH_3GD_NOSUPPORT,
- "Error creating thread %s: you do not have support for Napatech 3GD adapter "
- "enabled please recompile with --enable-napatech-3gd", tv->name);
+ SCLogError(SC_ERR_NAPATECH_NOSUPPORT,
+ "Error creating thread %s: you do not have support for Napatech adapter "
+ "enabled please recompile with --enable-napatech", tv->name);
exit(EXIT_FAILURE);
}
-#else /* Implied we do have NAPATECH 3GD support */
+#else /* Implied we do have NAPATECH support */
-#include "source-napatech-3gd.h"
+#include "source-napatech.h"
#include <nt.h>
extern int max_pending_packets;
extern uint8_t suricata_ctl_flags;
-typedef struct Napatech3GDThreadVars_ {
+typedef struct NapatechThreadVars_ {
ThreadVars *tv;
NtNetStreamRx_t rx_stream;
uint64_t stream_id;
uint64_t bytes;
TmSlot *slot;
-} Napatech3GDThreadVars;
+} NapatechThreadVars;
-TmEcode Napatech3GDStreamThreadInit(ThreadVars *, void *, void **);
-void Napatech3GDStreamThreadExitStats(ThreadVars *, void *);
-TmEcode Napatech3GDStreamLoop(ThreadVars *tv, void *data, void *slot);
+TmEcode NapatechStreamThreadInit(ThreadVars *, void *, void **);
+void NapatechStreamThreadExitStats(ThreadVars *, void *);
+TmEcode NapatechStreamLoop(ThreadVars *tv, void *data, void *slot);
-TmEcode Napatech3GDDecodeThreadInit(ThreadVars *, void *, void **);
-TmEcode Napatech3GDDecode(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
+TmEcode NapatechDecodeThreadInit(ThreadVars *, void *, void **);
+TmEcode NapatechDecode(ThreadVars *, Packet *, void *, PacketQueue *, PacketQueue *);
/**
- * \brief Register the Napatech 3GD receiver (reader) module.
+ * \brief Register the Napatech receiver (reader) module.
*/
-void TmModuleNapatech3GDStreamRegister(void)
+void TmModuleNapatechStreamRegister(void)
{
- tmm_modules[TMM_RECEIVENAPATECH3GD].name = "Napatech3GDStream";
- tmm_modules[TMM_RECEIVENAPATECH3GD].ThreadInit = Napatech3GDStreamThreadInit;
- tmm_modules[TMM_RECEIVENAPATECH3GD].Func = NULL;
- tmm_modules[TMM_RECEIVENAPATECH3GD].PktAcqLoop = Napatech3GDStreamLoop;
- tmm_modules[TMM_RECEIVENAPATECH3GD].ThreadExitPrintStats = Napatech3GDStreamThreadExitStats;
- tmm_modules[TMM_RECEIVENAPATECH3GD].ThreadDeinit = Napatech3GDStreamThreadDeinit;
- tmm_modules[TMM_RECEIVENAPATECH3GD].RegisterTests = NULL;
- tmm_modules[TMM_RECEIVENAPATECH3GD].cap_flags = SC_CAP_NET_RAW;
- tmm_modules[TMM_RECEIVENAPATECH3GD].flags = TM_FLAG_RECEIVE_TM;
+ tmm_modules[TMM_RECEIVENAPATECH].name = "NapatechStream";
+ tmm_modules[TMM_RECEIVENAPATECH].ThreadInit = NapatechStreamThreadInit;
+ tmm_modules[TMM_RECEIVENAPATECH].Func = NULL;
+ tmm_modules[TMM_RECEIVENAPATECH].PktAcqLoop = NapatechStreamLoop;
+ tmm_modules[TMM_RECEIVENAPATECH].ThreadExitPrintStats = NapatechStreamThreadExitStats;
+ tmm_modules[TMM_RECEIVENAPATECH].ThreadDeinit = NapatechStreamThreadDeinit;
+ tmm_modules[TMM_RECEIVENAPATECH].RegisterTests = NULL;
+ tmm_modules[TMM_RECEIVENAPATECH].cap_flags = SC_CAP_NET_RAW;
+ tmm_modules[TMM_RECEIVENAPATECH].flags = TM_FLAG_RECEIVE_TM;
}
/**
- * \brief Register the Napatech 3GD decoder module.
+ * \brief Register the Napatech decoder module.
*/
-void TmModuleNapatech3GDDecodeRegister(void)
+void TmModuleNapatechDecodeRegister(void)
{
- tmm_modules[TMM_DECODENAPATECH3GD].name = "Napatech3GDDecode";
- tmm_modules[TMM_DECODENAPATECH3GD].ThreadInit = Napatech3GDDecodeThreadInit;
- tmm_modules[TMM_DECODENAPATECH3GD].Func = Napatech3GDDecode;
- tmm_modules[TMM_DECODENAPATECH3GD].ThreadExitPrintStats = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].ThreadDeinit = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].RegisterTests = NULL;
- tmm_modules[TMM_DECODENAPATECH3GD].cap_flags = 0;
- tmm_modules[TMM_DECODENAPATECH3GD].flags = TM_FLAG_DECODE_TM;
+ tmm_modules[TMM_DECODENAPATECH].name = "NapatechDecode";
+ tmm_modules[TMM_DECODENAPATECH].ThreadInit = NapatechDecodeThreadInit;
+ tmm_modules[TMM_DECODENAPATECH].Func = NapatechDecode;
+ tmm_modules[TMM_DECODENAPATECH].ThreadExitPrintStats = NULL;
+ tmm_modules[TMM_DECODENAPATECH].ThreadDeinit = NULL;
+ tmm_modules[TMM_DECODENAPATECH].RegisterTests = NULL;
+ tmm_modules[TMM_DECODENAPATECH].cap_flags = 0;
+ tmm_modules[TMM_DECODENAPATECH].flags = TM_FLAG_DECODE_TM;
}
/**
- * \brief Initialize the Napatech 3GD receiver thread, generate a single
+ * \brief Initialize the Napatech receiver thread, generate a single
* NapatechThreadVar structure for each thread, this will
* contain a NtNetStreamRx_t stream handle which is used when the
* thread executes to acquire the packets.
* \param initdata Initial data to the adapter passed from the user,
* this is processed by the user.
*
- * For now, we assume that we have only a single name for the NAPATECH 3GD
+ * For now, we assume that we have only a single name for the NAPATECH
* adapter.
*
* \param data data pointer gets populated with
*
*/
-TmEcode Napatech3GDStreamThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode NapatechStreamThreadInit(ThreadVars *tv, void *initdata, void **data)
{
SCEnter();
- struct Napatech3GDStreamDevConf *conf = (struct Napatech3GDStreamDevConf *)initdata;
+ struct NapatechStreamDevConf *conf = (struct NapatechStreamDevConf *)initdata;
uintmax_t stream_id = conf->stream_id;
*data = NULL;
- SCLogInfo("Napatech 3GD Thread Stream ID:%lu", stream_id);
+ SCLogInfo("Napatech Thread Stream ID:%lu", stream_id);
- Napatech3GDThreadVars *ntv3 = SCMalloc(sizeof(Napatech3GDThreadVars));
- if (ntv3 == NULL) {
+ NapatechThreadVars *ntv = SCMalloc(sizeof(NapatechThreadVars));
+ if (ntv == NULL) {
SCLogError(SC_ERR_MEM_ALLOC,
- "Failed to allocate memory for NAPATECH 3GD thread vars.");
+ "Failed to allocate memory for NAPATECH thread vars.");
exit(EXIT_FAILURE);
}
- memset(ntv3, 0, sizeof (Napatech3GDThreadVars));
- ntv3->stream_id = stream_id;
- ntv3->tv = tv;
+ memset(ntv, 0, sizeof (NapatechThreadVars));
+ ntv->stream_id = stream_id;
+ ntv->tv = tv;
- SCLogInfo("Started processing packets from NAPATECH 3GD Stream: %lu", ntv3->stream_id);
+ SCLogInfo("Started processing packets from NAPATECH Stream: %lu", ntv->stream_id);
- *data = (void *)ntv3;
+ *data = (void *)ntv;
SCReturnInt(TM_ECODE_OK);
}
/**
- * \brief Main Napatech 3GD reading Loop function
+ * \brief Main Napatech reading Loop function
*/
-TmEcode Napatech3GDStreamLoop(ThreadVars *tv, void *data, void *slot)
+TmEcode NapatechStreamLoop(ThreadVars *tv, void *data, void *slot)
{
SCEnter();
uint16_t packet_q_len = 0;
uint64_t pkt_ts;
NtNetBuf_t packet_buffer;
- Napatech3GDThreadVars *ntv3 = (Napatech3GDThreadVars *)data;
+ NapatechThreadVars *ntv = (NapatechThreadVars *)data;
NtNetRx_t stat_cmd;
- SCLogInfo("Opening NAPATECH 3GD Stream: %lu for processing", ntv3->stream_id);
+ SCLogInfo("Opening NAPATECH Stream: %lu for processing", ntv->stream_id);
- if ((status = NT_NetRxOpen(&(ntv3->rx_stream), "SuricataStream", NT_NET_INTERFACE_PACKET, ntv3->stream_id, -1)) != NT_SUCCESS) {
+ if ((status = NT_NetRxOpen(&(ntv->rx_stream), "SuricataStream", NT_NET_INTERFACE_PACKET, ntv->stream_id, -1)) != NT_SUCCESS) {
NT_ExplainError(status, errbuf, sizeof(errbuf));
- SCLogError(SC_ERR_NAPATECH_3GD_OPEN_FAILED, "Failed to open NAPATECH 3GD Stream: %lu - %s", ntv3->stream_id, errbuf);
- SCFree(ntv3);
+ SCLogError(SC_ERR_NAPATECH_OPEN_FAILED, "Failed to open NAPATECH Stream: %lu - %s", ntv->stream_id, errbuf);
+ SCFree(ntv);
SCReturnInt(TM_ECODE_FAILED);
}
stat_cmd.cmd = NT_NETRX_READ_CMD_STREAM_DROP;
- SCLogInfo("Napatech 3GD Packet Stream Loop Started for Stream ID: %lu", ntv3->stream_id);
+ SCLogInfo("Napatech Packet Stream Loop Started for Stream ID: %lu", ntv->stream_id);
TmSlot *s = (TmSlot *)slot;
- ntv3->slot = s->slot_next;
+ ntv->slot = s->slot_next;
while (!(suricata_ctl_flags & (SURICATA_STOP | SURICATA_KILL))) {
/* make sure we have at least one packet in the packet pool, to prevent
} while (packet_q_len == 0);
/*
- * Napatech 3GD returns packets 1 at a time
+ * Napatech returns packets 1 at a time
*/
- status = NT_NetRxGet(ntv3->rx_stream, &packet_buffer, 1000);
+ status = NT_NetRxGet(ntv->rx_stream, &packet_buffer, 1000);
if (unlikely(status == NT_STATUS_TIMEOUT || status == NT_STATUS_TRYAGAIN)) {
/*
* no frames currently available
*/
continue;
} else if (unlikely(status != NT_SUCCESS)) {
- SCLogError(SC_ERR_NAPATECH_3GD_STREAM_NEXT_FAILED,
- "Failed to read from Napatech 3GD Stream: %lu",
- ntv3->stream_id);
+ SCLogError(SC_ERR_NAPATECH_STREAM_NEXT_FAILED,
+ "Failed to read from Napatech Stream: %lu",
+ ntv->stream_id);
SCReturnInt(TM_ECODE_FAILED);
}
Packet *p = PacketGetFromQueueOrAlloc();
if (unlikely(p == NULL)) {
- NT_NetRxRelease(ntv3->rx_stream, packet_buffer);
+ NT_NetRxRelease(ntv->rx_stream, packet_buffer);
SCReturnInt(TM_ECODE_FAILED);
}
p->ts.tv_usec = ((pkt_ts % 100000000) / 100) + (pkt_ts % 100) > 50 ? 1 : 0;
break;
default:
- SCLogError(SC_ERR_NAPATECH_3GD_TIMESTAMP_TYPE_NOT_SUPPORTED,
- "Packet from Napatech 3GD Stream: %lu does not have a supported timestamp format",
- ntv3->stream_id);
- NT_NetRxRelease(ntv3->rx_stream, packet_buffer);
+ SCLogError(SC_ERR_NAPATECH_TIMESTAMP_TYPE_NOT_SUPPORTED,
+ "Packet from Napatech Stream: %lu does not have a supported timestamp format",
+ ntv->stream_id);
+ NT_NetRxRelease(ntv->rx_stream, packet_buffer);
SCReturnInt(TM_ECODE_FAILED);
}
SCLogDebug("p->ts.tv_sec %"PRIuMAX"", (uintmax_t)p->ts.tv_sec);
p->datalink = LINKTYPE_ETHERNET;
- ntv3->pkts++;
- ntv3->bytes += NT_NET_GET_PKT_WIRE_LENGTH(packet_buffer);
+ ntv->pkts++;
+ ntv->bytes += NT_NET_GET_PKT_WIRE_LENGTH(packet_buffer);
// Update drop counter
- if (unlikely((status = NT_NetRxRead(ntv3->rx_stream, &stat_cmd)) != NT_SUCCESS))
+ if (unlikely((status = NT_NetRxRead(ntv->rx_stream, &stat_cmd)) != NT_SUCCESS))
{
NT_ExplainError(status, errbuf, sizeof(errbuf));
- SCLogWarning(SC_ERR_NAPATECH_3GD_STAT_DROPS_FAILED, "Couldn't retrieve drop statistics from the RX stream: %lu - %s", ntv3->stream_id, errbuf);
+ SCLogWarning(SC_ERR_NAPATECH_STAT_DROPS_FAILED, "Couldn't retrieve drop statistics from the RX stream: %lu - %s", ntv->stream_id, errbuf);
}
else
{
- ntv3->drops += stat_cmd.u.streamDrop.pktsDropped;
+ ntv->drops += stat_cmd.u.streamDrop.pktsDropped;
}
if (unlikely(PacketCopyData(p, (uint8_t *)NT_NET_GET_PKT_L2_PTR(packet_buffer), NT_NET_GET_PKT_WIRE_LENGTH(packet_buffer)))) {
- TmqhOutputPacketpool(ntv3->tv, p);
- NT_NetRxRelease(ntv3->rx_stream, packet_buffer);
+ TmqhOutputPacketpool(ntv->tv, p);
+ NT_NetRxRelease(ntv->rx_stream, packet_buffer);
SCReturnInt(TM_ECODE_FAILED);
}
- if (unlikely(TmThreadsSlotProcessPkt(ntv3->tv, ntv3->slot, p) != TM_ECODE_OK)) {
- TmqhOutputPacketpool(ntv3->tv, p);
- NT_NetRxRelease(ntv3->rx_stream, packet_buffer);
+ if (unlikely(TmThreadsSlotProcessPkt(ntv->tv, ntv->slot, p) != TM_ECODE_OK)) {
+ TmqhOutputPacketpool(ntv->tv, p);
+ NT_NetRxRelease(ntv->rx_stream, packet_buffer);
SCReturnInt(TM_ECODE_FAILED);
}
- NT_NetRxRelease(ntv3->rx_stream, packet_buffer);
+ NT_NetRxRelease(ntv->rx_stream, packet_buffer);
SCPerfSyncCountersIfSignalled(tv, 0);
}
* \param tv Pointer to ThreadVars.
* \param data Pointer to data, ErfFileThreadVars.
*/
-void Napatech3GDStreamThreadExitStats(ThreadVars *tv, void *data)
+void NapatechStreamThreadExitStats(ThreadVars *tv, void *data)
{
- Napatech3GDThreadVars *ntv3 = (Napatech3GDThreadVars *)data;
+ NapatechThreadVars *ntv = (NapatechThreadVars *)data;
double percent = 0;
- if (ntv3->drops > 0)
- percent = (((double) ntv3->drops) / (ntv3->pkts+ntv3->drops)) * 100;
+ if (ntv->drops > 0)
+ percent = (((double) ntv->drops) / (ntv->pkts+ntv->drops)) * 100;
- SCLogInfo("Stream: %lu; Packets: %"PRIu64"; Drops: %"PRIu64" (%5.2f%%); Bytes: %"PRIu64, ntv3->stream_id, ntv3->pkts, ntv3->drops, percent, ntv3->bytes);
+ SCLogInfo("Stream: %lu; Packets: %"PRIu64"; Drops: %"PRIu64" (%5.2f%%); Bytes: %"PRIu64, ntv->stream_id, ntv->pkts, ntv->drops, percent, ntv->bytes);
}
/**
- * \brief Deinitializes the NAPATECH 3GD card.
+ * \brief Deinitializes the NAPATECH card.
* \param tv pointer to ThreadVars
* \param data pointer that gets cast into PcapThreadVars for ptv
*/
-TmEcode Napatech3GDStreamThreadDeinit(ThreadVars *tv, void *data)
+TmEcode NapatechStreamThreadDeinit(ThreadVars *tv, void *data)
{
SCEnter();
- Napatech3GDThreadVars *ntv3 = (Napatech3GDThreadVars *)data;
- SCLogDebug("Closing Napatech 3GD Stream: %d", ntv3->stream_id);
- NT_NetRxClose(ntv3->rx_stream);
+ NapatechThreadVars *ntv = (NapatechThreadVars *)data;
+ SCLogDebug("Closing Napatech Stream: %d", ntv->stream_id);
+ NT_NetRxClose(ntv->rx_stream);
SCReturnInt(TM_ECODE_OK);
}
-/** Decode Napatech 3GD */
+/** Decode Napatech */
/**
* \brief This function passes off to link type decoders.
*
- * Napatech3GDDecode reads packets from the PacketQueue and passes
+ * NapatechDecode reads packets from the PacketQueue and passes
* them off to the proper link type decoder.
*
* \param t pointer to ThreadVars
* \param data pointer that gets cast into PcapThreadVars for ptv
* \param pq pointer to the current PacketQueue
*/
-TmEcode Napatech3GDDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
+TmEcode NapatechDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq,
PacketQueue *postpq)
{
SCEnter();
break;
default:
SCLogError(SC_ERR_DATALINK_UNIMPLEMENTED,
- "Error: datalink type %" PRId32 " not yet supported in module Napatech3GDDecode",
+ "Error: datalink type %" PRId32 " not yet supported in module NapatechDecode",
p->datalink);
break;
}
SCReturnInt(TM_ECODE_OK);
}
-TmEcode Napatech3GDDecodeThreadInit(ThreadVars *tv, void *initdata, void **data)
+TmEcode NapatechDecodeThreadInit(ThreadVars *tv, void *initdata, void **data)
{
SCEnter();
DecodeThreadVars *dtv = NULL;
SCReturnInt(TM_ECODE_OK);
}
-#endif /* HAVE_NAPATECH_3GD */
-
+#endif /* HAVE_NAPATECH */
* \author Matt Keeler <mk@npulsetech.com>
*/
-#ifndef __SOURCE_NAPATECH_3GD_H__
-#define __SOURCE_NAPATECH_3GD_H__
+#ifndef __SOURCE_NAPATECH_H__
+#define __SOURCE_NAPATECH_H__
-void TmModuleNapatech3GDStreamRegister (void);
-TmEcode Napatech3GDStreamThreadDeinit(ThreadVars *tv, void *data);
-void TmModuleNapatech3GDDecodeRegister (void);
+void TmModuleNapatechStreamRegister (void);
+TmEcode NapatechStreamThreadDeinit(ThreadVars *tv, void *data);
+void TmModuleNapatechDecodeRegister (void);
-struct Napatech3GDStreamDevConf
+struct NapatechStreamDevConf
{
int stream_id;
};
-#ifdef HAVE_NAPATECH_3GD
+#ifdef HAVE_NAPATECH
#include <nt.h>
#endif
-#endif /* __SOURCE_NAPATECH_3GD_H__ */
+#endif /* __SOURCE_NAPATECH_H__ */
#include "source-erf-file.h"
#include "source-erf-dag.h"
-#include "source-napatech-3gd.h"
+#include "source-napatech.h"
#include "source-af-packet.h"
#ifdef HAVE_DAG
printf("\t--dag <dagX:Y> : process ERF records from DAG interface X, stream Y\n");
#endif
-#ifdef HAVE_NAPATECH_3GD
- printf("\t--napatech-3gd : run Napatech Streams using the 3GD API\n");
+#ifdef HAVE_NAPATECH
+ printf("\t--napatech : run Napatech Streams using the API\n");
#endif
printf("\n");
printf("\nTo run the engine with default configuration on "
{"group", required_argument, 0, 0},
{"erf-in", required_argument, 0, 0},
{"dag", required_argument, 0, 0},
- {"napatech-3gd", 0, 0, 0},
+ {"napatech", 0, 0, 0},
{"build-info", 0, &build_info, 1},
{NULL, 0, NULL, 0}
};
exit(EXIT_FAILURE);
#endif /* HAVE_DAG */
}
- else if (strcmp((long_opts[option_index]).name, "napatech-3gd") == 0) {
-#ifdef HAVE_NAPATECH_3GD
- run_mode = RUNMODE_NAPATECH_3GD;
+ else if (strcmp((long_opts[option_index]).name, "napatech") == 0) {
+#ifdef HAVE_NAPATECH
+ run_mode = RUNMODE_NAPATECH;
#else
- SCLogError(SC_ERR_NAPATECH_3GD_REQUIRED, "libntapi and a Napatech adapter are required"
- " to capture packets using --napatech-3gd.");
+ SCLogError(SC_ERR_NAPATECH_REQUIRED, "libntapi and a Napatech adapter are required"
+ " to capture packets using --napatech.");
exit(EXIT_FAILURE);
-#endif /* HAVE_NAPATECH_3GD */
+#endif /* HAVE_NAPATECH */
}
else if(strcmp((long_opts[option_index]).name, "pcap-buffer-size") == 0) {
#ifdef HAVE_PCAP_SET_BUFF
/* dag live */
TmModuleReceiveErfDagRegister();
TmModuleDecodeErfDagRegister();
- /* napatech-3gd */
- TmModuleNapatech3GDStreamRegister();
- TmModuleNapatech3GDDecodeRegister();
+ /* napatech */
+ TmModuleNapatechStreamRegister();
+ TmModuleNapatechDecodeRegister();
/* stream engine */
TmModuleStreamTcpRegister();
CASE_CODE (TMM_DECODEERFFILE);
CASE_CODE (TMM_RECEIVEERFDAG);
CASE_CODE (TMM_DECODEERFDAG);
- CASE_CODE (TMM_RECEIVENAPATECH3GD);
- CASE_CODE (TMM_DECODENAPATECH3GD);
+ CASE_CODE (TMM_RECEIVENAPATECH);
+ CASE_CODE (TMM_DECODENAPATECH);
CASE_CODE (TMM_RECEIVEAFP);
CASE_CODE (TMM_ALERTPCAPINFO);
CASE_CODE (TMM_DECODEAFP);
TMM_RECEIVEAFP,
TMM_DECODEAFP,
TMM_ALERTPCAPINFO,
- TMM_RECEIVENAPATECH3GD,
- TMM_DECODENAPATECH3GD,
+ TMM_RECEIVENAPATECH,
+ TMM_DECODENAPATECH,
TMM_SIZE,
} TmmId;
CASE_CODE (SC_ERR_ERF_DAG_STREAM_SET_FAILED);
CASE_CODE (SC_ERR_ERF_DAG_STREAM_READ_FAILED);
CASE_CODE (SC_WARN_ERF_DAG_REC_LEN_CHANGED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_OPEN_FAILED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_STREAM_NEXT_FAILED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_NOSUPPORT);
- CASE_CODE (SC_ERR_NAPATECH_3GD_REQUIRED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_TIMESTAMP_TYPE_NOT_SUPPORTED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_INIT_FAILED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_CONFIG_STREAM);
- CASE_CODE (SC_ERR_NAPATECH_3GD_STREAMS_REGISTER_FAILED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_STAT_DROPS_FAILED);
- CASE_CODE (SC_ERR_NAPATECH_3GD_PARSE_CONFIG);
+ CASE_CODE (SC_ERR_NAPATECH_OPEN_FAILED);
+ CASE_CODE (SC_ERR_NAPATECH_STREAM_NEXT_FAILED);
+ CASE_CODE (SC_ERR_NAPATECH_NOSUPPORT);
+ CASE_CODE (SC_ERR_NAPATECH_REQUIRED);
+ CASE_CODE (SC_ERR_NAPATECH_TIMESTAMP_TYPE_NOT_SUPPORTED);
+ CASE_CODE (SC_ERR_NAPATECH_INIT_FAILED);
+ CASE_CODE (SC_ERR_NAPATECH_CONFIG_STREAM);
+ CASE_CODE (SC_ERR_NAPATECH_STREAMS_REGISTER_FAILED);
+ CASE_CODE (SC_ERR_NAPATECH_STAT_DROPS_FAILED);
+ CASE_CODE (SC_ERR_NAPATECH_PARSE_CONFIG);
CASE_CODE (SC_WARN_COMPATIBILITY);
CASE_CODE (SC_ERR_DCERPC);
CASE_CODE (SC_ERR_DETECT_PREPARE);
SC_ERR_NO_LUAJIT_SUPPORT,
SC_ERR_LUAJIT_ERROR,
SC_ERR_DEFRAG_INIT,
- SC_ERR_NAPATECH_3GD_OPEN_FAILED,
- SC_ERR_NAPATECH_3GD_STREAM_NEXT_FAILED,
- SC_ERR_NAPATECH_3GD_NOSUPPORT,
- SC_ERR_NAPATECH_3GD_REQUIRED,
- SC_ERR_NAPATECH_3GD_TIMESTAMP_TYPE_NOT_SUPPORTED,
- SC_ERR_NAPATECH_3GD_INIT_FAILED,
- SC_ERR_NAPATECH_3GD_CONFIG_STREAM,
- SC_ERR_NAPATECH_3GD_STREAMS_REGISTER_FAILED,
- SC_ERR_NAPATECH_3GD_STAT_DROPS_FAILED,
- SC_ERR_NAPATECH_3GD_PARSE_CONFIG,
+ SC_ERR_NAPATECH_OPEN_FAILED,
+ SC_ERR_NAPATECH_STREAM_NEXT_FAILED,
+ SC_ERR_NAPATECH_NOSUPPORT,
+ SC_ERR_NAPATECH_REQUIRED,
+ SC_ERR_NAPATECH_TIMESTAMP_TYPE_NOT_SUPPORTED,
+ SC_ERR_NAPATECH_INIT_FAILED,
+ SC_ERR_NAPATECH_CONFIG_STREAM,
+ SC_ERR_NAPATECH_STREAMS_REGISTER_FAILED,
+ SC_ERR_NAPATECH_STAT_DROPS_FAILED,
+ SC_ERR_NAPATECH_PARSE_CONFIG,
} SCError;
const char *SCErrorToString(SCError);
projects / thirdparty / suricata.git / commitdiff
