diff --git a/configure.ac b/configure.ac
index 4fd47b525b..115a2f36ee 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1221,32 +1221,32 @@ AC_INIT(configure.ac)
         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
@@ -1369,7 +1369,7 @@ Suricata Configuration:
   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}
diff --git a/src/Makefile.am b/src/Makefile.am
index ef7346d3e6..7b1d31ebf4 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -15,7 +15,7 @@ runmode-nfq.c runmode-nfq.h \
 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 \
@@ -27,7 +27,7 @@ source-pfring.c source-pfring.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 \
diff --git a/src/runmode-napatech-3gd.c b/src/runmode-napatech-3gd.c
deleted file mode 100644
index 5cf1049488..0000000000
--- a/src/runmode-napatech-3gd.c
+++ /dev/null
@@ -1,207 +0,0 @@
-/* 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
-
diff --git a/src/runmode-napatech.c b/src/runmode-napatech.c
new file mode 100644
index 0000000000..bd5802bb24
--- /dev/null
+++ b/src/runmode-napatech.c
@@ -0,0 +1,206 @@
+/* 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
diff --git a/src/runmode-napatech-3gd.h b/src/runmode-napatech.h
similarity index 69%
rename from src/runmode-napatech-3gd.h
rename to src/runmode-napatech.h
index 99d085ae98..ffb1d42efe 100644
--- a/src/runmode-napatech-3gd.h
+++ b/src/runmode-napatech.h
@@ -22,17 +22,17 @@
  *  \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__ */
diff --git a/src/runmodes.c b/src/runmodes.c
index 8aaf94371f..f766ccac1c 100644
--- a/src/runmodes.c
+++ b/src/runmodes.c
@@ -114,8 +114,8 @@ static const char *RunModeTranslateModeToName(int runmode)
             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:
@@ -174,7 +174,7 @@ void RunModeRegisterRunModes(void)
     RunModeIpsIPFWRegister();
     RunModeErfFileRegister();
     RunModeErfDagRegister();
-    RunModeNapatech3GDRegister();
+    RunModeNapatechRegister();
     RunModeIdsAFPRegister();
 #ifdef UNITTESTS
     UtRunModeRegister();
@@ -260,8 +260,8 @@ void RunModeDispatch(int runmode, const char *custom_mode, DetectEngineCtx *de_c
             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();
diff --git a/src/runmodes.h b/src/runmodes.h
index d6934aafdb..ba9d589611 100644
--- a/src/runmodes.h
+++ b/src/runmodes.h
@@ -35,7 +35,7 @@ enum {
     RUNMODE_DAG,
     RUNMODE_AFP_DEV,
     RUNMODE_UNITTEST,
-    RUNMODE_NAPATECH_3GD,
+    RUNMODE_NAPATECH,
     RUNMODE_MAX,
 };
 
@@ -58,7 +58,7 @@ void RunModeShutDown(void);
 #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;
diff --git a/src/source-napatech-3gd.c b/src/source-napatech.c
similarity index 50%
rename from src/source-napatech-3gd.c
rename to src/source-napatech.c
index c0cec5a0bc..0a4f4e031c 100644
--- a/src/source-napatech-3gd.c
+++ b/src/source-napatech.c
@@ -37,49 +37,49 @@
 #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;
@@ -88,49 +88,49 @@ typedef struct Napatech3GDThreadVars_ {
     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.
@@ -139,43 +139,43 @@ void TmModuleNapatech3GDDecodeRegister(void)
  * \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();
 
@@ -184,24 +184,24 @@ TmEcode Napatech3GDStreamLoop(ThreadVars *tv, void *data, void *slot)
     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
@@ -214,24 +214,24 @@ TmEcode Napatech3GDStreamLoop(ThreadVars *tv, void *data, void *slot)
         } 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);
         }
 
@@ -260,43 +260,43 @@ TmEcode Napatech3GDStreamLoop(ThreadVars *tv, void *data, void *slot)
                 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);
     }
 
@@ -309,37 +309,37 @@ TmEcode Napatech3GDStreamLoop(ThreadVars *tv, void *data, void *slot)
  * \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
@@ -347,7 +347,7 @@ TmEcode Napatech3GDStreamThreadDeinit(ThreadVars *tv, void *data)
  * \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();
@@ -367,14 +367,14 @@ TmEcode Napatech3GDDecode(ThreadVars *tv, Packet *p, void *data, PacketQueue *pq
             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;
@@ -391,5 +391,4 @@ TmEcode Napatech3GDDecodeThreadInit(ThreadVars *tv, void *initdata, void **data)
     SCReturnInt(TM_ECODE_OK);
 }
 
-#endif /* HAVE_NAPATECH_3GD */
-
+#endif /* HAVE_NAPATECH */
diff --git a/src/source-napatech-3gd.h b/src/source-napatech.h
similarity index 72%
rename from src/source-napatech-3gd.h
rename to src/source-napatech.h
index f61c3cd778..8d3e8525fb 100644
--- a/src/source-napatech-3gd.h
+++ b/src/source-napatech.h
@@ -22,22 +22,22 @@
  * \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__ */
diff --git a/src/suricata.c b/src/suricata.c
index ab720dd309..349381938a 100644
--- a/src/suricata.c
+++ b/src/suricata.c
@@ -116,7 +116,7 @@
 
 #include "source-erf-file.h"
 #include "source-erf-dag.h"
-#include "source-napatech-3gd.h"
+#include "source-napatech.h"
 
 #include "source-af-packet.h"
 
@@ -521,8 +521,8 @@ void usage(const char *progname)
 #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 "
@@ -772,7 +772,7 @@ int main(int argc, char **argv)
         {"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}
     };
@@ -999,14 +999,14 @@ int main(int argc, char **argv)
                 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
@@ -1466,9 +1466,9 @@ int main(int argc, char **argv)
     /* dag live */
     TmModuleReceiveErfDagRegister();
     TmModuleDecodeErfDagRegister();
-    /* napatech-3gd */
-    TmModuleNapatech3GDStreamRegister();
-    TmModuleNapatech3GDDecodeRegister();
+    /* napatech */
+    TmModuleNapatechStreamRegister();
+    TmModuleNapatechDecodeRegister();
 
     /* stream engine */
     TmModuleStreamTcpRegister();
diff --git a/src/tm-modules.c b/src/tm-modules.c
index 217a46ad4a..aa6f895b68 100644
--- a/src/tm-modules.c
+++ b/src/tm-modules.c
@@ -260,8 +260,8 @@ const char * TmModuleTmmIdToString(TmmId id)
         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);
diff --git a/src/tm-threads-common.h b/src/tm-threads-common.h
index 32c4db18a0..615a4b5d05 100644
--- a/src/tm-threads-common.h
+++ b/src/tm-threads-common.h
@@ -76,8 +76,8 @@ typedef enum {
     TMM_RECEIVEAFP,
     TMM_DECODEAFP,
     TMM_ALERTPCAPINFO,
-    TMM_RECEIVENAPATECH3GD,
-    TMM_DECODENAPATECH3GD,
+    TMM_RECEIVENAPATECH,
+    TMM_DECODENAPATECH,
     TMM_SIZE,
 } TmmId;
 
diff --git a/src/util-error.c b/src/util-error.c
index 56eb7229a8..e08eabef71 100644
--- a/src/util-error.c
+++ b/src/util-error.c
@@ -190,16 +190,16 @@ const char * SCErrorToString(SCError err)
         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);
diff --git a/src/util-error.h b/src/util-error.h
index ce7d7176ea..8edf2dfdd1 100644
--- a/src/util-error.h
+++ b/src/util-error.h
@@ -243,16 +243,16 @@ typedef enum {
     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);