From 91338935dec8fa8e791019d21006b7f343723942 Mon Sep 17 00:00:00 2001
From: Orgad Shaneh <orgads@gmail.com>
Date: Sun, 23 May 2021 20:52:16 +0000
Subject: [PATCH 1/9] rtpstream: Remove unused audioport and videoport

---
 include/rtpstream.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/include/rtpstream.hpp b/include/rtpstream.hpp
index 6835033ed..238f9f761 100644
--- a/include/rtpstream.hpp
+++ b/include/rtpstream.hpp
@@ -27,8 +27,6 @@ struct taskentry_t;
 struct rtpstream_callinfo_t
 {
     taskentry_t* taskinfo;
-    int audioport;
-    int videoport;
 };
 
 struct rtpstream_actinfo_t
@@ -45,8 +43,6 @@ int rtpstream_new_call(rtpstream_callinfo_t *callinfo);
 void rtpstream_end_call(rtpstream_callinfo_t *callinfo);
 void rtpstream_shutdown(void);
 
-int rtpstream_get_audioport(rtpstream_callinfo_t *callinfo);
-int rtpstream_get_videoport(rtpstream_callinfo_t *callinfo);
 void rtpstream_set_remote(rtpstream_callinfo_t* callinfo, int ip_ver, const char* ip_addr,
                           int audio_port, int video_port);
 

From 754edfca9e63a831003cd055aec3b21676ee9620 Mon Sep 17 00:00:00 2001
From: Walter Doekes <walter+github@wjd.nu>
Date: Tue, 30 Nov 2021 10:36:00 +0100
Subject: [PATCH 2/9] build: Consistent find_library usage for PCAP/GSL/SCTP

Fixes build on CentOS7. Closes #540 reported by @Xyders.
---
 CMakeLists.txt | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 30bb7d2f6..ba18b1b99 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,18 +75,30 @@ if(USE_SSL)
 endif()
 
 if(USE_PCAP)
-  add_definitions("-DPCAPPLAY")
+  find_library(PCAP_LIBRARY pcap)
+  if(PCAP_LIBRARY)
+    add_definitions("-DPCAPPLAY")
+  else()
+    message(FATAL_ERROR "libpcap not found")
+  endif()
 endif(USE_PCAP)
 
 if(USE_GSL)
   find_library(GSL_LIBRARY gsl)
   if(GSL_LIBRARY)
     add_definitions("-DHAVE_GSL")
-  endif(GSL_LIBRARY)
+  else()
+    message(FATAL_ERROR "libgsl not found")
+  endif()
 endif(USE_GSL)
 
 if(USE_SCTP)
-  add_definitions("-DUSE_SCTP")
+  find_library(SCTP_LIBRARY sctp)
+  if(SCTP_LIBRARY)
+    add_definitions("-DUSE_SCTP")
+  else()
+    message(FATAL_ERROR "libsctp not found")
+  endif()
 endif(USE_SCTP)
 
 # add the executable

From f843dd8588d28bcd9f19c494518e9a944b7d12f7 Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan@nventures.net>
Date: Thu, 17 Mar 2022 09:58:07 -0500
Subject: [PATCH 3/9] 1. This adds the following new features: 	a) a plugin
 which can be built via make myapp which adds the ability to run lua scripts
 in a thread using exec command luarunthread@function_name arg1 arg2 arg3 etc.
 	   and then return a retkey which holds the key to shared memory which
 can read another variable msgDone to see if the memory has been updated with
 the results 	   from the thread. 	   example:  <exec
 command="luathread@my_function calling [$5] called [$2] /> 		<log 
 message="retkey [$retkey] calling = [$calling] called = [$called] />

!-- Do a loop looking for the data to be done -->

 <label id="start_of_loop"/>
    <pause milliseconds="100" />
    <!-- retrieve our variables back from our previous read -->
    <nop>
             <action>
                <log message="luaread@[$retkey] 0" />
                <exec command="luaread@[$retkey] 0" />
                <strcmp assign_to="result" variable="msgDone" value="0" />
                <log message="result for msgDone  check = [$msgDone]"/>
             </action>
   </nop>

  <!-- When we're done processing jump to finished else keep looping -->
  <nop next="finished" test="result"/>

  <!-- Increment the counter and continue looping up to 10 times-->
  <nop>
    <action>
      <add assign_to="counter" value="1"/>
      <test assign_to="flag_limit" variable="counter"
                compare="greater_than_equal" value="100"/>
        <log message="flag_limit=([$flag_limit])" />
    </action>
  </nop>

  <nop next="finished" test="flag_limit" />

  <nop next="start_of_loop"/>

 <label id="finished" />

    <nop>
        <action>
                <!-- Delete the shared memory because we're done -->
                <log message="finished!" />
                <log message="luaread@[$retkey] 1" />
                <exec command="luaread@[$retkey] 1" />
        </action>
  </nop>

	b) The ability to do rpc calls
2. Fixed memory leak associated with having AUTO RESPONSE on - leaked during OPTIONS messages
---
 CHANGES.md             |  13 --
 Makefile.am            |  17 ++
 README.md              |   2 +
 build.gradle           | 169 ++++++++++++++
 configure.ac           |   6 +-
 include/logger.hpp     |   4 +-
 include/send_packets.h |   2 +-
 include/sipp-rpc.h     |  72 ++++++
 include/sipp.hpp       |   6 +
 include/strings.hpp    |   3 +-
 rpc/sipp-rpc.h         |  72 ++++++
 rpc/sipp-rpc.x         |  19 ++
 rpc/sipp-rpc_client.c  |  84 +++++++
 rpc/sipp-rpc_clnt.c    |  37 +++
 rpc/sipp-rpc_server.c  |  55 +++++
 rpc/sipp-rpc_svc.c     | 111 +++++++++
 rpc/sipp-rpc_xdr.c     |  71 ++++++
 settings.gradle        |  10 +
 src/apifunc.cpp        | 303 ++++++++++++++++++++++++
 src/apifunc.h          |  68 ++++++
 src/call.cpp           | 278 +++++++++++++---------
 src/customfuncs.cpp    |  18 ++
 src/deadcall.cpp       |   3 +
 src/logger.cpp         |  48 ++++
 src/myapp.cpp          | 517 +++++++++++++++++++++++++++++++++++++++++
 src/scenario.cpp       |  10 +-
 src/screen.cpp         |   8 +-
 src/send_packets.c     |  12 +-
 src/sip_parser.cpp     |   8 +-
 src/sipp-rpc_xdr.c     |  71 ++++++
 src/sipp.cpp           | 314 ++++++++++++++++++++++++-
 src/socket.cpp         |   8 +-
 32 files changed, 2268 insertions(+), 151 deletions(-)
 create mode 100644 build.gradle
 create mode 100644 include/sipp-rpc.h
 create mode 100644 rpc/sipp-rpc.h
 create mode 100644 rpc/sipp-rpc.x
 create mode 100644 rpc/sipp-rpc_client.c
 create mode 100644 rpc/sipp-rpc_clnt.c
 create mode 100644 rpc/sipp-rpc_server.c
 create mode 100644 rpc/sipp-rpc_svc.c
 create mode 100644 rpc/sipp-rpc_xdr.c
 create mode 100644 settings.gradle
 create mode 100644 src/apifunc.cpp
 create mode 100644 src/apifunc.h
 create mode 100644 src/customfuncs.cpp
 create mode 100644 src/myapp.cpp
 create mode 100644 src/sipp-rpc_xdr.c

diff --git a/CHANGES.md b/CHANGES.md
index 22e3b0e06..2d4ed2c07 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,16 +1,3 @@
-Bugs fixed in 3.5.3
-===================
-
-* Fix `[routes]` header in UAS scenario's. (Issue #262, reported by
-  Stefan Mititelu (@smititelu).)
-  (Backported from b6c7b209 from 3.6.)
-* Fix bad Content-Length calculation when whitespace was between the CRLF
-  pairs that separate the body. (Issue #337, fixed by Serg Stetsuk
-  (@sergstetsuk)).
-* Fix crash in pcap play on send failure because of pthread\_cleanup macros.
-  (Issue #74, #370, reported by various people.)
-
-
 Bugs fixed in 3.5.2
 ===================
 
diff --git a/Makefile.am b/Makefile.am
index b60ffccf1..633dcbf24 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -6,6 +6,7 @@ TESTS = sipp_unittest
 
 check_PROGRAMS = $(TESTS)
 
+DEFAULT_INCLUDES = -I. -I$(top_builddir)/include -I/usr/include/lua5.3 -I/usr/include/x86_64-linux-gnu/curl -I/usr/include/mysql
 AM_CFLAGS=-I$(srcdir)/include -Wall -pedantic
 AM_CXXFLAGS=-I$(srcdir)/include -Wall -pedantic
 
@@ -82,6 +83,7 @@ common_incl = \
 	include/variables.hpp \
 	include/watchdog.hpp \
 	include/xp_parser.h \
+	include/sipp_rpc.h \
 	include/actions.hpp \
 	include/call.hpp \
 	include/auth.hpp \
@@ -92,6 +94,8 @@ common_SOURCES = \
 	src/auth.cpp \
 	src/comp.c \
 	src/call.cpp \
+	src/apifunc.cpp \
+	src/customfuncs.cpp \
 	src/deadcall.cpp \
 	src/infile.cpp \
 	src/listener.cpp \
@@ -115,6 +119,7 @@ common_SOURCES = \
 	src/variables.cpp \
 	src/watchdog.cpp \
 	src/xp_parser.c \
+	src/sipp-rpc_xdr.c \
 	$(common_incl) \
 	$(ssl_SOURCES) \
 	$(pcap_SOURCES) \
@@ -133,6 +138,18 @@ sipp_LDADD = @LIBOBJS@ @GSL_LIBS@
 src/call.cpp: include/version.h
 src/sipp.cpp: include/version.h
 
+# Make a shared library to use as a plugin
+myapp: myapp.so
+
+src/myapp.o: src/myapp.cpp
+	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) -rdynamic -fPIC $(CPPFLAGS) $(sipp_CXXFLAGS) $(CXXFLAGS) -c src/myapp.cpp  -o src/myapp.o
+	echo "done building shared custom app"
+
+
+myapp.so: src/myapp.o
+	g++ -rdynamic -fPIC -shared $(SO_OPTION) src/myapp.o  $(LIBS) -o $@
+
+
 gtest_SOURCES = \
 	gtest/src/gtest-death-test.cc \
 	gtest/src/gtest-filepath.cc \
diff --git a/README.md b/README.md
index 8314b5530..498b55309 100644
--- a/README.md
+++ b/README.md
@@ -42,6 +42,8 @@ can enable SSL, PCAP and SCTP support by calling `./build.sh
 --with-pcap --with-sctp --with-openssl` or `./build.sh --full` to enable
 all optional features.
 
+Note for trustid - normally we build with:  build.sh --with-openssl
+
 # Support
 
 I try and be responsive to issues raised on Github, and there's [a
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 000000000..627cb31b3
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,169 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * This generated file contains a sample C++ project to get you started.
+ * For more details take a look at the Building C++ applications and libraries chapter in the Gradle
+ * User Manual available at https://docs.gradle.org/7.0.2/userguide/building_cpp_projects.html
+ */
+
+plugins {
+    // Apply the cpp-application plugin to add support for building C++ executables
+    id 'cpp-application'
+
+    // Apply the cpp-unit-test plugin to add support for building and running C++ test executables
+    //id 'cpp-unit-test'
+}
+
+// Set the target operating system and architecture for this application
+application {
+    targetMachines.add(machines.linux.x86_64)
+}
+
+task cleanrpc(type:Exec) {
+
+  doFirst {
+    println("Cleaning files for sip:rpc")
+  }
+  workingDir 'rpc'
+
+  //on linux
+  commandLine 'make','clean'
+
+  //store the output instead of printing to the console:
+  standardOutput = new ByteArrayOutputStream()
+
+  //extension method stopTomcat.output() can be used to obtain the output:
+  ext.output = {
+    return standardOutput.toString()
+  }
+
+  doLast {
+    println("Finished cleaning files for sipp:rpc")
+  }
+}
+
+task cleansipp(type:Exec) {
+
+  doFirst {
+    println("Cleaning files")
+  }
+  workingDir '.'
+
+  //on linux
+  commandLine 'make','clean'
+
+  //store the output instead of printing to the console:
+  standardOutput = new ByteArrayOutputStream()
+
+  //extension method stopTomcat.output() can be used to obtain the output:
+  ext.output = {
+    return standardOutput.toString()
+  }
+
+  doLast {
+    println("Finished cleaning files")
+  }
+
+if (!file("./Makefile").exists()){
+  enabled = false
+}
+
+}
+
+task buildrpc(type:Exec) {
+
+  doFirst {
+    println("Running build rpc for sipp")
+  }
+
+  dependsOn tasks.cleanrpc
+
+  workingDir 'rpc'
+
+  //on linux
+  commandLine 'make'
+
+  //store the output instead of printing to the console:
+  standardOutput = new ByteArrayOutputStream()
+
+  //extension method stopTomcat.output() can be used to obtain the output:
+  ext.output = {
+    return standardOutput.toString()
+  }
+
+  doLast {
+    if (!file("rpc/sa_ctl").exists()){
+      throw new GradleException('Failed build sipp:rpc')
+      //throw new RuntimeException('Failed build sipp:rpc')
+    } else {
+      println("Finished build sipp:rpc")
+    }
+  }
+}
+
+task buildsipp(type:Exec) {
+
+  dependsOn tasks.cleansipp
+  workingDir '.'
+
+  doFirst {
+    println("Running build sipp")
+    if (!file("./Makefile").exists()){
+      commandLine './build.sh'
+    } else {
+      //on linux
+      commandLine 'make'
+    }
+
+    //store the output instead of printing to the console:
+    standardOutput = new ByteArrayOutputStream()
+
+    //extension method stopTomcat.output() can be used to obtain the output:
+    ext.output = {
+    return standardOutput.toString()
+    }
+  }
+
+  doLast {
+    if (!file("sipp").exists()){
+      throw new GradleException('Failed build sipp')
+      //throw new RuntimeException('Failed build sipp')
+    } else {
+      println("Finished build sipp")
+    }
+  }
+}
+
+task packsipp(type: Copy) {
+
+    doFirst {
+      println("Running pack sipp")
+    }
+
+    dependsOn tasks.buildrpc
+    dependsOn tasks.buildsipp
+
+    from('.') {
+        include 'sipp'
+    }
+    from('rpc') {
+        include 'sa_ctl'
+    }
+    into 'build/bin'
+    exclude '**/*.bak'
+
+    includeEmptyDirs = false
+
+    doLast {
+      if (!file("$buildDir/bin/sipp").exists()){
+        throw new GradleException('Failed pack sipp')
+        //throw new RuntimeException('Failed pack sipp')
+      } else if (!file("$buildDir/bin/sa_ctl").exists()){
+        throw new GradleException('Failed pack sipp:rpc')
+        //throw new RuntimeException('Failed pack sipp:rpc')
+      } else {
+        println("Finished running pack sipp")
+      }
+    }
+}
+
diff --git a/configure.ac b/configure.ac
index 17e669076..63d3543e2 100644
--- a/configure.ac
+++ b/configure.ac
@@ -53,8 +53,9 @@ AX_CHECK_COMPILE_FLAG([-std=gnu11],
 
 case "$host" in
     *-linux*)
-        CFLAGS="$CFLAGS -D__LINUX"
-        CPPFLAGS="$CPPFLAGS -D__LINUX"
+        CFLAGS="$CFLAGS -D__LINUX -rdynamic"
+        CPPFLAGS="$CPPFLAGS -D__LINUX -rdynamic"
+	LDFLAGS="$LDFLAGS -rdynamic"
         ;;
     *-darwin*)
         CFLAGS="$CFLAGS -D__DARWIN"
@@ -88,6 +89,7 @@ AC_CHECK_PROG([have_pkgconfig], [pkg-config], [yes], [no])
 
 # ==================== checks for libraries =============================
 
+LIBS="$LIBS -llua5.3 -lrt -lcrypto -lcurl -lperconaserverclient"
 if test "$have_pkgconfig" = "yes"; then
     # Use pkg-config when available
     PKG_PROG_PKG_CONFIG()
diff --git a/include/logger.hpp b/include/logger.hpp
index 4b12ef70b..d57a11299 100644
--- a/include/logger.hpp
+++ b/include/logger.hpp
@@ -52,6 +52,7 @@ struct logfile_info {
     bool fixedname;
     time_t starttime;
     unsigned int count;
+    pthread_mutex_t *lockfile;
 };
 
 void print_header_line(FILE *f);
@@ -64,7 +65,7 @@ void log_off(struct logfile_info *lfi);
 
 #ifdef GLOBALS_FULL_DEFINITION
 #define LOGFILE(name, s, check) \
-        struct logfile_info name = { s, check, NULL, 0, NULL, "", true, false, 0, 0}
+        struct logfile_info name = { s, check, NULL, 0, NULL, "", true, false, 0, 0, NULL}
 #else
 #define LOGFILE(name, s, check) \
         extern struct logfile_info name
@@ -79,6 +80,7 @@ LOGFILE(error_lfi, "errors", false);
 void rotate_logfile();
 void rotate_shortmessagef();
 void rotate_errorf();
+void rotate_errorf_nolock();
 void rotate_messagef();
 void rotate_screenf();
 void rotate_calldebugf();
diff --git a/include/send_packets.h b/include/send_packets.h
index 542b767f8..27271ec45 100644
--- a/include/send_packets.h
+++ b/include/send_packets.h
@@ -122,7 +122,7 @@ extern "C"
 #endif
     int parse_play_args(const char*, pcap_pkts*);
     void free_pcaps(pcap_pkts *pkts);
-    void send_packets(play_args_t*);
+    int send_packets(play_args_t*);
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/sipp-rpc.h b/include/sipp-rpc.h
new file mode 100644
index 000000000..ac29fdbda
--- /dev/null
+++ b/include/sipp-rpc.h
@@ -0,0 +1,72 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _SIPP-RPC_H_RPCGEN
+#define _SIPP-RPC_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct callcounter {
+	int incomingcalls;
+	int outgoingcalls;
+	int successcalls;
+	int failurecalls;
+};
+typedef struct callcounter callcounter;
+
+typedef callcounter callcounter_t;
+
+#define SIPPRPCPROG 0x20000002
+#define SIPPRPCVERS 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define GETCALLCOUNTER 1
+extern  enum clnt_stat getcallcounter_1(callcounter_t *, callcounter_t *, CLIENT *);
+extern  bool_t getcallcounter_1_svc(callcounter_t *, callcounter_t *, struct svc_req *);
+#define ENABLELOG4AUTOANSWER 2
+extern  enum clnt_stat enablelog4autoanswer_1(void *, bool_t *, CLIENT *);
+extern  bool_t enablelog4autoanswer_1_svc(void *, bool_t *, struct svc_req *);
+#define DISABLELOG4AUTOANSWER 3
+extern  enum clnt_stat disablelog4autoanswer_1(void *, bool_t *, CLIENT *);
+extern  bool_t disablelog4autoanswer_1_svc(void *, bool_t *, struct svc_req *);
+extern int sipprpcprog_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define GETCALLCOUNTER 1
+extern  enum clnt_stat getcallcounter_1();
+extern  bool_t getcallcounter_1_svc();
+#define ENABLELOG4AUTOANSWER 2
+extern  enum clnt_stat enablelog4autoanswer_1();
+extern  bool_t enablelog4autoanswer_1_svc();
+#define DISABLELOG4AUTOANSWER 3
+extern  enum clnt_stat disablelog4autoanswer_1();
+extern  bool_t disablelog4autoanswer_1_svc();
+extern int sipprpcprog_1_freeresult ();
+#endif /* K&R C */
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern  bool_t xdr_callcounter (XDR *, callcounter*);
+extern  bool_t xdr_callcounter_t (XDR *, callcounter_t*);
+
+#else /* K&R C */
+extern bool_t xdr_callcounter ();
+extern bool_t xdr_callcounter_t ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_SIPP-RPC_H_RPCGEN */
diff --git a/include/sipp.hpp b/include/sipp.hpp
index d65e93583..7a216a0be 100644
--- a/include/sipp.hpp
+++ b/include/sipp.hpp
@@ -115,6 +115,8 @@
 #define T_TLS                      2
 #define T_SCTP                     3
 
+#define DEFAULT_PID_FILE            "sipp.pid"
+#define DEFAULT_LUA_FILE            "sipp.lua"
 #ifdef USE_OPENSSL
 #define DEFAULT_TLS_CERT           "cacert.pem"
 #define DEFAULT_TLS_KEY            "cakey.pem"
@@ -204,6 +206,8 @@ extern unsigned long      default_behaviors       _DEFVAL(DEFAULT_BEHAVIOR_ALL);
 extern unsigned long      deadcall_wait           _DEFVAL(DEFAULT_DEADCALL_WAIT);
 extern bool               pause_msg_ign           _DEFVAL(0);
 extern bool               auto_answer             _DEFVAL(false);
+extern bool               log4auto_answer         _DEFVAL(false);
+extern bool               enable_rpc              _DEFVAL(false);
 extern int                multisocket             _DEFVAL(0);
 extern int                compression             _DEFVAL(0);
 extern int                peripsocket             _DEFVAL(0);
@@ -314,6 +318,8 @@ extern unsigned int       tdm_map_z               _DEFVAL(0);
 extern unsigned int       tdm_map_h               _DEFVAL(0);
 extern bool               tdm_map[1024];
 
+extern const char       * pid_file            _DEFVAL(DEFAULT_PID_FILE);
+extern const char       * lua_file            _DEFVAL(DEFAULT_LUA_FILE);
 #ifdef USE_OPENSSL
 extern BIO              * twinSipp_bio;
 extern SSL              * twinSipp_ssl;
diff --git a/include/strings.hpp b/include/strings.hpp
index 600a09469..e2c4711c7 100644
--- a/include/strings.hpp
+++ b/include/strings.hpp
@@ -21,7 +21,8 @@
 #ifndef __SIPP_STRINGS_H__
 #define __SIPP_STRINGS_H__
 
-#include <cstddef>
+//#include <cstddef>
+#include <stddef.h>
 
 char *strcasestr2 (char *__haystack, const char *__needle);
 char *strncasestr (char *s, const char *find, size_t n);
diff --git a/rpc/sipp-rpc.h b/rpc/sipp-rpc.h
new file mode 100644
index 000000000..ac29fdbda
--- /dev/null
+++ b/rpc/sipp-rpc.h
@@ -0,0 +1,72 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _SIPP-RPC_H_RPCGEN
+#define _SIPP-RPC_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct callcounter {
+	int incomingcalls;
+	int outgoingcalls;
+	int successcalls;
+	int failurecalls;
+};
+typedef struct callcounter callcounter;
+
+typedef callcounter callcounter_t;
+
+#define SIPPRPCPROG 0x20000002
+#define SIPPRPCVERS 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define GETCALLCOUNTER 1
+extern  enum clnt_stat getcallcounter_1(callcounter_t *, callcounter_t *, CLIENT *);
+extern  bool_t getcallcounter_1_svc(callcounter_t *, callcounter_t *, struct svc_req *);
+#define ENABLELOG4AUTOANSWER 2
+extern  enum clnt_stat enablelog4autoanswer_1(void *, bool_t *, CLIENT *);
+extern  bool_t enablelog4autoanswer_1_svc(void *, bool_t *, struct svc_req *);
+#define DISABLELOG4AUTOANSWER 3
+extern  enum clnt_stat disablelog4autoanswer_1(void *, bool_t *, CLIENT *);
+extern  bool_t disablelog4autoanswer_1_svc(void *, bool_t *, struct svc_req *);
+extern int sipprpcprog_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define GETCALLCOUNTER 1
+extern  enum clnt_stat getcallcounter_1();
+extern  bool_t getcallcounter_1_svc();
+#define ENABLELOG4AUTOANSWER 2
+extern  enum clnt_stat enablelog4autoanswer_1();
+extern  bool_t enablelog4autoanswer_1_svc();
+#define DISABLELOG4AUTOANSWER 3
+extern  enum clnt_stat disablelog4autoanswer_1();
+extern  bool_t disablelog4autoanswer_1_svc();
+extern int sipprpcprog_1_freeresult ();
+#endif /* K&R C */
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern  bool_t xdr_callcounter (XDR *, callcounter*);
+extern  bool_t xdr_callcounter_t (XDR *, callcounter_t*);
+
+#else /* K&R C */
+extern bool_t xdr_callcounter ();
+extern bool_t xdr_callcounter_t ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_SIPP-RPC_H_RPCGEN */
diff --git a/rpc/sipp-rpc.x b/rpc/sipp-rpc.x
new file mode 100644
index 000000000..396bf9972
--- /dev/null
+++ b/rpc/sipp-rpc.x
@@ -0,0 +1,19 @@
+struct callcounter
+{
+    int      incomingcalls;
+    int      outgoingcalls;
+    int      successcalls;
+    int      failurecalls;
+};
+
+typedef struct callcounter callcounter_t;
+
+program SIPPRPCPROG
+{
+    version SIPPRPCVERS
+        {
+            callcounter_t GETCALLCOUNTER(callcounter_t)    = 1;
+            bool ENABLELOG4AUTOANSWER()    = 2;
+            bool DISABLELOG4AUTOANSWER()    = 3;
+        } = 1;
+} = 0x20000002;
diff --git a/rpc/sipp-rpc_client.c b/rpc/sipp-rpc_client.c
new file mode 100644
index 000000000..284af95bd
--- /dev/null
+++ b/rpc/sipp-rpc_client.c
@@ -0,0 +1,84 @@
+/*
+ * This is sample code generated by rpcgen.
+ * These are only templates and you can use them
+ * as a guideline for developing your own functions.
+ */
+
+#include "sipp-rpc.h"
+
+
+void
+sipprpcprog_1(char *command)
+{
+	char *host = "127.0.0.1";
+	CLIENT *clnt;
+	enum clnt_stat retval_1;
+	callcounter_t result_1;
+	callcounter_t  getcallcounter_1_arg;
+	enum clnt_stat retval_2;
+	bool_t result_2;
+	char *enablelog4autoanswer_1_arg;
+	enum clnt_stat retval_3;
+	bool_t result_3;
+	char *disablelog4autoanswer_1_arg;
+
+#ifndef	DEBUG
+	clnt = clnt_create (host, SIPPRPCPROG, SIPPRPCVERS, "udp");
+	if (clnt == NULL) {
+		clnt_pcreateerror (host);
+		exit (1);
+	}
+#endif	/* DEBUG */
+
+	if (strcmp(command,"get_callcount") ==0 ) {
+		retval_1 = getcallcounter_1(&getcallcounter_1_arg, &result_1, clnt);
+		if (retval_1 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Total incoming calls: %d\n",result_1.incomingcalls);
+			printf("Total outgoing calls: %d\n",result_1.outgoingcalls);
+			printf("Total success calls: %d\n",result_1.successcalls);
+			printf("Total failure calls: %d\n",result_1.failurecalls);
+		}
+	}
+	if (strcmp(command,"enable_log4aa") ==0 ) {
+		retval_2 = enablelog4autoanswer_1((void*)&enablelog4autoanswer_1_arg, &result_2, clnt);
+		if (retval_2 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Error log for auto response enabled.\n");
+		}
+	}
+	if (strcmp(command,"disable_log4aa") ==0 ) {
+		retval_3 = disablelog4autoanswer_1((void*)&disablelog4autoanswer_1_arg, &result_3, clnt);
+		if (retval_3 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Error log for auto response disabled.\n");
+		}
+	}
+#ifndef	DEBUG
+	clnt_destroy (clnt);
+#endif	 /* DEBUG */
+}
+
+
+int
+main (int argc, char *argv[])
+{
+	char *command;
+
+	if (argc < 2) {
+		printf ("usage: %s [get_callcount|enable_log4aa|disable_log4aa]\n", argv[0]);
+		exit (1);
+	}
+	command = argv[1];
+	if (strcmp(command,"get_callcount") != 0 &&
+	    strcmp(command,"enable_log4aa") != 0 &&
+	    strcmp(command,"disable_log4aa") != 0 ) {
+		printf ("usage: %s [get_callcount|enable_log4aa|disable_log4aa]\n", argv[0]);
+		exit (1);
+	}
+	sipprpcprog_1 (command);
+exit (0);
+}
diff --git a/rpc/sipp-rpc_clnt.c b/rpc/sipp-rpc_clnt.c
new file mode 100644
index 000000000..5342bf936
--- /dev/null
+++ b/rpc/sipp-rpc_clnt.c
@@ -0,0 +1,37 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <memory.h> /* for memset */
+#include "sipp-rpc.h"
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+enum clnt_stat 
+getcallcounter_1(callcounter_t *argp, callcounter_t *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, GETCALLCOUNTER,
+		(xdrproc_t) xdr_callcounter_t, (caddr_t) argp,
+		(xdrproc_t) xdr_callcounter_t, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+enablelog4autoanswer_1(void *argp, bool_t *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, ENABLELOG4AUTOANSWER,
+		(xdrproc_t) xdr_void, (caddr_t) argp,
+		(xdrproc_t) xdr_bool, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+disablelog4autoanswer_1(void *argp, bool_t *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, DISABLELOG4AUTOANSWER,
+		(xdrproc_t) xdr_void, (caddr_t) argp,
+		(xdrproc_t) xdr_bool, (caddr_t) clnt_res,
+		TIMEOUT));
+}
diff --git a/rpc/sipp-rpc_server.c b/rpc/sipp-rpc_server.c
new file mode 100644
index 000000000..9dbfd1914
--- /dev/null
+++ b/rpc/sipp-rpc_server.c
@@ -0,0 +1,55 @@
+/*
+ * This is sample code generated by rpcgen.
+ * These are only templates and you can use them
+ * as a guideline for developing your own functions.
+ */
+
+#include "sipp-rpc.h"
+
+bool_t
+getcallcounter_1_svc(callcounter_t *argp, callcounter_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+bool_t
+enablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+bool_t
+disablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+int
+sipprpcprog_1_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+	xdr_free (xdr_result, result);
+
+	/*
+	 * Insert additional freeing code here, if needed
+	 */
+
+	return 1;
+}
diff --git a/rpc/sipp-rpc_svc.c b/rpc/sipp-rpc_svc.c
new file mode 100644
index 000000000..40d136400
--- /dev/null
+++ b/rpc/sipp-rpc_svc.c
@@ -0,0 +1,111 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "sipp-rpc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <rpc/pmap_clnt.h>
+#include <string.h>
+#include <memory.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifndef SIG_PF
+#define SIG_PF void(*)(int)
+#endif
+
+static void
+sipprpcprog_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+	union {
+		callcounter_t getcallcounter_1_arg;
+	} argument;
+	union {
+		callcounter_t getcallcounter_1_res;
+		bool_t enablelog4autoanswer_1_res;
+		bool_t disablelog4autoanswer_1_res;
+	} result;
+	bool_t retval;
+	xdrproc_t _xdr_argument, _xdr_result;
+	bool_t (*local)(char *, void *, struct svc_req *);
+
+	switch (rqstp->rq_proc) {
+	case NULLPROC:
+		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+		return;
+
+	case GETCALLCOUNTER:
+		_xdr_argument = (xdrproc_t) xdr_callcounter_t;
+		_xdr_result = (xdrproc_t) xdr_callcounter_t;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))getcallcounter_1_svc;
+		break;
+
+	case ENABLELOG4AUTOANSWER:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_bool;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))enablelog4autoanswer_1_svc;
+		break;
+
+	case DISABLELOG4AUTOANSWER:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_bool;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))disablelog4autoanswer_1_svc;
+		break;
+
+	default:
+		svcerr_noproc (transp);
+		return;
+	}
+	memset ((char *)&argument, 0, sizeof (argument));
+	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+		svcerr_decode (transp);
+		return;
+	}
+	retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+	if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+		svcerr_systemerr (transp);
+	}
+	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+		fprintf (stderr, "%s", "unable to free arguments");
+		exit (1);
+	}
+	if (!sipprpcprog_1_freeresult (transp, _xdr_result, (caddr_t) &result))
+		fprintf (stderr, "%s", "unable to free results");
+
+	return;
+}
+
+int
+main (int argc, char **argv)
+{
+	register SVCXPRT *transp;
+
+	pmap_unset (SIPPRPCPROG, SIPPRPCVERS);
+
+	transp = svcudp_create(RPC_ANYSOCK);
+	if (transp == NULL) {
+		fprintf (stderr, "%s", "cannot create udp service.");
+		exit(1);
+	}
+	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_UDP)) {
+		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
+		exit(1);
+	}
+
+	transp = svctcp_create(RPC_ANYSOCK, 0, 0);
+	if (transp == NULL) {
+		fprintf (stderr, "%s", "cannot create tcp service.");
+		exit(1);
+	}
+	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_TCP)) {
+		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
+		exit(1);
+	}
+
+	svc_run ();
+	fprintf (stderr, "%s", "svc_run returned");
+	exit (1);
+	/* NOTREACHED */
+}
diff --git a/rpc/sipp-rpc_xdr.c b/rpc/sipp-rpc_xdr.c
new file mode 100644
index 000000000..9dd8e3835
--- /dev/null
+++ b/rpc/sipp-rpc_xdr.c
@@ -0,0 +1,71 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "sipp-rpc.h"
+
+bool_t
+xdr_callcounter (XDR *xdrs, callcounter *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->incomingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->outgoingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->successcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->failurecalls))
+				 return FALSE;
+		} else {
+			IXDR_PUT_LONG(buf, objp->incomingcalls);
+			IXDR_PUT_LONG(buf, objp->outgoingcalls);
+			IXDR_PUT_LONG(buf, objp->successcalls);
+			IXDR_PUT_LONG(buf, objp->failurecalls);
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->incomingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->outgoingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->successcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->failurecalls))
+				 return FALSE;
+		} else {
+			objp->incomingcalls = IXDR_GET_LONG(buf);
+			objp->outgoingcalls = IXDR_GET_LONG(buf);
+			objp->successcalls = IXDR_GET_LONG(buf);
+			objp->failurecalls = IXDR_GET_LONG(buf);
+		}
+	 return TRUE;
+	}
+
+	 if (!xdr_int (xdrs, &objp->incomingcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->outgoingcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->successcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->failurecalls))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_callcounter_t (XDR *xdrs, callcounter_t *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_callcounter (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 000000000..f68b0e39e
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,10 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * The settings file is used to specify which projects to include in your build.
+ *
+ * Detailed information about configuring a multi-project build in Gradle can be found
+ * in the user manual at https://docs.gradle.org/7.0.2/userguide/multi_project_builds.html
+ */
+
+rootProject.name = 'sipp'
diff --git a/src/apifunc.cpp b/src/apifunc.cpp
new file mode 100644
index 000000000..be01315fd
--- /dev/null
+++ b/src/apifunc.cpp
@@ -0,0 +1,303 @@
+/* Functions to handle loading/unloading .so files to replace certain functions in an API table
+ * Author: Nathan Franzmeier
+ * March 15, 2022
+ *  This provides a framework for adding a plugin which overrides the exec_command function in SIPP with new user defined functions 
+ *  that are implemented via the sipp plugin mechanism
+ *  The format of these new functions in the xml script is
+ *  <exec command="command@function  arg1 arg2 arg3 "  - up to 10 args
+ */
+
+#include "apifunc.h"
+#include "pthread.h"
+#include "defines.h"
+#include <cstring>
+#include <dlfcn.h>
+
+static pthread_mutex_t ApiFuncMutex = PTHREAD_MUTEX_INITIALIZER;
+
+
+API_FUNC_TABLE ApiHandler[MAXFUNCS][MAXAPPLICATIONS] = {
+    {(API_FUNC)customFunc,(char *)"custom1"},
+    {(API_FUNC)customFunc,(char *)"custom2"},
+    {(API_FUNC)customFunc,(char *)"custom3"},
+    {(API_FUNC)customFunc,(char *)"custom4"},
+    {(API_FUNC)customFunc,(char *)"custom5"},
+    {(API_FUNC)customFunc,(char *)"custom6"},
+    {(API_FUNC)customFunc,(char *)"custom7"},
+    {(API_FUNC)customFunc,(char *)"custom8"},
+    {(API_FUNC)customFunc,(char *)"custom9"},
+    {(API_FUNC)customFunc,(char *)"custom10"},
+    {(API_FUNC)NULL,(char *)NULL}
+};
+
+
+struct SAVEAPPDLL
+{
+    INT         index;
+    INT         appId;
+    BYTE        filename[80];
+    API_FUNC    currentApiFunc[MAXFUNCS];
+    API_FUNC    oldApiFunc[MAXFUNCS];
+    char *	oldApiCmd[MAXFUNCS];
+    char * 	currentCmd[MAXFUNCS];
+    void        (*unLoadFunc)(void);
+    void     *handle;
+};
+
+CUSTOMAPI      CustomApi[MAXCUSTOMAPPLICATIONS];  // Use this table to define any override functions
+
+static SAVEAPPDLL  *SaveApiDll;
+static INT CurrentApiIndex=0;
+static INT MyID = 1;
+INT MaxCustomApiTable=MAXCUSTOMAPPLICATIONS;
+
+// Call the generic handler at this index
+
+API_FUNC _ApiCustomFunc(int funcIndex, int app, char *data_str, void  *userVars, void *dispPtr) {
+
+    API_FUNC handler=NULL;
+
+    if(app < MAXAPPLICATIONS && app >=0)
+    {
+        pthread_mutex_lock(&ApiFuncMutex);
+        if(ApiHandler[funcIndex][app].funcPtr)
+            handler = ApiHandler[funcIndex][app].funcPtr;
+        else
+            handler = ApiHandler[funcIndex][0].funcPtr;
+        pthread_mutex_unlock(&ApiFuncMutex);
+        if (handler != NULL)
+           handler(app,data_str,userVars,dispPtr);
+    }
+    return EXIT_SUCCESS;
+}
+
+void setApiFunc(APIFUNCID funcId, API_FUNC handle, char *cmd, INT index)
+{
+    INT appId;
+
+    if(index < 0 || index >= MaxCustomApiTable)
+        index = CurrentApiIndex;
+
+    appId = SaveApiDll[index].appId;
+
+    if(appId >= 0 && appId < MAXAPPLICATIONS && funcId < API_MAX_FUNC_ID)
+    {
+        SaveApiDll[index].oldApiFunc[funcId] = ApiHandler[funcId][appId].funcPtr;
+        SaveApiDll[index].oldApiCmd[funcId] = ApiHandler[funcId][appId].cmdPtr;
+        pthread_mutex_lock(&ApiFuncMutex);
+        ApiHandler[funcId][appId].funcPtr = handle;
+        ApiHandler[funcId][appId].cmdPtr = cmd;
+        pthread_mutex_unlock(&ApiFuncMutex);
+        SaveApiDll[index].currentApiFunc[funcId] = handle;
+    }
+}
+
+API_FUNC getApiFunc (APIFUNCID funcId, char *cmd, INT appId)
+{
+    API_FUNC handler = NULL;
+    if(appId >= 0 && appId < MAXAPPLICATIONS && funcId < API_MAX_FUNC_ID)
+    {
+        pthread_mutex_lock(&ApiFuncMutex);
+        if (ApiHandler[funcId][appId].funcPtr !=  handler)
+           handler = ApiHandler[funcId][appId].funcPtr;
+        pthread_mutex_unlock(&ApiFuncMutex);
+    }
+    return handler;
+}
+
+void resetApiFunc(INT index)
+{
+    APIFUNCID funcId;
+    INT appId;
+
+    if(index < 0 || index >= MaxCustomApiTable)
+        index = CurrentApiIndex;
+
+    appId = SaveApiDll[index].appId;
+
+    if(appId >= 0 && appId < MAXAPPLICATIONS )
+    {
+        for(funcId = API_CUSTOM_FUNC_1; funcId < API_MAX_FUNC_ID;
+                funcId = APIFUNCID(funcId+1))
+        {
+            if(SaveApiDll[index].currentApiFunc[funcId])
+            {
+                pthread_mutex_lock(&ApiFuncMutex);
+                ApiHandler[funcId][appId].funcPtr = SaveApiDll[index].oldApiFunc[funcId];
+                ApiHandler[funcId][appId].cmdPtr = SaveApiDll[index].oldApiCmd[funcId];
+                pthread_mutex_unlock(&ApiFuncMutex);
+                SaveApiDll[index].currentApiFunc[funcId] = NULL;
+            }
+        }
+    }
+}
+INT saveDLLSetting(INT index,void *handle) {
+
+	SaveApiDll[index].index = index;
+	SaveApiDll[index].appId = CustomApi[index].appFlag;
+	SaveApiDll[index].handle = handle;
+        SaveApiDll[index].unLoadFunc = (VOID (*)(VOID))dlsym(SaveApiDll[index].handle, "appDllUnload");
+
+	return EXIT_SUCCESS;
+}
+
+INT loadApiDLL(INT index)
+{
+
+    VOID (*appDllInit)(INT index);
+
+    if(index >=0 && index < MaxCustomApiTable &&
+       (CustomApi[index].instanceId == MyID || CustomApi[index].instanceId == 0) )
+    {
+        if(strlen((const char *)CustomApi[index].filename) > 0)
+        {
+            if(SaveApiDll[index].handle)
+            {
+                ERROR( "Error: Custom APP %d (%s) already loaded.\n", index, SaveApiDll[index].filename);
+            }
+            else
+            {
+                SaveApiDll[index].index = index;
+                SaveApiDll[index].appId = CustomApi[index].appFlag;
+                strcpy((char *)SaveApiDll[index].filename, (const char *)CustomApi[index].filename);
+                CurrentApiIndex = index;
+                SaveApiDll[index].handle = dlopen(((const char *)SaveApiDll[index].filename), RTLD_NOW);
+                if(SaveApiDll[index].handle == NULL)
+                {
+                    ERROR( "Error: Failed to create handle - Custom APP %d (%s).\n", index, SaveApiDll[index].filename);
+                    return EXIT_FAILURE;
+                }
+                else
+                {
+                    appDllInit = (VOID (*)(const INT))dlsym(SaveApiDll[index].handle, "appDllLoad");
+		    const char* err = dlerror();
+                    if(err)
+                    {
+                        ERROR( "Error: Unable to find 'appDllLoad' function for Custom APP %d (%s).\n", index, SaveApiDll[index].filename);
+                        return EXIT_FAILURE;
+                    }
+
+                    SaveApiDll[index].unLoadFunc = (VOID (*)(VOID))dlsym(SaveApiDll[index].handle, "appDllUnload");
+
+                    (*appDllInit)(index);
+                }
+            }
+        }
+        else
+        {
+            ERROR( "Error: Custom APP %d name empty(%s).\n", index, CustomApi[index].filename);
+            return EXIT_FAILURE;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+INT reloadApiDll(INT index)
+{
+    INT ret = EXIT_SUCCESS;
+    SAVEAPPDLL tempSaveDLL;
+    APIFUNCID funcId;
+    INT         appId;
+
+    /// save the dll ptrs first, then load new ones, then delete
+    if(SaveApiDll[index].handle)
+    {
+        ERROR( "save DLL index %d name %s\n", index, SaveApiDll[index].filename);
+        memcpy(&tempSaveDLL, &SaveApiDll[index], sizeof(SAVEAPPDLL));
+        SaveApiDll[index].handle = NULL;
+        SaveApiDll[index].filename[0] = 0;
+        SaveApiDll[index].appId = 0;
+
+        ret = loadApiDLL(index);
+        if(ret != EXIT_SUCCESS)
+        {
+            ERROR( "reload DLL Failed: index %d name %s, rollback to previous one\n", index, SaveApiDll[index].filename);
+            memcpy(&SaveApiDll[index], &tempSaveDLL, sizeof(SAVEAPPDLL));
+        }
+        else /// load new one succeeded, delete old ones
+        {
+            ERROR( "delete old DLL index %d name %s\n", index, SaveApiDll[index].filename);
+
+            appId = tempSaveDLL.appId;
+
+            if(appId >= 0 && appId < MAXAPPLICATIONS )
+            {
+                for(funcId = API_CUSTOM_FUNC_1; funcId < API_MAX_FUNC_ID;
+                        funcId = APIFUNCID(funcId+1))
+                {
+                    if(tempSaveDLL.currentApiFunc[funcId] && SaveApiDll[index].currentApiFunc[funcId] == NULL) /// no more needed
+                    {
+                        pthread_mutex_lock(&ApiFuncMutex);
+                        ApiHandler[funcId][appId].funcPtr = tempSaveDLL.oldApiFunc[funcId];
+                        ApiHandler[funcId][appId].cmdPtr = tempSaveDLL.oldApiCmd[funcId];
+                        pthread_mutex_unlock(&ApiFuncMutex);
+                    }
+                }
+
+            }
+        }
+    }
+    else /// last time failed to load
+    {
+        /// just load it
+        ret = loadApiDLL(index);
+    }
+
+    ERROR( "reload DLL index %d name %s finished %d\n", index, SaveApiDll[index].filename, ret);
+    return ret;
+}
+
+INT unloadApiDll(INT index)
+{
+    INT ret = EXIT_SUCCESS;
+
+    if(SaveApiDll[index].handle)
+    {
+        CurrentApiIndex = index;
+        resetApiFunc(index);
+
+        if(SaveApiDll[index].unLoadFunc)
+        {
+           (*SaveApiDll[index].unLoadFunc)();
+        }
+
+       dlclose(SaveApiDll[index].handle);
+       SaveApiDll[index].handle = NULL;
+       ERROR( "Unloaded index %d name %s\n", index, SaveApiDll[index].filename);
+       SaveApiDll[index].filename[0] = 0;
+       SaveApiDll[index].appId = 0;
+    }
+    else
+    {
+       ERROR( "Error: appId or name mismatch for Custom APP %d(%s).\n", index, SaveApiDll[index].filename);
+       ret = EXIT_FAILURE;
+    }
+    return ret;
+}
+
+
+INT loadCustomApis(VOID)
+{
+    initSaveApi();
+    for(INT i=0; i<MaxCustomApiTable; i++)
+    {
+       if( (CustomApi[i].instanceId == MyID || CustomApi[i].instanceId == 0))
+           loadApiDLL(i);
+    }
+
+    return EXIT_SUCCESS;
+}
+
+INT initSaveApi() {
+
+    SaveApiDll = new SAVEAPPDLL [MaxCustomApiTable];
+
+    if(SaveApiDll == NULL)
+        return EXIT_FAILURE;
+
+    memset(SaveApiDll, 0, sizeof(SAVEAPPDLL)*MaxCustomApiTable);
+
+    return EXIT_SUCCESS;
+
+}
diff --git a/src/apifunc.h b/src/apifunc.h
new file mode 100644
index 000000000..26ad86b3f
--- /dev/null
+++ b/src/apifunc.h
@@ -0,0 +1,68 @@
+/*
+ *  Definitions for setting up an API table to override functionality of the exec command with our own commands so we can add to sipp functionality 
+ *  for things like adding lua scripts which can both read and write sipp variables, execute C calls etc.  and in general influence the script execution
+ */
+extern "C" {
+#define MAXAPPLICATIONS 2
+#define MAXCUSTOMAPPLICATIONS 1
+enum APIFUNCID
+{
+        API_CUSTOM_FUNC_1,
+        API_CUSTOM_FUNC_2,
+        API_CUSTOM_FUNC_3,
+        API_CUSTOM_FUNC_4,
+        API_CUSTOM_FUNC_5,
+        API_CUSTOM_FUNC_6,
+        API_CUSTOM_FUNC_7,
+        API_CUSTOM_FUNC_8,
+        API_CUSTOM_FUNC_9,
+        API_CUSTOM_FUNC_10,
+        API_MAX_FUNC_ID
+};
+
+#define INT int
+#define VOID void
+#define BYTE unsigned char
+#define WORD short
+#define MAXFUNCS (API_MAX_FUNC_ID+1)
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS            0
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE            1
+#endif
+
+typedef INT (*API_FUNC)(...);
+
+
+typedef struct S_API_FUNC_TABLE {
+	API_FUNC	funcPtr;
+	char    *cmdPtr;
+	
+} API_FUNC_TABLE;
+
+typedef struct S_CUSTOMAPI
+{
+    INT index;
+    BYTE appFlag;      
+    BYTE subsystem;   
+    WORD instanceId; 
+    BYTE filename[80];
+} CUSTOMAPI;
+
+extern CUSTOMAPI        CustomApi[MAXCUSTOMAPPLICATIONS];
+extern INT              MaxCustomApiTable;
+
+extern API_FUNC_TABLE ApiHandler[MAXFUNCS][MAXAPPLICATIONS];
+
+// Functions to get/set the functions in the API table
+API_FUNC _ApiCustomFunc(int func, int app, char *data_str, void *userVars, void *dispPtr);
+API_FUNC  customFunc(int app, char *data_str, void *userVars, void *dispPtr);
+INT initSaveApi();
+INT saveDLLSetting(INT index,void *handle);
+void setApiFunc(APIFUNCID funcId, API_FUNC handle, char *cmd, INT index);
+API_FUNC getAppFunc(APIFUNCID funcId, INT appId);
+void resetAppFunc(INT appId);
+}
+
+
diff --git a/src/call.cpp b/src/call.cpp
index 300494be3..af772b2d2 100644
--- a/src/call.cpp
+++ b/src/call.cpp
@@ -36,18 +36,35 @@
  *           Roland Meub
  *           Andy Aicken
  *           Martin H. VanLeeuwen
+ * 	      4/25/19 - NVF Added code to allow longer arguments and more arguments - see MAXARGS, also added support for a rawdata tag which will take all the remaining command line and pass it as a value to the lua program
+ * 	      3/16/22 - NVF Restructured the code so we can add the extra functionality using the built-in plugin capability with some extra code to allow plugins to 
+ * 	      add extra sipp functionality via the exec command by interpreting the commands before running the default executor - this allows adding things like threading, lua scripting etc.
+ *	
  */
 
+#include <iterator>
 #include <algorithm>
-#include <cstring>
 #include <fstream>
 #include <iostream>
-#include <iterator>
-#include <sstream>
-#include <vector>
+#include <cstring>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <assert.h>
+// Added for LUA support
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+// Added for shared memory support
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <malloc.h>
+
+
+#include <inttypes.h>
+#include <errno.h>
 
 #ifdef PCAPPLAY
 #include "send_packets.h"
@@ -57,46 +74,18 @@
 #include "deadcall.hpp"
 #include "config.h"
 #include "version.h"
+#include "apifunc.h"
 
-template<typename Out>
-void split(const std::string &s, char delim, Out result) {
-    std::stringstream ss;
-    ss.str(s);
-    std::string item;
-    while (std::getline(ss, item, delim)) {
-        *(result++) = item;
-    }
-}
-
-std::vector<std::string> split(const std::string &s, char delim) {
-    std::vector<std::string> elems;
-    split(s, delim, std::back_inserter(elems));
-    return elems;
-}
-
-std::string join(const std::vector<std::string> &s, const char* delim) {
-    std::ostringstream imploded;
-    std::copy(s.begin(), s.end(), std::ostream_iterator<std::string>(imploded, delim));
-    std::string ret = imploded.str();
-    if (ret.length()) {
-        ret.resize(ret.length() - strlen(delim));
-    }
-    return ret;
-}
-
-std::string trim(const std::string &s) {
-    size_t first = s.find_first_not_of(' ');
-    if (first == string::npos) {
-        return s;
-    }
-    size_t last = s.find_last_not_of(' ');
-    return s.substr(first, (last - first + 1));
-}
+// 02/9/2022 - NVF Added when trying to fix mysql thread support
+#include "mysql.h"
 
 #define callDebug(...) do { if (useCallDebugf) { _callDebug( __VA_ARGS__ ); } } while (0)
 
+using namespace std;
+
 extern  map<string, struct sipp_socket *>     map_perip_fd;
 
+
 #ifdef PCAPPLAY
 /* send_packets pthread wrapper */
 void *send_wrapper(void *);
@@ -105,7 +94,6 @@ int call::dynamicId       = 0;
 int call::maxDynamicId    = 10000+2000*4;      // FIXME both param to be in command line !!!!
 int call::startDynamicId  = 10000;             // FIXME both param to be in command line !!!!
 int call::stepDynamicId   = 4;                // FIXME both param to be in command line !!!!
-
 /************** Call map and management routines **************/
 static unsigned int next_number = 1;
 
@@ -459,16 +447,16 @@ unsigned long call::hash(const char * msg)
     } else if (rtcheck == RTCHECK_LOOSE) {
         /* Based on section 11.5 (bullet 2) of RFC2543 we only take into account
          * the To, From, Call-ID, and CSeq values. */
-        const char *hdr = get_header_content(msg, "To:");
+        const char *hdr = get_header_content(msg,"To:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
-        hdr = get_header_content(msg, "From:");
+        hdr = get_header_content(msg,"From:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
-        hdr = get_header_content(msg, "Call-ID:");
+        hdr = get_header_content(msg,"Call-ID:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
-        hdr = get_header_content(msg, "CSeq:");
+        hdr = get_header_content(msg,"CSeq:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
         /* For responses, we should also consider the code and body (if any),
@@ -729,12 +717,30 @@ void call::init(scenario * call_scenario, struct sipp_socket *socket, struct soc
             tdm_map_number = 0;
         }
     }
+  // Added LUA setup here
+
+/*
+     if (!L) {
+     	L = luaL_newstate();                        // Create Lua state variable 
+     	luaL_openlibs(L);                           // Load Lua libraries 
+
+     	if (luaL_loadfile(L, "sipp.lua")) // Load but don't run the Lua script 
+         bail(L, "luaL_loadfile() failed");      // Error out if file can't be read 
+
+     	if (lua_pcall(L, 0, 0, 0))                  // PRIMING RUN. FORGET THIS AND YOU'RE TOAST 
+         bail(L, "lua_pcall() failed");          // Error out if Lua file has an error 
+    }
+*/
+	
+
 
     callDebug("Starting call %s\n", id);
 
     setRunning();
 }
 
+
+
 int call::_callDebug(const char *fmt, ...)
 {
     va_list ap;
@@ -794,21 +800,21 @@ call::~call()
         free(transactions);
     }
 
-    if (last_recv_msg) {
+    if(last_recv_msg) {
         free(last_recv_msg);
     }
-    if (last_send_msg) {
+    if(last_send_msg) {
         free(last_send_msg);
     }
-    if (peer_tag) {
+    if(peer_tag) {
         free(peer_tag);
     }
 
-    if (dialog_route_set) {
+    if(dialog_route_set) {
         free(dialog_route_set);
     }
 
-    if (next_req_url) {
+    if(next_req_url) {
         free(next_req_url);
     }
 
@@ -816,7 +822,7 @@ call::~call()
   rtpstream_end_call (&rtpstream_callinfo);
 #endif
 
-    if (dialog_authentication) {
+    if(dialog_authentication) {
         free(dialog_authentication);
     }
 
@@ -2750,7 +2756,7 @@ bool call::check_peer_src(char * msg, int search_index)
 }
 
 
-void call::extract_cseq_method(char* method, char* msg)
+void call::extract_cseq_method (char* method, char* msg)
 {
     char* cseq ;
     if ((cseq = strstr (msg, "CSeq"))) {
@@ -2773,7 +2779,7 @@ void call::extract_cseq_method(char* method, char* msg)
     }
 }
 
-void call::extract_transaction(char* txn, char* msg)
+void call::extract_transaction (char* txn, char* msg)
 {
     char *via = get_header_content(msg, "via:");
     if (!via) {
@@ -2816,68 +2822,94 @@ void call::formatNextReqUrl(const char* contact)
 
 void call::computeRouteSetAndRemoteTargetUri(const char* rr, const char* contact, bool bRequestIncoming)
 {
-    if (!*contact) {
-        WARNING("Cannot record route set if there is no Contact\n");
-        return;
-    }
-
     if (!*rr) {
-        /* There are no RR headers. Simply set up the contact as our
-         * target uri.  Note that this is only called if there was no
-         * dialog_route_set at the moment.  And in either case, we
-         * wouldn't want to clear the dialog_route_set because changing
-         * RR mid-dialog is not allowed. */
-        formatNextReqUrl(contact);
+        //
+        // there are no RR headers. Simply set up the contact as our target uri
+        //
+        if (*contact) {
+            formatNextReqUrl(contact);
+        }
         return;
     }
 
-    std::vector<std::string> headers = split(rr, ',');
-    std::vector<std::string>::iterator it;
-    std::vector<std::string>::iterator end;
-    int direction;
+    char tmp_rr[MAX_HEADER_LEN];
+    char actual_rr[MAX_HEADER_LEN];
+    char targetURI[MAX_HEADER_LEN];
 
-    if (bRequestIncoming) {
-        it = headers.begin();
-        end = headers.end();
-        direction = 1;
-    } else {
-        it = headers.end() - 1;
-        end = headers.begin() - 1;
-        direction = -1;
-    }
+    actual_rr[0] = tmp_rr[0] = targetURI[0] = '\0';
+    strncat(tmp_rr, rr, MAX_HEADER_LEN - 1);
 
-    std::vector<std::string> routes;
-    std::string targetUri;
-    bool first = true;
+    bool isFirst = true;
+    bool bCopyContactToRR = false;
 
-    for (; it != end; it += direction) {
-        const std::string& header = *it;
+    while (1) {
+        char* pointer = NULL;
+        if (bRequestIncoming) {
+            pointer = strchr(tmp_rr, ',');
+        } else {
+            pointer = strrchr(tmp_rr, ',');
+        }
 
-        if (first && header.find(";lr") == std::string::npos) {
-            /* If the next hop is a static router, set target URI to
-             * that router. We'll push the original contact onto the end
-             * of the route set. We won't need to record this route,
-             * because we've set the target to it. */
-            targetUri = header;
+        if (pointer) {
+            if (!isFirst) {
+                strcat(actual_rr, pointer + 1);
+                strcat(actual_rr, ",");
+            } else {
+                isFirst = false;
+                if (NULL == strstr(pointer, ";lr")) {
+                    /* bottom most RR is the next_req_url */
+                    strncpy(targetURI, pointer + 1, sizeof(targetURI) - 1);
+                    bCopyContactToRR = true;
+                } else {
+                    /* the hop is a loose router. Thus, the target URI should be the
+                     * contact
+                     */
+                    strcpy(targetURI, contact);
+                    strcpy(actual_rr, pointer + 1);
+                    strcat(actual_rr, ",");
+                }
+            }
         } else {
-            first = false;
-            routes.push_back(trim(header));
+            if (!isFirst) {
+                strcat(actual_rr, tmp_rr);
+            }
+            //
+            // this is the *only* RR header that was found
+            //
+            else {
+                if (NULL == strstr(tmp_rr, ";lr")) {
+                    /* bottom most RR is the next_req_url */
+                    strcpy(targetURI, tmp_rr);
+                    bCopyContactToRR = true;
+                } else {
+                    /* the hop is a loose router. Thus, the target URI should be the
+                     * contact
+                     */
+                    strcpy(actual_rr, tmp_rr);
+                    strcpy(targetURI, contact);
+                }
+            }
+            break;
         }
+        *pointer = '\0';
     }
 
-    /* If target URI is set, the first hop is a strict router.  Add the
-     * Contact as tailing route. */
-    if (targetUri.length()) {
-        routes.push_back(trim(contact));
-    } else {
-        targetUri = contact;
+    if (bCopyContactToRR) {
+        if (*actual_rr) {
+            strcat(actual_rr, ",");
+            strcat(actual_rr, contact);
+        } else {
+            strcpy(actual_rr, contact);
+        }
     }
 
-    if (routes.size()) {
-        dialog_route_set = strdup(join(routes, ", ").c_str());
+    if (*actual_rr) {
+        dialog_route_set = strdup(actual_rr);
     }
 
-    formatNextReqUrl(targetUri.c_str());
+    if (*targetURI) {
+        formatNextReqUrl(targetURI);
+    }
 }
 
 bool call::matches_scenario(unsigned int index, int reply_code, char * request, char * responsecseqmethod, char *txn)
@@ -3307,8 +3339,8 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
     }
 
     /* store the route set only once. TODO: does not support target refreshes!! */
-    if (call_scenario->messages[search_index]->bShouldRecordRoutes &&
-            dialog_route_set == NULL) {
+    if (call_scenario->messages[search_index] -> bShouldRecordRoutes &&
+            NULL == dialog_route_set) {
         realloc_ptr = (char*)realloc(next_req_url, MAX_HEADER_LEN);
         if (realloc_ptr) {
             next_req_url = realloc_ptr;
@@ -3829,7 +3861,36 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
             ERROR("%s", x);
         } else if (currentAction->getActionType() == CAction::E_AT_EXECUTE_CMD) {
             char* x = createSendingMessage(currentAction->getMessage(), -2 /* do not add crlf*/);
-            // TRACE_MSG("Trying to execute [%s]", x);
+            TRACE_MSG("Trying to execute [%s]", x);
+
+		// Find out what command we're doing	
+		std::string str = x;
+		std::string delimiter = "@";
+		int end = str.find(delimiter);
+		std::string command = str.substr(0, end);		
+		std::string data = str.substr(end+1);
+		char data_str[4096];
+		memset(data_str,0,sizeof(data_str));
+		strcpy(data_str,data.c_str());
+
+	  // Process possible commands that override the default functionality:   format is command@<file.lua>
+	  //	custom calls - user defined
+	  //	<exec command="command@<argstring>  where argstring is a list of args sent to command.
+	  //	if we don't find anything - do a system call - default sipp behavior
+	  //	We pass in pointers to the call variables and the current scenario to allow manipulation of sipp variables
+	  //	These should be initialized in a plugin
+	
+	  int found = false;
+	  for (int i=0;(i<MAXFUNCS && !found);i++) {
+	  	if (command.compare(ApiHandler[i][0].cmdPtr)==0) {  // Check if this command matches any we've setup
+			found = true;
+			_ApiCustomFunc(i,0,data_str,(void *)M_callVariableTable,display_scenario);
+		}
+	  }
+	  if (!found) {
+
+	    // Execute a system call with the command passed in - default SIPP behavior
+
             pid_t l_pid;
             switch(l_pid = fork()) {
             case -1:
@@ -3859,10 +3920,11 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 while ((ret=waitpid(l_pid, NULL, 0)) != l_pid) {
                     if (ret != -1) {
                         ERROR("waitpid returns %1d for child %1d",ret,l_pid);
-                    }
-                }
-                break;
-            }
+                   	}
+               	 }
+               	 break;
+            	}
+	   }
         } else if (currentAction->getActionType() == CAction::E_AT_EXEC_INTCMD) {
             switch (currentAction->getIntCmd()) {
             case CAction::E_INTCMD_STOP_ALL:
@@ -3937,6 +3999,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
     return(call::E_AR_NO_ERROR);
 }
 
+
 void call::extractSubMessage(char * msg, char * matchingString, char* result, bool case_indep, int occurrence, bool headers)
 {
 
@@ -4202,8 +4265,10 @@ bool call::automaticResponseMode(T_AutoMode P_case, char * P_recv)
 
         strcpy(last_recv_msg, P_recv);
 
-        WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
-                (id == NULL) ? "none" : id);
+	if (log4auto_answer) {
+        	WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
+			(id == NULL) ? "none" : id);
+	}
         sendBuffer(createSendingMessage(get_default_message("200"), -1));
 
         // restore previous last msg
@@ -4225,6 +4290,7 @@ bool call::automaticResponseMode(T_AutoMode P_case, char * P_recv)
             }
         }
         CStat::globalStat(CStat::E_AUTO_ANSWERED);
+	delete this;  // 2/16/2022 - NVF Added this for auto response messages as it looked like it wasn't being done otherwise - resulting in a memory leak
         return true;
         break;
 
diff --git a/src/customfuncs.cpp b/src/customfuncs.cpp
new file mode 100644
index 000000000..47625b3d5
--- /dev/null
+++ b/src/customfuncs.cpp
@@ -0,0 +1,18 @@
+/* 
+ * This is a stub function that serves as a placeholder for any plugins that might be added
+ *
+ */
+
+#include <iterator>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <cstring>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <assert.h>
+#include "apifunc.h"
+
+
+
+API_FUNC  customFunc(int app, char *data_str, void *userVars, void *dispPtr){return EXIT_SUCCESS;}
diff --git a/src/deadcall.cpp b/src/deadcall.cpp
index a540bc0d4..24d41c226 100644
--- a/src/deadcall.cpp
+++ b/src/deadcall.cpp
@@ -42,6 +42,9 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
+#ifdef PCAPPLAY
+#include "send_packets.h"
+#endif
 #include "sipp.hpp"
 #include "deadcall.hpp"
 #include "assert.h"
diff --git a/src/logger.cpp b/src/logger.cpp
index 98d36d501..6f632aefb 100644
--- a/src/logger.cpp
+++ b/src/logger.cpp
@@ -297,10 +297,12 @@ void print_statistics(int last)
 void log_off(struct logfile_info *lfi)
 {
     if (lfi->fptr) {
+	pthread_mutex_lock(lfi->lockfile);
         fflush(lfi->fptr);
         fclose(lfi->fptr);
         lfi->fptr = NULL;
         lfi->overwrite = false;
+	pthread_mutex_unlock(lfi->lockfile);
     }
 }
 
@@ -827,6 +829,7 @@ void print_screens(void)
     int oldScreen = currentScreenToDisplay;
     int oldRepartition = currentRepartitionToDisplay;
 
+    pthread_mutex_lock(screen_lfi.lockfile);
     currentScreenToDisplay = DISPLAY_SCENARIO_SCREEN;
     print_header_line(   screen_lfi.fptr);
     print_stats_in_file( screen_lfi.fptr);
@@ -848,6 +851,7 @@ void print_screens(void)
         display_scenario->stats->displayRtdRepartition(screen_lfi.fptr, currentRepartitionToDisplay);
         print_bottom_line(   screen_lfi.fptr, NOTLAST);
     }
+    pthread_mutex_unlock(screen_lfi.lockfile);
 
     currentScreenToDisplay = oldScreen;
     currentRepartitionToDisplay = oldRepartition;
@@ -856,6 +860,21 @@ void print_screens(void)
 static void rotatef(struct logfile_info* lfi)
 {
     char L_rotate_file_name [MAX_PATH];
+    struct tm *tim;
+    struct timeval nowx;
+    char time_str[64];
+    time_t now;
+
+	gettimeofday(&nowx, NULL);
+	now = nowx.tv_sec;
+	tim = gmtime(&now);
+	sprintf(time_str, "%04d%02d%02d%02d%02d%02d",
+			tim->tm_year + 1900,
+			tim->tm_mon + 1,
+			tim->tm_mday,
+			tim->tm_hour,
+			tim->tm_min,
+			tim->tm_sec);
 
     if (!lfi->fixedname) {
         sprintf (lfi->file_name, "%s_%d_%s.log", scenario_file, getpid(), lfi->name);
@@ -867,6 +886,7 @@ static void rotatef(struct logfile_info* lfi)
         }
         /* We need to rotate away an existing file. */
         if (lfi->nfiles == ringbuffer_files) {
+/*
             if ((lfi->ftimes)[0].n) {
                 sprintf(L_rotate_file_name, "%s_%d_%s_%lu.%d.log",
                         scenario_file, getpid(), lfi->name,
@@ -877,6 +897,10 @@ static void rotatef(struct logfile_info* lfi)
                         scenario_file, getpid(), lfi->name,
                         (unsigned long)(lfi->ftimes)[0].start);
             }
+HYDE
+*/
+
+sprintf(L_rotate_file_name, "%s_%s",lfi->file_name,time_str);
             unlink(L_rotate_file_name);
             lfi->nfiles--;
             memmove(lfi->ftimes, &((lfi->ftimes)[1]), sizeof(struct logfile_id) * (lfi->nfiles));
@@ -888,6 +912,7 @@ static void rotatef(struct logfile_info* lfi)
             if (lfi->nfiles && ((lfi->ftimes)[lfi->nfiles].start == (lfi->ftimes)[lfi->nfiles - 1].start)) {
                 (lfi->ftimes)[lfi->nfiles].n = (lfi->ftimes)[lfi->nfiles - 1].n + 1;
             }
+/*
             if ((lfi->ftimes)[lfi->nfiles].n) {
                 sprintf(L_rotate_file_name, "%s_%d_%s_%lu.%d.log",
                         scenario_file, getpid(), lfi->name,
@@ -898,6 +923,10 @@ static void rotatef(struct logfile_info* lfi)
                         scenario_file, getpid(), lfi->name,
                         (unsigned long)(lfi->ftimes)[lfi->nfiles].start);
             }
+*/
+
+//sprintf(L_rotate_file_name, "%s_%d",lfi->file_name,(unsigned long)(lfi->ftimes)[lfi->nfiles].start);
+sprintf(L_rotate_file_name, "%s_%s",lfi->file_name,time_str);
             lfi->nfiles++;
             fflush(lfi->fptr);
             fclose(lfi->fptr);
@@ -921,37 +950,54 @@ static void rotatef(struct logfile_info* lfi)
 
 void rotate_screenf()
 {
+    pthread_mutex_lock(screen_lfi.lockfile);
     rotatef(&screen_lfi);
+    pthread_mutex_unlock(screen_lfi.lockfile);
 }
 
 void rotate_calldebugf()
 {
+    pthread_mutex_lock(calldebug_lfi.lockfile);
     rotatef(&calldebug_lfi);
+    pthread_mutex_unlock(calldebug_lfi.lockfile);
 }
 
 void rotate_messagef()
 {
+    pthread_mutex_lock(message_lfi.lockfile);
     rotatef(&message_lfi);
+    pthread_mutex_unlock(message_lfi.lockfile);
 }
 
 
 void rotate_shortmessagef()
 {
+    pthread_mutex_lock(shortmessage_lfi.lockfile);
     rotatef(&shortmessage_lfi);
+    pthread_mutex_unlock(shortmessage_lfi.lockfile);
 }
 
 
 void rotate_logfile()
 {
+    pthread_mutex_lock(log_lfi.lockfile);
     rotatef(&log_lfi);
+    pthread_mutex_unlock(log_lfi.lockfile);
 }
 
 void rotate_errorf()
 {
+    pthread_mutex_lock(error_lfi.lockfile);
     rotatef(&error_lfi);
+    pthread_mutex_unlock(error_lfi.lockfile);
     strcpy(screen_logfile, error_lfi.file_name);
 }
 
+void rotate_errorf_nolock()
+{
+    rotatef(&error_lfi);
+    strcpy(screen_logfile, error_lfi.file_name);
+}
 
 /*#ifdef __cplusplus
 extern "C" {
@@ -962,6 +1008,7 @@ extern "C" {
     {
         int ret = 0;
         if(lfi->fptr) {
+            pthread_mutex_lock(lfi->lockfile);
             ret = vfprintf(lfi->fptr, fmt, ap);
             fflush(lfi->fptr);
 
@@ -976,6 +1023,7 @@ extern "C" {
                 rotatef(lfi);
                 lfi->count = 0;
             }
+            pthread_mutex_unlock(lfi->lockfile);
         }
         return ret;
     }
diff --git a/src/myapp.cpp b/src/myapp.cpp
new file mode 100644
index 000000000..6ee4bfb6e
--- /dev/null
+++ b/src/myapp.cpp
@@ -0,0 +1,517 @@
+/* 
+ * Description: Custom modifications to support running LUA inside of a sipp test script, sending values to lua from sipp
+ * and returning values to local sipp variables
+ *
+ * Author: Nathan Franzmeier Sky Networks LLC 2022
+ * Mail: Nathan.Franzmeier@sky-networks.com
+ *
+ */
+
+#include <iterator>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <cstring>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <assert.h>
+// Added for LUA support
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+// Added for shared memory support
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <malloc.h>
+
+
+#include <inttypes.h>
+#include <errno.h>
+
+#ifdef PCAPPLAY
+#include "send_packets.h"
+#endif
+#include "sipp.hpp"
+#include "auth.hpp"
+#include "deadcall.hpp"
+#include "config.h"
+#include "version.h"
+#include "apifunc.h"
+
+// 02/9/2022 - NVF Added when trying to fix mysql thread support
+#include "mysql.h"
+
+#define callDebug(...) do { if (useCallDebugf) { _callDebug( __VA_ARGS__ ); } } while (0)
+
+using namespace std;
+
+#define USE_PTHREADS 1
+// Added for thread support
+#if USE_PTHREADS == 0
+	#include <thread>
+#endif
+#define MAXARGS 50 // Most argument pairs that can be passed into a lua script
+extern  map<string, struct sipp_socket *>     map_perip_fd;
+typedef struct tag_value {
+	char tag[80];
+	char value[2048];
+
+}TAG_VAL;
+
+typedef struct tv_array {
+
+	int count;
+	bool useThread;
+	bool dataIsReady;  // Flag indicating data has been set
+#if USE_PTHREADS == 1
+	pthread_t  myThread;
+#else
+	std::thread myThread;
+#endif
+	TAG_VAL	element[MAXARGS];
+
+} TV_ARRAY;
+
+
+void bail(lua_State *L, char *msg){
+        WARNING( "\nLUA ERROR:\n  %s: %s\n\n",
+                msg, lua_tostring(L, -1));
+}
+typedef struct thread_data {
+	char data_str[4096];
+	char name[256]; // shared memory name
+	int fd;
+	lua_State *L;
+
+} THREAD_DATA;
+
+void do_lua_thread(THREAD_DATA *thread_data);
+void do_lua_thread_detached(THREAD_DATA *thread_data); 
+
+lua_State*  openLua() {
+
+
+#ifndef USE_GLOBAL_LUA
+        lua_State *L = luaL_newstate();
+#else
+        if (L) return L;
+
+        L = luaL_newstate();                        // Create Global Lua state variable
+#endif
+        if (L) {
+
+                luaL_openlibs(L);                           /* Load Lua libraries */
+
+                //HYDE if (luaL_loadfile(L, "sipp.lua")) /* Load but don't run the Lua script */
+                if (luaL_loadfile(L, lua_file)) /* Load but don't run the Lua script */
+                {
+                        bail(L, "luaL_loadfile() failed");      /* Error out if file can't be read */
+                        L=0;
+                } else{
+
+                        if (lua_pcall(L, 0, 0, 0))                  /* PRIMING RUN. FORGET THIS AND YOU'RE TOAST */
+                        {
+                                bail(L, "lua_pcall1() failed");          /* Error out if Lua file has an error */
+                                L=0;
+                        }
+                }
+        }
+   return L;
+}
+
+API_FUNC  customFunc(int app, char *data_str, void *userVars, void *dispPtr){ return EXIT_SUCCESS;}
+API_FUNC  processLuaRun(int app, char *data_str, void *tblPtr, void *dispPtr){
+			VariableTable *userVars = (VariableTable *)tblPtr;
+			scenario *display_scenario = (scenario *)dispPtr;
+			char tmp[80];
+			char *fname;
+			char *name;
+			int msize = sizeof(TV_ARRAY);
+			TV_ARRAY *shared_memory;
+ 			fname  = strdup(tmpnam(tmp));
+			name = strdup(basename(fname));
+			free(fname);
+
+	    		// Allocate some shared memory to pass the variables later after this executes
+			TRACE_MSG("Opening shared memory for [%s] - data:(%s)",name,data_str);
+	        	int shm_fd = shm_open (name, O_CREAT | O_EXCL | O_RDWR, S_IRWXU | S_IRWXG);
+    			if (shm_fd < 0) 
+    			{
+        			WARNING("Error in shm_open(%s)",name);
+				goto fail;
+    			}
+    			ftruncate(shm_fd, msize);
+			
+    			TRACE_MSG("Created shared memory object %s\n", name);
+			
+			
+    			// attach the shared memory segment
+    			shared_memory = (TV_ARRAY *) mmap(NULL, msize, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
+    			if (shared_memory == MAP_FAILED) 
+    			{
+        			WARNING("Error 1 in mmap()");
+				goto fail;
+    			}
+		
+    			TRACE_MSG("Shared memory segment allocated correctly (%d bytes).\n", msize);
+			// Save off the shared memory segment name for now so we can get it later - pass this back to the sipp script
+			shared_memory->count = 0;
+			shared_memory->dataIsReady = 0;
+			strcpy(shared_memory->element[shared_memory->count].tag,"retkey"); // This is a magic variable name which is used by the script to get our values back with a luaread@retkey
+			strcpy(shared_memory->element[shared_memory->count].value,name);
+			free(name);
+			shared_memory->useThread = false;
+			shared_memory->count++;
+
+           		pid_t l_pid;
+            		switch(l_pid = fork()) {
+            		case -1:
+                		// error when forking !
+                		ERROR_NO("Forking error main");
+                		break;
+	
+           		case 0:
+                		// first child process - execute the command
+                		if((l_pid = fork()) < 0) {
+                    			ERROR_NO("Forking error child");
+                		} else {
+                    			if( l_pid == 0) {
+						THREAD_DATA *thread_data = (THREAD_DATA *)calloc(1,sizeof(THREAD_DATA));
+						strcpy(thread_data->data_str,data_str);
+						strcpy(thread_data->name,name);
+						do_lua_thread(thread_data);
+					}
+                    	
+                    			exit(EXIT_OTHER);
+                		}// end else
+                		break;
+            		default:
+                		// parent process continue
+                		// reap first child immediately
+                		pid_t ret;
+                		while ((ret=waitpid(l_pid, NULL, 0)) != l_pid) {
+                    			if (ret != -1) {
+                        			ERROR("waitpid returns %1d for child %1d",ret,l_pid);
+                    			}
+                		}
+                		int index;
+				for (int i=0;i<shared_memory->count;i++)
+				{
+                			// Set the internal variable value based on the returned table
+                			index = display_scenario->allocVars->find(shared_memory->element[i].tag,false);
+                       			if (index>0)
+                       				userVars->getVar(index)->setString(strdup(shared_memory->element[i].value));
+					TRACE_MSG("Setting TV pair 1 (%s/%s)\n",shared_memory->element[i].tag, shared_memory->element[i].value);
+					//printf("Setting TV pair (%s/%s)\n",shared_memory->element[i].tag, shared_memory->element[i].value);
+				}
+				munmap(shared_memory,sizeof(TV_ARRAY));
+				// Don't unlink here, we will do this later when we retrieve the value
+				//shm_unlink(name);
+                		break;
+            		}
+			fail:
+			TRACE_MSG("End luarun\n");
+			return EXIT_SUCCESS;
+}
+API_FUNC  processLuaRead(int app, char *data_str, void *tblPtr, void *dispPtr){
+		VariableTable *userVars = (VariableTable *)tblPtr;
+		scenario *display_scenario = (scenario *)dispPtr;
+
+		// Retrieve previously read variables
+
+		int msize = sizeof(TV_ARRAY);
+		TV_ARRAY *shared_memory;
+		char *tmptr;
+		// char *name = data_str;
+		//
+       		char *name = strtok_r(data_str," ",&tmptr);
+       		char *deleteMem = strtok_r(NULL," ",&tmptr);
+       		/*char *timeout = strtok_r(NULL," ",&tmptr);
+		uintmax_t  millisecondsToWait = 0; 
+		// Get the timeout
+		if (timeout!=0)
+		{
+			millisecondsToWait = strtoumax(timeout, NULL, 10);
+			if (millisecondsToWait == UINTMAX_MAX && errno == ERANGE){
+				WARNING("Failed to convert timeout");
+				millisecondsToWait = 0;
+			} 
+
+			
+		}
+		*/
+
+		// Reattach to the named segment and read the valuse from it
+		int  shm_fd = shm_open(name, O_RDONLY, 0666);
+    		// allocating the shared memory
+    		shared_memory = (TV_ARRAY *) mmap(NULL, msize, PROT_READ, MAP_SHARED, shm_fd, 0);
+    		if (shared_memory == MAP_FAILED) 
+    		{
+        		WARNING("Error 3 in mmap()");
+    		
+		} else {
+
+			/*
+			// Pause for the required time and then retrieve the data
+			//for (int t=0;t<millisecondsToWait/10 && !shared_memory->dataIsReady;t++) {
+			for (int t=0;t<millisecondsToWait/10;t++) {
+				usleep(10000);
+			}
+			*/
+			// This ensures the thread is done or else we hangup here - so make sure and add an expected delay in the script or end up waiting on the main thread making SIPP unresponsive
+			// Switched to detached threads as this doesn't work anyway as we land here possibly from a different thread and the passed values don't seem to work
+			//if (shared_memory->useThread && shared_memory->myThread.joinable())
+				//shared_memory->myThread.join();
+
+			// Read the data 
+                	int index;
+			for (int i=0;i<shared_memory->count;i++)
+			{
+                       		// Set the internal variable value based on the returned table
+                		index = display_scenario->allocVars->find(shared_memory->element[i].tag,false);
+                       		if (index>0)
+                       			userVars->getVar(index)->setString(strdup(shared_memory->element[i].value));
+				TRACE_MSG("Setting TV pair 3(%s/%s)\n",shared_memory->element[i].tag, shared_memory->element[i].value);
+				//printf("Setting TV pair (%s/%s)\n",shared_memory->element[i].tag, shared_memory->element[i].value);
+			}
+			munmap(shared_memory,sizeof(TV_ARRAY));
+			close(shm_fd);
+			if (strcmp(deleteMem,"1")==0) {
+				shm_unlink(name);
+				TRACE_MSG("Deleting shared memory(%s)\n",name);
+			}
+
+
+		}
+		return EXIT_SUCCESS;
+
+}
+//_ApiProcessLuaThread
+API_FUNC  processLuaThread(int app, char *data_str, void *tblPtr, void *dispPtr){
+		VariableTable *userVars = (VariableTable *)tblPtr;
+		scenario *display_scenario = (scenario *)dispPtr;
+		char tmp[128];
+		char *fname;
+		char tmpfname[128];
+		char *name;
+		int msize = sizeof(TV_ARRAY);
+		TV_ARRAY *shared_memory;
+ 		fname  = tmpnam(tmp);
+		strcpy(tmpfname,fname);
+		name = basename(tmpfname);
+
+		//if (true) {
+    		// Allocate some shared memory to pass the variables later after this executes
+		TRACE_MSG("Opening shared memory for [%s] - data:(%s)",name,data_str);
+        	int shm_fd = shm_open (name, O_CREAT | O_EXCL | O_RDWR, S_IRWXU | S_IRWXG);
+   		if (shm_fd < 0) 
+   		{
+       			WARNING("Error in shm_open(%s)",name);
+    		} else {
+
+    			ftruncate(shm_fd, msize);
+    			TRACE_MSG("Created shared memory object %s\n", name);
+    			// attach the shared memory segment
+    			shared_memory = (TV_ARRAY *) mmap(NULL, msize, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
+    			if (shared_memory == MAP_FAILED) 
+    			{
+        			WARNING("Error 2 in mmap()");
+    			} else {
+		
+    				TRACE_MSG("Shared memory segment allocated correctly (%d bytes).\n", msize);
+				// Save off the shared memory segment name for now so we can get it later - pass this back to the sipp script
+				shared_memory->count = 0;
+				shared_memory->dataIsReady = 0;
+				strcpy(shared_memory->element[shared_memory->count].tag,"retkey"); // This is a magic variable name which is used by the script to get our values back with a luaread@retkey
+				strcpy(shared_memory->element[shared_memory->count].value,name);
+				shared_memory->useThread = true;
+				shared_memory->count++;
+
+				THREAD_DATA *thread_data = (THREAD_DATA *)calloc(1,sizeof(THREAD_DATA));
+				strcpy(thread_data->data_str,data_str);
+				strcpy(thread_data->name,name);
+				// Create a detached thread so we don't need to join it later
+#if USE_PTHREADS == 1
+				TRACE_MSG("Create pthread shared memory\n");
+				if (pthread_create(&shared_memory->myThread, NULL, (void *(*)(void *))do_lua_thread_detached, thread_data) == -1) {
+            				ERROR_NO("Unable to create lua thread");
+        			}
+
+#else
+				TRACE_MSG("Create std shared memory\n");
+				shared_memory->myThread = std::thread(do_lua_thread, thread_data);
+				shared_memory->myThread.detach();
+#endif
+
+                		int index;
+				for (int i=0;i<shared_memory->count;i++)
+				{
+                			// Set the internal variable value based on the returned table
+                			index = display_scenario->allocVars->find(shared_memory->element[i].tag,false);
+                       			if (index>0)
+                       				userVars->getVar(index)->setString(strdup(shared_memory->element[i].value));
+					TRACE_MSG("Setting TV pair 2(%s/%s)\n",shared_memory->element[i].tag, shared_memory->element[i].value);
+				}
+				munmap(shared_memory,sizeof(TV_ARRAY));
+			}
+		close(shm_fd);
+		}
+		//}
+		//shm_unlink(name);
+		TRACE_MSG("Ending lua thread\n");
+		return EXIT_SUCCESS;
+
+}
+
+// This is a thread for executing our lua command
+void do_lua_thread_detached(THREAD_DATA *thread_data) {
+	mysql_thread_init();
+        pthread_detach(pthread_self());
+	do_lua_thread(thread_data);
+	mysql_thread_end();
+	pthread_exit(NULL);
+
+}
+
+void do_lua_thread(THREAD_DATA *thread_data) {
+
+		char data_str[4096];
+		TV_ARRAY *shared_memory;
+		strcpy(data_str,thread_data->data_str);
+        	int shm_fd = shm_open (thread_data->name, O_RDWR, S_IRWXU | S_IRWXG);
+		char *tmptr;
+   		if (shm_fd < 0) 
+   		{
+       			ERROR("Error in shm_open(%s)",thread_data->name);
+    		} else {
+
+    			// attach the shared memory segment
+    			shared_memory = (TV_ARRAY *) mmap(NULL, sizeof(TV_ARRAY), PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
+    			if (shared_memory == MAP_FAILED) 
+    			{
+        			ERROR("Error 4 in mmap()");
+    			} else {
+			//strcpy(data_str,data.c_str());
+
+			//int shm_fd = thread_data->fd;
+       			char *prog = strtok_r(data_str," ",&tmptr);
+        		char *name[80];
+        		char *val[2048];
+			int i=0;
+			
+       			if (prog!=NULL)
+			{
+			thread_data->L = openLua();
+			if (!thread_data->L)  {
+				WARNING("Unable to create a new LUA state!\n");	
+			}
+			else {
+   				//printf("In C, calling Lua->%s()\n",x);
+   				lua_getglobal(thread_data->L, prog);                                  /* Tell it to run sipp.lua->xxx() */
+   				lua_newtable(thread_data->L);                            /* Push empty table onto stack table now at -1 */
+	
+   				for (int i=0;i<MAXARGS;i++) {
+           				name[i] = strtok_r(NULL," ",&tmptr);
+           				if (name[i]==NULL)
+                   				break;
+
+					// If we get a rawdata tag - then we will copy to the end
+					if (strcmp(name[i],"rawdata")==0) 
+           					val[i] = strtok_r(NULL,"",&tmptr);
+					else
+           					val[i] = strtok_r(NULL," ",&tmptr);
+					if (val[i]== NULL)
+                   				break;
+
+           				lua_pushstring(thread_data->L, name[i]);                /* Push a key onto the stack, table now at -2 */
+           				lua_pushstring(thread_data->L, val[i]);               /* Push a value onto the stack, table now at -3 */
+           				lua_settable(thread_data->L, -3);                        /* Take key and value, put into table at -3, */
+	
+   				}
+				
+   				int totalargs = i;
+				
+   				if (lua_pcall(thread_data->L, 1, 1, 0))                  // Run function, !!! NRETURN=1 !!! 
+	
+           				bail(thread_data->L, "lua_pcall2() failed");
+   				else {
+	
+                                		//printf("============ Back in C again, Iterating thru returned table ============\n");
+				
+   						// table is in the stack at index 't' 
+           					lua_pushnil(thread_data->L);  // Make sure lua_next starts at beginning 
+           					const char *k, *v;
+           					int index;
+           					while (lua_next(thread_data->L, -2)) {                    // TABLE LOCATED AT -2 IN STACK 
+	
+            						v = lua_tostring(thread_data->L, -1);                 // Value at stacktop 
+            						lua_pop(thread_data->L,1);                            // Remove value 
+            						k = lua_tostring(thread_data->L, -1);                 // Read key at stacktop, 
+							if (k != 0)
+							{
+								strcpy(shared_memory->element[shared_memory->count].tag,k);
+								if (v != 0) {
+									strcpy(shared_memory->element[shared_memory->count].value,v);
+									shared_memory->count++;
+               								TRACE_MSG("Fromc k=>%s<, v=>%s<\n", k, v);
+								}
+							}
+							else {
+								TRACE_MSG("Nothing on return stack\n");
+							}
+       						}
+						shared_memory->dataIsReady = 1; // Mark the data as being available.
+				}
+			  	lua_gc(thread_data->L, LUA_GCCOLLECT, 0);
+#ifndef USE_GLOBAL_LUA
+			  	lua_close(thread_data->L);
+#endif
+				// 02/15/2022 - NVF Added trim capability based on the environment variable TRIM_MEMORY
+				char* trim_mem = getenv("TRIM_MEMORY");
+                                if (trim_mem) {
+                                        malloc_trim(M_TOP_PAD);
+					TRACE_MSG("Trim memory\n");
+                                }
+
+				}
+       			}
+		munmap(shared_memory,sizeof(TV_ARRAY));
+		close(shm_fd);
+       		}
+	}
+	free(thread_data);
+}
+
+//
+// Replace various custom functions with our own
+//
+extern "C" void appDllLoad(INT index)
+{
+
+    TRACE_MSG( "Custom App loaded!.\n");
+
+
+    /* and/or by overriding default app event handler here */
+    setApiFunc(API_CUSTOM_FUNC_1, (API_FUNC)processLuaRun,"luarun",index);
+    setApiFunc(API_CUSTOM_FUNC_2, (API_FUNC)processLuaThread,"luathread",index);
+    setApiFunc(API_CUSTOM_FUNC_3, (API_FUNC)processLuaRead,"luaread",index);
+
+}
+
+// This hooks into the built-in plugin capability of sipp
+
+extern "C" int init(void *handle) {
+	strcpy((char *)CustomApi[0].filename, "myapp.so");
+	CustomApi[0].instanceId = 1;
+	CustomApi[0].subsystem = 0;
+	CustomApi[0].appFlag = 0;
+	CustomApi[0].index = 0;
+	initSaveApi();
+	saveDLLSetting(0,handle);
+	appDllLoad(0);
+	return  EXIT_SUCCESS;
+}
+
diff --git a/src/scenario.cpp b/src/scenario.cpp
index b5c913b32..b6772f0de 100644
--- a/src/scenario.cpp
+++ b/src/scenario.cpp
@@ -602,7 +602,7 @@ static char* clean_cdata(char *ptr, int *removed_crlf = NULL)
     strcpy(msg, ptr);
 
     ptr = msg + strlen(msg);
-    ptr--;
+    ptr --;
 
     while((ptr >= msg) &&
             ((*ptr == ' ')  ||
@@ -614,6 +614,10 @@ static char* clean_cdata(char *ptr, int *removed_crlf = NULL)
         *ptr-- = 0;
     }
 
+    if(!strstr(msg, "\n\n")) {
+        strcat(msg, "\n\n");
+    }
+
     if(ptr == msg) {
         ERROR("Empty cdata in xml scenario file");
     }
@@ -630,10 +634,6 @@ static char* clean_cdata(char *ptr, int *removed_crlf = NULL)
         memmove(ptr, ptr + 1, strlen(ptr));
     }
 
-    if (!strstr(msg, "\n\n")) {
-        strcat(msg, "\n\n");
-    }
-
     return msg;
 }
 
diff --git a/src/screen.cpp b/src/screen.cpp
index 4df91dad7..7a679445b 100644
--- a/src/screen.cpp
+++ b/src/screen.cpp
@@ -135,8 +135,11 @@ static void _screen_error(int fatal, bool use_errno, int error, const char *fmt,
     c+= sprintf(c, ".\n");
     screen_errors++;
 
+    // 02/16/2022 - NVF Removed this to prevent deadlock when  the rotate_errorf() reueses the same lock
+    // 02/16/2022 - HYDE changed to use rotate_errorf_nolock() to avoid dead lock
+    pthread_mutex_lock(error_lfi.lockfile);
     if (!error_lfi.fptr && print_all_responses) {
-        rotate_errorf();
+        rotate_errorf_nolock();
         if (error_lfi.fptr) {
             fprintf(error_lfi.fptr, "%s: The following events occured:\n",
                     screen_exename);
@@ -154,7 +157,7 @@ static void _screen_error(int fatal, bool use_errno, int error, const char *fmt,
         count += fprintf(error_lfi.fptr, "%s", screen_last_error);
         fflush(error_lfi.fptr);
         if (ringbuffer_size && count > ringbuffer_size) {
-            rotate_errorf();
+            rotate_errorf_nolock();
             count = 0;
         }
         if (max_log_size && count > max_log_size) {
@@ -170,6 +173,7 @@ static void _screen_error(int fatal, bool use_errno, int error, const char *fmt,
         fprintf(stderr, "%s", screen_last_error);
         fflush(stderr);
     }
+    pthread_mutex_unlock(error_lfi.lockfile);
 
     if (fatal) {
         if (!screen_inited) {
diff --git a/src/send_packets.c b/src/send_packets.c
index ab800e2f0..db2be70bf 100644
--- a/src/send_packets.c
+++ b/src/send_packets.c
@@ -149,7 +149,7 @@ void send_packets_cleanup(void *arg)
     close(*sock);
 }
 
-void send_packets(play_args_t * play_args)
+int send_packets (play_args_t * play_args)
 {
     int ret, sock, port_diff;
     pcap_pkt *pkt_index, *pkt_max;
@@ -186,14 +186,14 @@ void send_packets(play_args_t * play_args)
         to_port = &(((struct sockaddr_in *)(void *) to )->sin_port);
         if (sock < 0) {
             ERROR("Can't create raw IPv4 socket (need to run as root?): %s", strerror(errno));
-            return;
+            return ret;
         }
     }
 
 
     if ((ret = bind(sock, (struct sockaddr *)(void *)from, len))) {
         ERROR("Can't bind media raw socket");
-        return;
+        return ret;
     }
 
 #ifndef MSG_DONTWAIT
@@ -215,11 +215,13 @@ void send_packets(play_args_t * play_args)
         memcpy(&(from6.sin6_addr.s6_addr), &(((struct sockaddr_in6 *)(void *) from)->sin6_addr.s6_addr), sizeof(from6.sin6_addr.s6_addr));
     }
 
+
     /* Ensure the sender socket is closed when the thread exits - this
      * allows the thread to be cancelled cleanly.
      */
     pthread_cleanup_push(send_packets_cleanup, ((void *) &sock));
 
+
     while (pkt_index < pkt_max) {
         memcpy(udp, pkt_index->data, pkt_index->pktlen);
 #if defined(__HPUX) || defined(__DARWIN) || (defined __CYGWIN) || defined(__FreeBSD__)
@@ -288,8 +290,9 @@ void send_packets(play_args_t * play_args)
         }
 #endif
         if (ret < 0) {
+            close(sock);
             WARNING("send_packets.c: sendto failed with error: %s", strerror(errno));
-            break;
+            return( -1);
         }
 
         rtp_pckts_pcap++;
@@ -300,6 +303,7 @@ void send_packets(play_args_t * play_args)
 
     /* Closing the socket is handled by pthread_cleanup_push()/pthread_cleanup_pop() */
     pthread_cleanup_pop(1);
+    return 0;
 }
 
 /*
diff --git a/src/sip_parser.cpp b/src/sip_parser.cpp
index 97f49b66c..ebc00241b 100644
--- a/src/sip_parser.cpp
+++ b/src/sip_parser.cpp
@@ -153,10 +153,6 @@ char * get_header(const char* message, const char * name, bool content)
                 /* Just want the header's content, so skip over the header
                  * and newline */
                 src += strlen(name) + 1;
-                /* Skip over leading spaces. */
-                while (*src == ' ') {
-                    src++;
-                }
             } else {
                 /* Just skip the newline */
                 src++;
@@ -173,7 +169,7 @@ char * get_header(const char* message, const char * name, bool content)
             if (ptr) {
                 *ptr = 0;
             }
-            // Add ", " when several headers are present
+            // Add "," when several headers are present
             if (dest != last_header) {
                 /* Remove trailing whitespaces, tabs, and CRs */
                 while (dest > last_header &&
@@ -184,7 +180,7 @@ char * get_header(const char* message, const char * name, bool content)
                     *(--dest) = 0;
                 }
 
-                dest += sprintf(dest, ", ");
+                dest += sprintf(dest, ",");
             }
             dest += sprintf(dest, "%s", src);
             if (ptr) {
diff --git a/src/sipp-rpc_xdr.c b/src/sipp-rpc_xdr.c
new file mode 100644
index 000000000..9dd8e3835
--- /dev/null
+++ b/src/sipp-rpc_xdr.c
@@ -0,0 +1,71 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "sipp-rpc.h"
+
+bool_t
+xdr_callcounter (XDR *xdrs, callcounter *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->incomingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->outgoingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->successcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->failurecalls))
+				 return FALSE;
+		} else {
+			IXDR_PUT_LONG(buf, objp->incomingcalls);
+			IXDR_PUT_LONG(buf, objp->outgoingcalls);
+			IXDR_PUT_LONG(buf, objp->successcalls);
+			IXDR_PUT_LONG(buf, objp->failurecalls);
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->incomingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->outgoingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->successcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->failurecalls))
+				 return FALSE;
+		} else {
+			objp->incomingcalls = IXDR_GET_LONG(buf);
+			objp->outgoingcalls = IXDR_GET_LONG(buf);
+			objp->successcalls = IXDR_GET_LONG(buf);
+			objp->failurecalls = IXDR_GET_LONG(buf);
+		}
+	 return TRUE;
+	}
+
+	 if (!xdr_int (xdrs, &objp->incomingcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->outgoingcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->successcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->failurecalls))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_callcounter_t (XDR *xdrs, callcounter_t *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_callcounter (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
diff --git a/src/sipp.cpp b/src/sipp.cpp
index 97ef33c05..04164235d 100644
--- a/src/sipp.cpp
+++ b/src/sipp.cpp
@@ -47,8 +47,26 @@
 #include "config.h"
 #include "version.h"
 
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+
+//#include "/usr/include/curl/curl.h"
+//#include "/usr/include/curl/easy.h"
+#include "curl.h"
+#include "easy.h"
+
+#include "mysql.h"
+
+#include "sipp-rpc.h"
+#include <rpc/pmap_clnt.h>
+
 extern struct sipp_socket *ctrl_socket;
 extern struct sipp_socket *stdin_socket;
+void rpc_thread(void* param);
 
 /* These could be local to main, but for the option processing table. */
 static int argiFileName;
@@ -105,6 +123,10 @@ struct sipp_option {
 #define SIPP_OPTION_NEED_SCTP     39
 #define SIPP_HELP_TEXT_HEADER    255
 
+#ifndef SIG_PF
+#define SIG_PF void(*)(int)
+#endif
+
 /* Put each option, its help text, and type in this table. */
 struct sipp_option options_table[] = {
     {"h", NULL, SIPP_OPTION_HELP, NULL, 0},
@@ -210,6 +232,7 @@ struct sipp_option options_table[] = {
 
     {"", "Call behavior options:", SIPP_HELP_TEXT_HEADER, NULL, 0},
     {"aa", "Enable automatic 200 OK answer for INFO, NOTIFY, OPTIONS and UPDATE.", SIPP_OPTION_SETFLAG, &auto_answer, 1},
+    {"aalog", "When auto answer enabled, whether log the action in error log file.", SIPP_OPTION_SETFLAG, &log4auto_answer, 1},
     {"base_cseq", "Start value of [cseq] for each call.", SIPP_OPTION_CSEQ, NULL, 1},
     {"cid_str", "Call ID string (default %u-%p@%s).  %u=call_number, %s=ip_address, %p=process_number, %%=% (in any order).", SIPP_OPTION_STRING, &call_id_string, 1},
     {"d", "Controls the length of calls. More precisely, this controls the duration of 'pause' instructions in the scenario, if they do not have a 'milliseconds' section. Default value is 0 and default unit is milliseconds.", SIPP_OPTION_TIME_MS, &duration, 1},
@@ -371,10 +394,13 @@ struct sipp_option options_table[] = {
     {"trace_logs", "Allow tracing of <log> actions in <scenario file name>_<pid>_logs.log.", SIPP_OPTION_SETFLAG, &useLogf, 1},
     {"log_file", "Set the name of the log actions log file.", SIPP_OPTION_LFNAME, &log_lfi, 1},
     {"log_overwrite", "Overwrite the log actions log file (default true).", SIPP_OPTION_LFOVERWRITE, &log_lfi, 1},
+    {"enable_rpc", "Enable binding to RPC", SIPP_OPTION_SETFLAG, &enable_rpc, 1},
 
     {"ringbuffer_files", "How many error, message, shortmessage and calldebug files should be kept after rotation?", SIPP_OPTION_INT, &ringbuffer_files, 1},
     {"ringbuffer_size", "How large should error, message, shortmessage and calldebug files be before they get rotated?", SIPP_OPTION_LONG_LONG, &ringbuffer_size, 1},
     {"max_log_size", "What is the limit for error, message, shortmessage and calldebug file sizes.", SIPP_OPTION_LONG_LONG, &max_log_size, 1},
+    {"pid_file", "Set the name for pid file. Default is 'sipp.pid'", SIPP_OPTION_STRING, &pid_file, 1},
+    {"lua_file", "Set the name for lua file. Default is 'sipp.lua'", SIPP_OPTION_STRING, &lua_file, 1},
 
 };
 
@@ -863,6 +889,7 @@ static void rtp_echo_thread(void* param)
             rtp2_bytes += ns;
         }
     }
+    pthread_exit(NULL); // 2/8/2022 - NVF Added
 }
 
 /* Wrap the help text. */
@@ -1404,11 +1431,82 @@ static void setup_media_sockets()
     }
 }
 
+
+#define USE_OPENSSLX /* or USE_GNUTLS accordingly */
+
+/* we have this global to let the callback get easy access to it */
+static pthread_mutex_t *lockarray;
+
+#ifdef USE_OPENSSLX
+#include <openssl/crypto.h>
+static void lock_callback(int mode, int type, char *file, int line)
+{
+        (void)file;
+        (void)line;
+        if (mode & CRYPTO_LOCK) {
+                pthread_mutex_lock(&(lockarray[type]));
+        } else {
+                pthread_mutex_unlock(&(lockarray[type]));
+        }
+}
+
+static unsigned long thread_id(void)
+{
+        unsigned long ret;
+
+        ret = (unsigned long)pthread_self();
+        return (ret);
+}
+
+static void init_locks(void)
+{
+        int i;
+        struct logfile_info** logfile_ptr;
+        struct logfile_info* logfiles[] = {
+            &screen_lfi, &calldebug_lfi, &message_lfi, &shortmessage_lfi, &log_lfi, &error_lfi, NULL};
+
+        lockarray = (pthread_mutex_t *)OPENSSL_malloc(CRYPTO_num_locks() *
+                    sizeof(pthread_mutex_t));
+        for (i = 0; i < CRYPTO_num_locks(); i++) {
+                pthread_mutex_init(&(lockarray[i]), NULL);
+        }
+
+        CRYPTO_set_id_callback((unsigned long (*)())thread_id);
+        CRYPTO_set_locking_callback((void (*)(int, int, const char *, int))lock_callback);
+
+        /* Inite logfile mutexs. */
+        for (logfile_ptr = logfiles; *logfile_ptr; ++logfile_ptr) {
+            (*logfile_ptr)->lockfile = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+            pthread_mutex_init((*logfile_ptr)->lockfile, NULL);
+        }
+
+}
+
+static void kill_locks(void)
+{
+        int i;
+        struct logfile_info** logfile_ptr;
+        struct logfile_info* logfiles[] = {
+            &screen_lfi, &calldebug_lfi, &message_lfi, &shortmessage_lfi, &log_lfi, &error_lfi, NULL};
+
+        CRYPTO_set_locking_callback(NULL);
+        for (i = 0; i < CRYPTO_num_locks(); i++)
+                pthread_mutex_destroy(&(lockarray[i]));
+
+        OPENSSL_free(lockarray);
+
+        /* Inite logfile mutexs. */
+        for (logfile_ptr = logfiles; *logfile_ptr; ++logfile_ptr) {
+            (*logfile_ptr)->lockfile = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+            pthread_mutex_destroy((*logfile_ptr)->lockfile);
+        }
+}
+#endif
 /* Main */
 int main(int argc, char *argv[])
 {
     int                  argi = 0;
-    pthread_t pthread2_id = 0, pthread3_id = 0;
+    pthread_t pthread2_id = 0, pthread3_id = 0, pthread4_id = 0;
     unsigned int         generic_count = 0;
     bool                 slave_masterSet = false;
 
@@ -1420,7 +1518,12 @@ int main(int argc, char *argv[])
         exit(EXIT_OTHER);
     }
     {
-        /* Ignore the SIGPIPE signal */
+  	// 2/9/2022 NVF This has to be above the SIGPIPE handler (added to support mysqlclient multithreaded): https://dev.mysql.com/doc/c-api/8.0/en/c-api-threaded-clients.html
+  	if (mysql_library_init(0, NULL, NULL)) {
+    		fprintf(stderr, "Warning: Could not initialize MySQL client library.  MySQL should not be used in a threaded call as a result\n");
+    		exit(1);
+   	}
+        /* Ignore the SIGPIPE signal - note: this also works for MYSQL*/
         struct sigaction action_pipe;
         memset(&action_pipe, 0, sizeof(action_pipe));
         action_pipe.sa_handler=SIG_IGN;
@@ -1444,6 +1547,11 @@ int main(int argc, char *argv[])
         sigaction(SIGUSR2, &action_usr2, NULL);
     }
 
+    init_locks();
+
+    curl_global_init(CURL_GLOBAL_DEFAULT);
+
+
     screen_set_exename("sipp");
 
     pid = getpid();
@@ -1978,17 +2086,18 @@ int main(int argc, char *argv[])
                     ERROR("Could not open plugin %s: %s", argv[argi], dlerror());
                 }
 
-                int (*init)();
-                void* funcptr = dlsym(handle, "init");
+                int (*init)(void *);
+		init = (int (*)(void *))dlsym(handle, "init");
+                //void* funcptr = dlsym(handle, "init");
                 /* http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c */
-                *reinterpret_cast<void**>(&init) = funcptr; // yuck
+                //*reinterpret_cast<void**>(&init)(void *) = funcptr; // yuck
 
                 const char* error;
                 if ((error = dlerror())) {
                     ERROR("Could not locate init function in %s: %s", argv[argi], error);
                 }
 
-                ret = init();
+                ret = init(handle);
                 if (ret != 0) {
                     ERROR("Plugin %s initialization failed.", argv[argi]);
                 }
@@ -2199,6 +2308,17 @@ int main(int argc, char *argv[])
         }
     }
 
+    //HYDE write pid file
+    if (pid_file != NULL && strlen(pid_file)>0)
+    {
+        FILE *f;
+        f = fopen(pid_file, "w");
+        fprintf(f, "%d\n",getpid());
+        fflush(f);
+        fclose(f);
+    }
+    //HYDE write pid file
+
     sipp_usleep(sleeptime * 1000);
 
     /* Create the statistics reporting task. */
@@ -2254,6 +2374,14 @@ int main(int argc, char *argv[])
         }
     }
 
+    /* Creating RPC thread. */
+    if (enable_rpc) {
+        if (pthread_create(&pthread4_id, NULL,
+            (void *(*)(void *)) rpc_thread, NULL) == -1) {
+                ERROR_NO("Unable to create video RTP echo thread");
+        }
+    }
+
     if (traffic_thread()) {
         if (!nostdin) {
             sipp_close_socket(stdin_socket);
@@ -2268,12 +2396,18 @@ int main(int argc, char *argv[])
     if (pthread3_id) {
         pthread_cancel(pthread3_id);
     }
+    if (pthread4_id) {
+        pthread_cancel(pthread4_id);
+    }
     if (pthread2_id) {
         pthread_join(pthread2_id, NULL);
     }
     if (pthread3_id) {
         pthread_join(pthread3_id, NULL);
     }
+    if (pthread4_id) {
+        pthread_join(pthread4_id, NULL);
+    }
 
 #ifdef HAVE_EPOLL
     close(epollfd);
@@ -2286,4 +2420,172 @@ int main(int argc, char *argv[])
     free(scenario_file);
 
     sipp_exit(EXIT_TEST_RES_UNKNOWN);
+    kill_locks(); 
+    curl_global_cleanup();
+    mysql_library_end(); // 2/9/2022 - NVF Added to allow mysql threaded support
+
+}
+
+bool_t
+getcallcounter_1_svc(callcounter_t *argp, callcounter_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	unsigned long long incomingcalls = main_scenario->stats->GetStat(CStat::CPT_C_IncomingCallCreated);
+	unsigned long long outgoingcalls = main_scenario->stats->GetStat(CStat::CPT_C_OutgoingCallCreated);
+	unsigned long long successcalls = main_scenario->stats->GetStat(CStat::CPT_C_SuccessfulCall);
+	unsigned long long failurecalls = main_scenario->stats->GetStat(CStat::CPT_C_FailedCall);
+
+	result->incomingcalls=incomingcalls;
+	result->outgoingcalls=outgoingcalls;
+	result->successcalls=successcalls;
+	result->failurecalls=failurecalls;
+
+	retval = true;
+	return retval;
+}
+
+bool_t
+enablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	log4auto_answer=true;
+	retval = true;
+	return retval;
+}
+
+bool_t
+disablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	log4auto_answer=false;
+	retval = true;
+	return retval;
+}
+
+int
+sipprpcprog_1_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+	xdr_free (xdr_result, result);
+
+	/*
+	 * Insert additional freeing code here, if needed
+	 */
+
+	return 1;
+}
+
+void
+sipprpcprog_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+	union {
+		callcounter_t getcallcounter_1_arg;
+	} argument;
+	union {
+		callcounter_t getcallcounter_1_res;
+		bool_t enablelog4autoanswer_1_res;
+		bool_t disablelog4autoanswer_1_res;
+	} result;
+	bool_t retval;
+	xdrproc_t _xdr_argument, _xdr_result;
+	bool_t (*local)(char *, void *, struct svc_req *);
+
+	switch (rqstp->rq_proc) {
+	case NULLPROC:
+		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+		return;
+
+	case GETCALLCOUNTER:
+		_xdr_argument = (xdrproc_t) xdr_callcounter_t;
+		_xdr_result = (xdrproc_t) xdr_callcounter_t;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))getcallcounter_1_svc;
+		break;
+
+	case ENABLELOG4AUTOANSWER:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_bool;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))enablelog4autoanswer_1_svc;
+		break;
+
+	case DISABLELOG4AUTOANSWER:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_bool;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))disablelog4autoanswer_1_svc;
+		break;
+
+	default:
+		svcerr_noproc (transp);
+		return;
+	}
+	memset ((char *)&argument, 0, sizeof (argument));
+	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+		svcerr_decode (transp);
+		return;
+	}
+	retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+	if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+		svcerr_systemerr (transp);
+	}
+	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+		fprintf (stderr, "%s", "unable to free arguments");
+		exit (1);
+	}
+	if (!sipprpcprog_1_freeresult (transp, _xdr_result, (caddr_t) &result))
+		fprintf (stderr, "%s", "unable to free results");
+
+	return;
+}
+
+void rpc_thread(void* param)
+{
+	register SVCXPRT *transp;
+	sigset_t              mask;
+	sigfillset(&mask); /* Mask all allowed signals */
+	int rc = pthread_sigmask(SIG_BLOCK, &mask, NULL);
+	if (rc) {
+	    WARNING("pthread_sigmask returned %d", rc);
+	    return;
+	}
+
+	pmap_unset (SIPPRPCPROG, SIPPRPCVERS);
+
+	transp = svcudp_create(RPC_ANYSOCK);
+	if (transp == NULL) {
+		fprintf (stderr, "%s", "cannot create udp service.");
+		exit(1);
+	}
+	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_UDP)) {
+		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
+		exit(1);
+	}
+
+	transp = svctcp_create(RPC_ANYSOCK, 0, 0);
+	if (transp == NULL) {
+		fprintf (stderr, "%s", "cannot create tcp service.");
+		exit(1);
+	}
+	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_TCP)) {
+		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
+		exit(1);
+	}
+
+	svc_run ();
+	fprintf (stderr, "%s", "svc_run returned");
+	pthread_exit(NULL); // 2/8/2022 - NVF Added
+	//exit (1);
+	/* NOTREACHED */
 }
diff --git a/src/socket.cpp b/src/socket.cpp
index d69cc8608..b5c9c9cca 100644
--- a/src/socket.cpp
+++ b/src/socket.cpp
@@ -1164,9 +1164,9 @@ void process_message(struct sipp_socket *socket, char *msg, ssize_t msg_size, st
             listener_ptr = new_ptr;
         } else if (creationMode == MODE_SERVER) {
             if (quitting >= 1) {
-                CStat::globalStat(CStat::E_OUT_OF_CALL_MSGS);
-                TRACE_MSG("Discarded message for new calls while quitting\n");
-                return;
+                //HYDE CStat::globalStat(CStat::E_OUT_OF_CALL_MSGS);
+                TRACE_MSG("Discarded message for new calls while quitting(%d)\n",quitting);
+                //HYDE return;
             }
 
             // Adding a new INCOMING call !
@@ -2532,7 +2532,7 @@ int open_connections()
 
         if (!strlen(local_ip)) {
             get_inet_address(_RCAST(struct sockaddr_storage*, local_addr->ai_addr),
-                             local_ip, sizeof(local_ip));
+			     local_ip, sizeof(local_ip));
         } else {
             memcpy(&local_sockaddr,
                    local_addr->ai_addr,

From c2b792ad15774371787f506066a7ce2dad03f412 Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan@nventures.net>
Date: Thu, 17 Mar 2022 16:22:55 -0500
Subject: [PATCH 4/9] 1. Fixed the merge with various files from later merges

---
 CHANGES.md         | 13 +++++++++++++
 src/deadcall.cpp   |  3 ---
 src/scenario.cpp   | 10 +++++-----
 src/send_packets.c | 12 ++++--------
 src/sip_parser.cpp |  8 ++++++--
 src/sipp.cpp       |  2 +-
 src/socket.cpp     |  8 ++++----
 7 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 2d4ed2c07..22e3b0e06 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,3 +1,16 @@
+Bugs fixed in 3.5.3
+===================
+
+* Fix `[routes]` header in UAS scenario's. (Issue #262, reported by
+  Stefan Mititelu (@smititelu).)
+  (Backported from b6c7b209 from 3.6.)
+* Fix bad Content-Length calculation when whitespace was between the CRLF
+  pairs that separate the body. (Issue #337, fixed by Serg Stetsuk
+  (@sergstetsuk)).
+* Fix crash in pcap play on send failure because of pthread\_cleanup macros.
+  (Issue #74, #370, reported by various people.)
+
+
 Bugs fixed in 3.5.2
 ===================
 
diff --git a/src/deadcall.cpp b/src/deadcall.cpp
index 24d41c226..a540bc0d4 100644
--- a/src/deadcall.cpp
+++ b/src/deadcall.cpp
@@ -42,9 +42,6 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 
-#ifdef PCAPPLAY
-#include "send_packets.h"
-#endif
 #include "sipp.hpp"
 #include "deadcall.hpp"
 #include "assert.h"
diff --git a/src/scenario.cpp b/src/scenario.cpp
index b6772f0de..b5c913b32 100644
--- a/src/scenario.cpp
+++ b/src/scenario.cpp
@@ -602,7 +602,7 @@ static char* clean_cdata(char *ptr, int *removed_crlf = NULL)
     strcpy(msg, ptr);
 
     ptr = msg + strlen(msg);
-    ptr --;
+    ptr--;
 
     while((ptr >= msg) &&
             ((*ptr == ' ')  ||
@@ -614,10 +614,6 @@ static char* clean_cdata(char *ptr, int *removed_crlf = NULL)
         *ptr-- = 0;
     }
 
-    if(!strstr(msg, "\n\n")) {
-        strcat(msg, "\n\n");
-    }
-
     if(ptr == msg) {
         ERROR("Empty cdata in xml scenario file");
     }
@@ -634,6 +630,10 @@ static char* clean_cdata(char *ptr, int *removed_crlf = NULL)
         memmove(ptr, ptr + 1, strlen(ptr));
     }
 
+    if (!strstr(msg, "\n\n")) {
+        strcat(msg, "\n\n");
+    }
+
     return msg;
 }
 
diff --git a/src/send_packets.c b/src/send_packets.c
index db2be70bf..ab800e2f0 100644
--- a/src/send_packets.c
+++ b/src/send_packets.c
@@ -149,7 +149,7 @@ void send_packets_cleanup(void *arg)
     close(*sock);
 }
 
-int send_packets (play_args_t * play_args)
+void send_packets(play_args_t * play_args)
 {
     int ret, sock, port_diff;
     pcap_pkt *pkt_index, *pkt_max;
@@ -186,14 +186,14 @@ int send_packets (play_args_t * play_args)
         to_port = &(((struct sockaddr_in *)(void *) to )->sin_port);
         if (sock < 0) {
             ERROR("Can't create raw IPv4 socket (need to run as root?): %s", strerror(errno));
-            return ret;
+            return;
         }
     }
 
 
     if ((ret = bind(sock, (struct sockaddr *)(void *)from, len))) {
         ERROR("Can't bind media raw socket");
-        return ret;
+        return;
     }
 
 #ifndef MSG_DONTWAIT
@@ -215,13 +215,11 @@ int send_packets (play_args_t * play_args)
         memcpy(&(from6.sin6_addr.s6_addr), &(((struct sockaddr_in6 *)(void *) from)->sin6_addr.s6_addr), sizeof(from6.sin6_addr.s6_addr));
     }
 
-
     /* Ensure the sender socket is closed when the thread exits - this
      * allows the thread to be cancelled cleanly.
      */
     pthread_cleanup_push(send_packets_cleanup, ((void *) &sock));
 
-
     while (pkt_index < pkt_max) {
         memcpy(udp, pkt_index->data, pkt_index->pktlen);
 #if defined(__HPUX) || defined(__DARWIN) || (defined __CYGWIN) || defined(__FreeBSD__)
@@ -290,9 +288,8 @@ int send_packets (play_args_t * play_args)
         }
 #endif
         if (ret < 0) {
-            close(sock);
             WARNING("send_packets.c: sendto failed with error: %s", strerror(errno));
-            return( -1);
+            break;
         }
 
         rtp_pckts_pcap++;
@@ -303,7 +300,6 @@ int send_packets (play_args_t * play_args)
 
     /* Closing the socket is handled by pthread_cleanup_push()/pthread_cleanup_pop() */
     pthread_cleanup_pop(1);
-    return 0;
 }
 
 /*
diff --git a/src/sip_parser.cpp b/src/sip_parser.cpp
index ebc00241b..97f49b66c 100644
--- a/src/sip_parser.cpp
+++ b/src/sip_parser.cpp
@@ -153,6 +153,10 @@ char * get_header(const char* message, const char * name, bool content)
                 /* Just want the header's content, so skip over the header
                  * and newline */
                 src += strlen(name) + 1;
+                /* Skip over leading spaces. */
+                while (*src == ' ') {
+                    src++;
+                }
             } else {
                 /* Just skip the newline */
                 src++;
@@ -169,7 +173,7 @@ char * get_header(const char* message, const char * name, bool content)
             if (ptr) {
                 *ptr = 0;
             }
-            // Add "," when several headers are present
+            // Add ", " when several headers are present
             if (dest != last_header) {
                 /* Remove trailing whitespaces, tabs, and CRs */
                 while (dest > last_header &&
@@ -180,7 +184,7 @@ char * get_header(const char* message, const char * name, bool content)
                     *(--dest) = 0;
                 }
 
-                dest += sprintf(dest, ",");
+                dest += sprintf(dest, ", ");
             }
             dest += sprintf(dest, "%s", src);
             if (ptr) {
diff --git a/src/sipp.cpp b/src/sipp.cpp
index 04164235d..9a03dac1c 100644
--- a/src/sipp.cpp
+++ b/src/sipp.cpp
@@ -1549,7 +1549,7 @@ int main(int argc, char *argv[])
 
     init_locks();
 
-    curl_global_init(CURL_GLOBAL_DEFAULT);
+    curl_global_init(CURL_GLOBAL_DEFAULT);  // This is so we can use CURL inside our lua scripts in multi-threaded environments
 
 
     screen_set_exename("sipp");
diff --git a/src/socket.cpp b/src/socket.cpp
index b5c9c9cca..d69cc8608 100644
--- a/src/socket.cpp
+++ b/src/socket.cpp
@@ -1164,9 +1164,9 @@ void process_message(struct sipp_socket *socket, char *msg, ssize_t msg_size, st
             listener_ptr = new_ptr;
         } else if (creationMode == MODE_SERVER) {
             if (quitting >= 1) {
-                //HYDE CStat::globalStat(CStat::E_OUT_OF_CALL_MSGS);
-                TRACE_MSG("Discarded message for new calls while quitting(%d)\n",quitting);
-                //HYDE return;
+                CStat::globalStat(CStat::E_OUT_OF_CALL_MSGS);
+                TRACE_MSG("Discarded message for new calls while quitting\n");
+                return;
             }
 
             // Adding a new INCOMING call !
@@ -2532,7 +2532,7 @@ int open_connections()
 
         if (!strlen(local_ip)) {
             get_inet_address(_RCAST(struct sockaddr_storage*, local_addr->ai_addr),
-			     local_ip, sizeof(local_ip));
+                             local_ip, sizeof(local_ip));
         } else {
             memcpy(&local_sockaddr,
                    local_addr->ai_addr,

From 867f5fd6b536c24c7a78d16233f9552e63017164 Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan.franzmeier@sky-networks.com>
Date: Tue, 22 Mar 2022 21:55:48 +0000
Subject: [PATCH 5/9] 1. Second pass at merging 3.6 with the plugin and other
 changes 2. This pass has the plugin working

---
 CMakeLists.txt     |    7 +
 include/logger.hpp |   62 ++-
 include/sipp.hpp   |  529 +++++++++---------
 src/call.cpp       | 1293 ++++++++++++++++++++------------------------
 src/logger.cpp     | 1000 +++++++++-------------------------
 src/myapp.cpp      |    4 +-
 src/screen.cpp     |  937 +++++++++++++++++++++++++++-----
 src/sipp.cpp       |  878 +++++++-----------------------
 8 files changed, 2147 insertions(+), 2563 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ba18b1b99..4da8b7525 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -101,10 +101,15 @@ if(USE_SCTP)
   endif()
 endif(USE_SCTP)
 
+ list(REMOVE_ITEM all_SRCS
+    "${PROJECT_SOURCE_DIR}/src/myapp.cpp")
+
 # add the executable
 link_directories("/usr/local/lib")
 add_executable(sipp ${all_SRCS} "${PROJECT_SOURCE_DIR}/src/sipp.cpp")
 add_executable(sipp_unittest EXCLUDE_FROM_ALL ${all_SRCS} "${PROJECT_SOURCE_DIR}/src/sipp_unittest.cpp")
+add_library(myapp SHARED ${PROJECT_SOURCE_DIR}/src/myapp.cpp  )
+target_link_libraries(myapp -rdynamic -fPIC -llua5.3 -lrt -lcrypto -lcurl -lperconaserverclient )
 target_compile_definitions(sipp_unittest PUBLIC "-DGTEST")
 
 # add version
@@ -173,6 +178,8 @@ else()
   message(FATAL_ERROR "libcurses / libncurses was not found; please install devel package")
 endif()
 
+include_directories(${LUA_LIBRARY_INCLUDE_DIR} ${CURL_LIBRARY_INCLUDE_DIR} ${MYSQL_LIBRARY_INCLUDE_DIR})
+
 find_library(RT_LIBRARY NAMES rt)
 if(RT_LIBRARY)
   target_link_libraries(sipp ${RT_LIBRARY})
diff --git a/include/logger.hpp b/include/logger.hpp
index d57a11299..5fac32138 100644
--- a/include/logger.hpp
+++ b/include/logger.hpp
@@ -7,34 +7,36 @@
 #include "sipp.hpp"
 
 #ifdef GLOBALS_FULL_DEFINITION
-#define extern
-#define _DEFVAL(value) = value
+#define MAYBE_EXTERN
+#define DEFVAL(value) = value
 #else
-#define _DEFVAL(value)
+#define MAYBE_EXTERN extern
+#define DEFVAL(value)
 #endif
 
-extern FILE * screenf                             _DEFVAL(0);
-extern FILE * countf                              _DEFVAL(0);
-extern FILE * codesf                              _DEFVAL(0);
-// extern FILE * timeoutf                            _DEFVAL(0);
-extern bool   useMessagef                         _DEFVAL(0);
-extern bool   useErrorCodesf                      _DEFVAL(0);
-extern bool   useCallDebugf                       _DEFVAL(0);
-extern bool   useShortMessagef                    _DEFVAL(0);
-extern bool   useScreenf                          _DEFVAL(0);
-extern bool   useLogf                             _DEFVAL(0);
-// extern bool   useTimeoutf                         _DEFVAL(0);
-extern bool   dumpInFile                          _DEFVAL(0);
-extern bool   dumpInRtt                           _DEFVAL(0);
-extern bool   useCountf                           _DEFVAL(0);
-extern char * slave_cfg_file;
+MAYBE_EXTERN FILE * screenf             DEFVAL(0);
+MAYBE_EXTERN FILE * countf              DEFVAL(0);
+MAYBE_EXTERN FILE * codesf              DEFVAL(0);
+//MAYBE_EXTERN FILE * timeoutf           DEFVAL(0);
+MAYBE_EXTERN bool   useMessagef         DEFVAL(0);
+MAYBE_EXTERN bool   useErrorCodesf      DEFVAL(0);
+MAYBE_EXTERN bool   useCallDebugf       DEFVAL(0);
+MAYBE_EXTERN bool   useShortMessagef    DEFVAL(0);
+MAYBE_EXTERN bool   useScreenf          DEFVAL(0);
+MAYBE_EXTERN bool   useLogf             DEFVAL(0);
+//MAYBE_EXTERN bool   useTimeoutf        DEFVAL(0);
+MAYBE_EXTERN bool   dumpInFile          DEFVAL(0);
+MAYBE_EXTERN bool   dumpInRtt           DEFVAL(0);
+MAYBE_EXTERN bool   useCountf           DEFVAL(0);
+MAYBE_EXTERN char * slave_cfg_file;
 
-extern unsigned long long max_log_size            _DEFVAL(0);
-extern unsigned long long ringbuffer_size         _DEFVAL(0);
-extern int    ringbuffer_files                    _DEFVAL(0);
+MAYBE_EXTERN unsigned long long max_log_size DEFVAL(0);
+MAYBE_EXTERN unsigned long long ringbuffer_size DEFVAL(0);
+MAYBE_EXTERN int    ringbuffer_files    DEFVAL(0);
+
+MAYBE_EXTERN char   screen_last_error[32768];
+MAYBE_EXTERN char   screen_logfile[MAX_PATH] DEFVAL("");
 
-extern char   screen_last_error[32768];
-extern char   screen_logfile[MAX_PATH]            _DEFVAL("");
 /* Log Rotation Functions. */
 struct logfile_id {
     time_t start;
@@ -65,10 +67,10 @@ void log_off(struct logfile_info *lfi);
 
 #ifdef GLOBALS_FULL_DEFINITION
 #define LOGFILE(name, s, check) \
-        struct logfile_info name = { s, check, NULL, 0, NULL, "", true, false, 0, 0, NULL}
+    struct logfile_info name = { s, check, NULL, 0, NULL, "", true, false, 0, 0 }
 #else
 #define LOGFILE(name, s, check) \
-        extern struct logfile_info name
+    extern struct logfile_info name
 #endif
 LOGFILE(calldebug_lfi, "calldebug", true);
 LOGFILE(message_lfi, "messages", true);
@@ -78,19 +80,21 @@ LOGFILE(log_lfi, "logs", true);
 LOGFILE(error_lfi, "errors", false);
 
 void rotate_logfile();
+void rotate_errorf_nolock();
 void rotate_shortmessagef();
 void rotate_errorf();
-void rotate_errorf_nolock();
 void rotate_messagef();
 void rotate_screenf();
 void rotate_calldebugf();
 
-/* Screen/Statistics Printing Functions. */
-void print_statistics(int last);
+/* Functions that print to stdout/stderr/logfiles.
+ * Any functions which print to the curses UI live in screen.cpp.
+ * */
+void print_errors();
+void print_closing();
 void print_count_file(FILE* f, int header);
 void print_error_codes_file(FILE* f);
 
-/* This must go after the GLOBALS_FULL_DEFINITION, because we need the extern keyword. */
 int TRACE_MSG(const char* fmt, ...) __attribute__((format(printf, 1, 2)));
 int TRACE_CALLDEBUG(const char* fmt, ...) __attribute__((format(printf, 1, 2)));
 int TRACE_SHORTMSG(const char* fmt, ...) __attribute__((format(printf, 1, 2)));
diff --git a/include/sipp.hpp b/include/sipp.hpp
index 7a216a0be..21ebf2041 100644
--- a/include/sipp.hpp
+++ b/include/sipp.hpp
@@ -21,7 +21,7 @@
 #define __SIPP__
 
 /* Std C includes */
-
+#include "config.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -36,7 +36,7 @@
 #endif
 #endif
 #include <sys/time.h>
-#include <sys/poll.h>
+#include <poll.h>
 #ifdef HAVE_EPOLL
 #include <sys/epoll.h>
 #endif
@@ -55,9 +55,7 @@
 #include <map>
 #include <set>
 #include <math.h>
-#ifndef __SUNOS
-#include <curses.h>
-#else
+#ifdef __SUNOS
 #include <stdarg.h>
 #endif
 
@@ -72,8 +70,8 @@
 #include "screen.hpp"
 #include "task.hpp"
 #include "listener.hpp"
-#include "socketowner.hpp"
 #include "socket.hpp"
+#include "socketowner.hpp"
 #include "call.hpp"
 #include "comp.h"
 #include "variables.hpp"
@@ -84,28 +82,35 @@
 #include "reporttask.hpp"
 #include "ratetask.hpp"
 #include "watchdog.hpp"
-/* Open SSL stuff */
-#ifdef USE_OPENSSL
-#include "sslcommon.h"
+
+/* Backwards compatibility */
+#ifndef HAVE_STD_TOSTRING
+#include <sstream>
+namespace std {
+template <typename T> string to_string(T value) {
+    ostringstream os;
+    os << value;
+    return os.str();
+}
+}
 #endif
 
 /*
  * If this files is included in the Main, then extern definitions
- * are removed, and the _DEFAULT macro becomes '= value;'. Else
+ * are removed, and the DEFVAL macro becomes '= value;'. Else
  * extern definition does not contain default values assignment
  */
 
 #ifdef GLOBALS_FULL_DEFINITION
-#define extern
-#define _DEFVAL(value) = value
-#define extern_c
-#else
-#define _DEFVAL(value)
-#ifdef __cplusplus
-#define extern_c extern "C"
+#define MAYBE_EXTERN
+#define DEFVAL(value) = value
 #else
-#define extern_c
+#define MAYBE_EXTERN extern
+#define DEFVAL(value)
 #endif
+
+#ifndef __cplusplus
+#error Unexpected include from non-cxx source
 #endif
 
 /************************** Constants **************************/
@@ -115,18 +120,20 @@
 #define T_TLS                      2
 #define T_SCTP                     3
 
-#define DEFAULT_PID_FILE            "sipp.pid"
-#define DEFAULT_LUA_FILE            "sipp.lua"
-#ifdef USE_OPENSSL
+#ifdef USE_TLS
 #define DEFAULT_TLS_CERT           "cacert.pem"
 #define DEFAULT_TLS_KEY            "cakey.pem"
+#define DEFAULT_TLS_CA             ""
 #define DEFAULT_TLS_CRL            ""
 #endif
 
 #define TRANSPORT_TO_STRING(p)     ((p==T_TCP) ? "TCP" : ((p==T_TLS)? "TLS" : ((p==T_UDP)? "UDP" : "SCTP")))
 
 #define SIPP_MAXFDS                65536
-#define SIPP_MAX_MSG_SIZE          65536
+
+#ifndef SIPP_MAX_MSG_SIZE
+#define SIPP_MAX_MSG_SIZE 65536
+#endif
 
 #define MSG_RETRANS_FIRST          0
 #define MSG_RETRANS_RETRANSMISSION 1
@@ -174,309 +181,285 @@ cmd messages are received */
 
 #define DEFAULT_BEHAVIOR_ALL         (DEFAULT_BEHAVIOR_BYE | DEFAULT_BEHAVIOR_ABORTUNEXP | DEFAULT_BEHAVIOR_PINGREPLY)
 
-#ifdef RTP_STREAM
 #define DEFAULT_MIN_RTP_PORT         8192
 #define DEFAULT_MAX_RTP_PORT         65535
 #define DEFAULT_RTP_PAYLOAD          8
 #define DEFAULT_RTP_THREADTASKS      20
-#endif
 
 /************ User controls and command line options ***********/
 
-extern int                duration                _DEFVAL(0);
-extern double             rate                    _DEFVAL(DEFAULT_RATE);
-extern double             rate_scale              _DEFVAL(DEFAULT_RATE_SCALE);
-extern int                rate_increase           _DEFVAL(0);
-extern int                rate_max                _DEFVAL(0);
-extern unsigned long      rate_increase_freq      _DEFVAL(DEFAULT_RATE_INCR_FREQ);
-extern bool               rate_quit               _DEFVAL(true);
-extern int                users                   _DEFVAL(-1);
-extern int                rate_period_ms          _DEFVAL(DEFAULT_RATE_PERIOD_MS);
-extern int                sleeptime               _DEFVAL(0);
-extern unsigned long      defl_recv_timeout       _DEFVAL(0);
-extern unsigned long      defl_send_timeout       _DEFVAL(0);
-extern unsigned long      global_timeout          _DEFVAL(0);
-extern int                transport               _DEFVAL(DEFAULT_TRANSPORT);
-extern bool               retrans_enabled         _DEFVAL(1);
-extern int                rtcheck                 _DEFVAL(RTCHECK_FULL);
-extern int                max_udp_retrans         _DEFVAL(UDP_MAX_RETRANS);
-extern int                max_invite_retrans      _DEFVAL(UDP_MAX_RETRANS_INVITE_TRANSACTION);
-extern int                max_non_invite_retrans  _DEFVAL(UDP_MAX_RETRANS_NON_INVITE_TRANSACTION);
-extern unsigned long      default_behaviors       _DEFVAL(DEFAULT_BEHAVIOR_ALL);
-extern unsigned long      deadcall_wait           _DEFVAL(DEFAULT_DEADCALL_WAIT);
-extern bool               pause_msg_ign           _DEFVAL(0);
-extern bool               auto_answer             _DEFVAL(false);
-extern bool               log4auto_answer         _DEFVAL(false);
-extern bool               enable_rpc              _DEFVAL(false);
-extern int                multisocket             _DEFVAL(0);
-extern int                compression             _DEFVAL(0);
-extern int                peripsocket             _DEFVAL(0);
-extern int                peripfield              _DEFVAL(0);
-extern bool               bind_local              _DEFVAL(false);
-extern void             * monosocket_comp_state   _DEFVAL(0);
-extern const char       * service                 _DEFVAL(DEFAULT_SERVICE);
-extern const char       * auth_password           _DEFVAL(DEFAULT_AUTH_PASSWORD);
-extern const char       * auth_username           _DEFVAL(0);
-extern unsigned long      report_freq             _DEFVAL(DEFAULT_REPORT_FREQ);
-extern unsigned long      report_freq_dumpLog     _DEFVAL
+MAYBE_EXTERN int                duration                DEFVAL(0);
+MAYBE_EXTERN double             rate                    DEFVAL(DEFAULT_RATE);
+MAYBE_EXTERN double             rate_scale              DEFVAL(DEFAULT_RATE_SCALE);
+MAYBE_EXTERN int                rate_increase           DEFVAL(0);
+MAYBE_EXTERN int                rate_max                DEFVAL(0);
+MAYBE_EXTERN unsigned long      rate_increase_freq      DEFVAL(DEFAULT_RATE_INCR_FREQ);
+MAYBE_EXTERN bool               rate_quit               DEFVAL(true);
+MAYBE_EXTERN int                users                   DEFVAL(-1);
+MAYBE_EXTERN int                rate_period_ms          DEFVAL(DEFAULT_RATE_PERIOD_MS);
+MAYBE_EXTERN int                sleeptime               DEFVAL(0);
+MAYBE_EXTERN unsigned long      defl_recv_timeout       DEFVAL(0);
+MAYBE_EXTERN unsigned long      defl_send_timeout       DEFVAL(0);
+MAYBE_EXTERN unsigned long      global_timeout          DEFVAL(0);
+MAYBE_EXTERN int                transport               DEFVAL(DEFAULT_TRANSPORT);
+MAYBE_EXTERN bool               retrans_enabled         DEFVAL(1);
+MAYBE_EXTERN int                rtcheck                 DEFVAL(RTCHECK_FULL);
+MAYBE_EXTERN int                max_udp_retrans         DEFVAL(UDP_MAX_RETRANS);
+MAYBE_EXTERN int                max_invite_retrans      DEFVAL(UDP_MAX_RETRANS_INVITE_TRANSACTION);
+MAYBE_EXTERN int                max_non_invite_retrans  DEFVAL(UDP_MAX_RETRANS_NON_INVITE_TRANSACTION);
+MAYBE_EXTERN unsigned long      default_behaviors       DEFVAL(DEFAULT_BEHAVIOR_ALL);
+MAYBE_EXTERN unsigned long      deadcall_wait           DEFVAL(DEFAULT_DEADCALL_WAIT);
+MAYBE_EXTERN bool               pause_msg_ign           DEFVAL(0);
+MAYBE_EXTERN bool               auto_answer             DEFVAL(false);
+MAYBE_EXTERN int                multisocket             DEFVAL(0);
+MAYBE_EXTERN int                compression             DEFVAL(0);
+MAYBE_EXTERN int                peripsocket             DEFVAL(0);
+MAYBE_EXTERN int                peripfield              DEFVAL(0);
+MAYBE_EXTERN bool               bind_local              DEFVAL(false);
+MAYBE_EXTERN void             * monosocket_comp_state   DEFVAL(0);
+MAYBE_EXTERN const char       * service                 DEFVAL(DEFAULT_SERVICE);
+MAYBE_EXTERN const char       * auth_password           DEFVAL(DEFAULT_AUTH_PASSWORD);
+MAYBE_EXTERN const char       * auth_username           DEFVAL(0);
+MAYBE_EXTERN unsigned long      report_freq             DEFVAL(DEFAULT_REPORT_FREQ);
+MAYBE_EXTERN unsigned long      report_freq_dumpLog     DEFVAL
 (DEFAULT_REPORT_FREQ_DUMP_LOG);
-extern bool               periodic_rtd            _DEFVAL(false);
-extern const char       * stat_delimiter          _DEFVAL(";");
+MAYBE_EXTERN bool               periodic_rtd            DEFVAL(false);
+MAYBE_EXTERN const char       * stat_delimiter          DEFVAL(";");
 
-extern bool               timeout_exit            _DEFVAL(false);
-extern bool               timeout_error           _DEFVAL(false);
+MAYBE_EXTERN bool               timeout_exit            DEFVAL(false);
+MAYBE_EXTERN bool               timeout_error           DEFVAL(false);
 
-extern unsigned long      report_freq_dumpRtt     _DEFVAL
+MAYBE_EXTERN unsigned long      report_freq_dumpRtt     DEFVAL
 (DEFAULT_FREQ_DUMP_RTT);
 
-extern int                max_multi_socket        _DEFVAL
+MAYBE_EXTERN unsigned           max_multi_socket        DEFVAL
 (DEFAULT_MAX_MULTI_SOCKET);
-extern bool               skip_rlimit             _DEFVAL(false);
+MAYBE_EXTERN bool               skip_rlimit             DEFVAL(false);
 
-extern unsigned int       timer_resolution        _DEFVAL(DEFAULT_TIMER_RESOLUTION);
-extern int                max_recv_loops          _DEFVAL(MAX_RECV_LOOPS_PER_CYCLE);
-extern int                max_sched_loops         _DEFVAL(MAX_SCHED_LOOPS_PER_CYCLE);
+MAYBE_EXTERN unsigned int       timer_resolution        DEFVAL(DEFAULT_TIMER_RESOLUTION);
+MAYBE_EXTERN int                max_recv_loops          DEFVAL(MAX_RECV_LOOPS_PER_CYCLE);
+MAYBE_EXTERN int                max_sched_loops         DEFVAL(MAX_SCHED_LOOPS_PER_CYCLE);
 
-extern unsigned int       global_t2               _DEFVAL(DEFAULT_T2_TIMER_VALUE);
+MAYBE_EXTERN unsigned int       global_t2               DEFVAL(DEFAULT_T2_TIMER_VALUE);
 
-extern char               local_ip[40];
-extern char               local_ip_escaped[42];   /* with [brackets] in case of IPv6 */
-extern bool               local_ip_is_ipv6;
-extern int                local_port              _DEFVAL(0);
+MAYBE_EXTERN char               local_ip[127];          /* also used for hostnames */
+MAYBE_EXTERN char               local_ip_w_brackets[42]; /* with [brackets] in case of IPv6 */
+MAYBE_EXTERN bool               local_ip_is_ipv6;
+MAYBE_EXTERN int                local_port              DEFVAL(0);
 #ifdef USE_SCTP
-extern char               multihome_ip[40];
-extern int                heartbeat               _DEFVAL(0);
-extern int                assocmaxret             _DEFVAL(0);
-extern int                pathmaxret              _DEFVAL(0);
-extern int                pmtu                    _DEFVAL(0);
-extern bool               gracefulclose           _DEFVAL(true);
+MAYBE_EXTERN char               multihome_ip[40];
+MAYBE_EXTERN int                heartbeat               DEFVAL(0);
+MAYBE_EXTERN int                assocmaxret             DEFVAL(0);
+MAYBE_EXTERN int                pathmaxret              DEFVAL(0);
+MAYBE_EXTERN int                pmtu                    DEFVAL(0);
+MAYBE_EXTERN bool               gracefulclose           DEFVAL(true);
 #endif
-extern char               control_ip[40];
-extern int                control_port            _DEFVAL(0);
-extern int                buff_size               _DEFVAL(65535);
-extern int                tcp_readsize            _DEFVAL(65535);
-#if defined(PCAPPLAY) || defined(RTP_STREAM)
-extern int                hasMedia                _DEFVAL(0);
-#endif
-#ifdef RTP_STREAM
-extern int                min_rtp_port            _DEFVAL(DEFAULT_MIN_RTP_PORT);
-extern int                max_rtp_port            _DEFVAL(DEFAULT_MAX_RTP_PORT);
-extern int                rtp_default_payload     _DEFVAL(DEFAULT_RTP_PAYLOAD);
-extern int                rtp_tasks_per_thread    _DEFVAL(DEFAULT_RTP_THREADTASKS);
-extern int                rtp_buffsize            _DEFVAL(65535);
-#endif
-
-extern bool               rtp_echo_enabled        _DEFVAL(0);
-extern char               media_ip[40];
-extern int                user_media_port         _DEFVAL(0);
-extern int                media_port              _DEFVAL(0);
-extern size_t             media_bufsize           _DEFVAL(2048);
-extern_c bool             media_ip_is_ipv6        _DEFVAL(false);
-extern char               remote_ip[40];
-extern char               remote_ip_escaped[42];  /* with [brackets] in case of IPv6 */
-extern int                remote_port             _DEFVAL(DEFAULT_PORT);
-extern unsigned int       pid                     _DEFVAL(0);
-extern bool               print_all_responses     _DEFVAL(false);
-extern unsigned long      stop_after              _DEFVAL(0xffffffff);
-extern int                quitting                _DEFVAL(0);
-extern int                interrupt               _DEFVAL(0);
-extern bool               paused                  _DEFVAL(false);
-extern int                lose_packets            _DEFVAL(0);
-extern double             global_lost             _DEFVAL(0.0);
-extern char               remote_host[255];
-extern char               twinSippHost[255];
-extern char               twinSippIp[40];
-extern char             * master_name;
-extern char             * slave_number;
-extern int                twinSippPort            _DEFVAL(DEFAULT_3PCC_PORT);
-extern bool               twinSippMode            _DEFVAL(false);
-extern bool               extendedTwinSippMode    _DEFVAL(false);
-
-extern bool               nostdin                 _DEFVAL(false);
-extern bool               use_curses              _DEFVAL(true);
-extern bool               backgroundMode          _DEFVAL(false);
-extern bool               signalDump              _DEFVAL(false);
-
-extern int                currentScreenToDisplay  _DEFVAL
+MAYBE_EXTERN char               control_ip[40];
+MAYBE_EXTERN int                control_port            DEFVAL(0);
+MAYBE_EXTERN int                buff_size               DEFVAL(65535);
+MAYBE_EXTERN int                tcp_readsize            DEFVAL(65535);
+MAYBE_EXTERN int                hasMedia                DEFVAL(0);
+MAYBE_EXTERN int                rtp_default_payload     DEFVAL(DEFAULT_RTP_PAYLOAD);
+MAYBE_EXTERN int                rtp_tasks_per_thread    DEFVAL(DEFAULT_RTP_THREADTASKS);
+MAYBE_EXTERN int                rtp_buffsize            DEFVAL(65535);
+
+MAYBE_EXTERN bool               rtp_echo_enabled        DEFVAL(0);
+MAYBE_EXTERN char               media_ip[127];          /* also used for hostnames */
+MAYBE_EXTERN int                user_media_port         DEFVAL(0);
+MAYBE_EXTERN int                media_port              DEFVAL(0);
+MAYBE_EXTERN size_t             media_bufsize           DEFVAL(2048);
+MAYBE_EXTERN bool               media_ip_is_ipv6        DEFVAL(false);
+MAYBE_EXTERN char               remote_ip[127];         /* also used for hostnames */
+MAYBE_EXTERN char               remote_ip_w_brackets[42]; /* with [brackets] in case of IPv6 */
+MAYBE_EXTERN int                remote_port             DEFVAL(DEFAULT_PORT);
+MAYBE_EXTERN unsigned int       pid                     DEFVAL(0);
+MAYBE_EXTERN bool               print_all_responses     DEFVAL(false);
+MAYBE_EXTERN unsigned long      stop_after              DEFVAL(0xffffffff);
+MAYBE_EXTERN int                quitting                DEFVAL(0);
+MAYBE_EXTERN int                interrupt               DEFVAL(0);
+MAYBE_EXTERN bool               paused                  DEFVAL(false);
+MAYBE_EXTERN int                lose_packets            DEFVAL(0);
+MAYBE_EXTERN double             global_lost             DEFVAL(0.0);
+MAYBE_EXTERN char               remote_host[255];
+MAYBE_EXTERN char               twinSippHost[255];
+MAYBE_EXTERN char               twinSippIp[40];
+MAYBE_EXTERN char             * master_name;
+MAYBE_EXTERN char             * slave_number;
+MAYBE_EXTERN int                twinSippPort            DEFVAL(DEFAULT_3PCC_PORT);
+MAYBE_EXTERN bool               twinSippMode            DEFVAL(false);
+MAYBE_EXTERN bool               extendedTwinSippMode    DEFVAL(false);
+
+MAYBE_EXTERN bool               nostdin                 DEFVAL(false);
+MAYBE_EXTERN bool               backgroundMode          DEFVAL(false);
+MAYBE_EXTERN bool               signalDump              DEFVAL(false);
+
+MAYBE_EXTERN int                currentScreenToDisplay  DEFVAL
 (DISPLAY_SCENARIO_SCREEN);
-extern int                currentRepartitionToDisplay  _DEFVAL(1);
-extern unsigned int       base_cseq               _DEFVAL(0);
-extern char             * auth_uri                _DEFVAL(0);
-extern const char       * call_id_string          _DEFVAL("%u-%p@%s");
-extern char             **generic[100];
+MAYBE_EXTERN int                currentRepartitionToDisplay  DEFVAL(1);
+MAYBE_EXTERN unsigned int       base_cseq               DEFVAL(0);
+MAYBE_EXTERN char             * auth_uri                DEFVAL(0);
+MAYBE_EXTERN const char       * call_id_string          DEFVAL("%u-%p@%s");
+MAYBE_EXTERN char             **generic[100];
 
-extern bool               callidSlash             _DEFVAL(false);
+MAYBE_EXTERN bool               rtp_echo_state          DEFVAL(true);
+MAYBE_EXTERN bool               callidSlash             DEFVAL(false);
 
 /* TDM map */
-extern bool               use_tdmmap              _DEFVAL(false);
-extern unsigned int       tdm_map_a               _DEFVAL(0);
-extern unsigned int       tdm_map_b               _DEFVAL(0);
-extern unsigned int       tdm_map_c               _DEFVAL(0);
-extern unsigned int       tdm_map_x               _DEFVAL(0);
-extern unsigned int       tdm_map_y               _DEFVAL(0);
-extern unsigned int       tdm_map_z               _DEFVAL(0);
-extern unsigned int       tdm_map_h               _DEFVAL(0);
-extern bool               tdm_map[1024];
-
-extern const char       * pid_file            _DEFVAL(DEFAULT_PID_FILE);
-extern const char       * lua_file            _DEFVAL(DEFAULT_LUA_FILE);
-#ifdef USE_OPENSSL
-extern BIO              * twinSipp_bio;
-extern SSL              * twinSipp_ssl;
-extern const char       * tls_cert_name           _DEFVAL(DEFAULT_TLS_CERT);
-extern const char       * tls_key_name            _DEFVAL(DEFAULT_TLS_KEY);
-extern const char       * tls_crl_name            _DEFVAL(DEFAULT_TLS_CRL);
-
+MAYBE_EXTERN bool               use_tdmmap              DEFVAL(false);
+MAYBE_EXTERN unsigned int       tdm_map_a               DEFVAL(0);
+MAYBE_EXTERN unsigned int       tdm_map_b               DEFVAL(0);
+MAYBE_EXTERN unsigned int       tdm_map_c               DEFVAL(0);
+MAYBE_EXTERN unsigned int       tdm_map_x               DEFVAL(0);
+MAYBE_EXTERN unsigned int       tdm_map_y               DEFVAL(0);
+MAYBE_EXTERN unsigned int       tdm_map_z               DEFVAL(0);
+MAYBE_EXTERN unsigned int       tdm_map_h               DEFVAL(0);
+MAYBE_EXTERN bool               tdm_map[1024];
+
+#ifdef USE_TLS
+MAYBE_EXTERN const char       * tls_cert_name           DEFVAL(DEFAULT_TLS_CERT);
+MAYBE_EXTERN const char       * tls_key_name            DEFVAL(DEFAULT_TLS_KEY);
+MAYBE_EXTERN const char       * tls_ca_name             DEFVAL(DEFAULT_TLS_CA);
+MAYBE_EXTERN const char       * tls_crl_name            DEFVAL(DEFAULT_TLS_CRL);
+MAYBE_EXTERN double             tls_version             DEFVAL(0.0);
 #endif
 
-extern char*              scenario_file           _DEFVAL(NULL);
-extern_c char*              scenario_path         _DEFVAL(NULL);
+MAYBE_EXTERN char*              scenario_file           DEFVAL(NULL);
+MAYBE_EXTERN char*              scenario_path           DEFVAL(NULL);
 
 // extern field file management
 typedef std::map<string, FileContents *> file_map;
-extern file_map inFiles;
+MAYBE_EXTERN file_map inFiles;
 typedef std::map<string, str_int_map *> file_index;
-extern char *ip_file _DEFVAL(NULL);
-extern char *default_file _DEFVAL(NULL);
+MAYBE_EXTERN char *ip_file DEFVAL(NULL);
+MAYBE_EXTERN char *default_file DEFVAL(NULL);
 
 // free user id list
-extern list<int> freeUsers;
-extern list<int> retiredUsers;
-extern AllocVariableTable *globalVariables        _DEFVAL(NULL);
-extern AllocVariableTable *userVariables          _DEFVAL(NULL);
+MAYBE_EXTERN list<int> freeUsers;
+MAYBE_EXTERN list<int> retiredUsers;
+MAYBE_EXTERN AllocVariableTable *globalVariables        DEFVAL(NULL);
+MAYBE_EXTERN AllocVariableTable *userVariables          DEFVAL(NULL);
 typedef std::map<int, VariableTable *> int_vt_map;
-extern int_vt_map         userVarMap;
-
-//extern int      new_socket(bool P_use_ipv6, int P_type_socket, int * P_status);
-extern struct   sipp_socket *new_sipp_socket(bool use_ipv6, int transport);
-struct sipp_socket *new_sipp_call_socket(bool use_ipv6, int transport, bool *existing);
-struct sipp_socket *sipp_accept_socket(struct sipp_socket *accept_socket);
-extern int      sipp_bind_socket(struct sipp_socket *socket, struct sockaddr_storage *saddr, int *port);
-extern int      sipp_connect_socket(struct sipp_socket *socket, struct sockaddr_storage *dest);
-extern int      sipp_reconnect_socket(struct sipp_socket *socket);
-extern void     sipp_customize_socket(struct sipp_socket *socket);
-extern int      delete_socket(int P_socket);
-extern int      min_socket          _DEFVAL(65535);
-extern int      select_socket       _DEFVAL(0);
-extern bool     socket_close        _DEFVAL(true);
-extern bool     test_socket         _DEFVAL(true);
-extern bool     maxSocketPresent    _DEFVAL(false);
+MAYBE_EXTERN int_vt_map         userVarMap;
+
+MAYBE_EXTERN SIPpSocket* new_sipp_socket(bool use_ipv6, int transport);
+MAYBE_EXTERN int      sipp_bind_socket(SIPpSocket *socket, struct sockaddr_storage *saddr, int *port);
+MAYBE_EXTERN void     sipp_customize_socket(SIPpSocket *socket);
+MAYBE_EXTERN int      min_socket          DEFVAL(65535);
+MAYBE_EXTERN int      select_socket       DEFVAL(0);
+MAYBE_EXTERN bool     socket_close        DEFVAL(true);
+MAYBE_EXTERN bool     test_socket         DEFVAL(true);
+MAYBE_EXTERN bool     maxSocketPresent    DEFVAL(false);
 
 #include "time.hpp"
 
 /************************ Statistics **************************/
 
-extern unsigned long last_report_calls            _DEFVAL(0);
-extern unsigned long nb_net_send_errors           _DEFVAL(0);
-extern unsigned long nb_net_cong                  _DEFVAL(0);
-extern unsigned long nb_net_recv_errors           _DEFVAL(0);
-extern bool          cpu_max                      _DEFVAL(false);
-extern bool          outbound_congestion          _DEFVAL(false);
-extern int           open_calls_user_setting      _DEFVAL(0);
-extern int           resynch_send                 _DEFVAL(0);
-extern int           resynch_recv                 _DEFVAL(0);
-extern unsigned long rtp_pckts                    _DEFVAL(0);
-extern unsigned long rtp_bytes                    _DEFVAL(0);
-extern_c unsigned long rtp_pckts_pcap             _DEFVAL(0);
-extern_c unsigned long rtp_bytes_pcap             _DEFVAL(0);
-extern unsigned long rtp2_pckts                   _DEFVAL(0);
-extern unsigned long rtp2_bytes                   _DEFVAL(0);
-extern unsigned long rtp2_pckts_pcap              _DEFVAL(0);
-extern unsigned long rtp2_bytes_pcap              _DEFVAL(0);
-#ifdef RTP_STREAM
-extern volatile unsigned long rtpstream_numthreads _DEFVAL(0);
-extern volatile unsigned long rtpstream_bytes_in  _DEFVAL(0);
-extern volatile unsigned long rtpstream_bytes_out _DEFVAL(0);
-extern volatile unsigned long rtpstream_pckts     _DEFVAL(0);
-#endif
+MAYBE_EXTERN unsigned long last_report_calls            DEFVAL(0);
+MAYBE_EXTERN unsigned long nb_net_send_errors           DEFVAL(0);
+MAYBE_EXTERN unsigned long nb_net_cong                  DEFVAL(0);
+MAYBE_EXTERN unsigned long nb_net_recv_errors           DEFVAL(0);
+MAYBE_EXTERN bool          cpu_max                      DEFVAL(false);
+MAYBE_EXTERN bool          outbound_congestion          DEFVAL(false);
+MAYBE_EXTERN int           open_calls_user_setting      DEFVAL(0);
+MAYBE_EXTERN int           resynch_send                 DEFVAL(0);
+MAYBE_EXTERN int           resynch_recv                 DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp_pckts                    DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp_bytes                    DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp_pckts_pcap               DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp_bytes_pcap               DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp2_pckts                   DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp2_bytes                   DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp2_pckts_pcap              DEFVAL(0);
+MAYBE_EXTERN unsigned long rtp2_bytes_pcap              DEFVAL(0);
+MAYBE_EXTERN volatile unsigned long rtpstream_numthreads DEFVAL(0);
+MAYBE_EXTERN volatile unsigned long rtpstream_bytes_in  DEFVAL(0);
+MAYBE_EXTERN volatile unsigned long rtpstream_bytes_out DEFVAL(0);
+MAYBE_EXTERN volatile unsigned long rtpstream_pckts     DEFVAL(0);
 
 
 /************* Rate Control & Contexts variables **************/
 
-extern int           last_running_calls           _DEFVAL(0);
-extern int           last_woken_calls             _DEFVAL(0);
-extern int           last_paused_calls            _DEFVAL(0);
-extern unsigned int  open_calls_allowed           _DEFVAL(0);
-extern unsigned long last_report_time             _DEFVAL(0);
-extern unsigned long last_dump_time               _DEFVAL(0);
-extern unsigned long last_rate_increase_time      _DEFVAL(0);
+MAYBE_EXTERN int           last_running_calls           DEFVAL(0);
+MAYBE_EXTERN int           last_woken_calls             DEFVAL(0);
+MAYBE_EXTERN int           last_paused_calls            DEFVAL(0);
+MAYBE_EXTERN unsigned int  open_calls_allowed           DEFVAL(0);
+MAYBE_EXTERN unsigned long last_report_time             DEFVAL(0);
+MAYBE_EXTERN unsigned long last_dump_time               DEFVAL(0);
+MAYBE_EXTERN unsigned long last_rate_increase_time      DEFVAL(0);
 
 /********************** Clock variables ***********************/
 
-extern unsigned long clock_tick                   _DEFVAL(0);
-extern unsigned long scheduling_loops             _DEFVAL(0);
-extern unsigned long last_timer_cycle             _DEFVAL(0);
+MAYBE_EXTERN unsigned long clock_tick                   DEFVAL(0);
+MAYBE_EXTERN unsigned long scheduling_loops             DEFVAL(0);
+MAYBE_EXTERN unsigned long last_timer_cycle             DEFVAL(0);
 
-extern unsigned long watchdog_interval            _DEFVAL(400);
-extern unsigned long watchdog_minor_threshold     _DEFVAL(500);
-extern unsigned long watchdog_minor_maxtriggers   _DEFVAL(120);
-extern unsigned long watchdog_major_threshold     _DEFVAL(3000);
-extern unsigned long watchdog_major_maxtriggers   _DEFVAL(10);
-extern unsigned long watchdog_reset               _DEFVAL(600000);
+MAYBE_EXTERN unsigned long watchdog_interval            DEFVAL(400);
+MAYBE_EXTERN unsigned long watchdog_minor_threshold     DEFVAL(500);
+MAYBE_EXTERN unsigned long watchdog_minor_maxtriggers   DEFVAL(120);
+MAYBE_EXTERN unsigned long watchdog_major_threshold     DEFVAL(3000);
+MAYBE_EXTERN unsigned long watchdog_major_maxtriggers   DEFVAL(10);
+MAYBE_EXTERN unsigned long watchdog_reset               DEFVAL(600000);
 
 
 /********************* dynamic Id ************************* */
-extern  int maxDynamicId    _DEFVAL(12000);  // max value for dynamicId; this value is reached
-extern  int startDynamicId  _DEFVAL(10000);  // offset for first dynamicId  FIXME:in CmdLine
-extern  int stepDynamicId   _DEFVAL(4);      // step of increment for dynamicId
-
-
-
-#define GET_TIME(clock)       \
-{                             \
-  struct timezone tzp;        \
-  gettimeofday (clock, &tzp); \
+MAYBE_EXTERN  int maxDynamicId    DEFVAL(12000);  // max value for dynamicId; this value is reached
+MAYBE_EXTERN  int startDynamicId  DEFVAL(10000);  // offset for first dynamicId  FIXME:in CmdLine
+MAYBE_EXTERN  int stepDynamicId   DEFVAL(4);      // step of increment for dynamicId
+
+#define GET_TIME(clock) \
+{ \
+    struct timezone tzp; \
+    gettimeofday (clock, &tzp); \
 }
 
 /*********************** Global Sockets  **********************/
 
-extern struct sipp_socket *main_socket            _DEFVAL(NULL);
-extern struct sipp_socket *main_remote_socket     _DEFVAL(NULL);
-extern struct sipp_socket *tcp_multiplex          _DEFVAL(NULL);
-extern int media_socket_audio                     _DEFVAL(0);
-extern int media_socket_video                     _DEFVAL(0);
-
-extern struct sockaddr_storage  local_sockaddr;
-extern struct sockaddr_storage  localTwin_sockaddr;
-extern int           user_port                    _DEFVAL(0);
-extern char          hostname[80];
-extern bool          is_ipv6                      _DEFVAL(false);
-
-extern int           reset_number                 _DEFVAL(0);
-extern bool          reset_close                  _DEFVAL(true);
-extern int           reset_sleep                  _DEFVAL(1000);
-extern bool          sendbuffer_warn              _DEFVAL(false);
+MAYBE_EXTERN SIPpSocket   *main_socket                  DEFVAL(NULL);
+MAYBE_EXTERN SIPpSocket   *main_remote_socket           DEFVAL(NULL);
+MAYBE_EXTERN SIPpSocket   *tcp_multiplex                DEFVAL(NULL);
+MAYBE_EXTERN int media_socket_audio                     DEFVAL(0);
+MAYBE_EXTERN int media_socket_video                     DEFVAL(0);
+
+MAYBE_EXTERN struct sockaddr_storage local_sockaddr;
+MAYBE_EXTERN struct sockaddr_storage localTwin_sockaddr;
+MAYBE_EXTERN int           user_port                    DEFVAL(0);
+MAYBE_EXTERN char          hostname[80];
+
+MAYBE_EXTERN int           reset_number                 DEFVAL(0);
+MAYBE_EXTERN bool          reset_close                  DEFVAL(true);
+MAYBE_EXTERN int           reset_sleep                  DEFVAL(1000);
+MAYBE_EXTERN bool          sendbuffer_warn              DEFVAL(false);
 /* A list of sockets pending reset. */
-extern set<struct sipp_socket *> sockets_pending_reset;
+MAYBE_EXTERN set<SIPpSocket*> sockets_pending_reset;
 
-extern struct addrinfo *local_addr_storage;
+MAYBE_EXTERN struct sockaddr_storage local_addr_storage;
 
-extern struct sipp_socket *twinSippSocket         _DEFVAL(NULL);
-extern struct sipp_socket *localTwinSippSocket    _DEFVAL(NULL);
-extern struct sockaddr_storage twinSipp_sockaddr;
+MAYBE_EXTERN SIPpSocket   *twinSippSocket               DEFVAL(NULL);
+MAYBE_EXTERN SIPpSocket   *localTwinSippSocket          DEFVAL(NULL);
+MAYBE_EXTERN struct sockaddr_storage twinSipp_sockaddr;
 
 /* 3pcc extended mode */
 typedef struct _T_peer_infos {
-    char                      peer_host[40];
-    int                       peer_port;
-    struct sockaddr_storage   peer_sockaddr;
-    char                      peer_ip[40];
-    struct sipp_socket        *peer_socket;
+    char peer_host[40];
+    int peer_port;
+    struct sockaddr_storage peer_sockaddr;
+    char peer_ip[40];
+    SIPpSocket *peer_socket;
 } T_peer_infos;
 
-typedef std::map<std::string, char * > peer_addr_map;
-extern peer_addr_map peer_addrs;
+typedef std::map<std::string, char*> peer_addr_map;
+MAYBE_EXTERN peer_addr_map peer_addrs;
 typedef std::map<std::string, T_peer_infos> peer_map;
-extern peer_map      peers;
-typedef std::map<struct sipp_socket *, std::string > peer_socket_map;
-extern peer_socket_map peer_sockets;
-extern struct sipp_socket *local_sockets[MAX_LOCAL_TWIN_SOCKETS];
-extern int           local_nb                    _DEFVAL(0);
-extern int           peers_connected             _DEFVAL(0);
+MAYBE_EXTERN peer_map      peers;
+typedef std::map<SIPpSocket*, std::string> peer_socket_map;
+MAYBE_EXTERN peer_socket_map peer_sockets;
+MAYBE_EXTERN SIPpSocket *local_sockets[MAX_LOCAL_TWIN_SOCKETS];
+MAYBE_EXTERN int           local_nb                     DEFVAL(0);
+MAYBE_EXTERN int           peers_connected              DEFVAL(0);
 
-extern struct sockaddr_storage remote_sockaddr;
-extern short         use_remote_sending_addr      _DEFVAL(0);
-extern struct sockaddr_storage remote_sending_sockaddr;
+MAYBE_EXTERN struct sockaddr_storage remote_sockaddr;
+MAYBE_EXTERN short         use_remote_sending_addr      DEFVAL(0);
+MAYBE_EXTERN struct sockaddr_storage remote_sending_sockaddr;
 
 enum E_Alter_YesNo {
     E_ALTER_YES=0,
@@ -494,18 +477,18 @@ void sipp_exit(int rc);
 char *get_peer_addr(char *);
 
 bool reconnect_allowed();
-void reset_connection(struct sipp_socket *);
-void close_calls(struct sipp_socket *);
+void reset_connection(SIPpSocket *);
+void close_calls(SIPpSocket *);
 int close_connections();
 int open_connections();
 void timeout_alarm(int);
 
 /* extended 3PCC mode */
-struct sipp_socket **get_peer_socket(char *);
-bool is_a_peer_socket(struct sipp_socket *);
-bool is_a_local_socket(struct sipp_socket *);
-void connect_to_peer (char *, int , sockaddr_storage *, char *, struct sipp_socket **);
-void connect_to_all_peers ();
+SIPpSocket **get_peer_socket(char *);
+bool is_a_peer_socket(SIPpSocket *);
+bool is_a_local_socket(SIPpSocket *);
+void connect_to_peer(char *, int, sockaddr_storage *, char *, SIPpSocket **);
+void connect_to_all_peers();
 void connect_local_twin_socket(char *);
 void close_peer_sockets();
 void close_local_sockets();
@@ -513,8 +496,4 @@ void free_peer_addr_map();
 
 /********************* Reset global kludge  *******************/
 
-#ifdef GLOBALS_FULL_DEFINITION
-#undef extern
-#endif
-
 #endif // __SIPP__
diff --git a/src/call.cpp b/src/call.cpp
index af772b2d2..fc6b05b39 100644
--- a/src/call.cpp
+++ b/src/call.cpp
@@ -36,39 +36,25 @@
  *           Roland Meub
  *           Andy Aicken
  *           Martin H. VanLeeuwen
- * 	      4/25/19 - NVF Added code to allow longer arguments and more arguments - see MAXARGS, also added support for a rawdata tag which will take all the remaining command line and pass it as a value to the lua program
- * 	      3/16/22 - NVF Restructured the code so we can add the extra functionality using the built-in plugin capability with some extra code to allow plugins to 
- * 	      add extra sipp functionality via the exec command by interpreting the commands before running the default executor - this allows adding things like threading, lua scripting etc.
- *	
  */
 
-#include <iterator>
 #include <algorithm>
+#include <cstring>
 #include <fstream>
 #include <iostream>
-#include <cstring>
+#include <iterator>
+#include <sstream>
+#include <vector>
+
+#include <assert.h>
+#include <stdarg.h>
 #include <sys/types.h>
 #include <sys/wait.h>
-#include <assert.h>
-// Added for LUA support
-
-#include <lua.h>
-#include <lualib.h>
-#include <lauxlib.h>
-
-// Added for shared memory support
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <malloc.h>
-
-
-#include <inttypes.h>
-#include <errno.h>
 
 #ifdef PCAPPLAY
 #include "send_packets.h"
 #endif
+
 #include "sipp.hpp"
 #include "auth.hpp"
 #include "deadcall.hpp"
@@ -76,15 +62,47 @@
 #include "version.h"
 #include "apifunc.h"
 
-// 02/9/2022 - NVF Added when trying to fix mysql thread support
-#include "mysql.h"
+using namespace std;
 
-#define callDebug(...) do { if (useCallDebugf) { _callDebug( __VA_ARGS__ ); } } while (0)
 
-using namespace std;
+template<typename Out>
+void split(const std::string &s, char delim, Out result) {
+    std::stringstream ss;
+    ss.str(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        *(result++) = item;
+    }
+}
+
+std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    split(s, delim, std::back_inserter(elems));
+    return elems;
+}
+
+std::string join(const std::vector<std::string> &s, const char* delim) {
+    std::ostringstream imploded;
+    std::copy(s.begin(), s.end(), std::ostream_iterator<std::string>(imploded, delim));
+    std::string ret = imploded.str();
+    if (ret.length()) {
+        ret.resize(ret.length() - strlen(delim));
+    }
+    return ret;
+}
 
-extern  map<string, struct sipp_socket *>     map_perip_fd;
+std::string trim(const std::string &s) {
+    size_t first = s.find_first_not_of(' ');
+    if (first == string::npos) {
+        return s;
+    }
+    size_t last = s.find_last_not_of(' ');
+    return s.substr(first, (last - first + 1));
+}
 
+#define callDebug(...) do { if (useCallDebugf) { _callDebug( __VA_ARGS__ ); } } while (0)
+
+extern  map<string, SIPpSocket *>     map_perip_fd;
 
 #ifdef PCAPPLAY
 /* send_packets pthread wrapper */
@@ -94,6 +112,7 @@ int call::dynamicId       = 0;
 int call::maxDynamicId    = 10000+2000*4;      // FIXME both param to be in command line !!!!
 int call::startDynamicId  = 10000;             // FIXME both param to be in command line !!!!
 int call::stepDynamicId   = 4;                // FIXME both param to be in command line !!!!
+
 /************** Call map and management routines **************/
 static unsigned int next_number = 1;
 
@@ -147,292 +166,100 @@ unsigned int call::wake()
     return wake;
 }
 
-#ifdef PCAPPLAY
-static char* find_sdp_eol(char* line)
+static std::string find_in_sdp(std::string const &pattern, std::string const &msg)
 {
-    char* end = &line[strcspn(line, "\r\n")];
-    return end[0] == '\0' ? NULL : end;
-}
+    std::string::size_type begin, end;
 
-/******* Media information management *************************/
-/*
- * Look for "c=IN IP4 " pattern in the message and extract the following value
- * which should be IP address
- */
-uint32_t get_remote_ip_media(char *msg)
-{
-    char pattern[] = "c=IN IP4 ";
-    char *begin, *end;
-    char ip[32];
-    char *my_msg = strdup(msg);
-
-    if (!my_msg) {
-        return INADDR_NONE;
-    }
-    begin = strstr(my_msg, pattern);
-    if (!begin) {
-        free(my_msg);
-        /* Can't find what we're looking at -> return no address */
-        return INADDR_NONE;
-    }
-    begin += sizeof(pattern) - 1;
-    end = find_sdp_eol(begin);
-    if (!end) {
-        free(my_msg);
-        return INADDR_NONE;
-    }
-    *end = '\0';
-    memset(ip, 0, 32);
-    strncpy(ip, begin, sizeof(ip) - 1);
-    ip[sizeof(ip) - 1] = '\0';
-    free(my_msg);
-    return inet_addr(ip);
+    begin = msg.find(pattern);
+    if (begin == std::string::npos) {
+        return "";
+    }
+
+    begin += pattern.size();
+    end = msg.find_first_of(" \r\n", begin);
+    if (end == std::string::npos || begin == end) {
+        return "";
+    }
+
+    return msg.substr(begin, end - begin);
 }
 
-/*
- * Look for "c=IN IP6 " pattern in the message and extract the following value
- * which should be IPv6 address
- */
-uint8_t get_remote_ipv6_media(char *msg, struct in6_addr *addr)
+#ifdef PCAPPLAY
+void call::get_remote_media_addr(std::string const &msg)
 {
-    char pattern[] = "c=IN IP6 ";
-    char *begin, *end;
-    char ip[128];
-    char *my_msg = strdup(msg);
+    std::string host = find_in_sdp(media_ip_is_ipv6 ? "c=IN IP6 " : "c=IN IP4 ", msg);
+    if (host.empty()) {
+        return;
+    }
 
-    memset(addr, 0, sizeof(*addr));
-    memset(ip, 0, 128);
+    hasMediaInformation = 1;
+    const int family = media_ip_is_ipv6 ? AF_INET6 : AF_INET;
 
-    if (!my_msg) {
-        return 0;
+    std::string port = find_in_sdp("m=audio ", msg);
+    if (!port.empty()) {
+        gai_getsockaddr(&play_args_a.to, host.c_str(), port.c_str(),
+                        AI_NUMERICHOST | AI_NUMERICSERV, family);
     }
-    begin = strstr(my_msg,pattern);
-    if (!begin) {
-        free(my_msg);
-        /* Can't find what we're looking at -> return no address */
-        return 0;
-    }
-    begin += sizeof(pattern) - 1;
-    end = find_sdp_eol(begin);
-    if (!end) {
-        free(my_msg);
-        return 0;
+
+    port = find_in_sdp("m=image ", msg);
+    if (!port.empty()) {
+        gai_getsockaddr(&play_args_i.to, host.c_str(), port.c_str(),
+                        AI_NUMERICHOST | AI_NUMERICSERV, family);
     }
-    *end = '\0';
-    strncpy(ip, begin, sizeof(ip) -1);
-    ip[sizeof(ip) - 1] = '\0';
-    free(my_msg);
-    if (!inet_pton(AF_INET6, ip, addr)) {
-        return 0;
+
+    port = find_in_sdp("m=video ", msg);
+    if (!port.empty()) {
+        gai_getsockaddr(&play_args_v.to, host.c_str(), port.c_str(),
+                        AI_NUMERICHOST | AI_NUMERICSERV, family);
     }
-    return 1;
 }
+#endif
 
-/*
- * Look for "m=audio ", "m=image " or "m=video " pattern in the message
- * and extract the following value which should be port number.
- */
-enum media_ptn {
-    PAT_AUDIO,
-    PAT_IMAGE,
-    PAT_VIDEO
-};
-uint16_t get_remote_port_media(const char *msg, enum media_ptn pattype)
+/******* Extract RTP remote media infomartion from SDP  *******/
+/***** Similar to the routines used by the PCAP play code *****/
+
+void call::extract_rtp_remote_addr(const char* msg)
 {
-    const char *pattern;
-    char *begin, *end;
-    char number[6];
-
-    if (pattype == PAT_AUDIO) {
-        pattern = "m=audio ";
-    } else if (pattype == PAT_IMAGE) {
-        pattern = "m=image ";
-    } else if (pattype == PAT_VIDEO) {
-        pattern = "m=video ";
+    int ip_ver;
+    int audio_port = 0;
+    int image_port = 0;
+    int video_port = 0;
+
+    std::string host = find_in_sdp("c=IN IP4 ", msg);
+    if (host.empty()) {
+        host = find_in_sdp("c=IN IP6 ", msg);
+        if (host.empty()) {
+            ERROR("extract_rtp_remote_addr: invalid IP version in SDP message body");
+        }
+        ip_ver = 6;
     } else {
-        ERROR("Internal error: Undefined media pattern %d\n", 3);
+        ip_ver = 4;
     }
 
-    char *my_msg = strdup(msg);
-    if (!my_msg) {
-        return 0;
+    std::string port = find_in_sdp("m=audio ", msg);
+    if (!port.empty()) {
+        audio_port = ::atoi(port.c_str());
     }
-    begin = strstr(my_msg, pattern);
-    if (!begin) {
-        free(my_msg);
-        /* m=audio not found */
-        return 0;
-    }
-    begin += strlen(pattern);
-    end = find_sdp_eol(begin);
-    if (!end) {
-        free(my_msg);
-        ERROR("get_remote_port_media: no CRLF found");
-        return 0;
-    }
-    *end = '\0';
-    memset(number, 0, sizeof(number));
-    strncpy(number, begin, sizeof(number) - 1);
-    number[sizeof(number) - 1] = '\0';
-    free(my_msg);
-    return atoi(number);
-}
 
-/*
- * IPv{4,6} compliant
- */
-void call::get_remote_media_addr(char *msg)
-{
-    uint16_t audio_port, image_port, video_port;
-    if (media_ip_is_ipv6) {
-        struct in6_addr ip_media;
-        if (get_remote_ipv6_media(msg, &ip_media)) {
-            audio_port = get_remote_port_media(msg, PAT_AUDIO);
-            if (audio_port) {
-                /* We have audio in the SDP: set the to_audio addr */
-                (_RCAST(struct sockaddr_in6 *, &(play_args_a.to)))->sin6_flowinfo = 0;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_a.to)))->sin6_scope_id = 0;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_a.to)))->sin6_family = AF_INET6;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_a.to)))->sin6_port = htons(audio_port);
-                (_RCAST(struct sockaddr_in6 *, &(play_args_a.to)))->sin6_addr = ip_media;
-            }
-            image_port = get_remote_port_media(msg, PAT_IMAGE);
-            if (image_port) {
-                /* We have image in the SDP: set the to_image addr */
-                (_RCAST(struct sockaddr_in6 *, &(play_args_i.to)))->sin6_flowinfo = 0;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_i.to)))->sin6_scope_id = 0;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_i.to)))->sin6_family = AF_INET6;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_i.to)))->sin6_port = htons(image_port);
-                (_RCAST(struct sockaddr_in6 *, &(play_args_i.to)))->sin6_addr = ip_media;
-            }
-            video_port = get_remote_port_media(msg, PAT_VIDEO);
-            if (video_port) {
-                /* We have video in the SDP: set the to_video addr */
-                (_RCAST(struct sockaddr_in6 *, &(play_args_v.to)))->sin6_flowinfo = 0;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_v.to)))->sin6_scope_id = 0;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_v.to)))->sin6_family = AF_INET6;
-                (_RCAST(struct sockaddr_in6 *, &(play_args_v.to)))->sin6_port = htons(video_port);
-                (_RCAST(struct sockaddr_in6 *, &(play_args_v.to)))->sin6_addr = ip_media;
-            }
-            hasMediaInformation = 1;
-        }
-    } else {
-        uint32_t ip_media;
-        ip_media = get_remote_ip_media(msg);
-        if (ip_media != INADDR_NONE) {
-            audio_port = get_remote_port_media(msg, PAT_AUDIO);
-            if (audio_port) {
-                /* We have audio in the SDP: set the to_audio addr */
-                (_RCAST(struct sockaddr_in *, &(play_args_a.to)))->sin_family = AF_INET;
-                (_RCAST(struct sockaddr_in *, &(play_args_a.to)))->sin_port = htons(audio_port);
-                (_RCAST(struct sockaddr_in *, &(play_args_a.to)))->sin_addr.s_addr = ip_media;
-            }
-            image_port = get_remote_port_media(msg, PAT_IMAGE);
-            if (image_port) {
-                /* We have image in the SDP: set the to_image addr */
-                (_RCAST(struct sockaddr_in *, &(play_args_i.to)))->sin_family = AF_INET;
-                (_RCAST(struct sockaddr_in *, &(play_args_i.to)))->sin_port = htons(image_port);
-                (_RCAST(struct sockaddr_in *, &(play_args_i.to)))->sin_addr.s_addr = ip_media;
-            }
-            video_port = get_remote_port_media(msg, PAT_VIDEO);
-            if (video_port) {
-                /* We have video in the SDP: set the to_video addr */
-                (_RCAST(struct sockaddr_in *, &(play_args_v.to)))->sin_family = AF_INET;
-                (_RCAST(struct sockaddr_in *, &(play_args_v.to)))->sin_port = htons(video_port);
-                (_RCAST(struct sockaddr_in *, &(play_args_v.to)))->sin_addr.s_addr = ip_media;
-            }
-            hasMediaInformation = 1;
-        }
+    port = find_in_sdp("m=image ", msg);
+    if (!port.empty()) {
+        image_port = ::atoi(port.c_str());
     }
-}
 
-#endif
+    port = find_in_sdp("m=video ", msg);
+    if (!port.empty()) {
+        video_port = ::atoi(port.c_str());
+    }
 
-#ifdef RTP_STREAM
-/******* Extract RTP remote media infomartion from SDP  *******/
-/***** Similar to the routines used by the PCAP play code *****/
+    if (audio_port == 0 && image_port == 0 && video_port == 0) {
+        ERROR("extract_rtp_remote_addr: no m=audio, m=image or m=video line found in SDP message body");
+    }
 
-#define SDP_IPADDR_PREFIX    "\nc=IN IP"
-#define SDP_AUDIOPORT_PREFIX "\nm=audio"
-#define SDP_IMAGEPORT_PREFIX "\nm=image"
-#define SDP_VIDEOPORT_PREFIX "\nm=video"
-void call::extract_rtp_remote_addr (char * msg)
-{
-  char   *search;
-  char   *copy;
-  char   ip_addr[128];
-  int    ip_ver;
-  int    audio_port = 0;
-  int    image_port = 0;
-  int    video_port = 0;
-
-  /* Look for start of message body */
-  search= strstr(msg,"\r\n\r\n");
-  if (!search) {
-    ERROR("extract_rtp_remote_addr: SDP message body not found");
-  }
-  msg = search + 2; /* skip past header. point to blank line before body */
-  /* Now search for IP address field */
-  search= strstr(msg,SDP_IPADDR_PREFIX);
-  if (search) {
-    search+= strlen(SDP_IPADDR_PREFIX);
-    /* Get IP version number from c= */
-    if (*search=='4') {
-      ip_ver= 4;
-    } else if (*search=='6') {
-      ip_ver= 6;
-    } else {
-      ERROR("extract_rtp_remote_addr: invalid IP version '%c' in SDP message body",*search);
-    }
-    search++;
-    copy= ip_addr;
-    while ( (*search==' ') || (*search=='\t') ) {
-      search++;
-    }
-    while (!( (*search==' ') || (*search=='\t') || (*search=='\r') || (*search=='\n') )) {
-      *(copy++)= *(search++);
-    }
-    *copy= 0;
-  } else {
-    ERROR("extract_rtp_remote_addr: no IP address found in SDP message body");
-    *ip_addr= 0;
-  }
-  /* Now try to find the port number for the audio stream */
-  search= strstr(msg,SDP_AUDIOPORT_PREFIX);
-  if (search) {
-    search+= strlen(SDP_AUDIOPORT_PREFIX);
-    while ( (*search==' ') || (*search=='\t') ) {
-      search++;
-    }
-    sscanf (search,"%d",&audio_port);
-  }
-  /* And find the port number for the image stream */
-  search= strstr(msg,SDP_IMAGEPORT_PREFIX);
-  if (search) {
-    search+= strlen(SDP_IMAGEPORT_PREFIX);
-    while ( (*search==' ') || (*search=='\t') ) {
-      search++;
-    }
-    sscanf (search,"%d",&image_port);
-  }
-  /* And find the port number for the video stream */
-  search= strstr(msg,SDP_VIDEOPORT_PREFIX);
-  if (search) {
-    search+= strlen(SDP_VIDEOPORT_PREFIX);
-    while ( (*search==' ') || (*search=='\t') ) {
-      search++;
-    }
-    sscanf (search,"%d",&video_port);
-  }
-  if (audio_port == 0 && image_port == 0 && video_port == 0) {
-    ERROR("extract_rtp_remote_addr: no m=audio, m=image or m=video line found in SDP message body");
-  }
-  /* If we get an image_port only, we won't set anything useful.
-   * We cannot use rtpstream for udptl/t38 data because it has
-   * non-linear timing and data size. */
-  rtpstream_set_remote(&rtpstream_callinfo, ip_ver, ip_addr, audio_port, video_port);
+    /* If we get an image_port only, we won't set anything useful.
+     * We cannot use rtpstream for udptl/t38 data because it has
+     * non-linear timing and data size. */
+    rtpstream_set_remote(&rtpstream_callinfo, ip_ver, host.c_str(), audio_port, video_port);
 }
-#endif
 
 /******* Very simple hash for retransmission detection  *******/
 
@@ -447,16 +274,16 @@ unsigned long call::hash(const char * msg)
     } else if (rtcheck == RTCHECK_LOOSE) {
         /* Based on section 11.5 (bullet 2) of RFC2543 we only take into account
          * the To, From, Call-ID, and CSeq values. */
-        const char *hdr = get_header_content(msg,"To:");
+        const char *hdr = get_header_content(msg, "To:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
-        hdr = get_header_content(msg,"From:");
+        hdr = get_header_content(msg, "From:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
-        hdr = get_header_content(msg,"Call-ID:");
+        hdr = get_header_content(msg, "Call-ID:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
-        hdr = get_header_content(msg,"CSeq:");
+        hdr = get_header_content(msg, "CSeq:");
         while ((c = *hdr++))
             hash = c + (hash << 6) + (hash << 16) - hash;
         /* For responses, we should also consider the code and body (if any),
@@ -475,7 +302,7 @@ unsigned long call::hash(const char * msg)
             }
         }
     } else {
-        ERROR("Internal error: Invalid rtcheck %d\n", rtcheck);
+        ERROR("Internal error: Invalid rtcheck %d", rtcheck);
     }
 
     return hash;
@@ -487,12 +314,12 @@ call::call(const char *p_id, bool use_ipv6, int userId, struct sockaddr_storage
     init(main_scenario, NULL, dest, p_id, userId, use_ipv6, false, false);
 }
 
-call::call(const char *p_id, struct sipp_socket *socket, struct sockaddr_storage *dest) : listener(p_id, true)
+call::call(const char *p_id, SIPpSocket *socket, struct sockaddr_storage *dest) : listener(p_id, true)
 {
     init(main_scenario, socket, dest, p_id, 0 /* No User. */, socket->ss_ipv6, false /* Not Auto. */, false);
 }
 
-call::call(scenario * call_scenario, struct sipp_socket *socket, struct sockaddr_storage *dest, const char * p_id, int userId, bool ipv6, bool isAutomatic, bool isInitialization) : listener(p_id, true)
+call::call(scenario * call_scenario, SIPpSocket *socket, struct sockaddr_storage *dest, const char * p_id, int userId, bool ipv6, bool isAutomatic, bool isInitialization) : listener(p_id, true)
 {
     init(call_scenario, socket, dest, p_id, userId, ipv6, isAutomatic, isInitialization);
 }
@@ -535,7 +362,7 @@ call *call::add_call(int userId, bool ipv6, struct sockaddr_storage *dest)
 }
 
 
-void call::init(scenario * call_scenario, struct sipp_socket *socket, struct sockaddr_storage *dest, const char * p_id, int userId, bool ipv6, bool isAutomatic, bool isInitCall)
+void call::init(scenario * call_scenario, SIPpSocket *socket, struct sockaddr_storage *dest, const char * p_id, int userId, bool ipv6, bool isAutomatic, bool isInitCall)
 {
     this->call_scenario = call_scenario;
     zombie = false;
@@ -582,17 +409,15 @@ void call::init(scenario * call_scenario, struct sipp_socket *socket, struct soc
     dialog_authentication = NULL;
     dialog_challenge_type = 0;
 
-#ifdef USE_OPENSSL
-    m_ctx_ssl = NULL ;
-    m_bio = NULL ;
-#endif
-#ifdef RTP_STREAM
-  /* check and warn on rtpstream_new_call result? -> error alloc'ing mem */
-  rtpstream_new_call (&rtpstream_callinfo);
-#endif
+    next_nonce_count = 1;
+
+    /* check and warn on rtpstream_new_call result? -> error alloc'ing mem */
+    rtpstream_new_call(&rtpstream_callinfo);
 
 #ifdef PCAPPLAY
     hasMediaInformation = 0;
+    play_args_a.last_seq_no = 1200;
+    play_args_v.last_seq_no = 2400;
 #endif
 
     call_remote_socket = NULL;
@@ -603,7 +428,7 @@ void call::init(scenario * call_scenario, struct sipp_socket *socket, struct soc
         call_socket = NULL;
     }
     if (dest) {
-        memcpy(&call_peer, dest, SOCK_ADDR_SIZE(dest));
+        memcpy(&call_peer, dest, sizeof(call_peer));
     } else {
         memset(&call_peer, 0, sizeof(call_peer));
     }
@@ -717,30 +542,12 @@ void call::init(scenario * call_scenario, struct sipp_socket *socket, struct soc
             tdm_map_number = 0;
         }
     }
-  // Added LUA setup here
-
-/*
-     if (!L) {
-     	L = luaL_newstate();                        // Create Lua state variable 
-     	luaL_openlibs(L);                           // Load Lua libraries 
-
-     	if (luaL_loadfile(L, "sipp.lua")) // Load but don't run the Lua script 
-         bail(L, "luaL_loadfile() failed");      // Error out if file can't be read 
-
-     	if (lua_pcall(L, 0, 0, 0))                  // PRIMING RUN. FORGET THIS AND YOU'RE TOAST 
-         bail(L, "lua_pcall() failed");          // Error out if Lua file has an error 
-    }
-*/
-	
-
 
     callDebug("Starting call %s\n", id);
 
     setRunning();
 }
 
-
-
 int call::_callDebug(const char *fmt, ...)
 {
     va_list ap;
@@ -779,7 +586,7 @@ call::~call()
     }
 
     if (call_remote_socket && (call_remote_socket != main_remote_socket)) {
-        sipp_close_socket(call_remote_socket);
+        call_remote_socket->close();
     }
 
     /* Deletion of the call variable */
@@ -800,29 +607,27 @@ call::~call()
         free(transactions);
     }
 
-    if(last_recv_msg) {
+    if (last_recv_msg) {
         free(last_recv_msg);
     }
-    if(last_send_msg) {
+    if (last_send_msg) {
         free(last_send_msg);
     }
-    if(peer_tag) {
+    if (peer_tag) {
         free(peer_tag);
     }
 
-    if(dialog_route_set) {
+    if (dialog_route_set) {
         free(dialog_route_set);
     }
 
-    if(next_req_url) {
+    if (next_req_url) {
         free(next_req_url);
     }
 
-#ifdef RTP_STREAM
-  rtpstream_end_call (&rtpstream_callinfo);
-#endif
+    rtpstream_end_call(&rtpstream_callinfo);
 
-    if(dialog_authentication) {
+    if (dialog_authentication) {
         free(dialog_authentication);
     }
 
@@ -837,7 +642,6 @@ call::~call()
     }
 #endif
 
-
     free(start_time_rtd);
     free(rtd_done);
     free(debugBuffer);
@@ -871,23 +675,21 @@ void call::computeStat (CStat::E_Action P_action, unsigned long P_value, int whi
 void call::dump()
 {
     char s[MAX_HEADER_LEN];
-    char tmpbuf[MAX_HEADER_LEN];
-    sprintf(s, "%s: State %d", id, msg_index);
+    int slen = sizeof(s);
+    int written;
+
+    written = snprintf(s, slen, "%s: State %d", id, msg_index);
     if (next_retrans) {
-        snprintf(tmpbuf, 64, "%s (next retrans %u)", s, next_retrans);
-        strcat(s, tmpbuf);
+        written += snprintf(s + written, slen - written, " (next retrans %u)", next_retrans);
     }
     if (paused_until) {
-        snprintf(tmpbuf, 64, "%s (paused until %u)", s, paused_until);
-        strcat(s, tmpbuf);
+        written += snprintf(s + written, slen - written, " (paused until %u)", paused_until);
     }
     if (recv_timeout) {
-        snprintf(tmpbuf, 64, "%s (recv timeout %u)", s, recv_timeout);
-        strcat(s, tmpbuf);
+        written += snprintf(s + written, slen - written, " (recv timeout %u)", recv_timeout);
     }
     if (send_timeout) {
-        snprintf(tmpbuf, 64, "%s (send timeout %u)", s, send_timeout);
-        strcat(s, tmpbuf);
+        written += snprintf(s + written, slen - written, " (send timeout %u)", send_timeout);
     }
     WARNING("%s", s);
 }
@@ -907,17 +709,17 @@ bool call::connect_socket_if_needed()
 
         char peripaddr[256];
         if (!peripsocket) {
-            if ((associate_socket(new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
+            if ((associate_socket(SIPpSocket::new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
                 ERROR_NO("Unable to get a UDP socket (1)");
             }
         } else {
             char *tmp = peripaddr;
             getFieldFromInputFile(ip_file, peripfield, NULL, tmp);
-            map<string, struct sipp_socket *>::iterator i;
+            map<string, SIPpSocket *>::iterator i;
             i = map_perip_fd.find(peripaddr);
             if (i == map_perip_fd.end()) {
                 // Socket does not exist
-                if ((associate_socket(new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
+                if ((associate_socket(SIPpSocket::new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
                     ERROR_NO("Unable to get a UDP socket (2)");
                 } else {
                     /* Ensure that it stays persistent, because it is recorded in the map. */
@@ -935,13 +737,7 @@ bool call::connect_socket_if_needed()
             return true;
         }
 
-        memset(&saddr, 0, sizeof(struct sockaddr_storage));
-
-        memcpy(&saddr,
-               local_addr_storage->ai_addr,
-               SOCK_ADDR_SIZE(
-                   _RCAST(struct sockaddr_storage *,local_addr_storage->ai_addr)));
-
+        memcpy(&saddr, &local_addr_storage, sizeof(struct sockaddr_storage));
         if (use_ipv6) {
             saddr.ss_family       = AF_INET6;
         } else {
@@ -949,24 +745,7 @@ bool call::connect_socket_if_needed()
         }
 
         if (peripsocket) {
-            struct addrinfo * h ;
-            struct addrinfo   hints;
-            memset((char*)&hints, 0, sizeof(hints));
-            hints.ai_flags  = AI_PASSIVE;
-            hints.ai_family = PF_UNSPEC;
-            getaddrinfo(peripaddr,
-                        NULL,
-                        &hints,
-                        &h);
-            memcpy(&saddr, h->ai_addr,
-                   SOCK_ADDR_SIZE(_RCAST(struct sockaddr_storage*, h->ai_addr)));
-
-            if (use_ipv6) {
-                (_RCAST(struct sockaddr_in6*, &saddr))->sin6_port = htons(local_port);
-            } else {
-                (_RCAST(struct sockaddr_in*, &saddr))->sin_port = htons(local_port);
-            }
-            freeaddrinfo(h);
+            gai_getsockaddr(&saddr, peripaddr, local_port, AI_PASSIVE, AF_UNSPEC);
         }
 
         if (sipp_bind_socket(call_socket, &saddr, &call_port)) {
@@ -975,7 +754,7 @@ bool call::connect_socket_if_needed()
     } else { /* TCP, SCTP or TLS. */
         struct sockaddr_storage *L_dest = &remote_sockaddr;
 
-        if ((associate_socket(new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
+        if ((associate_socket(SIPpSocket::new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
             ERROR_NO("Unable to get a TCP/SCTP/TLS socket");
         }
 
@@ -989,7 +768,7 @@ bool call::connect_socket_if_needed()
             L_dest = &remote_sending_sockaddr;
         }
 
-        if (sipp_connect_socket(call_socket, L_dest)) {
+        if (call_socket->connect(L_dest)) {
             if (reconnect_allowed()) {
                 if(errno == EINVAL) {
                     /* This occurs sometime on HPUX but is not a true INVAL */
@@ -1019,6 +798,7 @@ bool call::connect_socket_if_needed()
                 }
             }
         }
+        call_port = call_socket->ss_port;
     }
     return true;
 }
@@ -1048,7 +828,7 @@ bool call::lost(int index)
 
 int call::send_raw(const char * msg, int index, int len)
 {
-    struct sipp_socket *sock;
+    SIPpSocket *sock;
     int rc;
 
     callDebug("Sending %s message for call %s (index %d, hash %lu):\n%s\n\n",
@@ -1080,7 +860,7 @@ int call::send_raw(const char * msg, int index, int len)
                 sipp_customize_socket(call_remote_socket);
 
                 if(transport != T_UDP) {
-                    if (sipp_connect_socket(call_remote_socket, L_dest)) {
+                    if (call_remote_socket->connect(L_dest)) {
                         if(errno == EINVAL) {
                             /* This occurs sometime on HPUX but is not a true INVAL */
                             ERROR("Unable to connect a %s socket for rsa option, remote peer error", TRANSPORT_TO_STRING(transport));
@@ -1109,7 +889,7 @@ int call::send_raw(const char * msg, int index, int len)
 
     assert(sock);
 
-    rc = write_socket(sock, msg, len, WS_BUFFER, &call_peer);
+    rc = sock->write(msg, len, WS_BUFFER, &call_peer);
     if(rc < 0 && errno == EWOULDBLOCK) {
         return rc;
     }
@@ -1212,7 +992,7 @@ char * call::get_last_request_uri()
     }
 
     if (!(last_request_uri = (char *)malloc(tmp_len + 1))) {
-        ERROR("Cannot allocate !\n");
+        ERROR("Cannot allocate!");
     }
 
     last_request_uri[0] = '\0';
@@ -1231,8 +1011,6 @@ char * call::send_scene(int index, int *send_status, int *len)
     char *L_ptr1 ;
     char *L_ptr2 ;
     int uselen = 0;
-    int tmplen;
-    char *hdrbdry;
 
     assert(send_status);
 
@@ -1272,16 +1050,6 @@ char * call::send_scene(int index, int *send_status, int *len)
         ack_is_pending = false ;
     }
 
-    /* Fix: Remove extra "\r\n" if message body ends with "\r\n\r\n" */
-    tmplen = (*len) - 1;
-    if ((dest[tmplen] == dest[tmplen-2] && dest[tmplen] == '\n')
-            && (dest[tmplen-1] == dest[tmplen-3] && dest[tmplen-1] == '\r'))  {
-        hdrbdry = strstr(dest, "\r\n\r\n");
-        if (NULL != hdrbdry &&  hdrbdry != dest+(tmplen-3))  {
-            *len = (*len) - 2;
-        }
-    }
-
     *send_status = send_raw(dest, index, *len);
 
     return dest;
@@ -1290,28 +1058,29 @@ char * call::send_scene(int index, int *send_status, int *len)
 void call::do_bookkeeping(message *curmsg)
 {
     /* If this message increments a counter, do it now. */
-    if(int counter = curmsg -> counter) {
-        computeStat(CStat::E_ADD_GENERIC_COUNTER, 1, counter - 1);
+    if (curmsg -> counter) {
+        computeStat(CStat::E_ADD_GENERIC_COUNTER, 1, curmsg->counter - 1);
     }
 
     /* If this message can be used to compute RTD, do it now */
-    if(int rtd = curmsg -> start_rtd) {
-        start_time_rtd[rtd - 1] = getmicroseconds();
+    if (curmsg->start_rtd) {
+        start_time_rtd[curmsg->start_rtd - 1] = getmicroseconds();
     }
 
-    if(int rtd = curmsg -> stop_rtd) {
+    if (curmsg->stop_rtd) {
+        int rtd = curmsg->stop_rtd;
         if (!rtd_done[rtd - 1]) {
             unsigned long long start = start_time_rtd[rtd - 1];
             unsigned long long end = getmicroseconds();
 
-            if(dumpInRtt) {
+            if (dumpInRtt) {
                 call_scenario->stats->computeRtt(start, end, rtd);
             }
 
             computeStat(CStat::E_ADD_RESPONSE_TIME_DURATION,
                         (end - start) / 1000, rtd - 1);
 
-            if (!curmsg -> repeat_rtd) {
+            if (!curmsg->repeat_rtd) {
                 rtd_done[rtd - 1] = true;
             }
         }
@@ -1368,6 +1137,38 @@ void call::terminate(CStat::E_Action reason)
         case call::E_AR_STOP_CALL:
             /* Do nothing. */
             break;
+        case call::E_AR_TEST_DOESNT_MATCH:
+            computeStat(CStat::E_CALL_FAILED);
+            computeStat(CStat::E_FAILED_TEST_DOESNT_MATCH);
+            if (deadcall_wait && !initCall) {
+                sprintf(reason_str, "test failure at index %d", msg_index);
+                new deadcall(id, reason_str);
+            }
+            break;
+        case call::E_AR_TEST_SHOULDNT_MATCH:
+            computeStat(CStat::E_CALL_FAILED);
+            computeStat(CStat::E_FAILED_TEST_SHOULDNT_MATCH);
+            if (deadcall_wait && !initCall) {
+                sprintf(reason_str, "test succeeded, but shouldn't at index %d", msg_index);
+                new deadcall(id, reason_str);
+            }
+            break;
+        case call::E_AR_STRCMP_DOESNT_MATCH:
+            computeStat(CStat::E_CALL_FAILED);
+            computeStat(CStat::E_FAILED_STRCMP_DOESNT_MATCH);
+            if (deadcall_wait && !initCall) {
+                sprintf(reason_str, "test failure at index %d", msg_index);
+                new deadcall(id, reason_str);
+            }
+            break;
+        case call::E_AR_STRCMP_SHOULDNT_MATCH:
+            computeStat(CStat::E_CALL_FAILED);
+            computeStat(CStat::E_FAILED_STRCMP_SHOULDNT_MATCH);
+            if (deadcall_wait && !initCall) {
+                sprintf(reason_str, "test succeeded, but shouldn't at index %d", msg_index);
+                new deadcall(id, reason_str);
+            }
+            break;
         }
     } else {
         if (reason == CStat::E_CALL_SUCCESSFULLY_ENDED || timewait) {
@@ -1512,6 +1313,12 @@ bool call::executeMessage(message *curmsg)
         }
 
         msg_snd = send_scene(msg_index, &send_status, &msgLen);
+        if (!msg_snd) {
+            /* This will hit connect_if_needed, and if it fails, the
+               entire call is deleted... */
+            ERROR("Call failed, cannot continue safely...");
+        }
+
         if(send_status < 0 && errno == EWOULDBLOCK) {
             if (incr_cseq) --cseq;
             /* Have we set the timeout yet? */
@@ -1677,12 +1484,12 @@ bool call::run()
     message *curmsg;
     if (initCall) {
         if(msg_index >= (int)call_scenario->initmessages.size()) {
-            ERROR("Scenario initialization overrun for call %s (%p) (index = %d)\n", id, _RCAST(void*, this), msg_index);
+            ERROR("Scenario initialization overrun for call %s (%p) (index = %d)", id, _RCAST(void*, this), msg_index);
         }
         curmsg = call_scenario->initmessages[msg_index];
     } else {
         if(msg_index >= (int)call_scenario->messages.size()) {
-            ERROR("Scenario overrun for call %s (%p) (index = %d)\n", id, _RCAST(void*, this), msg_index);
+            ERROR("Scenario overrun for call %s (%p) (index = %d)", id, _RCAST(void*, this), msg_index);
         }
         curmsg = call_scenario->messages[msg_index];
     }
@@ -1889,7 +1696,7 @@ void set_default_message(const char *which, char *msg)
     ERROR("Internal Error: Unknown default message: %s!", which);
 }
 
-bool call::process_unexpected(char * msg)
+bool call::process_unexpected(const char* msg)
 {
     char buffer[MAX_HEADER_LEN];
     char *desc = buffer;
@@ -2069,7 +1876,7 @@ int call::sendCmdMessage(message *curmsg)
 
     /* 3pcc extended mode */
     char * peer_dest;
-    struct sipp_socket **peer_socket;
+    SIPpSocket **peer_socket;
 
     if(curmsg -> M_sendCmdData) {
         // WARNING("---PREPARING_TWIN_CMD---%s---", scenario[index] -> M_sendCmdData);
@@ -2083,9 +1890,9 @@ int call::sendCmdMessage(message *curmsg)
         peer_dest = curmsg->peer_dest;
         if(peer_dest) {
             peer_socket = get_peer_socket(peer_dest);
-            rc = write_socket(*peer_socket, dest, strlen(dest), WS_BUFFER, &call_peer);
+            rc = (*peer_socket)->write(dest, strlen(dest), WS_BUFFER, &call_peer);
         } else {
-            rc = write_socket(twinSippSocket, dest, strlen(dest), WS_BUFFER, &call_peer);
+            rc = twinSippSocket->write(dest, strlen(dest), WS_BUFFER, &call_peer);
         }
         if(rc <  0) {
             computeStat(CStat::E_CALL_FAILED);
@@ -2113,7 +1920,7 @@ int call::sendCmdBuffer(char* cmd)
 
     strcat(dest, delimitor);
 
-    rc = write_socket(twinSippSocket, dest, strlen(dest), WS_BUFFER, &twinSippSocket->ss_remote_sockaddr);
+    rc = twinSippSocket->write(dest, strlen(dest), WS_BUFFER, &twinSippSocket->ss_dest);
     if(rc <  0) {
         computeStat(CStat::E_CALL_FAILED);
         computeStat(CStat::E_FAILED_CMD_NOT_SENT);
@@ -2160,7 +1967,7 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
             }
             break;
         case E_Message_Remote_IP:
-            dest += snprintf(dest, left, "%s", remote_ip_escaped);
+            dest += snprintf(dest, left, "%s", remote_ip_w_brackets);
             break;
         case E_Message_Remote_Host:
             dest += snprintf(dest, left, "%s", remote_host);
@@ -2169,11 +1976,11 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
             dest += snprintf(dest, left, "%d", remote_port + comp->offset);
             break;
         case E_Message_Local_IP:
-            dest += snprintf(dest, left, "%s", local_ip_escaped);
+            dest += snprintf(dest, left, "%s", local_ip_w_brackets);
             break;
         case E_Message_Local_Port:
             int port;
-            if((transport == T_UDP) && (multisocket) && (sendMode != MODE_SERVER)) {
+            if((multisocket) && (sendMode != MODE_SERVER)) {
                 port = call_port;
             } else {
                 port =  local_port;
@@ -2222,9 +2029,9 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
                 begin--;
             }
             if (begin == msg_buffer) {
-                ERROR("Can not find beginning of a line for the media port!\n");
+                ERROR("Can not find beginning of a line for the media port!");
             }
-            play_args_t *play_args = NULL;
+            play_args_t* play_args = NULL;
             if (strstr(begin, "audio")) {
                 play_args = &play_args_a;
             } else if (strstr(begin, "image")) {
@@ -2243,28 +2050,10 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
             dest += sprintf(dest, "%u", port);
             break;
         }
-#ifdef RTP_STREAM
-      case E_Message_RTPStream_Audio_Port:
-        {
-          int temp_audio_port= rtpstream_get_audioport (&rtpstream_callinfo);
-          if (!temp_audio_port) {
-            /* Make this a warning instead? */
-            ERROR("cannot assign a free audio port to this call - using 0 for [rtpstream_audio_port]");
-          }
-          dest += snprintf(dest, left, "%d",temp_audio_port);
-        }
-        break;
-      case E_Message_RTPStream_Video_Port:
-        {
-          int temp_video_port= rtpstream_get_videoport (&rtpstream_callinfo);
-          if (!temp_video_port) {
-            /* Make this a warning instead? */
-            ERROR("cannot assign a free video port to this call - using 0 for [rtpstream_video_port]");
-          }
-          dest += snprintf(dest, left, "%d",temp_video_port);
-        }
-        break;
-#endif
+        case E_Message_RTPStream_Audio_Port: /* DEPRECATED */
+        case E_Message_RTPStream_Video_Port: /* DEPRECATED */
+            dest += sprintf(dest, "%u", media_port);
+            break;
         case E_Message_Media_IP_Type:
             dest += snprintf(dest, left, "%s", (media_ip_is_ipv6 ? "6" : "4"));
             break;
@@ -2314,14 +2103,14 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
             break;
         case E_Message_Authentication:
             if (auth_marker) {
-                ERROR("Only one [authentication] keyword is currently supported!\n");
+                ERROR("Only one [authentication] keyword is currently supported!");
             }
             auth_marker = dest;
             dest += snprintf(dest, left, "[authentication place holder]");
             auth_comp = comp;
             break;
         case E_Message_Peer_Tag_Param:
-            if(peer_tag) {
+            if (peer_tag) {
                 dest += snprintf(dest, left, ";tag=%s", peer_tag);
             }
             break;
@@ -2404,7 +2193,7 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
             createSendingMessage(comp->comp_param.filename, -2, buffer, sizeof(buffer));
             FILE *f = fopen(buffer, "r");
             if (!f) {
-                ERROR("Could not open '%s': %s\n", buffer, strerror(errno));
+                ERROR("Could not open '%s': %s", buffer, strerror(errno));
             }
             int ret;
             while ((ret = fread(dest, 1, left, f)) > 0) {
@@ -2412,7 +2201,7 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
                 dest += ret;
             }
             if (ret < 0) {
-                ERROR("Error reading '%s': %s\n", buffer, strerror(errno));
+                ERROR("Error reading '%s': %s", buffer, strerror(errno));
             }
             fclose(f);
             break;
@@ -2423,7 +2212,7 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
             /* We are injecting an authentication line. */
             if (char *tmp = strstr(orig_dest, "[authentication")) {
                 if (auth_marker) {
-                    ERROR("Only one [authentication] keyword is currently supported!\n");
+                    ERROR("Only one [authentication] keyword is currently supported!");
                 }
                 auth_marker = tmp;
                 auth_comp = (struct MessageComponent *)calloc(1, sizeof(struct MessageComponent));
@@ -2538,21 +2327,10 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
         }
 
         int  auth_marker_len;
-        char * tmp;
         int  authlen;
 
         auth_marker_len = (strchr(auth_marker, ']') + 1) - auth_marker;
 
-        /* Need the Method name from the CSeq of the Challenge */
-        char method[MAX_HEADER_LEN];
-        tmp = get_last_header("CSeq:");
-        if(!tmp) {
-            ERROR("Could not extract method from cseq of challenge");
-        }
-        tmp += 5;
-        while(isspace(*tmp) || isdigit(*tmp)) tmp++;
-        sscanf(tmp,"%s", method);
-
         /* Determine the type of credentials. */
         char result[MAX_HEADER_LEN];
         if (dialog_challenge_type == 401) {
@@ -2579,8 +2357,11 @@ char* call::createSendingMessage(SendingMessage *src, int P_index, char *msg_buf
         createSendingMessage(auth_comp->comp_param.auth_param.aka_AMF, -2, my_aka_AMF, sizeof(my_aka_AMF));
         createSendingMessage(auth_comp->comp_param.auth_param.aka_OP, -2, my_aka_OP, sizeof(my_aka_OP));
 
-        if (createAuthHeader(my_auth_user, my_auth_pass, method, uri, auth_body, dialog_authentication,
-                             my_aka_OP, my_aka_AMF, my_aka_K, result + authlen) == 0) {
+        if (createAuthHeader(
+                my_auth_user, my_auth_pass, src->getMethod(), uri,
+                auth_body, dialog_authentication, my_aka_OP, my_aka_AMF,
+                my_aka_K, next_nonce_count++, result + authlen,
+                MAX_HEADER_LEN - authlen) == 0) {
             ERROR("%s", result + authlen);
         }
         authlen = strlen(result);
@@ -2631,7 +2412,7 @@ bool call::process_twinSippCom(char * msg)
                         found = true;
                         break;
                     } else {
-                        WARNING("Unexpected sender for the received peer message \n%s\n", msg);
+                        WARNING("Unexpected sender for the received peer message\n%s\n", msg);
                         return rejectCall();
                     }
                 } else {
@@ -2756,17 +2537,17 @@ bool call::check_peer_src(char * msg, int search_index)
 }
 
 
-void call::extract_cseq_method (char* method, char* msg)
+void call::extract_cseq_method(char* method, const char* msg)
 {
-    char* cseq ;
+    const char* cseq;
     if ((cseq = strstr (msg, "CSeq"))) {
-        char * value ;
-        if (( value = strchr (cseq,  ':'))) {
+        const char* value;
+        if ((value = strchr(cseq, ':'))) {
             value++;
-            while ( isspace(*value)) value++;  // ignore any white spaces after the :
-            while ( !isspace(*value)) value++;  // ignore the CSEQ number
-            while ( isspace(*value)) value++;  // ignore spaces after CSEQ number
-            char *end = value;
+            while (isspace(*value)) value++;  // ignore any white spaces after the :
+            while (!isspace(*value)) value++;  // ignore the CSEQ number
+            while (isspace(*value)) value++;  // ignore spaces after CSEQ number
+            const char* end = value;
             int nbytes = 0;
             /* A '\r' terminates the line, so we want to catch that too. */
             while ((*end != '\r') && (*end != '\n')) {
@@ -2779,7 +2560,7 @@ void call::extract_cseq_method (char* method, char* msg)
     }
 }
 
-void call::extract_transaction (char* txn, char* msg)
+void call::extract_transaction(char* txn, const char* msg)
 {
     char *via = get_header_content(msg, "via:");
     if (!via) {
@@ -2822,112 +2603,89 @@ void call::formatNextReqUrl(const char* contact)
 
 void call::computeRouteSetAndRemoteTargetUri(const char* rr, const char* contact, bool bRequestIncoming)
 {
+    if (!*contact) {
+        WARNING("Cannot record route set if there is no Contact");
+        return;
+    }
+
     if (!*rr) {
-        //
-        // there are no RR headers. Simply set up the contact as our target uri
-        //
-        if (*contact) {
-            formatNextReqUrl(contact);
-        }
+        /* There are no RR headers. Simply set up the contact as our
+         * target uri.  Note that this is only called if there was no
+         * dialog_route_set at the moment.  And in either case, we
+         * wouldn't want to clear the dialog_route_set because changing
+         * RR mid-dialog is not allowed. */
+        formatNextReqUrl(contact);
         return;
     }
 
-    char tmp_rr[MAX_HEADER_LEN];
-    char actual_rr[MAX_HEADER_LEN];
-    char targetURI[MAX_HEADER_LEN];
+    std::vector<std::string> headers = split(rr, ',');
+    std::vector<std::string>::iterator it;
+    std::vector<std::string>::iterator end;
+    int direction;
 
-    actual_rr[0] = tmp_rr[0] = targetURI[0] = '\0';
-    strncat(tmp_rr, rr, MAX_HEADER_LEN - 1);
+    if (bRequestIncoming) {
+        it = headers.begin();
+        end = headers.end();
+        direction = 1;
+    } else {
+        it = headers.end() - 1;
+        end = headers.begin() - 1;
+        direction = -1;
+    }
 
-    bool isFirst = true;
-    bool bCopyContactToRR = false;
+    std::vector<std::string> routes;
+    std::string targetUri;
+    bool first = true;
 
-    while (1) {
-        char* pointer = NULL;
-        if (bRequestIncoming) {
-            pointer = strchr(tmp_rr, ',');
-        } else {
-            pointer = strrchr(tmp_rr, ',');
-        }
+    for (; it != end; it += direction) {
+        const std::string& header = *it;
 
-        if (pointer) {
-            if (!isFirst) {
-                strcat(actual_rr, pointer + 1);
-                strcat(actual_rr, ",");
-            } else {
-                isFirst = false;
-                if (NULL == strstr(pointer, ";lr")) {
-                    /* bottom most RR is the next_req_url */
-                    strncpy(targetURI, pointer + 1, sizeof(targetURI) - 1);
-                    bCopyContactToRR = true;
-                } else {
-                    /* the hop is a loose router. Thus, the target URI should be the
-                     * contact
-                     */
-                    strcpy(targetURI, contact);
-                    strcpy(actual_rr, pointer + 1);
-                    strcat(actual_rr, ",");
-                }
-            }
+        if (first && header.find(";lr") == std::string::npos) {
+            /* If the next hop is a static router, set target URI to
+             * that router. We'll push the original contact onto the end
+             * of the route set. We won't need to record this route,
+             * because we've set the target to it. */
+            targetUri = header;
         } else {
-            if (!isFirst) {
-                strcat(actual_rr, tmp_rr);
-            }
-            //
-            // this is the *only* RR header that was found
-            //
-            else {
-                if (NULL == strstr(tmp_rr, ";lr")) {
-                    /* bottom most RR is the next_req_url */
-                    strcpy(targetURI, tmp_rr);
-                    bCopyContactToRR = true;
-                } else {
-                    /* the hop is a loose router. Thus, the target URI should be the
-                     * contact
-                     */
-                    strcpy(actual_rr, tmp_rr);
-                    strcpy(targetURI, contact);
-                }
-            }
-            break;
+            first = false;
+            routes.push_back(trim(header));
         }
-        *pointer = '\0';
     }
 
-    if (bCopyContactToRR) {
-        if (*actual_rr) {
-            strcat(actual_rr, ",");
-            strcat(actual_rr, contact);
-        } else {
-            strcpy(actual_rr, contact);
-        }
+    /* If target URI is set, the first hop is a strict router.  Add the
+     * Contact as tailing route. */
+    if (targetUri.length()) {
+        routes.push_back(trim(contact));
+    } else {
+        targetUri = contact;
     }
 
-    if (*actual_rr) {
-        dialog_route_set = strdup(actual_rr);
+    if (routes.size()) {
+        dialog_route_set = strdup(join(routes, ", ").c_str());
     }
 
-    if (*targetURI) {
-        formatNextReqUrl(targetURI);
-    }
+    formatNextReqUrl(targetUri.c_str());
 }
 
 bool call::matches_scenario(unsigned int index, int reply_code, char * request, char * responsecseqmethod, char *txn)
 {
     message *curmsg = call_scenario->messages[index];
 
-    if ((curmsg -> recv_request)) {
+    if ((curmsg->recv_request)) {
         if (curmsg->regexp_match) {
-            if (curmsg -> regexp_compile == NULL) {
+            if (curmsg->regexp_compile == NULL) {
                 regex_t *re = new regex_t;
-                if (regcomp(re, curmsg -> recv_request, REG_EXTENDED|REG_NOSUB)) {
+                /* No regex match position needed (NOSUB), we're simply
+                 * looking for the <request method="INVITE|REGISTER"../>
+                 * regex. */
+                if (regcomp(re, curmsg->recv_request, REGCOMP_PARAMS|REG_NOSUB)) {
                     ERROR("Invalid regular expression for index %d: %s", index, curmsg->recv_request);
                 }
-                curmsg -> regexp_compile = re;
+                curmsg->regexp_compile = re;
             }
-            return !regexec(curmsg -> regexp_compile, request, (size_t)0, NULL, 0);
+            return !regexec(curmsg->regexp_compile, request, (size_t)0, NULL, REGEXEC_PARAMS);
         } else {
-            return !strcmp(curmsg -> recv_request, request);
+            return !strcmp(curmsg->recv_request, request);
         }
     } else if (curmsg->recv_response && (curmsg->recv_response == reply_code)) {
         /* This is a potential candidate, we need to match transactions. */
@@ -2952,20 +2710,20 @@ bool call::matches_scenario(unsigned int index, int reply_code, char * request,
     return false;
 }
 
-void call::queue_up(char *msg)
+void call::queue_up(const char* msg)
 {
     free(queued_msg);
     queued_msg = strdup(msg);
 }
 
-bool call::process_incoming(char * msg, struct sockaddr_storage *src)
+bool call::process_incoming(const char* msg, const struct sockaddr_storage* src)
 {
-    int             reply_code;
+    int             reply_code = 0;
     static char     request[65];
     char            responsecseqmethod[65];
     char            txn[MAX_HEADER_LEN];
     unsigned long   cookie = 0;
-    char          * ptr;
+    const char*     ptr;
     int             search_index;
     bool            found = false;
     T_ActionResult  actionResult;
@@ -2975,18 +2733,21 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
               strlen(msg), id, hash(msg), msg);
 
     setRunning();
+    message *curmsg = call_scenario->messages[msg_index];
 
     /* Ignore the messages received during a pause if -pause_msg_ign is set */
-    if(call_scenario->messages[msg_index] -> M_type == MSG_TYPE_PAUSE && pause_msg_ign) return(true);
+    if (curmsg->M_type == MSG_TYPE_PAUSE && pause_msg_ign) {
+        return true;
+    }
 
     /* Get our destination if we have none. */
     if (call_peer.ss_family == AF_UNSPEC && src) {
-        memcpy(&call_peer, src, SOCK_ADDR_SIZE(src));
+        memcpy(&call_peer, src, sizeof(call_peer));
     }
 
     /* Authorize nop as a first command, even in server mode */
-    if((msg_index == 0) && (call_scenario->messages[msg_index] -> M_type == MSG_TYPE_NOP)) {
-        queue_up (msg);
+    if (msg_index == 0 && curmsg->M_type == MSG_TYPE_NOP) {
+        queue_up(msg);
         paused_until = 0;
         return run();
     }
@@ -3051,30 +2812,31 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
         }
     }
 
-#ifdef RTP_STREAM
-  /* Check if message has a SDP in it; and extract media information. */
-  if (!strcmp(get_header_content(msg, (char*)"Content-Type:"),"application/sdp") &&
-          (hasMedia == 1)) {
-    extract_rtp_remote_addr(msg);
-  }
-#endif
+    /* Check if message has a SDP in it; and extract media information. */
+    if (!strcmp(get_header_content(msg, "Content-Type:"), "application/sdp") &&
+            hasMedia == 1 && !curmsg->ignoresdp) {
+        const char* ptr = get_header_content(msg, "Content-Length:");
+        if (ptr && atoll(ptr) > 0) {
+            extract_rtp_remote_addr(msg);
+        }
+    }
 
     /* Is it a response ? */
-    if((msg[0] == 'S') &&
+    if ((msg[0] == 'S') &&
             (msg[1] == 'I') &&
             (msg[2] == 'P') &&
             (msg[3] == '/') &&
             (msg[4] == '2') &&
             (msg[5] == '.') &&
-            (msg[6] == '0')    ) {
+            (msg[6] == '0')) {
 
         reply_code = get_reply_code(msg);
-        if(!reply_code) {
+        if (!reply_code) {
             if (!process_unexpected(msg)) {
                 return false; // Call aborted by unexpected message handling
             }
 #ifdef PCAPPLAY
-        } else if ((hasMedia == 1) && *(strstr(msg, "\r\n\r\n")+4) != '\0') {
+        } else if (hasMedia == 1 && !curmsg->ignoresdp && *(strstr(msg, "\r\n\r\n") + 4) != '\0') {
             /* Get media info if we find something like an SDP */
             get_remote_media_addr(msg);
 #endif
@@ -3093,17 +2855,17 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
                 ERROR("Out of memory allocating peer tag.");
             }
         }
-        request[0]=0;
+        request[0] = 0;
         // extract the cseq method from the response
-        extract_cseq_method (responsecseqmethod, msg);
-        extract_transaction (txn, msg);
-    } else if((ptr = strchr(msg, ' '))) {
-        if((ptr - msg) < 64) {
+        extract_cseq_method(responsecseqmethod, msg);
+        extract_transaction(txn, msg);
+    } else if ((ptr = strchr(msg, ' '))) {
+        if ((ptr - msg) < 64) {
             memcpy(request, msg, ptr - msg);
             request[ptr - msg] = 0;
             // Check if we received an ACK => call established
-            if (strcmp(request,"ACK")==0) {
-                call_established=true;
+            if (strcmp(request,"ACK") == 0) {
+                call_established = true;
             }
 #ifdef PCAPPLAY
             /* In case of INVITE or re-INVITE, ACK or PRACK
@@ -3112,8 +2874,9 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
             if (((strncmp(request, "INVITE", 6) == 0)
                     || (strncmp(request, "ACK", 3) == 0)
                     || (strncmp(request, "PRACK", 5) == 0))
-                    && (hasMedia == 1))
+                    && hasMedia == 1 && !curmsg->ignoresdp) {
                 get_remote_media_addr(msg);
+            }
 #endif
 
             reply_code = 0;
@@ -3127,12 +2890,12 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
     }
 
     /* Try to find it in the expected non mandatory responses
-     * until the first mandatory response  in the scenario */
-    for(search_index = msg_index;
+     * until the first mandatory response in the scenario */
+    for (search_index = msg_index;
             search_index < (int)call_scenario->messages.size();
             search_index++) {
-        if(!matches_scenario(search_index, reply_code, request, responsecseqmethod, txn)) {
-            if(call_scenario->messages[search_index] -> optional) {
+        if (!matches_scenario(search_index, reply_code, request, responsecseqmethod, txn)) {
+            if (call_scenario->messages[search_index]->optional) {
                 continue;
             }
             /* The received message is different for the expected one */
@@ -3148,13 +2911,15 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
     }
 
     /* Try to find it in the old non-mandatory receptions */
-    if(!found) {
+    if (!found) {
         bool contig = true;
         for(search_index = msg_index - 1;
                 search_index >= 0;
                 search_index--) {
-            if (call_scenario->messages[search_index]->optional == OPTIONAL_FALSE) contig = false;
-            if(matches_scenario(search_index, reply_code, request, responsecseqmethod, txn)) {
+            if (call_scenario->messages[search_index]->optional == OPTIONAL_FALSE) {
+                contig = false;
+            }
+            if (matches_scenario(search_index, reply_code, request, responsecseqmethod, txn)) {
                 if (contig || call_scenario->messages[search_index]->optional == OPTIONAL_GLOBAL) {
                     found = true;
                     break;
@@ -3187,7 +2952,7 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
                                               TRANSPORT_TO_STRING(transport), call_scenario->transactions[checkTxn - 1].name, msg);
                                     callDebug("Ignoring final %s message for transaction %s (hash %lu):\n\n%s\n",
                                               TRANSPORT_TO_STRING(transport), call_scenario->transactions[checkTxn - 1].name, hash(msg), msg);
-                                    WARNING("Ignoring final %s message for transaction %s (hash %lu):\n\n%s\n",
+                                    WARNING("Ignoring final %s message for transaction %s (hash %lu):\n\n%s",
                                             TRANSPORT_TO_STRING(transport), call_scenario->transactions[checkTxn - 1].name, hash(msg), msg);
                                     return true;
                                 }
@@ -3339,8 +3104,8 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
     }
 
     /* store the route set only once. TODO: does not support target refreshes!! */
-    if (call_scenario->messages[search_index] -> bShouldRecordRoutes &&
-            NULL == dialog_route_set) {
+    if (call_scenario->messages[search_index]->bShouldRecordRoutes &&
+            dialog_route_set == NULL) {
         realloc_ptr = (char*)realloc(next_req_url, MAX_HEADER_LEN);
         if (realloc_ptr) {
             next_req_url = realloc_ptr;
@@ -3389,6 +3154,8 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
 
         /* Store the code of the challenge for building the proper header */
         dialog_challenge_type = reply_code;
+
+        next_nonce_count = 1;
     }
 
     /* If we are not advancing state, we should quite before we change this stuff. */
@@ -3428,7 +3195,7 @@ bool call::process_incoming(char * msg, struct sockaddr_storage *src)
         unsigned int candidate;
 
         if (call_scenario->messages[search_index]->next && M_callVariableTable->getVar(test)->isSet()) {
-            WARNING("Last message generates an error and will not be used for next sends (for last_ variables):\r\n%s",msg);
+            WARNING("Last message generates an error and will not be used for next sends (for last_ variables):\n%s\n", msg);
         }
 
         /* We are just waiting for a message to be received, if any of the
@@ -3464,18 +3231,18 @@ double call::get_rhs(CAction *currentAction)
     }
 }
 
-call::T_ActionResult call::executeAction(char * msg, message *curmsg)
+call::T_ActionResult call::executeAction(const char* msg, message* curmsg)
 {
     CActions*  actions;
     CAction*   currentAction;
 
     actions = curmsg->M_actions;
     // looking for action to do on this message
-    if(actions == NULL) {
+    if (actions == NULL) {
         return(call::E_AR_NO_ERROR);
     }
 
-    for(int i=0; i<actions->getActionSize(); i++) {
+    for (int i = 0; i < actions->getActionSize(); i++) {
         currentAction = actions->getAction(i);
         if(currentAction == NULL) {
             continue;
@@ -3485,7 +3252,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
             char msgPart[MAX_SUB_MESSAGE_LENGTH];
 
             /* Where to look. */
-            char *haystack;
+            const char* haystack = NULL;
 
             if(currentAction->getLookingPlace() == CAction::E_LP_HDR) {
                 extractSubMessage (msg,
@@ -3497,7 +3264,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 if(currentAction->getCheckIt() == true && (strlen(msgPart) == 0)) {
                     // the sub message is not found and the checking action say it
                     // MUST match --> Call will be marked as failed but will go on
-                    WARNING("Failed regexp match: header %s not found in message %s\n", currentAction->getLookingChar(), msg);
+                    WARNING("Failed regexp match: header %s not found in message\n%s\n", currentAction->getLookingChar(), msg);
                     return(call::E_AR_HDR_NOT_FOUND);
                 }
                 haystack = msgPart;
@@ -3505,7 +3272,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 haystack = strstr(msg, "\r\n\r\n");
                 if (!haystack) {
                     if (currentAction->getCheckIt() == true) {
-                        WARNING("Failed regexp match: body not found in message %s\n", msg);
+                        WARNING("Failed regexp match: body not found in message\n%s\n", msg);
                         return(call::E_AR_HDR_NOT_FOUND);
                     }
                     msgPart[0] = '\0';
@@ -3519,12 +3286,12 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 haystack = M_callVariableTable->getVar(currentAction->getVarInId())->getString();
                 if (!haystack) {
                     if (currentAction->getCheckIt() == true) {
-                        WARNING("Failed regexp match: variable $%d not set\n", currentAction->getVarInId());
+                        WARNING("Failed regexp match: variable $%d not set", currentAction->getVarInId());
                         return(call::E_AR_HDR_NOT_FOUND);
                     }
                 }
             } else {
-                ERROR("Invalid looking place: %d\n", currentAction->getLookingPlace());
+                ERROR("Invalid looking place: %d", currentAction->getLookingPlace());
             }
             bool did_match = (currentAction->executeRegExp(haystack, M_callVariableTable) > 0);
 
@@ -3600,8 +3367,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
             free(value);
         } else if (currentAction->getActionType() == CAction::E_AT_CLOSE_CON) {
             if (call_socket) {
-                sipp_socket_invalidate(call_socket);
-                sipp_close_socket(call_socket);
+                call_socket->close();
                 call_socket = NULL;
             }
         } else if (currentAction->getActionType() == CAction::E_AT_SET_DEST) {
@@ -3616,7 +3382,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 ERROR("Invalid port for setdest: %s", str_port);
             }
 
-            int protocol;
+            int protocol = 0;
             if (!strcmp(str_protocol, "udp") || !strcmp(str_protocol, "UDP")) {
                 protocol = T_UDP;
             } else if (!strcmp(str_protocol, "tcp") || !strcmp(str_protocol, "TCP")) {
@@ -3632,7 +3398,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
             if (!call_socket && ((protocol == T_TCP && transport == T_TCP) ||
                                  (protocol == T_SCTP && transport == T_SCTP))) {
                 bool existing;
-                if ((associate_socket(new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
+                if ((associate_socket(SIPpSocket::new_sipp_call_socket(use_ipv6, transport, &existing))) == NULL) {
                     switch (protocol) {
                     case T_SCTP:
                         ERROR_NO("Unable to get a SCTP socket");
@@ -3668,30 +3434,11 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 }
             }
 
-            struct addrinfo   hints;
-            struct addrinfo * local_addr;
-            memset((char*)&hints, 0, sizeof(hints));
-            hints.ai_flags  = AI_PASSIVE;
-            hints.ai_family = PF_UNSPEC;
-            is_ipv6 = false;
-
-            if (getaddrinfo(str_host, NULL, &hints, &local_addr) != 0) {
+            if (gai_getsockaddr(&call_peer, str_host, port,
+                                AI_PASSIVE, AF_UNSPEC) != 0) {
                 ERROR("Unknown host '%s' for setdest", str_host);
             }
-            if (_RCAST(struct sockaddr_storage *, local_addr->ai_addr)->ss_family != call_peer.ss_family) {
-                ERROR("Can not switch between IPv4 and IPV6 using setdest!");
-            }
-            memcpy(&call_peer, local_addr->ai_addr,
-                   SOCK_ADDR_SIZE(_RCAST(struct sockaddr_storage*, local_addr->ai_addr)));
-            freeaddrinfo(local_addr);
-
-            if (call_peer.ss_family == AF_INET) {
-                (_RCAST(struct sockaddr_in*, &call_peer))->sin_port = htons(port);
-            } else {
-                (_RCAST(struct sockaddr_in6*, &call_peer))->sin6_port = htons(port);
-            }
-            memcpy(&call_socket->ss_dest, &call_peer,
-                   SOCK_ADDR_SIZE(_RCAST(struct sockaddr_storage*, &call_peer)));
+            memcpy(&call_socket->ss_dest, &call_peer, sizeof(call_peer));
 
             free(str_host);
             free(str_port);
@@ -3701,7 +3448,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 close(call_socket->ss_fd);
                 call_socket->ss_fd = -1;
                 call_socket->ss_changed_dest = true;
-                if (sipp_reconnect_socket(call_socket)) {
+                if (call_socket->reconnect()) {
                     if (reconnect_allowed()) {
                         if(errno == EINVAL) {
                             /* This occurs sometime on HPUX but is not a true INVAL */
@@ -3730,8 +3477,8 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
             }
         } else if (currentAction->getActionType() == CAction::E_AT_VERIFY_AUTH) {
             bool result;
-            char *lf;
-            char *end;
+            const char* lf;
+            const char* end;
 
             lf = strchr(msg, '\n');
             end = strchr(msg, ' ');
@@ -3753,7 +3500,7 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 tmp= createSendingMessage(currentAction->getMessage(1), -2 /* do not add crlf*/);
                 char *password = strdup(tmp);
                 /* Need the body for length and auth-int calculation */
-                char *body;
+                const char *body;
                 const char *auth_body = NULL;
                 body = strstr(msg, "\r\n\r\n");
                 if (body) {
@@ -3807,18 +3554,71 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 M_callVariableTable->getVar(currentAction->getVarId())->setDouble(value / operand);
             }
         } else if (currentAction->getActionType() == CAction::E_AT_VAR_TEST) {
-            double value = currentAction->compare(M_callVariableTable);
-            M_callVariableTable->getVar(currentAction->getVarId())->setBool(value);
+            bool value = currentAction->compare(M_callVariableTable);
+            if ((currentAction->getCheckIt() && !value) ||
+                (currentAction->getCheckItInverse() && value)
+            ) {
+                double lhs = M_callVariableTable->getVar(currentAction->getVarInId())->getDouble();
+                double rhs = currentAction->getVarIn2Id() ?
+                    M_callVariableTable->getVar(currentAction->getVarIn2Id())->getDouble() :
+                    currentAction->getDoubleValue();
+                char *lhsName = call_scenario->allocVars->getName(currentAction->getVarInId());
+                const char *rhsName = "";
+                if (currentAction->getVarIn2Id()) {
+                    rhsName = call_scenario->allocVars->getName(currentAction->getVarIn2Id());
+                }
+                const char *_inverse = currentAction->getCheckIt() ? "" : "_inverse";
+                call::T_ActionResult result = currentAction->getCheckIt() ? call::E_AR_TEST_DOESNT_MATCH : call::E_AR_TEST_SHOULDNT_MATCH;
+
+                WARNING("test \"%s:%f %s %s:%f\" with check_it%s failed",
+                    lhsName,
+                    lhs,
+                    currentAction->comparatorToString(currentAction->getComparator()),
+                    rhsName,
+                    rhs,
+                    _inverse
+                );
+                return(result);
+            }
+            // "assign_to" is optional when "check_it" or "check_it_inverse" set
+            if (currentAction->getVarId() ||
+                (!currentAction->getCheckIt() && !currentAction->getCheckItInverse())
+            ) {
+                M_callVariableTable->getVar(currentAction->getVarId())->setBool(value);
+            }
         } else if (currentAction->getActionType() == CAction::E_AT_VAR_STRCMP) {
-            char *rhs = M_callVariableTable->getVar(currentAction->getVarInId())->getString();
-            char *lhs;
-            if (currentAction->getVarIn2Id()) {
-                lhs = M_callVariableTable->getVar(currentAction->getVarIn2Id())->getString();
-            } else {
-                lhs = currentAction->getStringValue();
+            char *lhs = M_callVariableTable->getVar(currentAction->getVarInId())->getString();
+            char *rhs = currentAction->getVarIn2Id() ?
+                M_callVariableTable->getVar(currentAction->getVarIn2Id())->getString() :
+                currentAction->getStringValue();
+            int value = strcmp(lhs, rhs);
+            if ((currentAction->getCheckIt() && value) ||
+                (currentAction->getCheckItInverse() && !value)
+            ) {
+                char *lhsName = call_scenario->allocVars->getName(currentAction->getVarInId());
+                const char *rhsName = "";
+                if (currentAction->getVarIn2Id()) {
+                    rhsName = call_scenario->allocVars->getName(currentAction->getVarIn2Id());
+                }
+                const char *_inverse = currentAction->getCheckIt() ? "" : "_inverse";
+                call::T_ActionResult result = currentAction->getCheckIt() ? call::E_AR_STRCMP_DOESNT_MATCH : call::E_AR_STRCMP_SHOULDNT_MATCH;
+
+                WARNING("strcmp %s:\"%s\" and %s:\"%s\" with check_it%s returned %d",
+                    lhsName,
+                    lhs,
+                    rhsName,
+                    rhs,
+                    _inverse,
+                    value
+                );
+                return(result);
+            }
+            // "assign_to" is optional when "check_it" or "check_it_inverse" set
+            if (currentAction->getVarId() ||
+                (!currentAction->getCheckIt() && !currentAction->getCheckItInverse())
+            ) {
+                M_callVariableTable->getVar(currentAction->getVarId())->setDouble((double)value);
             }
-            int value = strcmp(rhs, lhs);
-            M_callVariableTable->getVar(currentAction->getVarId())->setDouble((double)value);
         } else if (currentAction->getActionType() == CAction::E_AT_VAR_TRIM) {
             CCallVariable *var = M_callVariableTable->getVar(currentAction->getVarId());
             char *in = var->getString();
@@ -3861,35 +3661,35 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
             ERROR("%s", x);
         } else if (currentAction->getActionType() == CAction::E_AT_EXECUTE_CMD) {
             char* x = createSendingMessage(currentAction->getMessage(), -2 /* do not add crlf*/);
-            TRACE_MSG("Trying to execute [%s]", x);
-
-		// Find out what command we're doing	
-		std::string str = x;
-		std::string delimiter = "@";
-		int end = str.find(delimiter);
-		std::string command = str.substr(0, end);		
-		std::string data = str.substr(end+1);
-		char data_str[4096];
-		memset(data_str,0,sizeof(data_str));
-		strcpy(data_str,data.c_str());
-
-	  // Process possible commands that override the default functionality:   format is command@<file.lua>
-	  //	custom calls - user defined
-	  //	<exec command="command@<argstring>  where argstring is a list of args sent to command.
-	  //	if we don't find anything - do a system call - default sipp behavior
-	  //	We pass in pointers to the call variables and the current scenario to allow manipulation of sipp variables
-	  //	These should be initialized in a plugin
-	
-	  int found = false;
-	  for (int i=0;(i<MAXFUNCS && !found);i++) {
-	  	if (command.compare(ApiHandler[i][0].cmdPtr)==0) {  // Check if this command matches any we've setup
-			found = true;
-			_ApiCustomFunc(i,0,data_str,(void *)M_callVariableTable,display_scenario);
-		}
-	  }
-	  if (!found) {
-
-	    // Execute a system call with the command passed in - default SIPP behavior
+            // TRACE_MSG("Trying to execute [%s]", x);
+
+          // Find out what command we're doing  
+          std::string str = x;
+          std::string delimiter = "@";
+          int end = str.find(delimiter);
+          std::string command = str.substr(0, end);     
+          std::string data = str.substr(end+1);
+          char data_str[4096];
+          memset(data_str,0,sizeof(data_str));
+          strcpy(data_str,data.c_str());
+
+          // Process possible commands that override the default functionality:   format is command@<file.lua>
+          //    custom calls - user defined
+          //    <exec command="command@<argstring>  where argstring is a list of args sent to command.
+          //    if we don't find anything - do a forked system call - default sipp behavior
+          //    We pass in pointers to the call variables and the current scenario to allow manipulation of sipp variables
+          //    These should be initialized in a plugin - see myapp.cpp for a sample
+
+          int found = false;
+          for (int i=0;(i<MAXFUNCS && !found);i++) {
+                if (command.compare(ApiHandler[i][0].cmdPtr)==0) {  // Check if this command matches any we've setup
+                        found = true;
+                        _ApiCustomFunc(i,0,data_str,(void *)M_callVariableTable,display_scenario);
+                }
+          }
+          if (!found) {
+
+            // Execute a system call with the command passed in - default SIPP behavior
 
             pid_t l_pid;
             switch(l_pid = fork()) {
@@ -3920,11 +3720,12 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 while ((ret=waitpid(l_pid, NULL, 0)) != l_pid) {
                     if (ret != -1) {
                         ERROR("waitpid returns %1d for child %1d",ret,l_pid);
-                   	}
-               	 }
-               	 break;
-            	}
-	   }
+                        }
+                 }
+                 break;
+                }
+           }
+
         } else if (currentAction->getActionType() == CAction::E_AT_EXEC_INTCMD) {
             switch (currentAction->getIntCmd()) {
             case CAction::E_INTCMD_STOP_ALL:
@@ -3941,9 +3742,11 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
 #ifdef PCAPPLAY
         } else if ((currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_AUDIO) ||
                    (currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_IMAGE) ||
-                   (currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_VIDEO)) {
-            play_args_t *play_args;
-            if (currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_AUDIO) {
+                   (currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_VIDEO) ||
+                   (currentAction->getActionType() == CAction::E_AT_PLAY_DTMF)) {
+            play_args_t* play_args = 0;
+            if ((currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_AUDIO) ||
+                (currentAction->getActionType() == CAction::E_AT_PLAY_DTMF)) {
                 play_args = &(this->play_args_a);
             } else if (currentAction->getActionType() == CAction::E_AT_PLAY_PCAP_IMAGE) {
                 play_args = &(this->play_args_i);
@@ -3953,14 +3756,31 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
                 ERROR("Can't find pcap data to play");
             }
 
-            play_args->pcap = currentAction->getPcapPkts();
+            // existing media thread could be using play_args, so we have to kill it before modifying parameters
+            if (media_thread != 0) {
+                // If a media_thread is already active, kill it before starting a new one
+                pthread_cancel(media_thread);
+                pthread_join(media_thread, NULL);
+                media_thread = 0;
+            }
+
+            if (currentAction->getActionType() == CAction::E_AT_PLAY_DTMF) {
+                char* digits = createSendingMessage(currentAction->getMessage(), -2 /* do not add crlf */);
+                play_args->pcap = (pcap_pkts *) malloc(sizeof(pcap_pkts));
+                play_args->last_seq_no += parse_dtmf_play_args(digits, play_args->pcap, play_args->last_seq_no);
+                play_args->free_pcap_when_done = 1;
+            } else {
+                play_args->pcap = currentAction->getPcapPkts();
+                play_args->free_pcap_when_done = 0;
+            }
+
             /* port number is set in [auto_]media_port interpolation */
             if (media_ip_is_ipv6) {
-                struct sockaddr_in6 *from = (struct sockaddr_in6 *)(void *) &(play_args->from);
+                struct sockaddr_in6* from = (struct sockaddr_in6*) &(play_args->from);
                 from->sin6_family = AF_INET6;
                 inet_pton(AF_INET6, media_ip, &(from->sin6_addr));
             } else {
-                struct sockaddr_in *from = (struct sockaddr_in *)(void *) &(play_args->from);
+                struct sockaddr_in* from = (struct sockaddr_in*) &(play_args->from);
                 from->sin_family = AF_INET;
                 from->sin_addr.s_addr = inet_addr(media_ip);
             }
@@ -3970,28 +3790,21 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
 #ifndef PTHREAD_STACK_MIN
 #define PTHREAD_STACK_MIN  16384
 #endif
-            //pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
-            if (media_thread != 0) {
-                // If a media_thread is already active, kill it before starting a new one
-                pthread_cancel(media_thread);
-                pthread_join(media_thread, NULL);
-                media_thread = 0;
-            }
-            int ret = pthread_create(&media_thread, &attr, send_wrapper,
-                                     (void *) play_args);
-            if(ret)
+            int ret = pthread_create(&media_thread, &attr, send_wrapper, play_args);
+            if (ret) {
                 ERROR("Can't create thread to send RTP packets");
+            }
             pthread_attr_destroy(&attr);
 #endif
 
-#ifdef RTP_STREAM
-    } else if (currentAction->getActionType() == CAction::E_AT_RTP_STREAM_PAUSE) {
-      rtpstream_pause (&rtpstream_callinfo);
-    } else if (currentAction->getActionType() == CAction::E_AT_RTP_STREAM_RESUME) {
-      rtpstream_resume (&rtpstream_callinfo);
-    } else if (currentAction->getActionType() == CAction::E_AT_RTP_STREAM_PLAY) {
-      rtpstream_play (&rtpstream_callinfo,currentAction->getRTPStreamActInfo());
-#endif
+        } else if (currentAction->getActionType() == CAction::E_AT_RTP_ECHO) {
+            rtp_echo_state = (currentAction->getDoubleValue() != 0);
+        } else if (currentAction->getActionType() == CAction::E_AT_RTP_STREAM_PAUSE) {
+            rtpstream_pause(&rtpstream_callinfo);
+        } else if (currentAction->getActionType() == CAction::E_AT_RTP_STREAM_RESUME) {
+            rtpstream_resume(&rtpstream_callinfo);
+        } else if (currentAction->getActionType() == CAction::E_AT_RTP_STREAM_PLAY) {
+            rtpstream_play(&rtpstream_callinfo, currentAction->getRTPStreamActInfo());
         } else {
             ERROR("call::executeAction unknown action");
         }
@@ -3999,11 +3812,10 @@ call::T_ActionResult call::executeAction(char * msg, message *curmsg)
     return(call::E_AR_NO_ERROR);
 }
 
-
-void call::extractSubMessage(char * msg, char * matchingString, char* result, bool case_indep, int occurrence, bool headers)
+void call::extractSubMessage(const char* msg, char* matchingString, char* result, bool case_indep, int occurrence, bool headers)
 {
 
-    char *ptr, *ptr1;
+    const char *ptr, *ptr1;
     int sizeOf;
     int i = 0;
     int len = strlen(matchingString);
@@ -4088,7 +3900,7 @@ void call::getFieldFromInputFile(const char *fileName, int field, SendingMessage
     dest += inFiles[fileName]->getField(line, field, dest, SIPP_MAX_MSG_SIZE);
 }
 
-call::T_AutoMode call::checkAutomaticResponseMode(char * P_recv)
+call::T_AutoMode call::checkAutomaticResponseMode(char* P_recv)
 {
     if (strcmp(P_recv, "BYE")==0) {
         return E_AM_UNEXP_BYE;
@@ -4121,7 +3933,7 @@ void call::setLastMsg(const char *msg)
     strcpy(last_recv_msg, msg);
 }
 
-bool call::automaticResponseMode(T_AutoMode P_case, char * P_recv)
+bool call::automaticResponseMode(T_AutoMode P_case, const char* P_recv)
 {
 
     int res ;
@@ -4249,7 +4061,7 @@ bool call::automaticResponseMode(T_AutoMode P_case, char * P_recv)
         if (last_recv_msg != NULL) {
             last_recv_msg_saved = true;
             old_last_recv_msg = (char *) malloc(strlen(last_recv_msg)+1);
-            strcpy(old_last_recv_msg,last_recv_msg);
+            strcpy(old_last_recv_msg, last_recv_msg);
         }
         // usage of last_ keywords
         realloc_ptr = (char *) realloc(last_recv_msg, strlen(P_recv) + 1);
@@ -4265,10 +4077,8 @@ bool call::automaticResponseMode(T_AutoMode P_case, char * P_recv)
 
         strcpy(last_recv_msg, P_recv);
 
-	if (log4auto_answer) {
-        	WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
-			(id == NULL) ? "none" : id);
-	}
+        WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
+                (id == NULL) ? "none" : id);
         sendBuffer(createSendingMessage(get_default_message("200"), -1));
 
         // restore previous last msg
@@ -4290,7 +4100,6 @@ bool call::automaticResponseMode(T_AutoMode P_case, char * P_recv)
             }
         }
         CStat::globalStat(CStat::E_AUTO_ANSWERED);
-	delete this;  // 2/16/2022 - NVF Added this for auto response messages as it looked like it wasn't being done otherwise - resulting in a memory leak
         return true;
         break;
 
@@ -4319,3 +4128,99 @@ void *send_wrapper(void *arg)
     return NULL;
 }
 #endif
+
+#ifdef GTEST
+#include "gtest/gtest.h"
+#include "gtest/gtest.h"
+
+class mockcall : public call {
+public:
+    mockcall(bool is_ipv6) : listener("//testing", true), call("///testing", is_ipv6, 0, NULL) {}
+
+    /* Helpers to poke at protected internals */
+    void parse_media_addr(std::string const& msg) { get_remote_media_addr(msg); }
+
+#ifdef PCAPPLAY
+    bool has_media() { return hasMediaInformation; }
+
+    template<typename T>
+    T get_audio_addr() {
+        T sa;
+        std::memcpy(&sa, &play_args_a.to, sizeof(T));
+        return sa;
+    }
+#endif
+};
+
+bool operator==(const struct sockaddr_in& a, const struct sockaddr_in &b) {
+    return a.sin_family == b.sin_family
+        && a.sin_port == b.sin_port
+        && std::memcmp(&a.sin_addr, &b.sin_addr, sizeof(in_addr)) == 0;
+}
+
+bool operator==(const struct sockaddr_in6& a, const struct sockaddr_in6 &b) {
+    return a.sin6_family == b.sin6_family
+        && a.sin6_port == b.sin6_port
+        && std::memcmp(&a.sin6_addr, &b.sin6_addr, sizeof(in_addr)) == 0;
+}
+
+const std::string test_sdp_v4 = "v=0\r\n"
+                                "o=user1 53655765 2353687637 IN IP4 127.0.0.1\r\n"
+                                "s=-\r\n"
+                                "c=IN IP4 127.0.0.1\r\n"
+                                "t=0 0\r\n"
+                                "m=audio 12345 RTP/AVP 0\r\n"
+                                "a=rtpmap:0 PCMU/8000\r\n";
+
+const std::string test_sdp_v6 = "v=0\r\n"
+                                "o=user1 53655765 2353687637 IN IP6 ::1\r\n"
+                                "s=-\r\n"
+                                "c=IN IP6 ::1\r\n"
+                                "t=0 0\r\n"
+                                "m=audio 12345 RTP/AVP 0\r\n"
+                                "a=rtpmap:0 PCMU/8000\r\n";
+
+TEST(sdp, parse_valid_sdp_msg) {
+    ASSERT_EQ(find_in_sdp("c=IN IP4 ", test_sdp_v4), "127.0.0.1");
+    ASSERT_EQ(find_in_sdp("c=IN IP6 ", test_sdp_v6), "::1");
+    ASSERT_EQ(find_in_sdp("m=audio ", test_sdp_v4), "12345");
+    ASSERT_EQ(find_in_sdp("m=audio ", test_sdp_v6), "12345");
+}
+
+TEST(sdp, parse_invalid_sdp_msg) {
+    ASSERT_EQ(find_in_sdp("c=IN IP4 ", test_sdp_v6), "");
+    ASSERT_EQ(find_in_sdp("c=IN IP6 ", test_sdp_v4), "");
+    ASSERT_EQ(find_in_sdp("m=video ", test_sdp_v6), "");
+    ASSERT_EQ(find_in_sdp("m=video ", test_sdp_v4), "");
+}
+
+#ifdef PCAPPLAY
+TEST(sdp, good_remote_media_addr_v4) {
+    media_ip_is_ipv6 = false;
+
+    struct sockaddr_in reference;
+    reference.sin_family = AF_INET;
+    reference.sin_port = htons(12345);
+    inet_pton(AF_INET, "127.0.0.1", &reference.sin_addr);
+
+    mockcall call(false);
+    call.parse_media_addr(test_sdp_v4);
+    ASSERT_EQ(call.has_media(), true);
+    ASSERT_EQ(reference, call.get_audio_addr<struct sockaddr_in>());
+}
+
+TEST(sdp, good_remote_media_addr_v6) {
+    media_ip_is_ipv6 = true;
+
+    struct sockaddr_in6 reference;
+    reference.sin6_family = AF_INET6;
+    reference.sin6_port = htons(12345);
+    inet_pton(AF_INET6, "::1", &reference.sin6_addr);
+
+    mockcall call(true);
+    call.parse_media_addr(test_sdp_v6);
+    ASSERT_EQ(call.has_media(), true);
+    ASSERT_EQ(reference, call.get_audio_addr<struct sockaddr_in6>());
+}
+#endif /* PCAP_PLAY */
+#endif
diff --git a/src/logger.cpp b/src/logger.cpp
index 6f632aefb..a3ba201fa 100644
--- a/src/logger.cpp
+++ b/src/logger.cpp
@@ -35,643 +35,33 @@
  *           Michael Hirschbichler
  */
 
+#include <curses.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include "logger.hpp"
-#include "screen.hpp"
-#include "sipp.hpp"
-
-#define SIPP_ENDL "\r\n"
-
-#ifdef RTP_STREAM
-double last_rtpstream_rate_out= 0;
-double last_rtpstream_rate_in= 0;
-#endif
-
-extern void print_stats_in_file(FILE * f);
-
-bool do_hide = true;
-bool show_index = false;
-
-void print_header_line(FILE *f)
-{
-    switch(currentScreenToDisplay) {
-    case DISPLAY_STAT_SCREEN :
-        fprintf(f,"----------------------------- Statistics Screen ------- [1-9]: Change Screen --" SIPP_ENDL);
-        break;
-    case DISPLAY_REPARTITION_SCREEN :
-        fprintf(f,"---------------------------- Repartition Screen ------- [1-9]: Change Screen --" SIPP_ENDL);
-        break;
-    case DISPLAY_VARIABLE_SCREEN  :
-        fprintf(f,"----------------------------- Variables Screen -------- [1-9]: Change Screen --" SIPP_ENDL);
-        break;
-    case DISPLAY_TDM_MAP_SCREEN  :
-        fprintf(f,"------------------------------ TDM map Screen --------- [1-9]: Change Screen --" SIPP_ENDL);
-        break;
-    case DISPLAY_SECONDARY_REPARTITION_SCREEN :
-        fprintf(f,"--------------------------- Repartition %d Screen ------ [1-9]: Change Screen --" SIPP_ENDL, currentRepartitionToDisplay);
-        break;
-    case DISPLAY_SCENARIO_SCREEN :
-    default:
-        fprintf(f,"------------------------------ Scenario Screen -------- [1-9]: Change Screen --" SIPP_ENDL);
-        break;
-    }
-}
-
-void print_bottom_line(FILE *f, int last)
-{
-    if(last) {
-        fprintf(f,"------------------------------ Test Terminated --------------------------------" SIPP_ENDL);
-    } else if(quitting) {
-        fprintf(f,"------- Waiting for active calls to end. Press [q] again to force exit. -------" SIPP_ENDL );
-    } else if(paused) {
-        fprintf(f,"----------------- Traffic Paused - Press [p] again to resume ------------------" SIPP_ENDL );
-    } else if(cpu_max) {
-        fprintf(f,"-------------------------------- CPU CONGESTED ---------------------------------" SIPP_ENDL);
-    } else if(outbound_congestion) {
-        fprintf(f,"------------------------------ OUTBOUND CONGESTION -----------------------------" SIPP_ENDL);
-    } else {
-        if (creationMode == MODE_CLIENT) {
-            switch(thirdPartyMode) {
-            case MODE_MASTER :
-                fprintf(f,"-----------------------3PCC extended mode - Master side -------------------------" SIPP_ENDL);
-                break;
-            case MODE_3PCC_CONTROLLER_A :
-                fprintf(f,"----------------------- 3PCC Mode - Controller A side -------------------------" SIPP_ENDL);
-                break;
-            case MODE_3PCC_NONE:
-                fprintf(f,"------ [+|-|*|/]: Adjust rate ---- [q]: Soft exit ---- [p]: Pause traffic -----" SIPP_ENDL);
-                break;
-            default:
-                ERROR("Internal error: creationMode=%d, thirdPartyMode=%d", creationMode, thirdPartyMode);
-            }
-        } else {
-            assert(creationMode == MODE_SERVER);
-            switch(thirdPartyMode) {
-            case MODE_3PCC_A_PASSIVE :
-                fprintf(f,"------------------ 3PCC Mode - Controller A side (passive) --------------------" SIPP_ENDL);
-                break;
-            case MODE_3PCC_CONTROLLER_B :
-                fprintf(f,"----------------------- 3PCC Mode - Controller B side -------------------------" SIPP_ENDL);
-                break;
-            case MODE_MASTER_PASSIVE :
-                fprintf(f,"------------------ 3PCC extended mode - Master side (passive) --------------------" SIPP_ENDL);
-                break;
-            case MODE_SLAVE :
-                fprintf(f,"----------------------- 3PCC extended mode - Slave side -------------------------" SIPP_ENDL);
-                break;
-            case MODE_3PCC_NONE:
-                fprintf(f,"------------------------------ Sipp Server Mode -------------------------------" SIPP_ENDL);
-                break;
-            default:
-                ERROR("Internal error: creationMode=%d, thirdPartyMode=%d", creationMode, thirdPartyMode);
-            }
-        }
-    }
-    fprintf(f,SIPP_ENDL);
-    fflush(stdout);
-}
-
-void print_tdm_map()
-{
-    int i = 0;
-    int in_use = 0;
-    int interval = (tdm_map_a+1) * (tdm_map_b+1) * (tdm_map_c+1);
-
-    printf("TDM Circuits in use:"  SIPP_ENDL);
-    while (i<interval) {
-        if (tdm_map[i]) {
-            printf("*");
-            in_use++;
-        } else {
-            printf(".");
-        }
-        i++;
-        if (i%(tdm_map_c+1) == 0) printf(SIPP_ENDL);
-    }
-    printf(SIPP_ENDL);
-    printf("%d/%d circuits (%d%%) in use", in_use, interval, int(100*in_use/interval));
-    printf(SIPP_ENDL);
-    for(unsigned int i=0; i<(display_scenario->messages.size() + 8 - int(interval/(tdm_map_c+1))); i++) {
-        printf(SIPP_ENDL);
-    }
-}
-
-void print_variable_list()
-{
-    CActions  * actions;
-    CAction   * action;
-    int printed = 0;
-    bool found;
-
-    printf("Action defined Per Message :" SIPP_ENDL);
-    printed++;
-    found = false;
-    for(unsigned int i=0; i<display_scenario->messages.size(); i++) {
-        message *curmsg = display_scenario->messages[i];
-        actions = curmsg->M_actions;
-        if(actions != NULL) {
-            switch(curmsg->M_type) {
-            case MSG_TYPE_RECV:
-                printf("=> Message[%u] (Receive Message) - "
-                       "[%d] action(s) defined :" SIPP_ENDL,
-                       i,
-                       actions->getActionSize());
-                printed++;
-                break;
-            case MSG_TYPE_RECVCMD:
-                printf("=> Message[%u] (Receive Command Message) - "
-                       "[%d] action(s) defined :" SIPP_ENDL,
-                       i,
-                       actions->getActionSize());
-                printed++;
-                break;
-            default:
-                printf("=> Message[%u] - [%d] action(s) defined :" SIPP_ENDL,
-                       i,
-                       actions->getActionSize());
-                printed++;
-                break;
-            }
 
-            for(int j=0; j<actions->getActionSize(); j++) {
-                action = actions->getAction(j);
-                if(action != NULL) {
-                    printf("   --> action[%d] = ", j);
-                    action->afficheInfo();
-                    printf(SIPP_ENDL);
-                    printed++;
-                    found = true;
-                }
-            }
-        }
-    }
-    if(!found) {
-        printed++;
-        printf("=> No action found on any messages" SIPP_ENDL);
-    }
-
-    printf(SIPP_ENDL);
-    for(unsigned int i=0; i<(display_scenario->messages.size() + 5 - printed); i++) {
-        printf(SIPP_ENDL);
-    }
-}
+#include "logger.hpp"
 
+unsigned long total_errors = 0;
 
-void print_statistics(int last)
-{
-    static int first = 1;
-    extern int command_mode;
-    extern char *command_buffer;
-
-    if (backgroundMode == false && display_scenario) {
-        if (use_curses && !last) {
-            screen_clear();
-        }
-
-        if (use_curses && first) {
-            first = 0;
-            printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
-                   "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
-        }
-        if (command_mode) {
-            printf(SIPP_ENDL);
-        }
-        print_header_line(stdout);
-        switch(currentScreenToDisplay) {
-        case DISPLAY_STAT_SCREEN :
-            display_scenario->stats->displayStat(stdout);
-            break;
-        case DISPLAY_REPARTITION_SCREEN :
-            display_scenario->stats->displayRepartition(stdout);
-            break;
-        case DISPLAY_VARIABLE_SCREEN  :
-            print_variable_list();
-            break;
-        case DISPLAY_TDM_MAP_SCREEN  :
-            print_tdm_map();
-            break;
-        case DISPLAY_SECONDARY_REPARTITION_SCREEN :
-            display_scenario->stats->displayRtdRepartition(stdout, currentRepartitionToDisplay);
-            break;
-        case DISPLAY_SCENARIO_SCREEN :
-        default:
-            print_stats_in_file(stdout);
-            break;
-        }
-        print_bottom_line(stdout,last);
-        if (!last && screen_last_error[0]) {
-            char *errstart = screen_last_error;
-            int colonsleft = 3;/* We want to skip the time. */
-            while (*errstart && colonsleft) {
-                if (*errstart == ':') {
-                    colonsleft--;
-                }
-                errstart++;
-            }
-            while (isspace(*errstart)) {
-                errstart++;
-            }
-            if (strlen(errstart) > 60) {
-                printf("Last Error: %.60s..." SIPP_ENDL, errstart);
-            } else {
-                printf("Last Error: %s" SIPP_ENDL, errstart);
-            }
-            sipp_usleep(100);
-            fflush(stdout);
-        }
-        if (command_mode) {
-            printf("Command: %s", command_buffer ? command_buffer : "");
-            fflush(stdout);
-        }
-        if(last) {
-            fprintf(stdout,"\n");
-        }
-    }
-}
 
 void log_off(struct logfile_info *lfi)
 {
     if (lfi->fptr) {
-	pthread_mutex_lock(lfi->lockfile);
+        pthread_mutex_lock(lfi->lockfile);
         fflush(lfi->fptr);
         fclose(lfi->fptr);
         lfi->fptr = NULL;
         lfi->overwrite = false;
-	pthread_mutex_unlock(lfi->lockfile);
+        pthread_mutex_unlock(lfi->lockfile);
     }
 }
 
-void print_stats_in_file(FILE * f)
-{
-    static char temp_str[256];
-    int divisor;
-
-    extern int pollnfds;
-#define NOTLAST 0
-
-#define SIPP_ENDL "\r\n"
-
-    /* We are not initialized yet. */
-    if (!display_scenario) {
-        return;
-    }
-
-    /* Optional timestamp line for files only */
-    if(f != stdout) {
-        time_t tim;
-        time(&tim);
-        fprintf(f, "  Timestamp: %s" SIPP_ENDL, ctime(&tim));
-    }
-
-    /* Header line with global parameters */
-    if (users >= 0) {
-        sprintf(temp_str, "%d (%d ms)", users, duration);
-    } else {
-        sprintf(temp_str, "%3.1f(%d ms)/%5.3fs", rate, duration, (double)rate_period_ms / 1000.0);
-    }
-    unsigned long long total_calls = display_scenario->stats->GetStat(CStat::CPT_C_IncomingCallCreated) + display_scenario->stats->GetStat(CStat::CPT_C_OutgoingCallCreated);
-    if( creationMode == MODE_SERVER) {
-        fprintf
-        (f,
-         "  Port   Total-time  Total-calls  Transport"
-         SIPP_ENDL
-         "  %-5d %6lu.%02lu s     %8llu  %s"
-         SIPP_ENDL SIPP_ENDL,
-         local_port,
-         clock_tick / 1000, (clock_tick % 1000) / 10,
-         total_calls,
-         TRANSPORT_TO_STRING(transport));
-    } else {
-        assert(creationMode == MODE_CLIENT);
-        if (users >= 0) {
-            fprintf(f, "     Users (length)");
-        } else {
-            fprintf(f, "  Call-rate(length)");
-        }
-        fprintf(f, "   Port   Total-time  Total-calls  Remote-host" SIPP_ENDL
-                "%19s   %-5d %6lu.%02lu s     %8llu  %s:%d(%s)" SIPP_ENDL SIPP_ENDL,
-                temp_str,
-                local_port,
-                clock_tick / 1000, (clock_tick % 1000) / 10,
-                total_calls,
-                remote_ip,
-                remote_port,
-                TRANSPORT_TO_STRING(transport));
-    }
-
-    /* 1st line */
-    if(total_calls < stop_after) {
-        sprintf(temp_str, "%llu new calls during %lu.%03lu s period ",
-                display_scenario->stats->GetStat(CStat::CPT_PD_IncomingCallCreated) +
-                display_scenario->stats->GetStat(CStat::CPT_PD_OutgoingCallCreated),
-                (clock_tick-last_report_time) / 1000,
-                ((clock_tick-last_report_time) % 1000));
-    } else {
-        sprintf(temp_str, "Call limit reached (-m %lu), %lu.%03lu s period ",
-                stop_after,
-                (clock_tick-last_report_time) / 1000,
-                ((clock_tick-last_report_time) % 1000));
-    }
-    divisor = scheduling_loops;
-    if(!divisor) {
-        divisor = 1;
-    }
-    fprintf(f,"  %-38s %lu ms scheduler resolution"
-            SIPP_ENDL,
-            temp_str,
-            (clock_tick-last_report_time) / divisor);
-
-    /* 2nd line */
-    if( creationMode == MODE_SERVER) {
-        sprintf(temp_str, "%llu calls", display_scenario->stats->GetStat(CStat::CPT_C_CurrentCall));
-    } else {
-        sprintf(temp_str, "%llu calls (limit %u)", display_scenario->stats->GetStat(CStat::CPT_C_CurrentCall), open_calls_allowed);
-    }
-    fprintf(f,"  %-38s Peak was %llu calls, after %llu s" SIPP_ENDL,
-            temp_str,
-            display_scenario->stats->GetStat(CStat::CPT_C_CurrentCallPeak),
-            display_scenario->stats->GetStat(CStat::CPT_C_CurrentCallPeakTime));
-    fprintf(f,"  %d Running, %d Paused, %d Woken up" SIPP_ENDL,
-            last_running_calls, last_paused_calls, last_woken_calls);
-    last_woken_calls = 0;
-
-    /* 3rd line dead call msgs, and optional out-of-call msg */
-    sprintf(temp_str,"%llu dead call msg (discarded)",
-            display_scenario->stats->GetStat(CStat::CPT_G_C_DeadCallMsgs));
-    fprintf(f,"  %-37s", temp_str);
-    if( creationMode == MODE_CLIENT) {
-        sprintf(temp_str,"%llu out-of-call msg (discarded)",
-                display_scenario->stats->GetStat(CStat::CPT_G_C_OutOfCallMsgs));
-        fprintf(f,"  %-37s", temp_str);
-    }
-    fprintf(f,SIPP_ENDL);
-
-    if(compression) {
-        fprintf(f,"  Comp resync: %d sent, %d recv" ,
-                resynch_send, resynch_recv);
-        fprintf(f,SIPP_ENDL);
-    }
-
-    /* 4th line , sockets and optional errors */
-    sprintf(temp_str,"%d open sockets",
-            pollnfds);
-    fprintf(f,"  %-38s", temp_str);
-    if(nb_net_recv_errors || nb_net_send_errors || nb_net_cong) {
-        fprintf(f,"  %lu/%lu/%lu %s errors (send/recv/cong)" SIPP_ENDL,
-                nb_net_send_errors,
-                nb_net_recv_errors,
-                nb_net_cong,
-                TRANSPORT_TO_STRING(transport));
-    } else {
-        fprintf(f,SIPP_ENDL);
-    }
-
-#ifdef PCAPPLAY
-    /* if has media abilities */
-    if (hasMedia != 0) {
-        sprintf(temp_str, "%lu Total RTP pckts sent ",
-                rtp_pckts_pcap);
-        if (clock_tick-last_report_time) {
-            fprintf(f,"  %-38s %lu.%03lu last period RTP rate (kB/s)" SIPP_ENDL,
-                    temp_str,
-                    (rtp_bytes_pcap)/(clock_tick-last_report_time),
-                    (rtp_bytes_pcap)%(clock_tick-last_report_time));
-        }
-        rtp_bytes_pcap = 0;
-        rtp2_bytes_pcap = 0;
-    }
-#endif
-#ifdef RTP_STREAM
-  /* if we have rtp stream thread running */
-  if (rtpstream_numthreads) {
-    unsigned long TempBytes;
-    unsigned long last_tick= clock_tick;
-    /* Saved clock_tick to last_tick and use that in calcs since clock tick */
-    /* can change during calculations.                                      */
-    if (last_tick-last_report_time) {
-      TempBytes= rtpstream_bytes_out;
-      /* Calculate integer and fraction parts of rtp bandwidth; this value
-       * will be saved and reused in the case where last_tick==last_report_time
-       */
-      last_rtpstream_rate_out= ((double)TempBytes)/(last_tick-last_report_time);
-      /* Potential race condition betwen multiple threads updating the
-       * rtpstream_bytes value. We subtract the saved TempBytes value
-       * rather than setting it to zero to minimise the chances of missing
-       * an update to rtpstream_bytes [update between printing stats and
-       * zeroing the counter]. Ideally we would atomically subtract
-       * TempBytes from rtpstream_bytes.
-       */
-      rtpstream_bytes_out-= TempBytes;
-      TempBytes= rtpstream_bytes_in;
-      last_rtpstream_rate_in= ((double)TempBytes)/(last_tick-last_report_time);
-      rtpstream_bytes_in-= TempBytes;
-    }
-    sprintf(temp_str, "%lu Total RTP pckts sent",rtpstream_pckts);
-    fprintf(f,"  %-38s %.3f kB/s RTP OUT" SIPP_ENDL,
-              temp_str,last_rtpstream_rate_out);
-
-    sprintf(temp_str, "%lu RTP sending threads active",rtpstream_numthreads);
-    fprintf(f,"  %-38s %.3f kB/s RTP IN" SIPP_ENDL,
-              temp_str,last_rtpstream_rate_in);
-  }
-#endif
-
-    /* 5th line, RTP echo statistics */
-    if (rtp_echo_enabled && media_socket_audio > 0) {
-        sprintf(temp_str, "%lu Total echo RTP pckts 1st stream",
-                rtp_pckts);
-
-        // AComment: Fix for random coredump when using RTP echo
-        if (clock_tick-last_report_time) {
-            fprintf(f,"  %-38s %lu.%03lu last period RTP rate (kB/s)" SIPP_ENDL,
-                    temp_str,
-                    (rtp_bytes)/(clock_tick-last_report_time),
-                    (rtp_bytes)%(clock_tick-last_report_time));
-        }
-        /* second stream statitics: */
-        sprintf(temp_str, "%lu Total echo RTP pckts 2nd stream",
-                rtp2_pckts);
-
-        // AComment: Fix for random coredump when using RTP echo
-        if (clock_tick-last_report_time) {
-            fprintf(f,"  %-38s %lu.%03lu last period RTP rate (kB/s)" SIPP_ENDL,
-                    temp_str,
-                    (rtp2_bytes)/(clock_tick-last_report_time),
-                    (rtp2_bytes)%(clock_tick-last_report_time));
-        }
-        rtp_bytes = 0;
-        rtp2_bytes = 0;
-    }
-
-    /* Scenario counters */
-    fprintf(f,SIPP_ENDL);
-    if(!lose_packets) {
-        fprintf(f,"                                 "
-                "Messages  Retrans   Timeout   Unexpected-Msg"
-                SIPP_ENDL);
-    } else {
-        fprintf(f,"                                 "
-                "Messages  Retrans   Timeout   Unexp.    Lost"
-                SIPP_ENDL);
-    }
-    for(unsigned long index = 0;
-            index < display_scenario->messages.size();
-            index ++) {
-        message *curmsg = display_scenario->messages[index];
-
-        if(do_hide && curmsg->hide) {
-            continue;
-        }
-        if (show_index) {
-            fprintf(f, "%-2lu:", index);
-        }
-
-        if(SendingMessage *src = curmsg -> send_scheme) {
-            if (src->isResponse()) {
-                sprintf(temp_str, "%d", src->getCode());
-            } else {
-                sprintf(temp_str, "%s", src->getMethod());
-            }
-
-            if(creationMode == MODE_SERVER) {
-                fprintf(f,"  <---------- %-10s ", temp_str);
-            } else {
-                fprintf(f,"  %10s ----------> ", temp_str);
-            }
-            if (curmsg -> start_rtd) {
-                fprintf(f, " B-RTD%d ", curmsg -> start_rtd);
-            } else if (curmsg -> stop_rtd) {
-                fprintf(f, " E-RTD%d ", curmsg -> stop_rtd);
-            } else {
-                fprintf(f, "        ");
-            }
-
-            if(curmsg -> retrans_delay) {
-                fprintf(f,"%-9lu %-9lu %-9lu %-9s" ,
-                        curmsg -> nb_sent,
-                        curmsg -> nb_sent_retrans,
-                        curmsg -> nb_timeout,
-                        "" /* Unexpected */);
-            } else {
-                fprintf(f,"%-9lu %-9lu %-9s %-9s" ,
-                        curmsg -> nb_sent,
-                        curmsg -> nb_sent_retrans,
-                        "", /* Timeout. */
-                        "" /* Unexpected. */);
-            }
-        } else if(curmsg -> recv_response) {
-            if(creationMode == MODE_SERVER) {
-                fprintf(f,"  ----------> %-10d ", curmsg -> recv_response);
-            } else {
-                fprintf(f,"  %10d <---------- ", curmsg -> recv_response);
-            }
-
-            if (curmsg -> start_rtd) {
-                fprintf(f, " B-RTD%d ", curmsg -> start_rtd);
-            } else if (curmsg -> stop_rtd) {
-                fprintf(f, " E-RTD%d ", curmsg -> stop_rtd);
-            } else {
-                fprintf(f, "        ");
-            }
-
-            fprintf(f,"%-9ld %-9ld %-9ld %-9ld" ,
-                    curmsg->nb_recv,
-                    curmsg->nb_recv_retrans,
-                    curmsg->nb_timeout,
-                    curmsg->nb_unexp);
-        } else if (curmsg -> pause_distribution ||
-                   (curmsg -> pause_variable != -1)) {
-            char *desc = curmsg->pause_desc;
-            if (!desc) {
-                desc = (char *)malloc(24);
-                if (curmsg->pause_distribution) {
-                    desc[0] = '\0';
-                    curmsg->pause_distribution->timeDescr(desc, 23);
-                } else {
-                    snprintf(desc, 23, "$%s", display_scenario->allocVars->getName(curmsg->pause_variable));
-                }
-                desc[23] = '\0';
-                curmsg->pause_desc = desc;
-            }
-            int len = strlen(desc) < 9 ? 9 : strlen(desc);
-
-            if(creationMode == MODE_SERVER) {
-                fprintf(f,"  [%9s] Pause%*s", desc, 23 - len > 0 ? 23 - len : 0, "");
-            } else {
-                fprintf(f,"       Pause [%9s]%*s", desc, 18 - len > 0 ? 18 - len : 0, "");
-            }
-
-            fprintf(f,"%-9d", curmsg->sessions);
-            fprintf(f,"                     %-9lu" , curmsg->nb_unexp);
-        } else if(curmsg -> recv_request) {
-            if(creationMode == MODE_SERVER) {
-                fprintf(f,"  ----------> %-10s ", curmsg -> recv_request);
-            } else {
-                fprintf(f,"  %10s <---------- ", curmsg -> recv_request);
-            }
-
-            if (curmsg -> start_rtd) {
-                fprintf(f, " B-RTD%d ", curmsg -> start_rtd);
-            } else if (curmsg -> stop_rtd) {
-                fprintf(f, " E-RTD%d ", curmsg -> stop_rtd);
-            } else {
-                fprintf(f, "        ");
-            }
-
-            fprintf(f,"%-9ld %-9ld %-9ld %-9ld" ,
-                    curmsg -> nb_recv,
-                    curmsg -> nb_recv_retrans,
-                    curmsg -> nb_timeout,
-                    curmsg -> nb_unexp);
-        } else if(curmsg -> M_type == MSG_TYPE_NOP) {
-            if (curmsg->display_str) {
-                fprintf(f," %s", curmsg->display_str);
-            } else {
-                fprintf(f,"              [ NOP ]              ");
-            }
-        } else if(curmsg -> M_type == MSG_TYPE_RECVCMD) {
-            fprintf(f,"    [ Received Command ]         ");
-            if(curmsg->retrans_delay) {
-                fprintf(f,"%-9ld %-9s %-9ld %-9s" ,
-                        curmsg->M_nbCmdRecv,
-                        "",
-                        curmsg->nb_timeout,
-                        "");
-            } else {
-                fprintf(f,"%-9ld %-9s           %-9s" ,
-                        curmsg -> M_nbCmdRecv,
-                        "",
-                        "");
-            }
-        } else if(curmsg -> M_type == MSG_TYPE_SENDCMD) {
-            fprintf(f,"        [ Sent Command ]         ");
-            fprintf(f,"%-9lu %-9s           %-9s" ,
-                    curmsg -> M_nbCmdSent,
-                    "",
-                    "");
-        } else {
-            ERROR("Scenario command not implemented in display\n");
-        }
-
-        if(lose_packets && (curmsg -> nb_lost)) {
-            fprintf(f," %-9lu" SIPP_ENDL,
-                    curmsg -> nb_lost);
-        } else {
-            fprintf(f,SIPP_ENDL);
-        }
 
-        if(curmsg -> crlf) {
-            fprintf(f,SIPP_ENDL);
-        }
-    }
-}
-
-void print_count_file(FILE *f, int header)
+void print_count_file(FILE* f, int header)
 {
     char temp_str[256];
 
@@ -680,24 +70,28 @@ void print_count_file(FILE *f, int header)
     }
 
     if (header) {
-        fprintf(f, "CurrentTime%sElapsedTime%s", stat_delimiter, stat_delimiter);
+        fprintf(f, "CurrentTime%sElapsedTime%s", stat_delimiter,
+                stat_delimiter);
     } else {
         struct timeval currentTime, startTime;
         GET_TIME(&currentTime);
         main_scenario->stats->getStartTime(&startTime);
-        unsigned long globalElapsedTime = CStat::computeDiffTimeInMs (&currentTime, &startTime);
+        unsigned long globalElapsedTime =
+            CStat::computeDiffTimeInMs(&currentTime, &startTime);
         fprintf(f, "%s%s", CStat::formatTime(&currentTime), stat_delimiter);
-        fprintf(f, "%s%s", CStat::msToHHMMSSus(globalElapsedTime), stat_delimiter);
+        fprintf(f, "%s%s", CStat::msToHHMMSSus(globalElapsedTime),
+                stat_delimiter);
     }
 
-    for(unsigned int index = 0; index < main_scenario->messages.size(); index ++) {
-        message *curmsg = main_scenario->messages[index];
-        if(curmsg->hide) {
+    for (unsigned int index = 0; index < main_scenario->messages.size();
+         index++) {
+        message* curmsg = main_scenario->messages[index];
+        if (curmsg->hide) {
             continue;
         }
 
-        if(SendingMessage *src = curmsg -> send_scheme) {
-            if(header) {
+        if (SendingMessage* src = curmsg->send_scheme) {
+            if (header) {
                 if (src->isResponse()) {
                     sprintf(temp_str, "%u_%d_", index, src->getCode());
                 } else {
@@ -706,31 +100,31 @@ void print_count_file(FILE *f, int header)
 
                 fprintf(f, "%sSent%s", temp_str, stat_delimiter);
                 fprintf(f, "%sRetrans%s", temp_str, stat_delimiter);
-                if(curmsg -> retrans_delay) {
+                if (curmsg->retrans_delay) {
                     fprintf(f, "%sTimeout%s", temp_str, stat_delimiter);
                 }
-                if(lose_packets) {
+                if (lose_packets) {
                     fprintf(f, "%sLost%s", temp_str, stat_delimiter);
                 }
             } else {
                 fprintf(f, "%lu%s", curmsg->nb_sent, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_sent_retrans, stat_delimiter);
-                if(curmsg -> retrans_delay) {
+                if (curmsg->retrans_delay) {
                     fprintf(f, "%lu%s", curmsg->nb_timeout, stat_delimiter);
                 }
-                if(lose_packets) {
+                if (lose_packets) {
                     fprintf(f, "%lu%s", curmsg->nb_lost, stat_delimiter);
                 }
             }
-        } else if(curmsg -> recv_response) {
-            if(header) {
+        } else if (curmsg->recv_response) {
+            if (header) {
                 sprintf(temp_str, "%u_%d_", index, curmsg->recv_response);
 
                 fprintf(f, "%sRecv%s", temp_str, stat_delimiter);
                 fprintf(f, "%sRetrans%s", temp_str, stat_delimiter);
                 fprintf(f, "%sTimeout%s", temp_str, stat_delimiter);
                 fprintf(f, "%sUnexp%s", temp_str, stat_delimiter);
-                if(lose_packets) {
+                if (lose_packets) {
                     fprintf(f, "%sLost%s", temp_str, stat_delimiter);
                 }
             } else {
@@ -738,19 +132,19 @@ void print_count_file(FILE *f, int header)
                 fprintf(f, "%lu%s", curmsg->nb_recv_retrans, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_timeout, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_unexp, stat_delimiter);
-                if(lose_packets) {
+                if (lose_packets) {
                     fprintf(f, "%lu%s", curmsg->nb_lost, stat_delimiter);
                 }
             }
-        } else if(curmsg -> recv_request) {
-            if(header) {
+        } else if (curmsg->recv_request) {
+            if (header) {
                 sprintf(temp_str, "%u_%s_", index, curmsg->recv_request);
 
                 fprintf(f, "%sRecv%s", temp_str, stat_delimiter);
                 fprintf(f, "%sRetrans%s", temp_str, stat_delimiter);
                 fprintf(f, "%sTimeout%s", temp_str, stat_delimiter);
                 fprintf(f, "%sUnexp%s", temp_str, stat_delimiter);
-                if(lose_packets) {
+                if (lose_packets) {
                     fprintf(f, "%sLost%s", temp_str, stat_delimiter);
                 }
             } else {
@@ -758,14 +152,13 @@ void print_count_file(FILE *f, int header)
                 fprintf(f, "%lu%s", curmsg->nb_recv_retrans, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_timeout, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_unexp, stat_delimiter);
-                if(lose_packets) {
+                if (lose_packets) {
                     fprintf(f, "%lu%s", curmsg->nb_lost, stat_delimiter);
                 }
             }
-        } else if (curmsg -> pause_distribution ||
-                   curmsg -> pause_variable) {
+        } else if (curmsg->pause_distribution || curmsg->pause_variable) {
 
-            if(header) {
+            if (header) {
                 sprintf(temp_str, "%u_Pause_", index);
                 fprintf(f, "%sSessions%s", temp_str, stat_delimiter);
                 fprintf(f, "%sUnexp%s", temp_str, stat_delimiter);
@@ -773,10 +166,10 @@ void print_count_file(FILE *f, int header)
                 fprintf(f, "%d%s", curmsg->sessions, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_unexp, stat_delimiter);
             }
-        } else if(curmsg -> M_type == MSG_TYPE_NOP) {
+        } else if (curmsg->M_type == MSG_TYPE_NOP) {
             /* No output. */
-        }  else if(curmsg -> M_type == MSG_TYPE_RECVCMD) {
-            if(header) {
+        } else if (curmsg->M_type == MSG_TYPE_RECVCMD) {
+            if (header) {
                 sprintf(temp_str, "%u_RecvCmd", index);
                 fprintf(f, "%s%s", temp_str, stat_delimiter);
                 fprintf(f, "%s_Timeout%s", temp_str, stat_delimiter);
@@ -784,8 +177,8 @@ void print_count_file(FILE *f, int header)
                 fprintf(f, "%lu%s", curmsg->M_nbCmdRecv, stat_delimiter);
                 fprintf(f, "%lu%s", curmsg->nb_timeout, stat_delimiter);
             }
-        } else if(curmsg -> M_type == MSG_TYPE_SENDCMD) {
-            if(header) {
+        } else if (curmsg->M_type == MSG_TYPE_SENDCMD) {
+            if (header) {
                 sprintf(temp_str, "%u_SendCmd", index);
                 fprintf(f, "%s%s", temp_str, stat_delimiter);
             } else {
@@ -799,7 +192,7 @@ void print_count_file(FILE *f, int header)
     fflush(f);
 }
 
-void print_error_codes_file(FILE *f)
+void print_error_codes_file(FILE* f)
 {
     if (!main_scenario || !main_scenario->stats) {
         return;
@@ -809,13 +202,18 @@ void print_error_codes_file(FILE *f)
     struct timeval currentTime, startTime;
     GET_TIME(&currentTime);
     main_scenario->stats->getStartTime(&startTime);
-    unsigned long globalElapsedTime = CStat::computeDiffTimeInMs (&currentTime, &startTime);
+    unsigned long globalElapsedTime =
+        CStat::computeDiffTimeInMs(&currentTime, &startTime);
     fprintf(f, "%s%s", CStat::formatTime(&currentTime), stat_delimiter);
     fprintf(f, "%s%s", CStat::msToHHMMSSus(globalElapsedTime), stat_delimiter);
 
-    // Print comma-separated list of all error codes seen since the last time this function was called
+    // Print comma-separated list of all error codes seen since the last time
+    // this function was called
     for (; main_scenario->stats->error_codes.size() != 0;) {
-        fprintf(f, "%d,", main_scenario->stats->error_codes[main_scenario->stats->error_codes.size() - 1]);
+        fprintf(
+            f, "%d,",
+            main_scenario->stats
+                ->error_codes[main_scenario->stats->error_codes.size() - 1]);
         main_scenario->stats->error_codes.pop_back();
     }
 
@@ -823,6 +221,7 @@ void print_error_codes_file(FILE *f)
     fflush(f);
 }
 
+
 /* Function to dump all available screens in a file */
 void print_screens(void)
 {
@@ -831,102 +230,77 @@ void print_screens(void)
 
     pthread_mutex_lock(screen_lfi.lockfile);
     currentScreenToDisplay = DISPLAY_SCENARIO_SCREEN;
-    print_header_line(   screen_lfi.fptr);
-    print_stats_in_file( screen_lfi.fptr);
-    print_bottom_line(   screen_lfi.fptr, NOTLAST);
+    sp->print_to_file(screen_lfi.fptr);
 
     currentScreenToDisplay = DISPLAY_STAT_SCREEN;
-    print_header_line(   screen_lfi.fptr);
-    display_scenario->stats->displayStat(screen_lfi.fptr);
-    print_bottom_line(   screen_lfi.fptr, NOTLAST);
+    sp->print_to_file(screen_lfi.fptr);
 
     currentScreenToDisplay = DISPLAY_REPARTITION_SCREEN;
-    print_header_line(   screen_lfi.fptr);
-    display_scenario->stats->displayRepartition(screen_lfi.fptr);
-    print_bottom_line(   screen_lfi.fptr, NOTLAST);
+    sp->print_to_file(screen_lfi.fptr);
 
     currentScreenToDisplay = DISPLAY_SECONDARY_REPARTITION_SCREEN;
-    for (currentRepartitionToDisplay = 2; currentRepartitionToDisplay <= display_scenario->stats->nRtds(); currentRepartitionToDisplay++) {
-        print_header_line(   screen_lfi.fptr);
-        display_scenario->stats->displayRtdRepartition(screen_lfi.fptr, currentRepartitionToDisplay);
-        print_bottom_line(   screen_lfi.fptr, NOTLAST);
+    for (currentRepartitionToDisplay = 2;
+         currentRepartitionToDisplay <= display_scenario->stats->nRtds();
+         currentRepartitionToDisplay++) {
+        sp->print_to_file(screen_lfi.fptr);
     }
-    pthread_mutex_unlock(screen_lfi.lockfile);
 
+    pthread_mutex_unlock(screen_lfi.lockfile);
     currentScreenToDisplay = oldScreen;
     currentRepartitionToDisplay = oldRepartition;
 }
 
 static void rotatef(struct logfile_info* lfi)
 {
-    char L_rotate_file_name [MAX_PATH];
-    struct tm *tim;
-    struct timeval nowx;
-    char time_str[64];
-    time_t now;
-
-	gettimeofday(&nowx, NULL);
-	now = nowx.tv_sec;
-	tim = gmtime(&now);
-	sprintf(time_str, "%04d%02d%02d%02d%02d%02d",
-			tim->tm_year + 1900,
-			tim->tm_mon + 1,
-			tim->tm_mday,
-			tim->tm_hour,
-			tim->tm_min,
-			tim->tm_sec);
+    char L_rotate_file_name[MAX_PATH];
 
     if (!lfi->fixedname) {
-        sprintf (lfi->file_name, "%s_%d_%s.log", scenario_file, getpid(), lfi->name);
+        sprintf(lfi->file_name, "%s_%ld_%s.log", scenario_file, (long)getpid(),
+                lfi->name);
     }
 
     if (ringbuffer_files > 0) {
         if (!lfi->ftimes) {
-            lfi->ftimes = (struct logfile_id *)calloc(ringbuffer_files, sizeof(struct logfile_id));
+            lfi->ftimes = (struct logfile_id*)calloc(ringbuffer_files,
+                                                     sizeof(struct logfile_id));
         }
         /* We need to rotate away an existing file. */
         if (lfi->nfiles == ringbuffer_files) {
-/*
             if ((lfi->ftimes)[0].n) {
-                sprintf(L_rotate_file_name, "%s_%d_%s_%lu.%d.log",
-                        scenario_file, getpid(), lfi->name,
+                sprintf(L_rotate_file_name, "%s_%ld_%s_%lu.%d.log",
+                        scenario_file, (long)getpid(), lfi->name,
                         (unsigned long)(lfi->ftimes)[0].start,
                         (lfi->ftimes)[0].n);
             } else {
-                sprintf(L_rotate_file_name, "%s_%d_%s_%lu.log",
-                        scenario_file, getpid(), lfi->name,
+                sprintf(L_rotate_file_name, "%s_%ld_%s_%lu.log", scenario_file,
+                        (long)getpid(), lfi->name,
                         (unsigned long)(lfi->ftimes)[0].start);
             }
-HYDE
-*/
-
-sprintf(L_rotate_file_name, "%s_%s",lfi->file_name,time_str);
             unlink(L_rotate_file_name);
             lfi->nfiles--;
-            memmove(lfi->ftimes, &((lfi->ftimes)[1]), sizeof(struct logfile_id) * (lfi->nfiles));
+            memmove(lfi->ftimes, &((lfi->ftimes)[1]),
+                    sizeof(struct logfile_id) * (lfi->nfiles));
         }
         if (lfi->starttime) {
             (lfi->ftimes)[lfi->nfiles].start = lfi->starttime;
             (lfi->ftimes)[lfi->nfiles].n = 0;
-            /* If we have the same time, then we need to append an identifier. */
-            if (lfi->nfiles && ((lfi->ftimes)[lfi->nfiles].start == (lfi->ftimes)[lfi->nfiles - 1].start)) {
-                (lfi->ftimes)[lfi->nfiles].n = (lfi->ftimes)[lfi->nfiles - 1].n + 1;
+            /* If we have the same time, then we need to append an identifier.
+             */
+            if (lfi->nfiles && ((lfi->ftimes)[lfi->nfiles].start ==
+                                (lfi->ftimes)[lfi->nfiles - 1].start)) {
+                (lfi->ftimes)[lfi->nfiles].n =
+                    (lfi->ftimes)[lfi->nfiles - 1].n + 1;
             }
-/*
             if ((lfi->ftimes)[lfi->nfiles].n) {
-                sprintf(L_rotate_file_name, "%s_%d_%s_%lu.%d.log",
-                        scenario_file, getpid(), lfi->name,
+                sprintf(L_rotate_file_name, "%s_%ld_%s_%lu.%d.log",
+                        scenario_file, (long)getpid(), lfi->name,
                         (unsigned long)(lfi->ftimes)[lfi->nfiles].start,
                         (lfi->ftimes)[lfi->nfiles].n);
             } else {
-                sprintf(L_rotate_file_name, "%s_%d_%s_%lu.log",
-                        scenario_file, getpid(), lfi->name,
+                sprintf(L_rotate_file_name, "%s_%ld_%s_%lu.log", scenario_file,
+                        (long)getpid(), lfi->name,
                         (unsigned long)(lfi->ftimes)[lfi->nfiles].start);
             }
-*/
-
-//sprintf(L_rotate_file_name, "%s_%d",lfi->file_name,(unsigned long)(lfi->ftimes)[lfi->nfiles].start);
-sprintf(L_rotate_file_name, "%s_%s",lfi->file_name,time_str);
             lfi->nfiles++;
             fflush(lfi->fptr);
             fclose(lfi->fptr);
@@ -942,12 +316,12 @@ sprintf(L_rotate_file_name, "%s_%s",lfi->file_name,time_str);
         lfi->fptr = fopen(lfi->file_name, "a");
         lfi->overwrite = true;
     }
-    if(lfi->check && !lfi->fptr) {
-        /* We can not use the error functions from this function, as we may be rotating the error log itself! */
+    if (lfi->check && !lfi->fptr) {
+        /* We can not use the error functions from this function, as we may be
+         * rotating the error log itself! */
         ERROR("Unable to create '%s'", lfi->file_name);
     }
 }
-
 void rotate_screenf()
 {
     pthread_mutex_lock(screen_lfi.lockfile);
@@ -999,85 +373,203 @@ void rotate_errorf_nolock()
     strcpy(screen_logfile, error_lfi.file_name);
 }
 
-/*#ifdef __cplusplus
-extern "C" {
-#endif
- * w
-*/
-    static int _trace(struct logfile_info* lfi, const char* fmt, va_list ap)
-    {
-        int ret = 0;
-        if(lfi->fptr) {
-            pthread_mutex_lock(lfi->lockfile);
-            ret = vfprintf(lfi->fptr, fmt, ap);
-            fflush(lfi->fptr);
 
-            lfi->count += ret;
+static int _trace(struct logfile_info* lfi, const char* fmt, va_list ap)
+{
+    int ret = 0;
+    if(lfi->fptr) {
+        pthread_mutex_lock(lfi->lockfile);
+        ret = vfprintf(lfi->fptr, fmt, ap);
+        fflush(lfi->fptr);
+
+        lfi->count += ret;
+
+        if (max_log_size && lfi->count > max_log_size) {
+            fclose(lfi->fptr);
+            lfi->fptr = NULL;
+        }
+
+        if (ringbuffer_size && lfi->count > ringbuffer_size) {
+            rotatef(lfi);
+            lfi->count = 0;
+        }
+        pthread_mutex_unlock(lfi->lockfile);
+    }
+    return ret;
+}
+
+
+int TRACE_MSG(const char* fmt, ...)
+{
+    int ret;
+    va_list ap;
+
+    va_start(ap, fmt);
+    ret = _trace(&message_lfi, fmt, ap);
+    va_end(ap);
 
-            if (max_log_size && lfi->count > max_log_size) {
-                fclose(lfi->fptr);
-                lfi->fptr = NULL;
+    return ret;
+}
+
+int TRACE_SHORTMSG(const char* fmt, ...)
+{
+    int ret;
+    va_list ap;
+
+    va_start(ap, fmt);
+    ret = _trace(&shortmessage_lfi, fmt, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+int LOG_MSG(const char* fmt, ...)
+{
+    int ret;
+    va_list ap;
+
+    va_start(ap, fmt);
+    ret = _trace(&log_lfi, fmt, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+int TRACE_CALLDEBUG(const char* fmt, ...)
+{
+    int ret;
+    va_list ap;
+
+    va_start(ap, fmt);
+    ret = _trace(&calldebug_lfi, fmt, ap);
+    va_end(ap);
+
+    return ret;
+}
+
+void print_errors() {
+    if (total_errors == 0) {
+        return;
+    }
+
+    fprintf(stderr, "%s\n", screen_last_error);
+    if (total_errors > 1) {
+        if (screen_logfile[0] != '\0') {
+            fprintf(stderr,
+                    "There were more errors, see '%s' file\n",
+                    screen_logfile);
+        } else {
+            fprintf(stderr,
+                    "There were more errors, enable -trace_err to log them.\n");
+        }
+    }
+    fflush(stderr);
+}
+
+static void _advance(char*& c, const int snprintfResult)
+{
+    if (snprintfResult > 0) {
+        c += snprintfResult;
+    }
+}
+
+static void _screen_error(int fatal, bool use_errno, int error, const char *fmt, va_list ap)
+{
+    static unsigned long long count = 0;
+    struct timeval currentTime;
+
+    CStat::globalStat(fatal ? CStat::E_FATAL_ERRORS : CStat::E_WARNING);
+
+    GET_TIME (&currentTime);
+
+    const std::size_t bufSize = sizeof(screen_last_error) / sizeof(screen_last_error[0]);
+    const char* const bufEnd = &screen_last_error[bufSize];
+    char* c = screen_last_error;
+    _advance(c, snprintf(c, bufEnd - c, "%s: ", CStat::formatTime(&currentTime)));
+    if (c < bufEnd) {
+        _advance(c, vsnprintf(c, bufEnd - c, fmt, ap));
+    }
+    if (use_errno && c < bufEnd) {
+        _advance(c, snprintf(c, bufEnd - c, ", errno = %d (%s)", error, strerror(error)));
+    }
+    total_errors++;
+
+    if (!error_lfi.fptr && print_all_responses) {
+        rotate_errorf();
+        if (error_lfi.fptr) {
+            fprintf(error_lfi.fptr, "The following events occurred:\n");
+            fflush(error_lfi.fptr);
+        } else {
+            if (c < bufEnd) {
+                _advance(c, snprintf(c, bufEnd - c, "Unable to create '%s': %s.\n",
+                                     screen_logfile, strerror(errno)));
             }
+            sipp_exit(EXIT_FATAL_ERROR);
+        }
+    }
 
-            if (ringbuffer_size && lfi->count > ringbuffer_size) {
-                rotatef(lfi);
-                lfi->count = 0;
+    if (error_lfi.fptr) {
+        count += fprintf(error_lfi.fptr, "%s", screen_last_error);
+        fflush(error_lfi.fptr);
+        if (ringbuffer_size && count > ringbuffer_size) {
+            rotate_errorf();
+            count = 0;
+        }
+        if (max_log_size && count > max_log_size) {
+            print_all_responses = 0;
+            if (error_lfi.fptr) {
+                fflush(error_lfi.fptr);
+                fclose(error_lfi.fptr);
+                error_lfi.fptr = NULL;
+                error_lfi.overwrite = false;
             }
-            pthread_mutex_unlock(lfi->lockfile);
         }
-        return ret;
+    } else if (fatal) {
+        fprintf(stderr, "%s\n", screen_last_error);
+        fflush(stderr);
     }
 
+    if (fatal) {
+        if (error == EADDRINUSE) {
+            sipp_exit(EXIT_BIND_ERROR);
+        } else {
+            sipp_exit(EXIT_FATAL_ERROR);
+        }
+    }
+}
 
-    int TRACE_MSG(const char *fmt, ...)
+extern "C" {
+    void ERROR(const char *fmt, ...)
     {
-        int ret;
         va_list ap;
-
         va_start(ap, fmt);
-        ret = _trace(&message_lfi, fmt, ap);
+        _screen_error(true, false, 0, fmt, ap);
         va_end(ap);
-
-        return ret;
+        assert(0);
     }
 
-    int TRACE_SHORTMSG(const char *fmt, ...)
+    void ERROR_NO(const char *fmt, ...)
     {
-        int ret;
         va_list ap;
-
         va_start(ap, fmt);
-        ret = _trace(&shortmessage_lfi, fmt, ap);
+        _screen_error(true, true, errno, fmt, ap);
         va_end(ap);
-
-        return ret;
+        assert(0);
     }
 
-    int LOG_MSG(const char *fmt, ...)
+    void WARNING(const char *fmt, ...)
     {
-        int ret;
         va_list ap;
-
         va_start(ap, fmt);
-        ret = _trace(&log_lfi, fmt, ap);
+        _screen_error(false, false, 0, fmt, ap);
         va_end(ap);
-
-        return ret;
     }
 
-    int TRACE_CALLDEBUG(const char *fmt, ...)
+    void WARNING_NO(const char *fmt, ...)
     {
-        int ret;
         va_list ap;
-
         va_start(ap, fmt);
-        ret = _trace(&calldebug_lfi, fmt, ap);
+        _screen_error(false, true, errno, fmt, ap);
         va_end(ap);
-
-        return ret;
     }
-/*
-#ifdef __cplusplus
 }
-#endif
-*/
diff --git a/src/myapp.cpp b/src/myapp.cpp
index 6ee4bfb6e..62982e1cf 100644
--- a/src/myapp.cpp
+++ b/src/myapp.cpp
@@ -105,8 +105,8 @@ lua_State*  openLua() {
 
                 luaL_openlibs(L);                           /* Load Lua libraries */
 
-                //HYDE if (luaL_loadfile(L, "sipp.lua")) /* Load but don't run the Lua script */
-                if (luaL_loadfile(L, lua_file)) /* Load but don't run the Lua script */
+                if (luaL_loadfile(L, "sipp.lua")) /* Load but don't run the Lua script */
+                //if (luaL_loadfile(L, lua_file)) /* Load but don't run the Lua script */
                 {
                         bail(L, "luaL_loadfile() failed");      /* Error out if file can't be read */
                         L=0;
diff --git a/src/screen.cpp b/src/screen.cpp
index 7a679445b..e974dcd26 100644
--- a/src/screen.cpp
+++ b/src/screen.cpp
@@ -17,42 +17,21 @@
  *           From Hewlett Packard Company.
  */
 
-/****
- * Screen.cpp : Simple curses & logfile encapsulation
- */
+#include <curses.h>
 
-#include "stat.hpp"
+#include "screen.hpp"
 #include "sipp.hpp"
 
-#include <curses.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <screen.hpp>
-#include <errno.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-
-#ifdef __SUNOS
-#include <stdarg.h>
-#endif
+/* Export these so others needn't include curses.h */
+int key_backspace = KEY_BACKSPACE;
+int key_dc = KEY_DC;
 
-#include <unistd.h>
+int           screen_inited = 0;
 
-extern bool    timeout_exit;
+ScreenPrinter* sp;
 
-unsigned long screen_errors;
-int           screen_inited = 0;
-char          screen_exename[255];
-extern bool   backgroundMode;
-
-/* Clock must be a pointer to struct timeval */
-#define GET_TIME(clock)       \
-{                             \
-  struct timezone tzp;        \
-  gettimeofday (clock, &tzp); \
-}
+double last_rtpstream_rate_out = 0;
+double last_rtpstream_rate_in = 0;
 
 /* ERR is actually -1, but this prevents us from needing to use curses.h in
  * sipp.cpp. */
@@ -71,159 +50,845 @@ void screen_exit()
         return;
     }
 
+    clear();
+    refresh();
     endwin();
+    screen_inited = 0;
 }
 
-void screen_show_errors() {
-    if (!screen_errors) {
+void screen_init()
+{
+    if (backgroundMode || screen_inited) {
         return;
     }
 
-    fprintf(stderr, "%s", screen_last_error);
-    if (screen_errors > 1) {
-        if (screen_logfile[0] != '\0') {
-            fprintf(stderr,
-                    "%s: There were more errors, see '%s' file\n",
-                    screen_exename, screen_logfile);
-        } else {
-            fprintf(stderr,
-                    "%s: There were more errors, enable -trace_err to log them.\n",
-                    screen_exename);
+    screen_inited = 1;
+
+    setlocale(LC_ALL, "");
+    initscr();
+    cbreak();
+    noecho();
+    clear();
+}
+
+void print_statistics(int last)
+{
+    if (backgroundMode == false && display_scenario) {
+      sp->redraw();
+    }
+}
+
+void ScreenPrinter::print_closing_stats() {
+    M_last = true;
+    get_lines();
+    for (string_array::iterator it = lines.begin(); it != lines.end(); ++it) {
+        printf("%s\n", (*it).c_str());
+    }
+
+    if (currentScreenToDisplay != DISPLAY_STAT_SCREEN) {
+        currentScreenToDisplay = DISPLAY_STAT_SCREEN;
+        get_lines();
+        for (string_array::iterator it = lines.begin(); it != lines.end(); ++it) {
+            printf("%s\n", (*it).c_str());
         }
     }
-    fflush(stderr);
+
 }
 
-void screen_clear()
+void ScreenPrinter::print_to_file(FILE* f)
 {
-    printf("\033[2J");
+    get_lines();
+    for (string_array::iterator it = lines.begin(); it != lines.end(); ++it) {
+        fprintf(f, "%s\n", (*it).c_str());
+    }
 }
 
-void screen_set_exename(const char* exe_name)
+extern int command_mode;
+extern char* command_buffer;
+
+
+void ScreenPrinter::redraw()
 {
-    strncpy(screen_exename, exe_name, sizeof(screen_exename) - 1);
+    if (!M_headless) {
+        get_lines();
+        erase();
+        for (string_array::iterator it = lines.begin(); it != lines.end(); ++it) {
+            printw("%s\n", (*it).c_str());
+        }
+
+        if (command_mode) {
+            printw("\nCommand: %s", command_buffer ? command_buffer : "");
+        }
+
+        refresh();
+    }
 }
 
-void screen_init()
+void ScreenPrinter::get_lines()
 {
-    if (backgroundMode) {
-        return;
+    lines.clear();
+    switch (currentScreenToDisplay) {
+    case DISPLAY_STAT_SCREEN:
+        lines.push_back("----------------------------- Statistics Screen "
+                        "------- [1-9]: Change Screen --");
+        draw_stats_screen();
+        break;
+    case DISPLAY_REPARTITION_SCREEN:
+        lines.push_back("---------------------------- Repartition Screen "
+                        "------- [1-9]: Change Screen --");
+        draw_repartition_screen(1);
+        break;
+    case DISPLAY_VARIABLE_SCREEN:
+        lines.push_back("----------------------------- Variables Screen "
+                        "-------- [1-9]: Change Screen --");
+        draw_vars_screen();
+        break;
+    case DISPLAY_TDM_MAP_SCREEN:
+        lines.push_back("------------------------------ TDM map Screen "
+                        "--------- [1-9]: Change Screen --");
+        draw_tdm_screen();
+        break;
+    case DISPLAY_SECONDARY_REPARTITION_SCREEN:
+        lines.push_back("--------------------------- Repartition " +
+                        std::to_string(currentRepartitionToDisplay) +
+                        " Screen ------ [1-9]: Change Screen --");
+        draw_repartition_screen(currentRepartitionToDisplay);
+        break;
+    case DISPLAY_SCENARIO_SCREEN:
+    default:
+        lines.push_back("------------------------------ Scenario Screen "
+                        "-------- [1-9]: Change Screen --");
+        draw_scenario_screen();
+        break;
     }
 
-    screen_inited = 1;
+    unsigned const bufsiz = 80;
+    char buf[bufsiz];
+    if (!M_last && screen_last_error[0]) {
+      char* errstart = screen_last_error;
+      int colonsleft = 3; /* We want to skip the time. */
+      while (*errstart && colonsleft) {
+        if (*errstart == ':') {
+          colonsleft--;
+        }
+        errstart++;
+      }
+      while (isspace(*errstart)) {
+        errstart++;
+      }
+      if (strlen(errstart) > 60) {
+        snprintf(buf, bufsiz, "Last Error: %.60s...", errstart);
+      } else {
+        snprintf(buf, bufsiz, "Last Error: %s", errstart);
+      }
+      lines.push_back(buf);
+    }
 
-    initscr();
-    noecho();
-    screen_clear();
+    if (M_last) {
+        lines.push_back("------------------------------ Test Terminated "
+                   "--------------------------------");
+    } else if (quitting) {
+        lines.push_back(
+            "------- Waiting for active calls to end. Press [q] again "
+            "to force exit. -------");
+    } else if (paused) {
+        lines.push_back("----------------- Traffic Paused - Press [p] again to "
+                        "resume ------------------");
+    } else if (cpu_max) {
+        lines.push_back("-------------------------------- CPU CONGESTED "
+                        "---------------------------------");
+    } else if (outbound_congestion) {
+        lines.push_back("------------------------------ OUTBOUND CONGESTION "
+                        "-----------------------------");
+    } else {
+        if (creationMode == MODE_CLIENT) {
+            switch (thirdPartyMode) {
+            case MODE_MASTER:
+                lines.push_back(
+                    "-----------------------3PCC extended mode - Master "
+                    "side -------------------------");
+                break;
+            case MODE_3PCC_CONTROLLER_A:
+                lines.push_back(
+                    "----------------------- 3PCC Mode - Controller A "
+                    "side -------------------------");
+                break;
+            case MODE_3PCC_NONE:
+                lines.push_back(
+                    "------ [+|-|*|/]: Adjust rate ---- [q]: Soft exit "
+                    "---- [p]: Pause traffic -----");
+                break;
+            default:
+                ERROR("Internal error: creationMode=%d, thirdPartyMode=%d",
+                      creationMode, thirdPartyMode);
+            }
+        } else {
+            assert(creationMode == MODE_SERVER);
+            switch (thirdPartyMode) {
+            case MODE_3PCC_A_PASSIVE:
+                lines.push_back(
+                    "------------------ 3PCC Mode - Controller A side "
+                    "(passive) --------------------");
+                break;
+            case MODE_3PCC_CONTROLLER_B:
+                lines.push_back(
+                    "----------------------- 3PCC Mode - Controller B "
+                    "side -------------------------");
+                break;
+            case MODE_MASTER_PASSIVE:
+                lines.push_back(
+                    "------------------ 3PCC extended mode - Master "
+                    "side (passive) --------------------");
+                break;
+            case MODE_SLAVE:
+                lines.push_back(
+                    "----------------------- 3PCC extended mode - Slave "
+                    "side -------------------------");
+                break;
+            case MODE_3PCC_NONE:
+                lines.push_back(
+                    "------------------------------ SIPp Server Mode "
+                    "-------------------------------");
+                break;
+            default:
+                ERROR("Internal error: creationMode=%d, thirdPartyMode=%d",
+                      creationMode, thirdPartyMode);
+            }
+        }
+    }
 }
 
-static void _screen_error(int fatal, bool use_errno, int error, const char *fmt, va_list ap)
+bool do_hide = true;
+bool show_index = false;
+
+void ScreenPrinter::draw_scenario_screen()
 {
-    static unsigned long long count = 0;
-    char *c = screen_last_error;
-    struct timeval currentTime;
+    unsigned const bufsiz = 80;
+    char buf[bufsiz];
+    char left_buf[40];
+    char right_buf[bufsiz];
+    extern int pollnfds;
 
-    CStat::globalStat(fatal ? CStat::E_FATAL_ERRORS : CStat::E_WARNING);
+    unsigned long long total_calls =
+        display_scenario->stats->GetStat(CStat::CPT_C_IncomingCallCreated) +
+        display_scenario->stats->GetStat(CStat::CPT_C_OutgoingCallCreated);
+    if (creationMode == MODE_SERVER) {
+        lines.push_back("  Port   Total-time  Total-calls  Transport");
+        snprintf(buf, bufsiz, "  %-5d %6lu.%02lu s     %8llu  %s", local_port,
+                 clock_tick / 1000, (clock_tick % 1000) / 10, total_calls,
+                 TRANSPORT_TO_STRING(transport));
+        lines.push_back(buf);
+    } else {
+        assert(creationMode == MODE_CLIENT);
+        if (users >= 0) {
+            lines.push_back("  Users (length)   Port   Total-time  "
+                            "Total-calls  Remote-host");
+            snprintf(buf, bufsiz,
+                     "  %d (%d ms)   %-5d %6lu.%02lu s     %8llu  %.20s:%d(%s)",
+                     users, duration, local_port, clock_tick / 1000,
+                     (clock_tick % 1000) / 10, total_calls, remote_ip,
+                     remote_port, TRANSPORT_TO_STRING(transport));
+            lines.push_back(buf);
+        } else {
+            lines.push_back("  Call rate (length)   Port   Total-time  "
+                            "Total-calls  Remote-host");
+            snprintf(
+                buf, bufsiz,
+                "  %3.1f(%d ms)/%5.3fs   %-5d %6lu.%02lu s     %8llu  %.20s:%d(%s)",
+                rate, duration, (double)rate_period_ms / 1000.0, local_port,
+                clock_tick / 1000, (clock_tick % 1000) / 10, total_calls,
+                remote_ip, remote_port, TRANSPORT_TO_STRING(transport));
+            lines.push_back(buf);
+        }
+    }
+    lines.push_back("");
+    /* 1st line */
+    unsigned long ms_since_last_tick = clock_tick - last_report_time;
+    if (total_calls < stop_after) {
+        snprintf(left_buf, 40, "%llu new calls during %lu.%03lu s period",
+                 display_scenario->stats->GetStat(
+                     CStat::CPT_PD_IncomingCallCreated) +
+                     display_scenario->stats->GetStat(
+                         CStat::CPT_PD_OutgoingCallCreated),
+                 ms_since_last_tick / 1000, ms_since_last_tick % 1000);
+    } else {
+        snprintf(left_buf, 40,
+                 "Call limit %lu hit, %0.1f s period ", stop_after,
+                 (double)ms_since_last_tick / 100.0);
+    }
+    snprintf(right_buf, 40, "%lu ms scheduler resolution",
+             ms_since_last_tick / std::max(scheduling_loops, 1ul));
+    snprintf(buf, bufsiz, "  %-38.38s  %-37.37s", left_buf, right_buf);
+    lines.push_back(buf);
 
-    GET_TIME (&currentTime);
+    /* 2nd line */
+    if (creationMode == MODE_SERVER) {
+        snprintf(left_buf, 40, "%llu calls",
+                 display_scenario->stats->GetStat(CStat::CPT_C_CurrentCall));
+    } else {
+        snprintf(left_buf, 40, "%llu calls (limit %u)",
+                 display_scenario->stats->GetStat(CStat::CPT_C_CurrentCall),
+                 open_calls_allowed);
+    }
+    snprintf(
+        buf, bufsiz, "  %-38s  Peak was %llu calls, after %llu s", left_buf,
+        display_scenario->stats->GetStat(CStat::CPT_C_CurrentCallPeak),
+        display_scenario->stats->GetStat(CStat::CPT_C_CurrentCallPeakTime));
+    lines.push_back(buf);
 
-    c+= sprintf(c, "%s: ", CStat::formatTime(&currentTime));
-    c+= vsprintf(c, fmt, ap);
-    if (use_errno) {
-        c += sprintf(c, ", errno = %d (%s)", error, strerror(error));
-    }
-    c+= sprintf(c, ".\n");
-    screen_errors++;
-
-    // 02/16/2022 - NVF Removed this to prevent deadlock when  the rotate_errorf() reueses the same lock
-    // 02/16/2022 - HYDE changed to use rotate_errorf_nolock() to avoid dead lock
-    pthread_mutex_lock(error_lfi.lockfile);
-    if (!error_lfi.fptr && print_all_responses) {
-        rotate_errorf_nolock();
-        if (error_lfi.fptr) {
-            fprintf(error_lfi.fptr, "%s: The following events occured:\n",
-                    screen_exename);
-            fflush(error_lfi.fptr);
-        } else {
-            if (screen_inited) {
-                sprintf(c, "%s: Unable to create '%s': %s.\n",
-                        screen_exename, screen_logfile, strerror(errno));
-            }
-            sipp_exit(EXIT_FATAL_ERROR);
+    snprintf(buf, bufsiz, "  %d Running, %d Paused, %d Woken up",
+             last_running_calls, last_paused_calls, last_woken_calls);
+    last_woken_calls = 0;
+    lines.push_back(buf);
+
+    /* 3rd line dead call msgs, and optional out-of-call msg */
+    snprintf(left_buf, 40, "%llu dead call msg (discarded)",
+             display_scenario->stats->GetStat(CStat::CPT_G_C_DeadCallMsgs));
+    if (creationMode == MODE_CLIENT) {
+        snprintf(
+            buf, bufsiz, "  %-38s  %llu out-of-call msg (discarded)", left_buf,
+            display_scenario->stats->GetStat(CStat::CPT_G_C_OutOfCallMsgs));
+    } else {
+        snprintf(buf, bufsiz, "  %-38s", left_buf);
+    }
+    lines.push_back(buf);
+
+    if (compression) {
+        snprintf(buf, bufsiz, "  Comp resync: %d sent, %d recv", resynch_send,
+                 resynch_recv);
+        lines.push_back(buf);
+    }
+
+    /* 4th line , sockets and optional errors */
+    snprintf(left_buf, 40, "%d open sockets", pollnfds);
+    snprintf(buf, bufsiz, "  %-38s  %lu/%lu/%lu %s errors (send/recv/cong)",
+             left_buf, nb_net_send_errors, nb_net_recv_errors, nb_net_cong,
+             TRANSPORT_TO_STRING(transport));
+    lines.push_back(buf);
+
+#ifdef PCAPPLAY
+    /* if has media abilities */
+    if (hasMedia != 5) {
+        snprintf(left_buf, 40, "%lu Total RTP pckts sent ",
+                rtp_pckts_pcap);
+        if (ms_since_last_tick) {
+            snprintf(buf, bufsiz, "  %-38s  %lu.%03lu last period RTP rate (kB/s)",
+                    left_buf,
+                    rtp_bytes_pcap / ms_since_last_tick,
+                    rtp_bytes_pcap % ms_since_last_tick);
+        }
+        rtp_bytes_pcap = 0;
+        rtp2_bytes_pcap = 0;
+        lines.push_back(buf);
+    }
+#endif
+    /* if we have rtp stream thread running */
+    if (rtpstream_numthreads) {
+        unsigned long tempbytes;
+        if (ms_since_last_tick) {
+            tempbytes = rtpstream_bytes_out;
+            /* Calculate integer and fraction parts of rtp bandwidth; this value
+             * will be saved and reused in the case where last_tick==last_report_time
+             */
+            last_rtpstream_rate_out = ((double)tempbytes) / ms_since_last_tick;
+            /* Potential race condition betwen multiple threads updating the
+             * rtpstream_bytes value. We subtract the saved tempbytes value
+             * rather than setting it to zero to minimise the chances of missing
+             * an update to rtpstream_bytes [update between printing stats and
+             * zeroing the counter]. Ideally we would atomically subtract
+             * tempbytes from rtpstream_bytes.
+             */
+            rtpstream_bytes_out -= tempbytes;
+            tempbytes = rtpstream_bytes_in;
+            last_rtpstream_rate_in = ((double)tempbytes) / ms_since_last_tick;
+            rtpstream_bytes_in -= tempbytes;
         }
+
+        snprintf(left_buf, 40, "%lu Total RTP pckts sent", rtpstream_pckts);
+        snprintf(buf, bufsiz,"  %-38s  %.3f kB/s RTP OUT",
+                left_buf, last_rtpstream_rate_out);
+        lines.push_back(buf);
+
+        snprintf(left_buf, 40, "%lu RTP sending threads active", rtpstream_numthreads);
+        snprintf(buf, bufsiz, "  %-38s  %.3f kB/s RTP IN",
+                 left_buf, last_rtpstream_rate_in);
+        lines.push_back(buf);
     }
 
-    if (error_lfi.fptr) {
-        count += fprintf(error_lfi.fptr, "%s", screen_last_error);
-        fflush(error_lfi.fptr);
-        if (ringbuffer_size && count > ringbuffer_size) {
-            rotate_errorf_nolock();
-            count = 0;
+    /* 5th line, RTP echo statistics */
+    if (rtp_echo_enabled && media_socket_audio > 0) {
+        snprintf(left_buf, 40, "%lu Total echo RTP pckts 1st stream",
+                rtp_pckts);
+
+        if (ms_since_last_tick) {
+            snprintf(buf, bufsiz, "  %-38s  %lu.%03lu last period RTP rate (kB/s)",
+                    left_buf,
+                    rtp_bytes / ms_since_last_tick,
+                    rtp_bytes % ms_since_last_tick);
+            lines.push_back(buf);
         }
-        if (max_log_size && count > max_log_size) {
-            print_all_responses = 0;
-            if (error_lfi.fptr) {
-                fflush(error_lfi.fptr);
-                fclose(error_lfi.fptr);
-                error_lfi.fptr = NULL;
-                error_lfi.overwrite = false;
-            }
+
+        snprintf(left_buf, 40, "%lu Total echo RTP pckts 2nd stream",
+                rtp2_pckts);
+        if (ms_since_last_tick) {
+            snprintf(buf, bufsiz, "  %-38s  %lu.%03lu last period RTP rate (kB/s)",
+                    left_buf,
+                    rtp2_bytes / ms_since_last_tick,
+                    rtp2_bytes % ms_since_last_tick);
+            lines.push_back(buf);
         }
-    } else if (fatal) {
-        fprintf(stderr, "%s", screen_last_error);
-        fflush(stderr);
+        rtp_bytes = 0;
+        rtp2_bytes = 0;
     }
-    pthread_mutex_unlock(error_lfi.lockfile);
 
-    if (fatal) {
-        if (!screen_inited) {
-            if (error == EADDRINUSE) {
-                exit(EXIT_BIND_ERROR);
+    /* Scenario counters */
+    lines.push_back("");
+    if (!lose_packets) {
+        snprintf(buf, bufsiz,
+                 "                                 "
+                 "Messages  Retrans   Timeout   Unexpected-Msg");
+    } else {
+        snprintf(buf, bufsiz,
+                 "                                 "
+                 "Messages  Retrans   Timeout   Unexp.    Lost");
+    }
+    lines.push_back(buf);
+
+    for (unsigned long index = 0; index < display_scenario->messages.size();
+         index++) {
+        buf[0] = 0;
+        message* curmsg = display_scenario->messages[index];
+
+        if (do_hide && curmsg->hide) {
+            continue;
+        }
+        int buf_len = 0;
+        if (show_index) {
+            buf_len += snprintf(buf + buf_len, bufsiz - buf_len, "%-2lu:", index);
+        }
+
+        if (SendingMessage* src = curmsg->send_scheme) {
+            if (creationMode == MODE_SERVER) {
+                if (src->isResponse()) {
+                    buf_len += snprintf(buf + buf_len, bufsiz - buf_len,
+                                        "  <---------- %-10d ", src->getCode());
+                } else {
+                    buf_len +=
+                        snprintf(buf + buf_len, bufsiz - buf_len,
+                                 "  <---------- %-10s ", src->getMethod());
+                }
             } else {
-                exit(EXIT_FATAL_ERROR);
+                if (src->isResponse()) {
+                    buf_len += snprintf(buf + buf_len, bufsiz - buf_len,
+                                        "  %10d ----------> ", src->getCode());
+                } else {
+                    buf_len +=
+                        snprintf(buf + buf_len, bufsiz - buf_len,
+                                 "  %10s ----------> ", src->getMethod());
+                }
             }
-        } else {
-            if (error == EADDRINUSE) {
-                sipp_exit(EXIT_BIND_ERROR);
+
+            if (curmsg->start_rtd) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, " B-RTD%d ",
+                                    curmsg->start_rtd);
+            } else if (curmsg->stop_rtd) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, " E-RTD%d ",
+                                    curmsg->stop_rtd);
             } else {
-                sipp_exit(EXIT_FATAL_ERROR);
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, "        ");
             }
+
+            if (curmsg->retrans_delay) {
+                buf_len += snprintf(
+                    buf + buf_len, bufsiz - buf_len, "%-9lu %-9lu %-9lu %-9s %-9s",
+                    curmsg->nb_sent, curmsg->nb_sent_retrans,
+                    curmsg->nb_timeout, "" /* Unexpected */,
+                    (lose_packets && curmsg->nb_lost)
+                        ? std::to_string(curmsg->nb_lost).c_str()
+                        : "");
+            } else {
+                buf_len += snprintf(
+                    buf + buf_len, bufsiz - buf_len, "%-9lu %-9lu %-9s %-9s %-9s",
+                    curmsg->nb_sent, curmsg->nb_sent_retrans, "", /* Timeout. */
+                    "" /* Unexpected. */,
+                    (lose_packets && curmsg->nb_lost)
+                        ? std::to_string(curmsg->nb_lost).c_str()
+                        : "");
+            }
+        } else if (curmsg->recv_response) {
+            if (creationMode == MODE_SERVER) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len,
+                                    "  ----------> %-10d ", curmsg->recv_response);
+            } else {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len,
+                                    "  %10d <---------- ", curmsg->recv_response);
+            }
+
+            if (curmsg->start_rtd) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, " B-RTD%d ",
+                                    curmsg->start_rtd);
+            } else if (curmsg->stop_rtd) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, " E-RTD%d ",
+                                    curmsg->stop_rtd);
+            } else {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, "        ");
+            }
+
+            buf_len += snprintf(buf + buf_len, bufsiz - buf_len,
+                                "%-9ld %-9ld %-9ld %-9ld %-9s", curmsg->nb_recv,
+                                curmsg->nb_recv_retrans, curmsg->nb_timeout,
+                                curmsg->nb_unexp,
+                                (lose_packets && curmsg->nb_lost)
+                                    ? std::to_string(curmsg->nb_lost).c_str()
+                                    : "");
+        } else if (curmsg->pause_distribution ||
+                   (curmsg->pause_variable != -1)) {
+            char* desc = curmsg->pause_desc;
+            if (!desc) {
+                desc = (char*)malloc(24);
+                if (curmsg->pause_distribution) {
+                    desc[0] = '\0';
+                    curmsg->pause_distribution->timeDescr(desc, 23);
+                } else {
+                    snprintf(desc, 23, "$%s",
+                             display_scenario->allocVars->getName(
+                                 curmsg->pause_variable));
+                }
+                desc[23] = '\0';
+                curmsg->pause_desc = desc;
+            }
+            int len = strlen(desc) < 9 ? 9 : strlen(desc);
+
+            if (creationMode == MODE_SERVER) {
+                snprintf(left_buf, 40, "  [%9s] Pause%*s", desc,
+                        23 - len > 0 ? 23 - len : 0, "");
+            } else {
+                snprintf(left_buf, 40, "       Pause [%9s]%*s", desc,
+                        18 - len > 0 ? 18 - len : 0, "");
+            }
+
+            snprintf(buf, bufsiz, "%s%-9d                     %-9lu",
+                     left_buf,
+                     curmsg->sessions,
+                     curmsg->nb_unexp);
+        } else if (curmsg->recv_request) {
+            if (creationMode == MODE_SERVER) {
+                buf_len +=
+                    snprintf(buf + buf_len, bufsiz - buf_len,
+                             "  ----------> %-10s ", curmsg->recv_request);
+            } else {
+                buf_len +=
+                    snprintf(buf + buf_len, bufsiz - buf_len, "  %10s <---------- ",
+                             curmsg->recv_request);
+            }
+
+            if (curmsg->start_rtd) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, " B-RTD%d ",
+                                    curmsg->start_rtd);
+            } else if (curmsg->stop_rtd) {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, " E-RTD%d ",
+                                    curmsg->stop_rtd);
+            } else {
+                buf_len += snprintf(buf + buf_len, bufsiz - buf_len, "        ");
+            }
+
+            buf_len += snprintf(buf + buf_len, bufsiz - buf_len,
+                                "%-9ld %-9ld %-9ld %-9ld %-9s", curmsg->nb_recv,
+                                curmsg->nb_recv_retrans, curmsg->nb_timeout,
+                                curmsg->nb_unexp,
+                                (lose_packets && curmsg->nb_lost)
+                                    ? std::to_string(curmsg->nb_lost).c_str()
+                                    : "");
+        } else if (curmsg->M_type == MSG_TYPE_NOP) {
+            if (curmsg->display_str) {
+                snprintf(buf, bufsiz, " %s", curmsg->display_str);
+            } else {
+                snprintf(buf, bufsiz, "              [ NOP ]              ");
+            }
+        } else if (curmsg->M_type == MSG_TYPE_RECVCMD) {
+            snprintf(left_buf, 40, "    [ Received Command ]         ");
+            snprintf(buf, bufsiz, "%s%-9ld %-9s %-9s %-9s",
+                     left_buf,
+                     curmsg->M_nbCmdRecv,
+                     "",
+                     curmsg->retrans_delay ? std::to_string(curmsg->nb_timeout).c_str() : "",
+                     "");
+        } else if (curmsg->M_type == MSG_TYPE_SENDCMD) {
+            snprintf(left_buf, 40, "        [ Sent Command ]         ");
+            snprintf(buf, bufsiz, "%s%-9lu %-9s           %-9s",
+                     left_buf,
+                     curmsg->M_nbCmdSent,
+                     "",
+                     "");
+        } else {
+            ERROR("Scenario command not implemented in display");
+        }
+
+        lines.push_back(buf);
+        if (curmsg->crlf) {
+            lines.push_back("");
         }
     }
 }
 
-extern "C" {
-    void ERROR(const char *fmt, ...)
-    {
-        va_list ap;
-        va_start(ap, fmt);
-        _screen_error(true, false, 0, fmt, ap);
-        va_end(ap);
-        assert(0);
+// Warning! All DISPLAY_ macros must be called where 'bufsiz', 'buf' and 'lines' are defined.
+#define DISPLAY_CROSS_LINE() \
+    snprintf(buf, bufsiz, "-------------------------+---------------------------+--------------------------"); \
+    lines.push_back(buf);
+
+#define DISPLAY_HEADER() \
+    snprintf(buf, bufsiz, "  Counter Name           | Periodic value            | Cumulative value"); \
+    lines.push_back(buf);
+#define DISPLAY_TXT_COL(T1, V1, V2) \
+    snprintf(buf, bufsiz, "  %-22.22s | %-25.25s | %-24.24s ", T1, V1, V2); \
+    lines.push_back(buf);
+#define DISPLAY_VAL_RATEF_COL(T1, V1, V2) \
+    snprintf(buf, bufsiz, "  %-22.22s | %8.3f cps              | %8.3f cps             ", T1, V1, V2); \
+    lines.push_back(buf);
+#define DISPLAY_2VAL(T1, V1, V2) \
+    snprintf(buf, bufsiz, "  %-22.22s | %8llu                  | %8llu                 ", T1, V1, V2); \
+    lines.push_back(buf);
+#define DISPLAY_CUMUL(T1, V1) \
+    snprintf(buf, bufsiz, "  %-22.22s |                           | %8llu                 ", T1, V1); \
+    lines.push_back(buf);
+#define DISPLAY_PERIO(T1, V1) \
+    snprintf(buf, bufsiz, "  %-22.22s | %8llu                  |                          ", T1, V1); \
+    lines.push_back(buf);
+#define DISPLAY_TXT(T1, V1) \
+    snprintf(buf, bufsiz, "  %-22.22s | %-52.52s ", T1, V1); \
+    lines.push_back(buf);
+#define DISPLAY_INFO(T1) \
+    snprintf(buf, bufsiz, "  %-77.77s", T1); \
+    lines.push_back(buf);
+#define DISPLAY_REPART(T1, T2, V1) \
+    snprintf(buf, bufsiz, "    %10d ms <= n < %10d ms : %10lu", T1, T2, V1); \
+    lines.push_back(buf);
+#define DISPLAY_LAST_REPART(T1, V1) \
+    snprintf(buf, bufsiz, "    %14.14s n >= %10d ms : %10lu", "", T1, V1); \
+    lines.push_back(buf);
+
+void ScreenPrinter::draw_stats_screen()
+{
+    long   localElapsedTime, globalElapsedTime ;
+    struct timeval currentTime;
+    float  averageCallRate;
+    float  realInstantCallRate;
+    unsigned long numberOfCall;
+    CStat* s = display_scenario->stats;
+    unsigned const bufsiz = 256;
+    char buf[bufsiz];
+
+    GET_TIME (&currentTime);
+    // computing the real call rate
+    globalElapsedTime   = s->computeDiffTimeInMs (&currentTime, &s->M_startTime);
+    localElapsedTime    = s->computeDiffTimeInMs (&currentTime, &s->M_pdStartTime);
+    // the call rate is for all the call : incoming and outgoing
+    numberOfCall        = (s->M_counters[s->CPT_C_IncomingCallCreated] +
+                           s->M_counters[s->CPT_C_OutgoingCallCreated]);
+    averageCallRate     = (globalElapsedTime > 0 ?
+                           1000*(float)numberOfCall/(float)globalElapsedTime :
+                           0.0);
+    numberOfCall        = (s->M_counters[s->CPT_PD_IncomingCallCreated] +
+                           s->M_counters[s->CPT_PD_OutgoingCallCreated]);
+    realInstantCallRate = (localElapsedTime  > 0 ?
+                           1000*(float)numberOfCall / (float)localElapsedTime :
+                           0.0);
+
+    // build and display header info
+    DISPLAY_TXT ("Start Time  ", s->formatTime(&s->M_startTime));
+    DISPLAY_TXT ("Last Reset Time", s->formatTime(&s->M_pdStartTime));
+    DISPLAY_TXT ("Current Time", s->formatTime(&currentTime));
+
+    // printing the header in the middle
+    DISPLAY_CROSS_LINE();
+    DISPLAY_HEADER();
+    DISPLAY_CROSS_LINE();
+
+    DISPLAY_TXT_COL ("Elapsed Time",
+                     s->msToHHMMSSus(localElapsedTime),
+                     s->msToHHMMSSus(globalElapsedTime));
+
+    DISPLAY_VAL_RATEF_COL ("Call Rate",  realInstantCallRate, averageCallRate);
+    DISPLAY_CROSS_LINE ();
+
+    DISPLAY_2VAL  ("Incoming calls created",
+                   s->M_counters[s->CPT_PD_IncomingCallCreated],
+                   s->M_counters[s->CPT_C_IncomingCallCreated]);
+    DISPLAY_2VAL  ("Outgoing calls created",
+                   s->M_counters[s->CPT_PD_OutgoingCallCreated],
+                   s->M_counters[s->CPT_C_OutgoingCallCreated]);
+    DISPLAY_CUMUL ("Total Calls created", s->M_counters[s->CPT_C_IncomingCallCreated] +
+                   s->M_counters[s->CPT_C_OutgoingCallCreated]);
+    DISPLAY_PERIO ("Current Calls",
+                   s->M_counters[s->CPT_C_CurrentCall]);
+
+    if (s->M_genericMap.size()) {
+        DISPLAY_CROSS_LINE ();
     }
+    for (unsigned int i = 1; i < s->M_genericMap.size() + 1; i++) {
+        char *disp = (char *)malloc(20 + strlen(s->M_genericDisplay[i]));
+        sprintf(disp, "Counter %s", s->M_genericDisplay[i]);
 
-    void ERROR_NO(const char *fmt, ...)
-    {
-        va_list ap;
-        va_start(ap, fmt);
-        _screen_error(true, true, errno, fmt, ap);
-        va_end(ap);
-        assert(0);
+        DISPLAY_2VAL(disp, s->M_genericCounters[(i - 1)* GENERIC_TYPES + GENERIC_PD], s->M_genericCounters[(i - 1) * GENERIC_TYPES + GENERIC_C]);
+        free(disp);
     }
 
-    void WARNING(const char *fmt, ...)
-    {
-        va_list ap;
-        va_start(ap, fmt);
-        _screen_error(false, false, 0, fmt, ap);
-        va_end(ap);
+    DISPLAY_CROSS_LINE ();
+    DISPLAY_2VAL  ("Successful call",
+                   s->M_counters[s->CPT_PD_SuccessfulCall],
+                   s->M_counters[s->CPT_C_SuccessfulCall]);
+    DISPLAY_2VAL  ("Failed call",
+                   s->M_counters[s->CPT_PD_FailedCall],
+                   s->M_counters[s->CPT_C_FailedCall]);
+
+    DISPLAY_CROSS_LINE ();
+    for (int i = 1; i <= s->nRtds(); i++) {
+        char buf2[80];
+
+        snprintf(buf2, 80, "Response Time %s", s->M_revRtdMap[i]);
+        DISPLAY_TXT_COL (buf2,
+                         s->msToHHMMSSus( (unsigned long)s->computeRtdMean(i, GENERIC_PD)),
+                         s->msToHHMMSSus( (unsigned long)s->computeRtdMean(i, GENERIC_C)));
+    }
+    DISPLAY_TXT_COL ("Call Length",
+                     s->msToHHMMSSus( (unsigned long)s->computeMean(s->CPT_PD_AverageCallLength_Sum, s->CPT_PD_NbOfCallUsedForAverageCallLength ) ),
+                     s->msToHHMMSSus( (unsigned long)s->computeMean(s->CPT_C_AverageCallLength_Sum, s->CPT_C_NbOfCallUsedForAverageCallLength) ));
+}
+
+void ScreenPrinter::draw_repartition_screen(int which)
+{
+    unsigned const bufsiz = 80;
+    char buf[bufsiz];
+    char buf2[bufsiz];
+    CStat* s = display_scenario->stats;
+    if (which > s->nRtds()) {
+        DISPLAY_INFO ("  <No repartion defined>");
+        return;
     }
 
-    void WARNING_NO(const char *fmt, ...)
+    snprintf(buf2, bufsiz, "Average Response Time Repartition %s", s->M_revRtdMap[which]);
+    DISPLAY_INFO(buf2);
+    draw_repartition_detailed(s->M_ResponseTimeRepartition[which - 1],
+                              s->M_SizeOfResponseTimeRepartition);
+
+    if (which == 1)
     {
-        va_list ap;
-        va_start(ap, fmt);
-        _screen_error(false, true, errno, fmt, ap);
-        va_end(ap);
+        // Primary repartition screen
+        DISPLAY_INFO("Average Call Length Repartition");
+        draw_repartition_detailed(s->M_CallLengthRepartition,
+                                  s->M_SizeOfCallLengthRepartition);
+    }
+}
+
+void ScreenPrinter::draw_repartition_detailed(CStat::T_dynamicalRepartition * tabRepartition,
+                                            int sizeOfTab)
+{
+    unsigned const bufsiz = 80;
+    char buf[bufsiz];
+    if(tabRepartition != NULL) {
+        for(int i=0; i<(sizeOfTab-1); i++) {
+            if(i==0) {
+                DISPLAY_REPART(0, tabRepartition[i].borderMax,
+                               tabRepartition[i].nbInThisBorder);
+            } else {
+                DISPLAY_REPART(tabRepartition[i-1].borderMax,
+                               tabRepartition[i].borderMax,
+                               tabRepartition[i].nbInThisBorder);
+            }
+        }
+        DISPLAY_LAST_REPART (tabRepartition[sizeOfTab-1].borderMax,
+                             tabRepartition[sizeOfTab-1].nbInThisBorder);
+    } else {
+        DISPLAY_INFO ("  <No repartion defined>");
+    }
+}
+
+void ScreenPrinter::draw_vars_screen()
+{
+    CActions* actions;
+    CAction* action;
+    bool found;
+    unsigned const bufsiz = 80;
+    char buf[bufsiz];
+
+    lines.push_back("Action defined Per Message :");
+    found = false;
+    for (unsigned int i = 0; i < display_scenario->messages.size(); i++) {
+        message* curmsg = display_scenario->messages[i];
+        actions = curmsg->M_actions;
+        if (actions != NULL) {
+            switch (curmsg->M_type) {
+            case MSG_TYPE_RECV:
+                snprintf(buf, bufsiz, "=> Message[%u] (Receive Message) - "
+                         "[%d] action(s) defined :",
+                         i, actions->getActionSize());
+                break;
+            case MSG_TYPE_RECVCMD:
+                snprintf(buf, bufsiz, "=> Message[%u] (Receive Command Message) - "
+                         "[%d] action(s) defined :",
+                         i, actions->getActionSize());
+                break;
+            default:
+                snprintf(buf, bufsiz, "=> Message[%u] - [%d] action(s) defined :", i,
+                       actions->getActionSize());
+                break;
+            }
+            lines.push_back(buf);
+
+            for (int j = 0; j < actions->getActionSize(); j++) {
+                action = actions->getAction(j);
+                if (action != NULL) {
+                    int printed = snprintf(buf, bufsiz, "   --> action[%d] = ", j);
+                    action->printInfo(buf + printed, bufsiz - printed);
+                    lines.push_back(buf);
+                    found = true;
+                }
+            }
+        }
+    }
+    if (!found) {
+        lines.push_back("=> No action found on any messages");
+    }
+
+    lines.push_back("");
+    for (unsigned int i = 0;
+         i < (display_scenario->messages.size() + 6 - lines.size()); i++) {
+      lines.push_back("");
+    }
+}
+
+void ScreenPrinter::draw_tdm_screen()
+{
+    int i = 0;
+    int in_use = 0;
+    int height = (tdm_map_a + 1) * (tdm_map_b + 1);
+    int width = (tdm_map_c + 1);
+    int total_circuits = height * width;
+    unsigned const bufsiz = 80;
+    char buf[bufsiz] = {0};
+
+    lines.push_back("TDM Circuits in use:");
+    while (i < total_circuits) {
+        int buf_position = std::min(79, i % width);
+        if (tdm_map[i]) {
+            buf[buf_position] = '*';
+            in_use++;
+        } else {
+            buf[buf_position] = '.';
+        }
+        i++;
+        if (buf_position == (width - 1)) {
+            lines.push_back(buf);
+            memset(buf, 0, bufsiz);
+        }
+    }
+    lines.push_back("");
+    snprintf(buf, bufsiz, "%d/%d circuits (%d%%) in use", in_use, total_circuits,
+           int(100 * in_use / total_circuits));
+    lines.push_back(buf);
+    for (unsigned int i = 0;
+         i < (display_scenario->messages.size() + 8 - height);
+         i++) {
+        lines.push_back("");
     }
 }
diff --git a/src/sipp.cpp b/src/sipp.cpp
index 9a03dac1c..bc5feccf7 100644
--- a/src/sipp.cpp
+++ b/src/sipp.cpp
@@ -36,6 +36,17 @@
  */
 
 #include <dlfcn.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#ifdef __APPLE__
+/* Provide OSX version of extern char **environ; */
+#include <crt_externs.h>
+#define environ (*_NSGetEnviron())
+#endif
+extern char** environ;
 
 #define GLOBALS_FULL_DEFINITION
 #include "sipp.hpp"
@@ -47,26 +58,8 @@
 #include "config.h"
 #include "version.h"
 
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <unistd.h>
-
-//#include "/usr/include/curl/curl.h"
-//#include "/usr/include/curl/easy.h"
-#include "curl.h"
-#include "easy.h"
-
-#include "mysql.h"
-
-#include "sipp-rpc.h"
-#include <rpc/pmap_clnt.h>
-
-extern struct sipp_socket *ctrl_socket;
-extern struct sipp_socket *stdin_socket;
-void rpc_thread(void* param);
+extern SIPpSocket *ctrl_socket;
+extern SIPpSocket *stdin_socket;
 
 /* These could be local to main, but for the option processing table. */
 static int argiFileName;
@@ -123,10 +116,6 @@ struct sipp_option {
 #define SIPP_OPTION_NEED_SCTP     39
 #define SIPP_HELP_TEXT_HEADER    255
 
-#ifndef SIG_PF
-#define SIG_PF void(*)(int)
-#endif
-
 /* Put each option, its help text, and type in this table. */
 struct sipp_option options_table[] = {
     {"h", NULL, SIPP_OPTION_HELP, NULL, 0},
@@ -160,7 +149,7 @@ struct sipp_option options_table[] = {
         "- ui: UDP with one socket per IP address. The IP addresses must be defined in the injection file.\n"
         "- t1: TCP with one socket,\n"
         "- tn: TCP with one socket per call,\n"
-#ifdef USE_OPENSSL
+#ifdef USE_TLS
         "- l1: TLS with one socket,\n"
         "- ln: TLS with one socket per call,\n"
 #endif
@@ -183,14 +172,18 @@ struct sipp_option options_table[] = {
     {"reconnect_sleep", "How long (in milliseconds) to sleep between the close and reconnect?", SIPP_OPTION_TIME_MS, &reset_sleep, 1},
     {"rsa", "Set the remote sending address to host:port for sending the messages.", SIPP_OPTION_RSA, NULL, 1},
 
-#ifdef USE_OPENSSL
+#ifdef USE_TLS
     {"tls_cert", "Set the name for TLS Certificate file. Default is 'cacert.pem", SIPP_OPTION_STRING, &tls_cert_name, 1},
     {"tls_key", "Set the name for TLS Private Key file. Default is 'cakey.pem'", SIPP_OPTION_STRING, &tls_key_name, 1},
+    {"tls_ca", "Set the name for TLS CA file. If not specified, X509 verification is not activated.", SIPP_OPTION_STRING, &tls_ca_name, 1},
     {"tls_crl", "Set the name for Certificate Revocation List file. If not specified, X509 CRL is not activated.", SIPP_OPTION_STRING, &tls_crl_name, 1},
+    {"tls_version", "Set the TLS protocol version to use (1.0, 1.1, 1.2) -- default is autonegotiate", SIPP_OPTION_FLOAT, &tls_version, 1},
 #else
     {"tls_cert", NULL, SIPP_OPTION_NEED_SSL, NULL, 1},
     {"tls_key", NULL, SIPP_OPTION_NEED_SSL, NULL, 1},
+    {"tls_ca", NULL, SIPP_OPTION_NEED_SSL, NULL, 1},
     {"tls_crl", NULL, SIPP_OPTION_NEED_SSL, NULL, 1},
+    {"tls_version", NULL, SIPP_OPTION_NEED_SSL, NULL, 1},
 #endif
 
 #ifdef USE_SCTP
@@ -232,7 +225,6 @@ struct sipp_option options_table[] = {
 
     {"", "Call behavior options:", SIPP_HELP_TEXT_HEADER, NULL, 0},
     {"aa", "Enable automatic 200 OK answer for INFO, NOTIFY, OPTIONS and UPDATE.", SIPP_OPTION_SETFLAG, &auto_answer, 1},
-    {"aalog", "When auto answer enabled, whether log the action in error log file.", SIPP_OPTION_SETFLAG, &log4auto_answer, 1},
     {"base_cseq", "Start value of [cseq] for each call.", SIPP_OPTION_CSEQ, NULL, 1},
     {"cid_str", "Call ID string (default %u-%p@%s).  %u=call_number, %s=ip_address, %p=process_number, %%=% (in any order).", SIPP_OPTION_STRING, &call_id_string, 1},
     {"d", "Controls the length of calls. More precisely, this controls the duration of 'pause' instructions in the scenario, if they do not have a 'milliseconds' section. Default value is 0 and default unit is milliseconds.", SIPP_OPTION_TIME_MS, &duration, 1},
@@ -266,7 +258,7 @@ struct sipp_option options_table[] = {
     {"inf", "Inject values from an external CSV file during calls into the scenarios.\n"
      "First line of this file say whether the data is to be read in sequence (SEQUENTIAL), random (RANDOM), or user (USER) order.\n"
      "Each line corresponds to one call and has one or more ';' delimited data fields. Those fields can be referred as [field0], [field1], ... in the xml scenario file.  Several CSV files can be used simultaneously (syntax: -inf f1.csv -inf f2.csv ...)", SIPP_OPTION_INPUT_FILE, NULL, 1},
-    {"infindex", "file field\nCreate an index of file using field.  For example -inf users.csv -infindex users.csv 0 creates an index on the first key.", SIPP_OPTION_INDEX_FILE, NULL, 1 },
+    {"infindex", "file field\nCreate an index of file using field.  For example -inf ../path/to/users.csv -infindex users.csv 0 creates an index on the first key.", SIPP_OPTION_INDEX_FILE, NULL, 1 },
     {"ip_field", "Set which field from the injection file contains the IP address from which the client will send its messages.\n"
      "If this option is omitted and the '-t ui' option is present, then field 0 is assumed.\n"
      "Use this option together with '-t ui'", SIPP_OPTION_INT, &peripfield, 1},
@@ -279,13 +271,9 @@ struct sipp_option options_table[] = {
      SIPP_OPTION_SETFLAG, &rtp_echo_enabled, 1},
     {"mb", "Set the RTP echo buffer size (default: 2048).", SIPP_OPTION_INT, &media_bufsize, 1},
     {"mp", "Set the local RTP echo port number. Default is 6000.", SIPP_OPTION_INT, &user_media_port, 1},
-#ifdef RTP_STREAM
-    {"min_rtp_port", "Minimum port number for RTP socket range.", SIPP_OPTION_INT, &min_rtp_port, 1},
-    {"max_rtp_port", "Maximum port number for RTP socket range.", SIPP_OPTION_INT, &max_rtp_port, 1},
     {"rtp_payload", "RTP default payload type.", SIPP_OPTION_INT, &rtp_default_payload, 1},
     {"rtp_threadtasks", "RTP number of playback tasks per thread.", SIPP_OPTION_INT, &rtp_tasks_per_thread, 1},
     {"rtp_buffsize", "Set the rtp socket send/receive buffer size.", SIPP_OPTION_INT, &rtp_buffsize, 1},
-#endif
 
     {"", "Call rate options:", SIPP_HELP_TEXT_HEADER, NULL, 0},
     {"r", "Set the call rate (in calls per seconds).  This value can be"
@@ -394,13 +382,10 @@ struct sipp_option options_table[] = {
     {"trace_logs", "Allow tracing of <log> actions in <scenario file name>_<pid>_logs.log.", SIPP_OPTION_SETFLAG, &useLogf, 1},
     {"log_file", "Set the name of the log actions log file.", SIPP_OPTION_LFNAME, &log_lfi, 1},
     {"log_overwrite", "Overwrite the log actions log file (default true).", SIPP_OPTION_LFOVERWRITE, &log_lfi, 1},
-    {"enable_rpc", "Enable binding to RPC", SIPP_OPTION_SETFLAG, &enable_rpc, 1},
 
     {"ringbuffer_files", "How many error, message, shortmessage and calldebug files should be kept after rotation?", SIPP_OPTION_INT, &ringbuffer_files, 1},
     {"ringbuffer_size", "How large should error, message, shortmessage and calldebug files be before they get rotated?", SIPP_OPTION_LONG_LONG, &ringbuffer_size, 1},
     {"max_log_size", "What is the limit for error, message, shortmessage and calldebug file sizes.", SIPP_OPTION_LONG_LONG, &max_log_size, 1},
-    {"pid_file", "Set the name for pid file. Default is 'sipp.pid'", SIPP_OPTION_STRING, &pid_file, 1},
-    {"lua_file", "Set the name for lua file. Default is 'sipp.lua'", SIPP_OPTION_STRING, &lua_file, 1},
 
 };
 
@@ -431,14 +416,10 @@ static struct sipp_option *find_option(const char* option) {
 extern unsigned pollnfds;
 #ifdef HAVE_EPOLL
 extern int epollfd;
-extern struct epoll_event   epollfiles[SIPP_MAXFDS];
 extern struct epoll_event*  epollevents;
-#else
-extern struct pollfd        pollfiles[SIPP_MAXFDS];
 #endif
-extern struct sipp_socket  *sockets[SIPP_MAXFDS];
 
-extern int pending_messages;
+extern SIPpSocket  *sockets[SIPP_MAXFDS];
 
 /************** Statistics display & User control *************/
 
@@ -455,244 +436,6 @@ static void sipp_sigusr2(int /* not used */)
     }
 }
 
-static void pollset_process(int wait)
-{
-    int rs; /* Number of times to execute recv().
-            For TCP with 1 socket per call:
-                no. of events returned by poll
-            For UDP and TCP with 1 global socket:
-                recv_count is a flag that stays up as
-                long as there's data to read */
-
-#ifndef HAVE_EPOLL
-    /* What index should we try reading from? */
-    static size_t read_index;
-
-    int loops = max_recv_loops;
-
-    // If not using epoll, we have a queue of pending messages to spin through.
-
-    if (read_index >= pollnfds) {
-        read_index = 0;
-    }
-
-    /* We need to process any messages that we have left over. */
-    while (pending_messages && loops > 0) {
-        getmilliseconds();
-        if (sockets[read_index]->ss_msglen) {
-            struct sockaddr_storage src;
-            char msg[SIPP_MAX_MSG_SIZE];
-            ssize_t len = read_message(sockets[read_index], msg, sizeof(msg), &src);
-            if (len > 0) {
-                process_message(sockets[read_index], msg, len, &src);
-            } else {
-                assert(0);
-            }
-            loops--;
-        }
-        read_index = (read_index + 1) % pollnfds;
-    }
-
-    /* Don't read more data if we still have some left over. */
-    if (pending_messages) {
-        return;
-    }
-#endif
-    /* Get socket events. */
-#ifdef HAVE_EPOLL
-    /* Ignore the wait parameter and always wait - when establishing TCP
-     * connections, the alternative is that we tight-loop. */
-    rs = epoll_wait(epollfd, epollevents, max_recv_loops, 1);
-    // If we're receiving as many epollevents as possible, flag CPU congestion
-    cpu_max = (rs > (max_recv_loops - 2));
-#else
-    rs = poll(pollfiles, pollnfds, wait ? 1 : 0);
-#endif
-    if (rs < 0 && errno == EINTR) {
-        return;
-    }
-
-    /* We need to flush all sockets and pull data into all of our buffers. */
-#ifdef HAVE_EPOLL
-    for (int event_idx = 0; event_idx < rs; event_idx++) {
-        int poll_idx = (int)epollevents[event_idx].data.u32;
-#else
-    for (size_t poll_idx = 0; rs > 0 && poll_idx < pollnfds; poll_idx++) {
-#endif
-        struct sipp_socket *sock = sockets[poll_idx];
-        int events = 0;
-        int ret = 0;
-
-        assert(sock);
-
-#ifdef HAVE_EPOLL
-        if (epollevents[event_idx].events & EPOLLOUT) {
-#else
-        if (pollfiles[poll_idx].revents & POLLOUT) {
-#endif
-
-#ifdef USE_SCTP
-            if (transport == T_SCTP && sock->sctpstate != SCTP_UP);
-            else
-#endif
-            {
-                /* We can flush this socket. */
-                TRACE_MSG("Exit problem event on socket %d \n", sock->ss_fd);
-#ifdef HAVE_EPOLL
-                epollfiles[poll_idx].events &= ~EPOLLOUT;
-                int rc = epoll_ctl(epollfd, EPOLL_CTL_MOD, sock->ss_fd, &epollfiles[poll_idx]);
-                if (rc == -1) {
-                    ERROR_NO("Failed to clear EPOLLOUT");
-                }
-#else
-                pollfiles[poll_idx].events &= ~POLLOUT;
-#endif
-                sock->ss_congested = false;
-
-                flush_socket(sock);
-                events++;
-            }
-        }
-
-#ifdef HAVE_EPOLL
-        if (epollevents[event_idx].events & EPOLLIN) {
-#else
-        if (pollfiles[poll_idx].revents & POLLIN) {
-#endif
-            /* We can empty this socket. */
-            if ((transport == T_TCP || transport == T_TLS || transport == T_SCTP) && sock == main_socket) {
-                struct sipp_socket *new_sock = sipp_accept_socket(sock);
-                if (!new_sock) {
-                    ERROR_NO("Accepting new TCP connection.\n");
-                }
-            } else if (sock == ctrl_socket) {
-                handle_ctrl_socket();
-            } else if (sock == stdin_socket) {
-                handle_stdin_socket();
-            } else if (sock == localTwinSippSocket) {
-                if (thirdPartyMode == MODE_3PCC_CONTROLLER_B) {
-                    twinSippSocket = sipp_accept_socket(sock);
-                    if (!twinSippMode) {
-                        ERROR_NO("Accepting new TCP connection on Twin SIPp Socket.\n");
-                    }
-                    twinSippSocket->ss_control = 1;
-                } else {
-                    /* 3pcc extended mode: open a local socket
-                       which will be used for reading the infos sent by this remote
-                       twin sipp instance (slave or master) */
-                    if (local_nb == MAX_LOCAL_TWIN_SOCKETS) {
-                        ERROR("Max number of twin instances reached\n");
-                    }
-
-                    struct sipp_socket *localSocket = sipp_accept_socket(sock);
-                    localSocket->ss_control = 1;
-                    local_sockets[local_nb] = localSocket;
-                    local_nb++;
-                    if (!peers_connected) {
-                        connect_to_all_peers();
-                    }
-                }
-            } else {
-                if ((ret = empty_socket(sock)) <= 0) {
-#ifdef USE_SCTP
-                    if (sock->ss_transport == T_SCTP && ret == -2);
-                    else
-#endif
-                    {
-                        ret = read_error(sock, ret);
-                        if (ret == 0) {
-                            /* If read_error() then the poll_idx now belongs
-                             * to the newest/last socket added to the sockets[].
-                             * Need to re-do the same poll_idx for the "new" socket.
-                             * We do this differently when using epoll. */
-#ifdef HAVE_EPOLL
-                            for (int event_idx2 = event_idx + 1; event_idx2 < rs; event_idx2++) {
-                                if (epollevents[event_idx2].data.u32 == pollnfds) {
-                                    epollevents[event_idx2].data.u32 = poll_idx;
-                                }
-                            }
-#else
-                            poll_idx--;
-                            events++;
-                            rs--;
-#endif
-                            continue;
-                        }
-                    }
-                }
-            }
-            events++;
-        }
-
-        /* Here the logic diverges; if we're using epoll, we want to stay in the
-         * for-each-socket loop and handle messages on that socket. If we're not using
-         * epoll, we want to wait until after that loop, and spin through our
-         * pending_messages queue again. */
-
-#ifdef HAVE_EPOLL
-        unsigned old_pollnfds = pollnfds;
-        getmilliseconds();
-        /* Keep processing messages until this socket is freed (changing the number of file descriptors) or we run out of messages. */
-        while ((pollnfds == old_pollnfds) &&
-                (sock->ss_msglen)) {
-            char msg[SIPP_MAX_MSG_SIZE];
-            struct sockaddr_storage src;
-            ssize_t len;
-
-            len = read_message(sock, msg, sizeof(msg), &src);
-            if (len > 0) {
-                process_message(sock, msg, len, &src);
-            } else {
-                assert(0);
-            }
-        }
-
-        if (pollnfds != old_pollnfds) {
-            /* Processing messages has changed the number of pollnfds, so update any remaining events */
-            for (int event_idx2 = event_idx + 1; event_idx2 < rs; event_idx2++) {
-                if (epollevents[event_idx2].data.u32 == pollnfds) {
-                    epollevents[event_idx2].data.u32 = poll_idx;
-                }
-            }
-        }
-#else
-
-        if (events) {
-            rs--;
-        }
-        pollfiles[poll_idx].revents = 0;
-#endif
-    }
-
-#ifndef HAVE_EPOLL
-    if (read_index >= pollnfds) {
-        read_index = 0;
-    }
-
-    /* We need to process any new messages that we read. */
-    while (pending_messages && (loops > 0)) {
-        getmilliseconds();
-
-        if (sockets[read_index]->ss_msglen) {
-            char msg[SIPP_MAX_MSG_SIZE];
-            struct sockaddr_storage src;
-            ssize_t len;
-
-            len = read_message(sockets[read_index], msg, sizeof(msg), &src);
-            if (len > 0) {
-                process_message(sockets[read_index], msg, len, &src);
-            } else {
-                assert(0);
-            }
-            loops--;
-        }
-        read_index = (read_index + 1) % pollnfds;
-    }
-
-    cpu_max = (loops <= 0);
-#endif
-}
-
 void timeout_alarm(int /*param*/)
 {
     if (timeout_error) {
@@ -704,11 +447,11 @@ void timeout_alarm(int /*param*/)
 
 /* Send loop & trafic generation*/
 
-static bool traffic_thread()
+static void traffic_thread()
 {
     /* create the file */
     char L_file_name[MAX_PATH];
-    sprintf(L_file_name, "%s_%d_screen.log", scenario_file, getpid());
+    sprintf(L_file_name, "%s_%ld_screen.log", scenario_file, (long) getpid());
 
     getmilliseconds();
 
@@ -746,7 +489,7 @@ static bool traffic_thread()
         }
 
         while (sockets_pending_reset.begin() != sockets_pending_reset.end()) {
-            reset_connection(*(sockets_pending_reset.begin()));
+            (*(sockets_pending_reset.begin()))->reset_connection();
             sockets_pending_reset.erase(sockets_pending_reset.begin());
         }
 
@@ -758,15 +501,20 @@ static bool traffic_thread()
                 /* Force exit: abort all calls */
                 abort_all_tasks();
             }
-            /* Quitting and no more openned calls, close all */
+            /* Quitting and no more opened calls, close all */
             if (!main_scenario->stats->GetStat(CStat::CPT_C_CurrentCall)) {
                 /* We can have calls that do not count towards our open-call count (e.g., dead calls). */
                 abort_all_tasks();
-#ifdef RTP_STREAM
                 rtpstream_shutdown();
-#endif
-                for (unsigned i = 0; i < pollnfds; i++) {
-                    sipp_close_socket(sockets[i]);
+                /* Reverse order shutdown, because deleting reorders the
+                 * sockets list. */
+                for (int i = pollnfds - 1; i >= 0; --i) {
+                    sockets[i]->close();
+                    if (sockets[i] == ctrl_socket) {
+                        ctrl_socket = NULL;
+                    } else if (sockets[i] == stdin_socket) {
+                        stdin_socket = NULL;
+                    }
                 }
 
                 screentask::report(true);
@@ -774,7 +522,7 @@ static bool traffic_thread()
                 if (useScreenf == 1) {
                     print_screens();
                 }
-                return false;
+                return;
             }
         }
 
@@ -810,9 +558,9 @@ static bool traffic_thread()
         task * last = NULL;
 
         task_list::iterator iter;
-        for(iter = running_tasks->begin(); iter != running_tasks->end(); iter++) {
+        for (iter = running_tasks->begin(); iter != running_tasks->end(); iter++) {
             if (last) {
-                last -> run();
+                last->run();
                 if (sockets_pending_reset.begin() != sockets_pending_reset.end()) {
                     last = NULL;
                     break;
@@ -824,19 +572,19 @@ static bool traffic_thread()
             }
         }
         if (last) {
-            last -> run();
+            last->run();
         }
         while (sockets_pending_reset.begin() != sockets_pending_reset.end()) {
-            reset_connection(*(sockets_pending_reset.begin()));
+            (*(sockets_pending_reset.begin()))->reset_connection();
             sockets_pending_reset.erase(sockets_pending_reset.begin());
         }
 
         /* Update the clock. */
         getmilliseconds();
         /* Receive incoming messages */
-        pollset_process(running_tasks->empty());
+        SIPpSocket::pollset_process(running_tasks->empty());
     }
-    return true;
+    assert(0);
 }
 
 /*************** RTP ECHO THREAD ***********************/
@@ -870,6 +618,9 @@ static void rtp_echo_thread(void* param)
                     errno);
             return;
         }
+        if (!rtp_echo_state) {
+            continue;
+        }
         ns = sendto(*(int*)param, msg, nr, 0,
                     (sockaddr*)&remote_rtp_addr, len);
 
@@ -889,7 +640,6 @@ static void rtp_echo_thread(void* param)
             rtp2_bytes += ns;
         }
     }
-    pthread_exit(NULL); // 2/8/2022 - NVF Added
 }
 
 /* Wrap the help text. */
@@ -975,11 +725,96 @@ static char* wrap(const char* in, int offset, int size)
     return out;
 }
 
+/* If stdout is a TTY, wrap stdout in a call to PAGER (generally less(1)).
+ * Returns a pid_t you'll have to pass to end_pager(). */
+static pid_t begin_pager() {
+    char pager[15] = "/usr/bin/pager";
+    char *argv[2] = {NULL, NULL};
+
+    int stdout_fd = fileno(stdout);
+    int read_write[2];
+    pid_t ret;
+
+    if (!isatty(stdout_fd)) {
+        return 0;
+    }
+
+    /* Get pager first, so we can bail if it's not there */
+    argv[0] = getenv("PAGER");
+    if (!argv[0]) {
+        argv[0] = pager; /* missing PAGER */
+    } else if (!*argv[0]) {
+        return 0; /* blank PAGER */
+    }
+
+    /* Should use euidaccess(3), but requires _GNU_SOURCE */
+    if (access(argv[0], X_OK) < 0) {
+        perror(argv[0]);
+        return 0;
+    }
+
+    /* Set up pipes and fork */
+    if (pipe(&read_write[0]) < 0) {
+        perror("pipe");
+        return 0;
+    }
+    if ((ret = fork()) < 0) {
+        perror("fork");
+        return 0;
+    }
+
+    /* Switch stdout FD in parent */
+    if (ret != 0) {
+        fflush(stdout);
+        close(stdout_fd);
+        close(read_write[0]);
+        if (dup2(read_write[1], stdout_fd) < 0) {
+            perror("dup2");
+        } else {
+            close(read_write[1]);
+        }
+        return ret;
+    }
+
+    /* Switch stdin FD and start pager in child */
+    if (setenv("LESS", "FRX", 1) < 0) {
+        perror("setenv");
+    }
+
+    close(STDIN_FILENO);
+    close(read_write[1]);
+    if (dup2(read_write[0], STDIN_FILENO) < 0) {
+        perror("dup2");
+    } else {
+        close(read_write[0]);
+    }
+    execve(argv[0], argv, environ);
+
+    /* This was not supposed to happen. Missing binary? */
+    perror("execve");
+    return 0;
+}
+
+/* Make sure we flush and close, or the child won't get all the data (and know
+ * when we're done). Wait for the child to exit first. */
+void end_pager(pid_t pager) {
+    fflush(stdout);
+    fclose(stdout);
+    while (pager != 0) {
+        int wstatus;
+        if (waitpid(pager, &wstatus, 0) == pager) {
+            pager = 0;
+        }
+    }
+}
+
 /* Help screen */
 static void help()
 {
     int i, max;
 
+    pid_t pager = begin_pager();
+
     printf
     ("\n"
      "Usage:\n"
@@ -1040,6 +875,8 @@ static void help()
         "   99: Normal exit without calls processed\n"
         "   -1: Fatal error\n"
         "   -2: Fatal error binding a socket\n");
+
+    end_pager(pager);
 }
 
 
@@ -1147,11 +984,9 @@ static void help_stats()
 static void print_last_stats()
 {
     interrupt = 1;
-    // print last current screen
-    print_statistics(1);
-    // and print statistics screen
-    currentScreenToDisplay = DISPLAY_STAT_SCREEN;
-    print_statistics(1);
+    if (sp) {
+        sp->print_closing_stats();
+    }
     if (main_scenario) {
         stattask::report();
     }
@@ -1193,10 +1028,10 @@ static void manage_oversized_file(int signum)
     }
     managing = 1;
 
-    snprintf(L_file_name, MAX_PATH, "%s_%d_traces_oversized.log", scenario_file, getpid());
+    snprintf(L_file_name, MAX_PATH, "%s_%ld_traces_oversized.log", scenario_file, (long) getpid());
     f = fopen(L_file_name, "w");
     if (!f) {
-        ERROR_NO("Unable to open oversized log file\n");
+        ERROR_NO("Unable to open oversized log file");
     }
 
     GET_TIME(&currentTime);
@@ -1241,7 +1076,11 @@ void sipp_exit(int rc)
 
     screen_exit();
     print_last_stats();
-    screen_show_errors();
+    print_errors();
+    if (sp) {
+        delete sp;
+        sp = NULL;
+    }
 
     /* Close open files. */
     struct logfile_info** logfile_ptr;
@@ -1307,18 +1146,20 @@ static void set_scenario(const char* name)
     free(scenario_file);
     free(scenario_path);
 
-    const char* ext = strrchr(name, '.');
-    if (ext && strcmp(ext, ".xml") == 0) {
-        scenario_file = strndup(name, ext - name);
+    const char* sep = strrchr(name, '/');
+    if (sep) {
+        ++sep; // include slash
+        scenario_path = strndup(name, sep - name);
     } else {
-        scenario_file = strdup(name);
+        scenario_path = strdup("");
+        sep = name;
     }
 
-    const char* sep = strrchr(scenario_file, '/');
-    if (sep) {
-        scenario_path = strndup(scenario_file, sep - scenario_file);
+    const char* ext = strrchr(sep, '.');
+    if (ext && strcmp(ext, ".xml") == 0) {
+        scenario_file = strndup(sep, ext - sep);
     } else {
-        scenario_path = NULL;
+        scenario_file = strdup(sep);
     }
 }
 
@@ -1331,7 +1172,7 @@ static void set_scenario(const char* name)
 static int bind_rtp_sockets(struct sockaddr_storage* media_sa, int try_port, int last_attempt)
 {
     /* Create RTP sockets for audio and video. */
-    if ((media_socket_audio = socket(media_sa->ss_family, SOCK_DGRAM, 0)) == -1) {
+    if ((media_socket_audio = socket(media_sa->ss_family, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
         ERROR_NO("Unable to create the audio RTP socket");
     }
 
@@ -1341,7 +1182,7 @@ static int bind_rtp_sockets(struct sockaddr_storage* media_sa, int try_port, int
         (_RCAST(struct sockaddr_in6*, media_sa))->sin6_port = htons(try_port);
     }
 
-    if (::bind(media_socket_audio, (sockaddr*)media_sa, SOCK_ADDR_SIZE(media_sa)) != 0) {
+    if (::bind(media_socket_audio, (sockaddr*)media_sa, socklen_from_addr(media_sa)) != 0) {
         if (last_attempt) {
             ERROR_NO("Unable to bind audio RTP socket (IP=%s, port=%d)", media_ip, try_port);
         }
@@ -1352,7 +1193,7 @@ static int bind_rtp_sockets(struct sockaddr_storage* media_sa, int try_port, int
 
     /* Create and bind the second/video socket to try_port+2 */
     /* (+1 is reserved for RTCP) */
-    if ((media_socket_video = socket(media_sa->ss_family, SOCK_DGRAM, 0)) == -1) {
+    if ((media_socket_video = socket(media_sa->ss_family, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
         ERROR_NO("Unable to create the video RTP socket");
     }
 
@@ -1362,7 +1203,7 @@ static int bind_rtp_sockets(struct sockaddr_storage* media_sa, int try_port, int
         (_RCAST(struct sockaddr_in6*, media_sa))->sin6_port = htons(try_port + 2);
     }
 
-    if (::bind(media_socket_video, (sockaddr*)media_sa, SOCK_ADDR_SIZE(media_sa)) != 0) {
+    if (::bind(media_socket_video, (sockaddr*)media_sa, socklen_from_addr(media_sa)) != 0) {
         if (last_attempt) {
             ERROR_NO("Unable to bind video RTP socket (IP=%s, port=%d)",
                      media_ip, try_port + 2);
@@ -1406,7 +1247,7 @@ static void setup_media_sockets()
               "Use 'sipp -h' for details", media_ip);
     }
     memcpy(&media_sockaddr, local_addr->ai_addr,
-           SOCK_ADDR_SIZE(_RCAST(struct sockaddr_storage*, local_addr->ai_addr)));
+           socklen_from_addr(_RCAST(struct sockaddr_storage*, local_addr->ai_addr)));
     freeaddrinfo(local_addr);
 
     media_ip_is_ipv6 = (media_sockaddr.ss_family == AF_INET6);
@@ -1431,82 +1272,11 @@ static void setup_media_sockets()
     }
 }
 
-
-#define USE_OPENSSLX /* or USE_GNUTLS accordingly */
-
-/* we have this global to let the callback get easy access to it */
-static pthread_mutex_t *lockarray;
-
-#ifdef USE_OPENSSLX
-#include <openssl/crypto.h>
-static void lock_callback(int mode, int type, char *file, int line)
-{
-        (void)file;
-        (void)line;
-        if (mode & CRYPTO_LOCK) {
-                pthread_mutex_lock(&(lockarray[type]));
-        } else {
-                pthread_mutex_unlock(&(lockarray[type]));
-        }
-}
-
-static unsigned long thread_id(void)
-{
-        unsigned long ret;
-
-        ret = (unsigned long)pthread_self();
-        return (ret);
-}
-
-static void init_locks(void)
-{
-        int i;
-        struct logfile_info** logfile_ptr;
-        struct logfile_info* logfiles[] = {
-            &screen_lfi, &calldebug_lfi, &message_lfi, &shortmessage_lfi, &log_lfi, &error_lfi, NULL};
-
-        lockarray = (pthread_mutex_t *)OPENSSL_malloc(CRYPTO_num_locks() *
-                    sizeof(pthread_mutex_t));
-        for (i = 0; i < CRYPTO_num_locks(); i++) {
-                pthread_mutex_init(&(lockarray[i]), NULL);
-        }
-
-        CRYPTO_set_id_callback((unsigned long (*)())thread_id);
-        CRYPTO_set_locking_callback((void (*)(int, int, const char *, int))lock_callback);
-
-        /* Inite logfile mutexs. */
-        for (logfile_ptr = logfiles; *logfile_ptr; ++logfile_ptr) {
-            (*logfile_ptr)->lockfile = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
-            pthread_mutex_init((*logfile_ptr)->lockfile, NULL);
-        }
-
-}
-
-static void kill_locks(void)
-{
-        int i;
-        struct logfile_info** logfile_ptr;
-        struct logfile_info* logfiles[] = {
-            &screen_lfi, &calldebug_lfi, &message_lfi, &shortmessage_lfi, &log_lfi, &error_lfi, NULL};
-
-        CRYPTO_set_locking_callback(NULL);
-        for (i = 0; i < CRYPTO_num_locks(); i++)
-                pthread_mutex_destroy(&(lockarray[i]));
-
-        OPENSSL_free(lockarray);
-
-        /* Inite logfile mutexs. */
-        for (logfile_ptr = logfiles; *logfile_ptr; ++logfile_ptr) {
-            (*logfile_ptr)->lockfile = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
-            pthread_mutex_destroy((*logfile_ptr)->lockfile);
-        }
-}
-#endif
 /* Main */
 int main(int argc, char *argv[])
 {
     int                  argi = 0;
-    pthread_t pthread2_id = 0, pthread3_id = 0, pthread4_id = 0;
+    pthread_t pthread2_id = 0, pthread3_id = 0;
     unsigned int         generic_count = 0;
     bool                 slave_masterSet = false;
 
@@ -1518,12 +1288,7 @@ int main(int argc, char *argv[])
         exit(EXIT_OTHER);
     }
     {
-  	// 2/9/2022 NVF This has to be above the SIGPIPE handler (added to support mysqlclient multithreaded): https://dev.mysql.com/doc/c-api/8.0/en/c-api-threaded-clients.html
-  	if (mysql_library_init(0, NULL, NULL)) {
-    		fprintf(stderr, "Warning: Could not initialize MySQL client library.  MySQL should not be used in a threaded call as a result\n");
-    		exit(1);
-   	}
-        /* Ignore the SIGPIPE signal - note: this also works for MYSQL*/
+        /* Ignore the SIGPIPE signal */
         struct sigaction action_pipe;
         memset(&action_pipe, 0, sizeof(action_pipe));
         action_pipe.sa_handler=SIG_IGN;
@@ -1547,23 +1312,13 @@ int main(int argc, char *argv[])
         sigaction(SIGUSR2, &action_usr2, NULL);
     }
 
-    init_locks();
-
-    curl_global_init(CURL_GLOBAL_DEFAULT);  // This is so we can use CURL inside our lua scripts in multi-threaded environments
-
-
-    screen_set_exename("sipp");
-
     pid = getpid();
-    memset(local_ip, 0, 40);
+    memset(local_ip, 0, sizeof(local_ip));
 #ifdef USE_SCTP
-    memset(multihome_ip, 0, 40);
+    memset(multihome_ip, 0, sizeof(multihome_ip));
 #endif
-    memset(media_ip, 0, 40);
-    memset(control_ip, 0, 40);
-
-    /* Initialize the tolower table. */
-    init_tolower_table();
+    memset(media_ip, 0, sizeof(media_ip));
+    memset(control_ip, 0, sizeof(control_ip));
 
     /* Initialize our global variable structure. */
     globalVariables = new AllocVariableTable(NULL);
@@ -1599,7 +1354,7 @@ int main(int argc, char *argv[])
                 printf("\n %s.\n\n",
                        /* SIPp v1.2.3-TLS-PCAP */
                        "SIPp " SIPP_VERSION
-#ifdef USE_OPENSSL
+#ifdef USE_TLS
                        "-TLS"
 #endif
 #ifdef USE_SCTP
@@ -1607,9 +1362,6 @@ int main(int argc, char *argv[])
 #endif
 #ifdef PCAPPLAY
                        "-PCAP"
-#endif
-#ifdef RTP_STREAM
-                       "-RTPSTREAM"
 #endif
                        );
 
@@ -1755,9 +1507,9 @@ int main(int argc, char *argv[])
 #endif
                     break;
                 case 'l':
-#ifdef USE_OPENSSL
+#ifdef USE_TLS
                     transport = T_TLS;
-                    if (init_OpenSSL() != 1) {
+                    if (TLS_init() != 1) {
                         printf("OpenSSL Initialization problem\n");
                         exit(-1);
                     }
@@ -1767,7 +1519,7 @@ int main(int argc, char *argv[])
                     break;
                 case 'c':
                     if (strlen(comp_error)) {
-                        ERROR("No " COMP_PLUGGIN " plugin available:\n%s", comp_error);
+                        ERROR("No " COMP_PLUGGIN " plugin available: %s", comp_error);
                     }
                     transport = T_UDP;
                     compression = 1;
@@ -1789,7 +1541,7 @@ int main(int argc, char *argv[])
                 }
 
                 if (peripsocket && transport != T_UDP) {
-                    ERROR("You can only use a perip socket with UDP!\n");
+                    ERROR("You can only use a perip socket with UDP!");
                 }
                 break;
             case SIPP_OPTION_NEED_SCTP:
@@ -1864,10 +1616,10 @@ int main(int argc, char *argv[])
                 break;
             case SIPP_OPTION_3PCC:
                 if (slave_masterSet) {
-                    ERROR("-3PCC option is not compatible with -master and -slave options\n");
+                    ERROR("-3PCC option is not compatible with -master and -slave options");
                 }
                 if (extendedTwinSippMode) {
-                    ERROR("-3pcc and -slave_cfg options are not compatible\n");
+                    ERROR("-3pcc and -slave_cfg options are not compatible");
                 }
                 REQUIRE_ARG();
                 CHECK_PASS();
@@ -1878,7 +1630,9 @@ int main(int argc, char *argv[])
             case SIPP_OPTION_SCENARIO:
                 REQUIRE_ARG();
                 CHECK_PASS();
-                if (!strcmp(argv[argi - 1], "-sf")) {
+                if (main_scenario) {
+                    ERROR("Internal error, main_scenario already set");
+                } else if (!strcmp(argv[argi - 1], "-sf")) {
                     set_scenario(argv[argi]);
                     if (useLogf == 1) {
                         rotate_logfile();
@@ -1887,16 +1641,15 @@ int main(int argc, char *argv[])
                     main_scenario->stats->setFileName(scenario_file, ".csv");
                 } else if (!strcmp(argv[argi - 1], "-sn")) {
                     int i = find_scenario(argv[argi]);
-
-                    main_scenario = new scenario(0, i);
                     set_scenario(argv[argi]);
-                    main_scenario->stats->setFileName(argv[argi], ".csv");
+                    main_scenario = new scenario(0, i);
+                    main_scenario->stats->setFileName(scenario_file, ".csv");
                 } else if (!strcmp(argv[argi - 1], "-sd")) {
                     int i = find_scenario(argv[argi]);
                     fprintf(stdout, "%s", default_scenario[i]);
                     exit(EXIT_OTHER);
                 } else {
-                    ERROR("Internal error, I don't recognize %s as a scenario option\n", argv[argi] - 1);
+                    ERROR("Internal error, I don't recognize %s as a scenario option", argv[argi] - 1);
                 }
                 break;
             case SIPP_OPTION_OOC_SCENARIO:
@@ -1908,14 +1661,14 @@ int main(int argc, char *argv[])
                     int i = find_scenario(argv[argi]);
                     ooc_scenario = new scenario(0, i);
                 } else {
-                    ERROR("Internal error, I don't recognize %s as a scenario option\n", argv[argi] - 1);
+                    ERROR("Internal error, I don't recognize %s as a scenario option", argv[argi] - 1);
                 }
                 break;
             case SIPP_OPTION_SLAVE_CFG:
                 REQUIRE_ARG();
                 CHECK_PASS();
                 if (twinSippMode) {
-                    ERROR("-slave_cfg and -3pcc options are not compatible\n");
+                    ERROR("-slave_cfg and -3pcc options are not compatible");
                 }
                 extendedTwinSippMode = true;
                 slave_cfg_file = new char [strlen(argv[argi]) + 1];
@@ -1926,10 +1679,10 @@ int main(int argc, char *argv[])
                 REQUIRE_ARG();
                 CHECK_PASS();
                 if (slave_masterSet) {
-                    ERROR("-slave and -master options are not compatible\n");
+                    ERROR("-slave and -master options are not compatible");
                 }
                 if (twinSippMode) {
-                    ERROR("-master and -slave options are not compatible with -3PCC option\n");
+                    ERROR("-master and -slave options are not compatible with -3PCC option");
                 }
                 *((char**)option->data) = argv[argi];
                 slave_masterSet = true;
@@ -1947,37 +1700,17 @@ int main(int argc, char *argv[])
                 if (temp_remote_s_p != 0) {
                     remote_s_p = temp_remote_s_p;
                 }
-                struct addrinfo   hints;
-                struct addrinfo * local_addr;
 
                 printf("Resolving remote sending address %s...\n", remote_s_address);
 
-                memset((char*)&hints, 0, sizeof(hints));
-                hints.ai_flags  = AI_PASSIVE;
-                hints.ai_family = PF_UNSPEC;
-
                 /* FIXME: add DNS SRV support using liburli? */
-                if (getaddrinfo(remote_s_address,
-                                NULL,
-                                &hints,
-                                &local_addr) != 0) {
+                if (gai_getsockaddr(&remote_sending_sockaddr, remote_s_address, remote_s_p,
+                                    AI_PASSIVE, AF_UNSPEC) != 0) {
                     ERROR("Unknown remote host '%s'.\n"
                           "Use 'sipp -h' for details", remote_s_address);
                 }
 
-                memcpy(&remote_sending_sockaddr,
-                       local_addr->ai_addr,
-                       SOCK_ADDR_SIZE(
-                           _RCAST(struct sockaddr_storage *, local_addr->ai_addr)));
-
-                if (remote_sending_sockaddr.ss_family == AF_INET) {
-                    (_RCAST(struct sockaddr_in*, &remote_sending_sockaddr))->sin_port = htons(remote_s_p);
-                } else {
-                    (_RCAST(struct sockaddr_in6*, &remote_sending_sockaddr))->sin6_port = htons(remote_s_p);
-                }
                 use_remote_sending_addr = 1;
-
-                freeaddrinfo(local_addr);
                 break;
             }
             case SIPP_OPTION_RTCHECK:
@@ -1988,7 +1721,7 @@ int main(int argc, char *argv[])
                 } else if (!strcmp(argv[argi], "loose")) {
                     *((int*)option->data) = RTCHECK_LOOSE;
                 } else {
-                    ERROR("Unknown retransmission detection method: %s\n", argv[argi]);
+                    ERROR("Unknown retransmission detection method: %s", argv[argi]);
                 }
                 break;
             case SIPP_OPTION_TDMMAP: {
@@ -2043,7 +1776,7 @@ int main(int argc, char *argv[])
                         } else if (!strcmp(p, "pingreply")) {
                             mask = DEFAULT_BEHAVIOR_PINGREPLY;
                         } else {
-                            ERROR("Unknown default behavior: '%s'\n", token);
+                            ERROR("Unknown default behavior: '%s'", token);
                         }
                         switch(mode) {
                         case 0:
@@ -2087,7 +1820,7 @@ int main(int argc, char *argv[])
                 }
 
                 int (*init)(void *);
-		init = (int (*)(void *))dlsym(handle, "init");
+                init = (int (*)(void *))dlsym(handle, "init");
                 //void* funcptr = dlsym(handle, "init");
                 /* http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c */
                 //*reinterpret_cast<void**>(&init)(void *) = funcptr; // yuck
@@ -2103,8 +1836,9 @@ int main(int argc, char *argv[])
                 }
             }
             break;
+
             default:
-                ERROR("Internal error: I don't recognize the option type for %s\n", argv[argi]);
+                ERROR("Internal error: I don't recognize the option type for %s", argv[argi]);
             }
         }
     }
@@ -2115,7 +1849,7 @@ int main(int argc, char *argv[])
     }
 
     if ((extendedTwinSippMode && !slave_masterSet) || (!extendedTwinSippMode && slave_masterSet)) {
-        ERROR("-slave_cfg option must be used with -slave or -master option\n");
+        ERROR("-slave_cfg option must be used with -slave or -master option");
     }
 
     if (peripsocket) {
@@ -2133,13 +1867,17 @@ int main(int argc, char *argv[])
         lose_packets = 1;
     }
 
-    /* trace file setting */
+    /* If no scenario was selected, choose the uac one */
     if (scenario_file == NULL) {
-        set_scenario("sipp");
+        assert(main_scenario == NULL);
+        int i = find_scenario("uac");
+        set_scenario("uac");
+        main_scenario = new scenario(0, i);
+        main_scenario->stats->setFileName(scenario_file, ".csv");
     }
 
-#ifdef USE_OPENSSL
-    if ((transport == T_TLS) && (FI_init_ssl_context() != SSL_INIT_NORMAL)) {
+#ifdef USE_TLS
+    if ((transport == T_TLS) && (TLS_init_context() != TLS_INIT_NORMAL)) {
         ERROR("FI_init_ssl_context() failed");
     }
 #endif
@@ -2173,7 +1911,7 @@ int main(int argc, char *argv[])
 
     if (useCountf == 1) {
         char L_file_name [MAX_PATH];
-        sprintf(L_file_name, "%s_%d_counts.csv", scenario_file, getpid());
+        sprintf(L_file_name, "%s_%ld_counts.csv", scenario_file, (long) getpid());
         countf = fopen(L_file_name, "w");
         if (!countf) {
             ERROR("Unable to create '%s'", L_file_name);
@@ -2183,7 +1921,7 @@ int main(int argc, char *argv[])
 
     if (useErrorCodesf == 1) {
         char L_file_name [MAX_PATH];
-        sprintf(L_file_name, "%s_%d_error_codes.csv", scenario_file, getpid());
+        sprintf(L_file_name, "%s_%ld_error_codes.csv", scenario_file, (long) getpid());
         codesf = fopen(L_file_name, "w");
         if (!codesf) {
             ERROR("Unable to create '%s'", L_file_name);
@@ -2192,7 +1930,7 @@ int main(int argc, char *argv[])
 
 
     if (dumpInRtt == 1) {
-        main_scenario->stats->initRtt((char*)scenario_file, (char*)".csv",
+        main_scenario->stats->initRtt(scenario_file, ".csv",
                                       report_freq_dumpRtt);
     }
 
@@ -2227,12 +1965,6 @@ int main(int argc, char *argv[])
         }
     }
 
-    /* Load default scenario in case nothing was loaded */
-    if (!main_scenario) {
-        main_scenario = new scenario(0, 0);
-        main_scenario->stats->setFileName("uac", ".csv");
-        sprintf(scenario_file,"uac");
-    }
     /*
     if (!ooc_scenario) {
       ooc_scenario = new scenario(0, find_scenario("ooc_default"));
@@ -2272,11 +2004,12 @@ int main(int argc, char *argv[])
         ERROR("SIPp cannot use out-of-call scenarios when running in server mode");
     }
 
-    if (!isatty(fileno(stdout)))
-        use_curses = false;
 
-    if (use_curses)
+    sp = new ScreenPrinter();
+    if (!sp->M_headless)
+    {
         screen_init();
+    }
 
     sighandle_set();
 
@@ -2303,22 +2036,11 @@ int main(int argc, char *argv[])
         break;
         default:
             // parent process - killing the parent - the child get the parent pid
-            printf("Background mode - PID=[%d]\n", l_pid);
+            printf("Background mode - PID=[%ld]\n", (long) l_pid);
             exit(EXIT_OTHER);
         }
     }
 
-    //HYDE write pid file
-    if (pid_file != NULL && strlen(pid_file)>0)
-    {
-        FILE *f;
-        f = fopen(pid_file, "w");
-        fprintf(f, "%d\n",getpid());
-        fflush(f);
-        fclose(f);
-    }
-    //HYDE write pid file
-
     sipp_usleep(sleeptime * 1000);
 
     /* Create the statistics reporting task. */
@@ -2374,20 +2096,7 @@ int main(int argc, char *argv[])
         }
     }
 
-    /* Creating RPC thread. */
-    if (enable_rpc) {
-        if (pthread_create(&pthread4_id, NULL,
-            (void *(*)(void *)) rpc_thread, NULL) == -1) {
-                ERROR_NO("Unable to create video RTP echo thread");
-        }
-    }
-
-    if (traffic_thread()) {
-        if (!nostdin) {
-            sipp_close_socket(stdin_socket);
-        }
-        sipp_close_socket(ctrl_socket);
-    }
+    traffic_thread();
 
     /* Cancel and join other threads. */
     if (pthread2_id) {
@@ -2396,196 +2105,19 @@ int main(int argc, char *argv[])
     if (pthread3_id) {
         pthread_cancel(pthread3_id);
     }
-    if (pthread4_id) {
-        pthread_cancel(pthread4_id);
-    }
     if (pthread2_id) {
         pthread_join(pthread2_id, NULL);
     }
     if (pthread3_id) {
         pthread_join(pthread3_id, NULL);
     }
-    if (pthread4_id) {
-        pthread_join(pthread4_id, NULL);
-    }
 
 #ifdef HAVE_EPOLL
     close(epollfd);
     free(epollevents);
 #endif
 
-    if (local_addr_storage) {
-        freeaddrinfo(local_addr_storage);
-    }
     free(scenario_file);
-
+    free(scenario_path);
     sipp_exit(EXIT_TEST_RES_UNKNOWN);
-    kill_locks(); 
-    curl_global_cleanup();
-    mysql_library_end(); // 2/9/2022 - NVF Added to allow mysql threaded support
-
-}
-
-bool_t
-getcallcounter_1_svc(callcounter_t *argp, callcounter_t *result, struct svc_req *rqstp)
-{
-	bool_t retval;
-
-	/*
-	 * insert server code here
-	 */
-
-	unsigned long long incomingcalls = main_scenario->stats->GetStat(CStat::CPT_C_IncomingCallCreated);
-	unsigned long long outgoingcalls = main_scenario->stats->GetStat(CStat::CPT_C_OutgoingCallCreated);
-	unsigned long long successcalls = main_scenario->stats->GetStat(CStat::CPT_C_SuccessfulCall);
-	unsigned long long failurecalls = main_scenario->stats->GetStat(CStat::CPT_C_FailedCall);
-
-	result->incomingcalls=incomingcalls;
-	result->outgoingcalls=outgoingcalls;
-	result->successcalls=successcalls;
-	result->failurecalls=failurecalls;
-
-	retval = true;
-	return retval;
-}
-
-bool_t
-enablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
-{
-	bool_t retval;
-
-	/*
-	 * insert server code here
-	 */
-
-	log4auto_answer=true;
-	retval = true;
-	return retval;
-}
-
-bool_t
-disablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
-{
-	bool_t retval;
-
-	/*
-	 * insert server code here
-	 */
-
-	log4auto_answer=false;
-	retval = true;
-	return retval;
-}
-
-int
-sipprpcprog_1_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
-{
-	xdr_free (xdr_result, result);
-
-	/*
-	 * Insert additional freeing code here, if needed
-	 */
-
-	return 1;
-}
-
-void
-sipprpcprog_1(struct svc_req *rqstp, register SVCXPRT *transp)
-{
-	union {
-		callcounter_t getcallcounter_1_arg;
-	} argument;
-	union {
-		callcounter_t getcallcounter_1_res;
-		bool_t enablelog4autoanswer_1_res;
-		bool_t disablelog4autoanswer_1_res;
-	} result;
-	bool_t retval;
-	xdrproc_t _xdr_argument, _xdr_result;
-	bool_t (*local)(char *, void *, struct svc_req *);
-
-	switch (rqstp->rq_proc) {
-	case NULLPROC:
-		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
-		return;
-
-	case GETCALLCOUNTER:
-		_xdr_argument = (xdrproc_t) xdr_callcounter_t;
-		_xdr_result = (xdrproc_t) xdr_callcounter_t;
-		local = (bool_t (*) (char *, void *,  struct svc_req *))getcallcounter_1_svc;
-		break;
-
-	case ENABLELOG4AUTOANSWER:
-		_xdr_argument = (xdrproc_t) xdr_void;
-		_xdr_result = (xdrproc_t) xdr_bool;
-		local = (bool_t (*) (char *, void *,  struct svc_req *))enablelog4autoanswer_1_svc;
-		break;
-
-	case DISABLELOG4AUTOANSWER:
-		_xdr_argument = (xdrproc_t) xdr_void;
-		_xdr_result = (xdrproc_t) xdr_bool;
-		local = (bool_t (*) (char *, void *,  struct svc_req *))disablelog4autoanswer_1_svc;
-		break;
-
-	default:
-		svcerr_noproc (transp);
-		return;
-	}
-	memset ((char *)&argument, 0, sizeof (argument));
-	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
-		svcerr_decode (transp);
-		return;
-	}
-	retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
-	if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
-		svcerr_systemerr (transp);
-	}
-	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
-		fprintf (stderr, "%s", "unable to free arguments");
-		exit (1);
-	}
-	if (!sipprpcprog_1_freeresult (transp, _xdr_result, (caddr_t) &result))
-		fprintf (stderr, "%s", "unable to free results");
-
-	return;
-}
-
-void rpc_thread(void* param)
-{
-	register SVCXPRT *transp;
-	sigset_t              mask;
-	sigfillset(&mask); /* Mask all allowed signals */
-	int rc = pthread_sigmask(SIG_BLOCK, &mask, NULL);
-	if (rc) {
-	    WARNING("pthread_sigmask returned %d", rc);
-	    return;
-	}
-
-	pmap_unset (SIPPRPCPROG, SIPPRPCVERS);
-
-	transp = svcudp_create(RPC_ANYSOCK);
-	if (transp == NULL) {
-		fprintf (stderr, "%s", "cannot create udp service.");
-		exit(1);
-	}
-	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_UDP)) {
-		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
-		exit(1);
-	}
-
-	transp = svctcp_create(RPC_ANYSOCK, 0, 0);
-	if (transp == NULL) {
-		fprintf (stderr, "%s", "cannot create tcp service.");
-		exit(1);
-	}
-	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_TCP)) {
-		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
-		exit(1);
-	}
-
-	svc_run ();
-	fprintf (stderr, "%s", "svc_run returned");
-	pthread_exit(NULL); // 2/8/2022 - NVF Added
-	//exit (1);
-	/* NOTREACHED */
 }

From a24c5993993c29f9f52f6d7f760a035aeb0a5527 Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan.franzmeier@sky-networks.com>
Date: Mon, 28 Mar 2022 20:41:53 +0000
Subject: [PATCH 6/9] 1. Completed the merge with the 3.6 branch. 2. Moved the
 custom functionality for lua scripting, rpc calls and argument processing
 into a plugin 3. Added some code to cause sipp to include the lualib if the
 USE_LUA=1 flag is set when doing the CMAKE - this is so the lua environment
 can be accessible to lua scripts running in the plugin

---
 CMakeLists.txt      |  13 +-
 include/xp_parser.h |   3 +-
 src/call.cpp        |  14 +-
 src/myapp.cpp       | 349 ++++++++++++++++++++++++++++++++++++++------
 src/scenario.cpp    |   4 +-
 src/sipp.cpp        | 156 +++++++++++++++++++-
 src/xp_parser.c     | 166 ++++++---------------
 7 files changed, 528 insertions(+), 177 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4da8b7525..7b908a8c6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,6 +26,7 @@ option(USE_SSL "Build with SIPS support" OFF)
 option(USE_SCTP "Build with SCTP support" OFF)
 option(USE_PCAP "Build with PCAP playback support" OFF)
 option(USE_GSL "Build with improved statistical support" ON)
+option(USE_LUA "Build with lua support for plugins" ON)
 
 file(GLOB all_SRCS
   "${PROJECT_SOURCE_DIR}/src/*.cpp"
@@ -74,6 +75,10 @@ if(USE_SSL)
   add_definitions("-DUSE_TLS -DUSE_OPENSSL")
 endif()
 
+if (USE_LUA)
+  add_definitions("-DUSE_LUA")
+endif()
+
 if(USE_PCAP)
   find_library(PCAP_LIBRARY pcap)
   if(PCAP_LIBRARY)
@@ -104,12 +109,16 @@ endif(USE_SCTP)
  list(REMOVE_ITEM all_SRCS
     "${PROJECT_SOURCE_DIR}/src/myapp.cpp")
 
+ list(REMOVE_ITEM all_SRCS
+    "${PROJECT_SOURCE_DIR}/src/sipp-rpc_xdr.c")
+
 # add the executable
 link_directories("/usr/local/lib")
 add_executable(sipp ${all_SRCS} "${PROJECT_SOURCE_DIR}/src/sipp.cpp")
 add_executable(sipp_unittest EXCLUDE_FROM_ALL ${all_SRCS} "${PROJECT_SOURCE_DIR}/src/sipp_unittest.cpp")
-add_library(myapp SHARED ${PROJECT_SOURCE_DIR}/src/myapp.cpp  )
-target_link_libraries(myapp -rdynamic -fPIC -llua5.3 -lrt -lcrypto -lcurl -lperconaserverclient )
+target_link_libraries(sipp -rdynamic -fPIC -dl -llua5.3 )
+add_library(myapp SHARED ${PROJECT_SOURCE_DIR}/src/myapp.cpp ${PROJECT_SOURCE_DIR}/src/sipp-rpc_xdr.c )
+target_link_libraries(myapp -rdynamic -fPIC -dl -llua5.3 -lcurl -lrt -lcrypto -lperconaserverclient )
 target_compile_definitions(sipp_unittest PUBLIC "-DGTEST")
 
 # add version
diff --git a/include/xp_parser.h b/include/xp_parser.h
index b9d5bd615..48f0ccc05 100644
--- a/include/xp_parser.h
+++ b/include/xp_parser.h
@@ -28,8 +28,7 @@ int xp_set_xml_buffer_from_string(const char *str);
 int xp_set_xml_buffer_from_file(const char *filename);
 char* xp_open_element(int index);
 void xp_close_element(void);
-int xp_is_invalid();
-const char* xp_get_value(const char *name);
+char* xp_get_value(const char *name);
 char* xp_get_cdata(void);
 int xp_get_content_length(const char *P_buffer);
 
diff --git a/src/call.cpp b/src/call.cpp
index fc6b05b39..9a711ad48 100644
--- a/src/call.cpp
+++ b/src/call.cpp
@@ -64,6 +64,7 @@
 
 using namespace std;
 
+bool log4auto_answer = true;  // This just adds the ability to not log auto_answer via a plugin
 
 template<typename Out>
 void split(const std::string &s, char delim, Out result) {
@@ -3675,7 +3676,11 @@ call::T_ActionResult call::executeAction(const char* msg, message* curmsg)
 
           // Process possible commands that override the default functionality:   format is command@<file.lua>
           //    custom calls - user defined
-          //    <exec command="command@<argstring>  where argstring is a list of args sent to command.
+          //    <exec command="command@<argstring>  where argstring is a list of space separated args sent to command : tag1 val1 tag2 val2 tag3 val3 etc. - these will form a lua table
+	  //    use the value of the magic variable $retkey  to create a loop looking with the command  <exec command="luaread@[$retkey] 0" />
+	  //
+	  //    then check the magic variable $msgDone  for a  non-zero value indicating the other args  are also updated - usually the same list of tag value pairs sent down
+	  //     <strcmp assign_to="result" variable="msgDone" value="0" />
           //    if we don't find anything - do a forked system call - default sipp behavior
           //    We pass in pointers to the call variables and the current scenario to allow manipulation of sipp variables
           //    These should be initialized in a plugin - see myapp.cpp for a sample
@@ -4077,8 +4082,10 @@ bool call::automaticResponseMode(T_AutoMode P_case, const char* P_recv)
 
         strcpy(last_recv_msg, P_recv);
 
-        WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
-                (id == NULL) ? "none" : id);
+	if (log4auto_answer) {
+        	WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
+                	(id == NULL) ? "none" : id);
+	}
         sendBuffer(createSendingMessage(get_default_message("200"), -1));
 
         // restore previous last msg
@@ -4100,6 +4107,7 @@ bool call::automaticResponseMode(T_AutoMode P_case, const char* P_recv)
             }
         }
         CStat::globalStat(CStat::E_AUTO_ANSWERED);
+        delete this;  // 2/16/2022 - NVF Added this for auto response messages as it looked like it wasn't being done otherwise - resulting in a memory leak
         return true;
         break;
 
diff --git a/src/myapp.cpp b/src/myapp.cpp
index 62982e1cf..77d9b05d8 100644
--- a/src/myapp.cpp
+++ b/src/myapp.cpp
@@ -1,6 +1,28 @@
 /* 
- * Description: Custom modifications to support running LUA inside of a sipp test script, sending values to lua from sipp
- * and returning values to local sipp variables
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  
+ * Description: This is a demo program demonstrating customizations to sipp via a plugin to support 
+ *
+ * 1. Running LUA inside of a sipp test script, sending values to lua from sipp
+ * and returning values to local sipp variables. This includes the ability to utilize curl and mysql in the lua scripts
+ *
+ * 2. The capability to do RPC calls to a running sipp instance to get various call counts and enable/disable
+ * logging on auto response messages
+ *
+ * 3. Processing some custom startup arguments to capture the running pid and to get the name of the lua file
+ *
  *
  * Author: Nathan Franzmeier Sky Networks LLC 2022
  * Mail: Nathan.Franzmeier@sky-networks.com
@@ -17,9 +39,14 @@
 #include <assert.h>
 // Added for LUA support
 
-#include <lua.h>
-#include <lualib.h>
-#include <lauxlib.h>
+#ifdef __cplusplus
+  #include "lua.hpp"
+#else
+  #include "lua.h"
+  #include "lualib.h"
+  #include "lauxlib.h"
+#endif
+
 
 // Added for shared memory support
 #include <sys/mman.h>
@@ -41,18 +68,20 @@
 #include "version.h"
 #include "apifunc.h"
 
-// 02/9/2022 - NVF Added when trying to fix mysql thread support
+// For CURL support
+
+#include "curl.h"
+#include "easy.h"
+
+// For mysql thread support
 #include "mysql.h"
 
-#define callDebug(...) do { if (useCallDebugf) { _callDebug( __VA_ARGS__ ); } } while (0)
+// For rpc support
+#include "sipp-rpc.h"
+#include <rpc/pmap_clnt.h>
 
-using namespace std;
+#define callDebug(...) do { if (useCallDebugf) { _callDebug( __VA_ARGS__ ); } } while (0)
 
-#define USE_PTHREADS 1
-// Added for thread support
-#if USE_PTHREADS == 0
-	#include <thread>
-#endif
 #define MAXARGS 50 // Most argument pairs that can be passed into a lua script
 extern  map<string, struct sipp_socket *>     map_perip_fd;
 typedef struct tag_value {
@@ -66,18 +95,15 @@ typedef struct tv_array {
 	int count;
 	bool useThread;
 	bool dataIsReady;  // Flag indicating data has been set
-#if USE_PTHREADS == 1
 	pthread_t  myThread;
-#else
-	std::thread myThread;
-#endif
 	TAG_VAL	element[MAXARGS];
 
 } TV_ARRAY;
 
 
 void bail(lua_State *L, char *msg){
-        WARNING( "\nLUA ERROR:\n  %s: %s\n\n",
+//WARNING( "\nLUA ERROR:\n  %s: %s\n\n",
+fprintf( stderr, "\nLUA ERROR:\n  %s: %s\n\n",
                 msg, lua_tostring(L, -1));
 }
 typedef struct thread_data {
@@ -90,37 +116,68 @@ typedef struct thread_data {
 
 void do_lua_thread(THREAD_DATA *thread_data);
 void do_lua_thread_detached(THREAD_DATA *thread_data); 
+void rpc_thread(void* param);
+
+pthread_t pthread4_id = 0;  // Thread id for the RPC thread
+
+#define LUA_LIB
 
+extern "C" 
+{
+
+	static const luaL_Reg lualibs[] = {
+  	{"", luaopen_base},
+	{LUA_COLIBNAME, luaopen_coroutine},
+  	{LUA_LOADLIBNAME, luaopen_package},
+  	{LUA_TABLIBNAME, luaopen_table},
+  	{LUA_IOLIBNAME, luaopen_io},
+  	{LUA_OSLIBNAME, luaopen_os},
+  	{LUA_STRLIBNAME, luaopen_string},
+  	{LUA_UTF8LIBNAME, luaopen_utf8},
+  	{LUA_MATHLIBNAME, luaopen_math},
+  	{LUA_DBLIBNAME, luaopen_debug},
+  	{LUA_LOADLIBNAME, luaopen_package},
+  	{NULL, NULL}
+	};
+
+	LUALIB_API void my_openlibs (lua_State *L) {
+  		const luaL_Reg *lib = lualibs;
+  		for (; lib->func; lib++) {
+    			lua_pushcfunction(L, lib->func);
+    			lua_pushstring(L, lib->name);
+    			lua_call(L, 1, 0);
+			fprintf(stderr,"lua_call result (%s):%s\n",lib->name, lua_tostring(L, -1));
+  		}
+	}
+}
+extern "C"
+{
+char	lua_file[128];
 lua_State*  openLua() {
 
 
-#ifndef USE_GLOBAL_LUA
         lua_State *L = luaL_newstate();
-#else
-        if (L) return L;
-
-        L = luaL_newstate();                        // Create Global Lua state variable
-#endif
         if (L) {
 
                 luaL_openlibs(L);                           /* Load Lua libraries */
+		//my_openlibs(L);
 
-                if (luaL_loadfile(L, "sipp.lua")) /* Load but don't run the Lua script */
-                //if (luaL_loadfile(L, lua_file)) /* Load but don't run the Lua script */
+                if (luaL_loadfile(L, lua_file)) /* Load but don't run the Lua script */
                 {
-                        bail(L, "luaL_loadfile() failed");      /* Error out if file can't be read */
+                        bail(L, (char *)"luaL_loadfile() failed");      /* Error out if file can't be read */
                         L=0;
                 } else{
 
                         if (lua_pcall(L, 0, 0, 0))                  /* PRIMING RUN. FORGET THIS AND YOU'RE TOAST */
                         {
-                                bail(L, "lua_pcall1() failed");          /* Error out if Lua file has an error */
+                                bail(L, (char *)"lua_pcall1() failed");          /* Error out if Lua file has an error */
                                 L=0;
                         }
                 }
         }
    return L;
 }
+}
 
 API_FUNC  customFunc(int app, char *data_str, void *userVars, void *dispPtr){ return EXIT_SUCCESS;}
 API_FUNC  processLuaRun(int app, char *data_str, void *tblPtr, void *dispPtr){
@@ -334,17 +391,11 @@ API_FUNC  processLuaThread(int app, char *data_str, void *tblPtr, void *dispPtr)
 				strcpy(thread_data->data_str,data_str);
 				strcpy(thread_data->name,name);
 				// Create a detached thread so we don't need to join it later
-#if USE_PTHREADS == 1
 				TRACE_MSG("Create pthread shared memory\n");
 				if (pthread_create(&shared_memory->myThread, NULL, (void *(*)(void *))do_lua_thread_detached, thread_data) == -1) {
             				ERROR_NO("Unable to create lua thread");
         			}
 
-#else
-				TRACE_MSG("Create std shared memory\n");
-				shared_memory->myThread = std::thread(do_lua_thread, thread_data);
-				shared_memory->myThread.detach();
-#endif
 
                 		int index;
 				for (int i=0;i<shared_memory->count;i++)
@@ -436,7 +487,7 @@ void do_lua_thread(THREAD_DATA *thread_data) {
 				
    				if (lua_pcall(thread_data->L, 1, 1, 0))                  // Run function, !!! NRETURN=1 !!! 
 	
-           				bail(thread_data->L, "lua_pcall2() failed");
+           				bail(thread_data->L, (char *)"lua_pcall2() failed");
    				else {
 	
                                 		//printf("============ Back in C again, Iterating thru returned table ============\n");
@@ -466,9 +517,8 @@ void do_lua_thread(THREAD_DATA *thread_data) {
 						shared_memory->dataIsReady = 1; // Mark the data as being available.
 				}
 			  	lua_gc(thread_data->L, LUA_GCCOLLECT, 0);
-#ifndef USE_GLOBAL_LUA
 			  	lua_close(thread_data->L);
-#endif
+
 				// 02/15/2022 - NVF Added trim capability based on the environment variable TRIM_MEMORY
 				char* trim_mem = getenv("TRIM_MEMORY");
                                 if (trim_mem) {
@@ -485,6 +535,167 @@ void do_lua_thread(THREAD_DATA *thread_data) {
 	free(thread_data);
 }
 
+bool_t getcallcounter_1_svc(callcounter_t *argp, callcounter_t *result, struct svc_req *rqstp)
+{
+        bool_t retval;
+
+        /*
+         * insert server code here
+         */
+
+        unsigned long long incomingcalls = main_scenario->stats->GetStat(CStat::CPT_C_IncomingCallCreated);
+        unsigned long long outgoingcalls = main_scenario->stats->GetStat(CStat::CPT_C_OutgoingCallCreated);
+        unsigned long long successcalls = main_scenario->stats->GetStat(CStat::CPT_C_SuccessfulCall);
+        unsigned long long failurecalls = main_scenario->stats->GetStat(CStat::CPT_C_FailedCall);
+
+        result->incomingcalls=incomingcalls;
+        result->outgoingcalls=outgoingcalls;
+        result->successcalls=successcalls;
+        result->failurecalls=failurecalls;
+
+        retval = true;
+        return retval;
+}
+
+bool_t enablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+        bool_t retval;
+	extern bool log4auto_answer;
+        /*
+         * insert server code here
+         */
+
+        log4auto_answer=true;
+        retval = true;
+        return retval;
+}
+
+bool_t disablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+        bool_t retval;
+	extern bool log4auto_answer;
+
+        /*
+         * insert server code here
+         */
+
+        log4auto_answer=false;
+        retval = true;
+        return retval;
+}
+
+int sipprpcprog_1_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+        xdr_free (xdr_result, result);
+
+        /*
+         * Insert additional freeing code here, if needed
+         */
+
+        return 1;
+}
+void sipprpcprog_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+        union {
+                callcounter_t getcallcounter_1_arg;
+        } argument;
+        union {
+                callcounter_t getcallcounter_1_res;
+                bool_t enablelog4autoanswer_1_res;
+                bool_t disablelog4autoanswer_1_res;
+        } result;
+        bool_t retval;
+        xdrproc_t _xdr_argument, _xdr_result;
+        bool_t (*local)(char *, void *, struct svc_req *);
+
+        switch (rqstp->rq_proc) {
+        case NULLPROC:
+                (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+                return;
+
+        case GETCALLCOUNTER:
+                _xdr_argument = (xdrproc_t) xdr_callcounter_t;
+                _xdr_result = (xdrproc_t) xdr_callcounter_t;
+                local = (bool_t (*) (char *, void *,  struct svc_req *))getcallcounter_1_svc;
+                break;
+
+        case ENABLELOG4AUTOANSWER:
+                _xdr_argument = (xdrproc_t) xdr_void;
+                _xdr_result = (xdrproc_t) xdr_bool;
+                local = (bool_t (*) (char *, void *,  struct svc_req *))enablelog4autoanswer_1_svc;
+                break;
+
+        case DISABLELOG4AUTOANSWER:
+                _xdr_argument = (xdrproc_t) xdr_void;
+                _xdr_result = (xdrproc_t) xdr_bool;
+                local = (bool_t (*) (char *, void *,  struct svc_req *))disablelog4autoanswer_1_svc;
+                break;
+
+        default:
+                svcerr_noproc (transp);
+                return;
+        }
+        memset ((char *)&argument, 0, sizeof (argument));
+        if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+                svcerr_decode (transp);
+                return;
+        }
+        retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+        if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+                svcerr_systemerr (transp);
+        }
+        if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+                fprintf (stderr, "%s", "unable to free arguments");
+                exit (1);
+        }
+        if (!sipprpcprog_1_freeresult (transp, _xdr_result, (caddr_t) &result))
+                fprintf (stderr, "%s", "unable to free results");
+
+        return;
+}
+
+// Remote procedure calls thread
+void rpc_thread(void* param)
+{
+        register SVCXPRT *transp;
+        sigset_t              mask;
+        sigfillset(&mask); /* Mask all allowed signals */
+        int rc = pthread_sigmask(SIG_BLOCK, &mask, NULL);
+        if (rc) {
+            WARNING("pthread_sigmask returned %d", rc);
+            return;
+        }
+
+        pmap_unset (SIPPRPCPROG, SIPPRPCVERS);
+
+        transp = svcudp_create(RPC_ANYSOCK);
+        if (transp == NULL) {
+                fprintf (stderr, "%s", "cannot create udp service.");
+                exit(1);
+        }
+        if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_UDP)) {
+                fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
+                exit(1);
+        }
+
+        transp = svctcp_create(RPC_ANYSOCK, 0, 0);
+        if (transp == NULL) {
+                fprintf (stderr, "%s", "cannot create tcp service.");
+                exit(1);
+        }
+        if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_TCP)) {
+                fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
+                exit(1);
+        }
+
+        svc_run ();
+        fprintf (stderr, "%s", "svc_run returned");
+        pthread_exit(NULL); // 2/8/2022 - NVF Added
+        //exit (1);
+        /* NOTREACHED */
+}
+
+
 //
 // Replace various custom functions with our own
 //
@@ -495,15 +706,41 @@ extern "C" void appDllLoad(INT index)
 
 
     /* and/or by overriding default app event handler here */
-    setApiFunc(API_CUSTOM_FUNC_1, (API_FUNC)processLuaRun,"luarun",index);
-    setApiFunc(API_CUSTOM_FUNC_2, (API_FUNC)processLuaThread,"luathread",index);
-    setApiFunc(API_CUSTOM_FUNC_3, (API_FUNC)processLuaRead,"luaread",index);
+    setApiFunc(API_CUSTOM_FUNC_1, (API_FUNC)processLuaRun,(char *)"luarun",index);
+    setApiFunc(API_CUSTOM_FUNC_2, (API_FUNC)processLuaThread,(char *)"luathread",index);
+    setApiFunc(API_CUSTOM_FUNC_3, (API_FUNC)processLuaRead,(char *)"luaread",index);
 
 }
 
 // This hooks into the built-in plugin capability of sipp
 
-extern "C" int init(void *handle) {
+extern "C" int init(void *handle,int argc, char *argv[]) {
+
+	   // 2/9/2022 NVF This has to be above the SIGPIPE handler (added to support mysqlclient multithreaded): https://dev.mysql.com/doc/c-api/8.0/en/c-api-threaded-clients.html
+        if (mysql_library_init(0, NULL, NULL)) {
+                fprintf(stderr, "Warning: Could not initialize MySQL client library.  MySQL should not be used in a threaded call as a result\n");
+                exit(1);
+        }
+
+
+	curl_global_init(CURL_GLOBAL_DEFAULT);  // This is so we can use CURL inside our lua scripts in multi-threaded environments
+
+	// Enable the rpc thread
+    	if (pthread_create(&pthread4_id, NULL,
+            (void *(*)(void *)) rpc_thread, NULL) == -1) {
+                ERROR_NO("Unable to create video RTP echo thread");
+        }
+	// Get the name of the lua file
+	for (int i=0;i<argc;i++) {
+		if (strcmp(argv[i],"-lua_file")==0){
+			strcpy(lua_file,argv[i+1]);
+			break;
+		}
+	}
+
+
+	// Hook up the API's to run the lua scripts
+	//  
 	strcpy((char *)CustomApi[0].filename, "myapp.so");
 	CustomApi[0].instanceId = 1;
 	CustomApi[0].subsystem = 0;
@@ -515,3 +752,33 @@ extern "C" int init(void *handle) {
 	return  EXIT_SUCCESS;
 }
 
+extern "C" int handle_args(char *cmd, char *arg) {
+	fprintf(stderr,"Handling commands %s, arg = %s\n",cmd,arg);
+	if (strcmp(cmd,"-pid_file")==0) {
+		// Write a pid file
+
+        	FILE *f;
+		char pid_file[256];
+        	strcpy(pid_file, arg);
+		fprintf(stderr,"Storing pid at %s\n",pid_file);
+        	f = fopen(pid_file, "w");
+        	fprintf(f, "%d\n",getpid());
+        	fflush(f);
+        	fclose(f);
+	}
+
+	return  EXIT_SUCCESS;
+}
+
+extern "C" int app_shutdown(void *handle) {
+	fprintf(stderr,"App Shutdown\n");
+  	curl_global_cleanup();
+    	mysql_library_end(); // Required for mysql threaded support
+	// Cancel the rpc thread
+   	if (pthread4_id) {
+        	pthread_cancel(pthread4_id);
+        	pthread_join(pthread4_id, NULL);
+    	}
+
+	return  EXIT_SUCCESS;
+}
diff --git a/src/scenario.cpp b/src/scenario.cpp
index 1ef47393c..be39501ba 100644
--- a/src/scenario.cpp
+++ b/src/scenario.cpp
@@ -1008,9 +1008,11 @@ scenario::scenario(char * filename, int deflt)
 
     /* Close scenario element */
     xp_close_element();
-    if (xp_is_invalid()) {
+    /* 3/23/2022 - NVF Commented when trying to use the old xml_parser.c so our current SIPP scripts work!
+      if (xp_is_invalid()) {
         ERROR("Invalid XML in scenario");
     }
+    */
 
     str_int_map::iterator label_it = labelMap.find("_unexp.main");
     if (label_it != labelMap.end()) {
diff --git a/src/sipp.cpp b/src/sipp.cpp
index bc5feccf7..4233f2a01 100644
--- a/src/sipp.cpp
+++ b/src/sipp.cpp
@@ -58,6 +58,14 @@ extern char** environ;
 #include "config.h"
 #include "version.h"
 
+// Added for LUA support inside plugins - otherwise the requires won't work in lua scripts - this just causes liblua.so to be part of the sipp executable so lua functions are global to any .so loaded
+
+#ifdef USE_LUA
+#include "lua.hpp"
+lua_State *L = luaL_newstate();
+#endif
+
+
 extern SIPpSocket *ctrl_socket;
 extern SIPpSocket *stdin_socket;
 
@@ -114,6 +122,7 @@ struct sipp_option {
 #define SIPP_OPTION_LFOVERWRITE   37
 #define SIPP_OPTION_PLUGIN        38
 #define SIPP_OPTION_NEED_SCTP     39
+#define SIPP_OPTION_CUSTOM	  99
 #define SIPP_HELP_TEXT_HEADER    255
 
 /* Put each option, its help text, and type in this table. */
@@ -1271,6 +1280,77 @@ static void setup_media_sockets()
         media_port += 2;
     }
 }
+#define USE_OPENSSLX /* or USE_GNUTLS accordingly */
+
+/* we have this global to let the callback get easy access to it */
+static pthread_mutex_t *lockarray;
+
+#ifdef USE_OPENSSLX
+#include <openssl/crypto.h>
+static void lock_callback(int mode, int type, char *file, int line)
+{
+        (void)file;
+        (void)line;
+        if (mode & CRYPTO_LOCK) {
+                pthread_mutex_lock(&(lockarray[type]));
+        } else {
+                pthread_mutex_unlock(&(lockarray[type]));
+        }
+}
+
+static unsigned long thread_id(void)
+{
+        unsigned long ret;
+
+        ret = (unsigned long)pthread_self();
+        return (ret);
+}
+
+static void init_locks(void)
+{
+        int i;
+        struct logfile_info** logfile_ptr;
+        struct logfile_info* logfiles[] = {
+            &screen_lfi, &calldebug_lfi, &message_lfi, &shortmessage_lfi, &log_lfi, &error_lfi, NULL};
+
+        lockarray = (pthread_mutex_t *)OPENSSL_malloc(CRYPTO_num_locks() *
+                    sizeof(pthread_mutex_t));
+        for (i = 0; i < CRYPTO_num_locks(); i++) {
+                pthread_mutex_init(&(lockarray[i]), NULL);
+        }
+
+        CRYPTO_set_id_callback((unsigned long (*)())thread_id);
+        CRYPTO_set_locking_callback((void (*)(int, int, const char *, int))lock_callback);
+
+        /* Inite logfile mutexs. */
+        for (logfile_ptr = logfiles; *logfile_ptr; ++logfile_ptr) {
+            (*logfile_ptr)->lockfile = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+            pthread_mutex_init((*logfile_ptr)->lockfile, NULL);
+        }
+
+}
+
+static void kill_locks(void)
+{
+        int i;
+        struct logfile_info** logfile_ptr;
+        struct logfile_info* logfiles[] = {
+            &screen_lfi, &calldebug_lfi, &message_lfi, &shortmessage_lfi, &log_lfi, &error_lfi, NULL};
+
+        CRYPTO_set_locking_callback(NULL);
+        for (i = 0; i < CRYPTO_num_locks(); i++)
+                pthread_mutex_destroy(&(lockarray[i]));
+
+        OPENSSL_free(lockarray);
+
+        /* Inite logfile mutexs. */
+        for (logfile_ptr = logfiles; *logfile_ptr; ++logfile_ptr) {
+            (*logfile_ptr)->lockfile = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
+            pthread_mutex_destroy((*logfile_ptr)->lockfile);
+        }
+}
+#endif
+
 
 /* Main */
 int main(int argc, char *argv[])
@@ -1279,6 +1359,8 @@ int main(int argc, char *argv[])
     pthread_t pthread2_id = 0, pthread3_id = 0;
     unsigned int         generic_count = 0;
     bool                 slave_masterSet = false;
+    void* handle 	= NULL;  // Plugin handle
+    char *plugin_name	= NULL;  // Plugin name
 
     generic[0] = NULL;
 
@@ -1289,12 +1371,15 @@ int main(int argc, char *argv[])
     }
     {
         /* Ignore the SIGPIPE signal */
+	/* Moved this down so if we want to do a mysql_library_init or some other function that needs this handler it will be done later
         struct sigaction action_pipe;
         memset(&action_pipe, 0, sizeof(action_pipe));
         action_pipe.sa_handler=SIG_IGN;
         sigaction(SIGPIPE, &action_pipe, NULL);
+	*/
 
         /* The Window Size change Signal is also useless, and causes failures. */
+        struct sigaction action_pipe;
 #ifdef SIGWINCH
         sigaction(SIGWINCH, &action_pipe, NULL);
 #endif
@@ -1311,6 +1396,8 @@ int main(int argc, char *argv[])
         action_usr2.sa_handler = sipp_sigusr2;
         sigaction(SIGUSR2, &action_usr2, NULL);
     }
+    // Added pthread locks around the logs so these can be reused in a multithreaded environment in plugins etc.
+    init_locks();
 
     pid = getpid();
     memset(local_ip, 0, sizeof(local_ip));
@@ -1337,9 +1424,13 @@ int main(int argc, char *argv[])
                     strncpy(remote_host, argv[argi], sizeof(remote_host) - 1);
                     continue;
                 }
+		/* Commented this so we can let the plugin handle it if there is one
                 help();
                 ERROR("Invalid argument: '%s'.\n"
                       "Use 'sipp -h' for details", argv[argi]);
+	        */
+		struct sipp_option temp = {"custom_option", "Set the value for the custom option", SIPP_OPTION_CUSTOM, NULL, 1};
+		option = &temp;
             }
 
             switch(option->type) {
@@ -1814,13 +1905,14 @@ int main(int argc, char *argv[])
                 REQUIRE_ARG();
                 CHECK_PASS();
 
-                void* handle = dlopen(argv[argi], RTLD_NOW);
+                handle = dlopen(argv[argi], RTLD_NOW);
+		plugin_name = argv[argi];
                 if (!handle) {
                     ERROR("Could not open plugin %s: %s", argv[argi], dlerror());
                 }
 
-                int (*init)(void *);
-                init = (int (*)(void *))dlsym(handle, "init");
+                int (*init)(void *, int, char **);
+                init = (int (*)(void *,int, char **))dlsym(handle, "init");
                 //void* funcptr = dlsym(handle, "init");
                 /* http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c */
                 //*reinterpret_cast<void**>(&init)(void *) = funcptr; // yuck
@@ -1830,7 +1922,7 @@ int main(int argc, char *argv[])
                     ERROR("Could not locate init function in %s: %s", argv[argi], error);
                 }
 
-                ret = init(handle);
+                ret = init(handle,argc,argv);
                 if (ret != 0) {
                     ERROR("Plugin %s initialization failed.", argv[argi]);
                 }
@@ -1838,11 +1930,46 @@ int main(int argc, char *argv[])
             break;
 
             default:
-                ERROR("Internal error: I don't recognize the option type for %s", argv[argi]);
-            }
+	    	int ret;
+		if (option->pass == pass) {
+	    		if (plugin_name != NULL) {
+				if ((++argi) < argc) {
+                			int (*handle_args)(char *,char *);
+                			handle_args = (int (*)(char *, char *))dlsym(handle, "handle_args");
+                			const char* error;
+                			if ((error = dlerror())) {
+                    				ERROR("Could not locate arg_handling function in %s: %s", plugin_name, error);
+                			}
+		
+                			ret = handle_args(argv[argi-1],argv[argi]);
+                			if (ret != 0) {
+                    				ERROR("Plugin %s arg handling failed.", argv[argi]);
+                			}
+				} else {
+		 	  		ERROR("Missing argument for param '%s'.\n",  argv[argi - 1]);
+				}
+			} else {
+                		ERROR("Internal error: I don't recognize the option type for %s", argv[argi]);
+			}
+            	} else {
+			// Just skip it if we're not processing it
+			argi++;
+		}
+		break;
+	    }
         }
     }
 
+     {
+        /* Ignore the SIGPIPE signal */
+	/* 3/23/2022 Moved this down so if we want to do a mysql_library_init or some other function that needs this handler it will be done later */
+        struct sigaction action_pipe;
+        memset(&action_pipe, 0, sizeof(action_pipe));
+        action_pipe.sa_handler=SIG_IGN;
+        sigaction(SIGPIPE, &action_pipe, NULL);
+     }
+
+
     /* Load compression plugin if needed/available. */
     if (compression) {
         comp_load();
@@ -2120,4 +2247,21 @@ int main(int argc, char *argv[])
     free(scenario_file);
     free(scenario_path);
     sipp_exit(EXIT_TEST_RES_UNKNOWN);
+    kill_locks();
+    // Cleanup call to any plugin
+    if (plugin_name != NULL) {
+		int ret=0;
+                int (*app_shutdown)(void *);
+                app_shutdown = (int (*)(void *))dlsym(handle, "app_shutdown");
+                const char* error;
+                if ((error = dlerror())) {
+                        ERROR("Could not locate shutdown function in %s: %s", plugin_name, error);
+                }
+
+                ret = app_shutdown(handle);
+                if (ret != 0) {
+                        ERROR("Plugin %s shutdown failed.", argv[argi]);
+                }
+    }
+    
 }
diff --git a/src/xp_parser.c b/src/xp_parser.c
index 0c40d2315..2b91ad14c 100644
--- a/src/xp_parser.c
+++ b/src/xp_parser.c
@@ -48,56 +48,12 @@
 #define XP_MAX_FILE_LEN   65536
 #define XP_MAX_STACK_LEN  256
 
-static char  xp_file[XP_MAX_FILE_LEN + 1];
-static char *xp_position[XP_MAX_STACK_LEN];
-static int   xp_stack = 0;
-static int   xp_stack_invalid = 0;
-
-static char  xp_history[XP_MAX_FILE_LEN + 1];
-static char *xp_history_pos;
-#define xp_history_reset() do { \
-    xp_history[0] = xp_history[1] = '\0'; \
-    xp_history_pos = &xp_history[0]; \
-    } while(0)
-#define xp_history_push(n) do { \
-    strcpy(xp_history_pos + 1, n); \
-    xp_history_pos += strlen(n) + 1; \
-    /*xp_history_debug();*/ \
-    } while(0)
-#define xp_history_pop() do { \
-    while (xp_history_pos > xp_history && *--xp_history_pos != '\0'); \
-    /*xp_history_debug();*/ \
-    } while(0)
+char  xp_file     [XP_MAX_FILE_LEN + 1];
+char *xp_position [XP_MAX_STACK_LEN];
+int   xp_stack    = 0;
 
 /****************** Internal routines ********************/
 
-static const char *find_first_of(const char *ptr, const char *needles, const char *end) {
-    while (ptr < end) {
-        const char *q;
-        for (q = needles; *q; ++q) {
-            if (*ptr == *q) {
-                return ptr;
-            }
-        }
-        ++ptr;
-    }
-    return NULL;
-}
-
-static void extract_name(char *name, const char *ptr, const char **end) {
-    const char *p;
-    name[0] = '\0';
-    if (!*end || *end < ptr) {
-        return;
-    }
-    p = find_first_of(ptr, " \t\r\n/>", *end);
-    if (p) {
-        *end = p;
-    }
-    memcpy(name, ptr, *end - ptr);
-    name[*end - ptr] = '\0';
-}
-
 static const char *xp_find_escape(const char *escape, size_t len)
 {
     static struct escape {
@@ -119,20 +75,6 @@ static const char *xp_find_escape(const char *escape, size_t len)
     return NULL;
 }
 
-#if 0
-static void xp_history_debug() {
-    char *p = &xp_history[0];
-    fprintf(stderr, "DBG:");
-    for (;;) {
-        if (p >= xp_history_pos)
-            break;
-        fprintf(stderr, " %s", p + 1);
-        p += strlen(p + 1) + 1;
-    }
-    fprintf(stderr, "\n");
-}
-#endif
-
 /* This finds the end of something like <send foo="bar">, and does not recurse
  * into other elements. */
 static char *xp_find_start_tag_end(char *ptr)
@@ -280,8 +222,7 @@ int xp_set_xml_buffer_from_string(const char *str)
     }
 
     strcpy(xp_file, str);
-    xp_stack = xp_stack_invalid = 0;
-    xp_history_reset();
+    xp_stack = 0;
     xp_position[xp_stack] = xp_file;
 
     if (!strstartswith(xp_position[xp_stack], "<?xml"))
@@ -310,8 +251,7 @@ int xp_set_xml_buffer_from_file(const char *filename)
         xp_file[index++] = c;
         if (index >= XP_MAX_FILE_LEN) {
             xp_file[index++] = 0;
-            xp_stack = xp_stack_invalid = 0;
-            xp_history_reset();
+            xp_stack = 0;
             xp_position[xp_stack] = xp_file;
             fclose(f);
             return 0;
@@ -320,8 +260,7 @@ int xp_set_xml_buffer_from_file(const char *filename)
     xp_file[index++] = 0;
     fclose(f);
 
-    xp_stack = xp_stack_invalid = 0;
-    xp_history_reset();
+    xp_stack = 0;
     xp_position[xp_stack] = xp_file;
 
     if (!strstartswith(xp_position[xp_stack], "<?xml"))
@@ -337,13 +276,8 @@ char *xp_open_element(int index)
 {
     char *ptr = xp_position[xp_stack];
     int level = 0;
-    int index_left = index;
     static char name[XP_MAX_NAME_LEN];
 
-    if (index > 0) {
-        xp_history_pop();
-    }
-
     while (*ptr) {
         if (*ptr == '<') {
             if ((*(ptr+1) == '!') &&
@@ -365,86 +299,74 @@ char *xp_open_element(int index)
                 if (!doctype_end)
                     return NULL;
                 ptr = doctype_end;
-            } else if (strstartswith(ptr, "<?xml-model")) {
-                char *xmlmodel_end = strstr(ptr, ">");
-                if (!xmlmodel_end)
-                    return NULL;
-                ptr = xmlmodel_end;
             } else if (*(ptr+1) == '/') {
-                char *end = xp_find_start_tag_end(ptr + 2);
-                if (!end) {
-                    return NULL;
-                }
-                extract_name(name, ptr + 2, (const char**)&end);
-
                 level--;
                 if (level < 0)
                     return NULL;
-
-                xp_history_pop();
-                if (strcmp(xp_history_pos + 1, name) && !xp_stack_invalid) {
-                    xp_stack_invalid = 1;
-                    fprintf(stderr, "Unexpected </%s> (expected </%s>)\n",
-                        name, xp_history_pos + 1);
-                }
             } else {
-                char *end = xp_find_start_tag_end(ptr + 1);
-                if (!end) {
-                    return NULL;
-                }
-                extract_name(name, ptr + 1, (const char**)&end);
-                xp_history_push(name);
-
                 if (level == 0) {
-                    if (index_left) {
-                        index_left--;
+                    if (index) {
+                        index--;
                     } else {
+                        char *end = xp_find_start_tag_end(ptr + 1);
+                        char *p;
+                        if (!end) {
+                            return NULL;
+                        }
+                        p = strchr(ptr, ' ');
+                        if (p && (p < end))  {
+                            end = p;
+                        }
+                        p = strchr(ptr, '\t');
+                        if (p && (p < end))  {
+                            end = p;
+                        }
+                        p = strchr(ptr, '\r');
+                        if (p && (p < end))  {
+                            end = p;
+                        }
+                        p = strchr(ptr, '\n');
+                        if (p && (p < end))  {
+                            end = p;
+                        }
+                        p = strchr(ptr, '/');
+                        if (p && (p < end))  {
+                            end = p;
+                        }
+
+                        memcpy(name, ptr + 1, end-ptr-1);
+                        name[end-ptr-1] = 0;
+
                         xp_position[++xp_stack] = end;
                         return name;
                     }
                 }
 
                 /* We want to skip over this particular element .*/
-                ptr = end - 1;
+                ptr = xp_find_start_tag_end(ptr + 1);
+                if (!ptr)
+                    return NULL;
+                ptr--;
                 level++;
             }
         } else if ((*ptr == '/') && (*(ptr+1) == '>')) {
             level--;
             if (level < 0)
                 return NULL;
-            xp_history_pop();
         }
         ptr++;
     }
     return NULL;
 }
 
-void xp_close_element()
-{
-    if (!xp_stack) {
-        xp_stack_invalid = 1;
-        return;
-    }
-    xp_stack--;
-}
-
-int xp_is_invalid(void)
+void xp_close_element(void)
 {
-    const char *elem;
-    if (xp_stack_invalid) {
-        return 1;
-    }
     if (xp_stack) {
-        return 1;
-    }
-    if ((elem = xp_open_element(1))) { /* anything after <scenario>? */
-        xp_close_element();
-        return 1;
+        xp_stack--;
     }
-    return 0;
 }
 
-const char *xp_get_value(const char *name)
+char *xp_get_value(const char *name)
 {
     int index = 0;
     static char buffer[XP_MAX_FILE_LEN + 1];

From 4b43f92e8e4dab2ef1b10a06666a790964846702 Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan.franzmeier@sky-networks.com>
Date: Mon, 28 Mar 2022 21:59:05 +0000
Subject: [PATCH 7/9] 1. Added a demo lua script and uas xml file to show how
 to use a plugin 2. Added a README for some brief instructions

---
 README_DEMO_PLUGIN.md |  15 ++++
 docs/sipp_demo.sh     |  75 +++++++++++++++++
 docs/uas_w_script.xml | 182 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 272 insertions(+)
 create mode 100644 README_DEMO_PLUGIN.md
 create mode 100755 docs/sipp_demo.sh
 create mode 100644 docs/uas_w_script.xml

diff --git a/README_DEMO_PLUGIN.md b/README_DEMO_PLUGIN.md
new file mode 100644
index 000000000..4f4bd40f5
--- /dev/null
+++ b/README_DEMO_PLUGIN.md
@@ -0,0 +1,15 @@
+A demo of the plugin functionality of sipp with a simple lua script can be found in the docs directory.
+1. sipp_demo.sh - this will executing uas_w_script.xml
+2. uas_w_script.xml
+
+Just send a call to it to see it utlize a plugin
+
+To create and use the plugin - 
+1. enable LUA and then build sipp with whatever other options you want to use.
+example:
+cmake . -DCMAKE_BUILD_TYPE=Debug -DUSE_GSL=0 -DUSE_SSL=1 -DUSE_SCTP=0 -DUSE_PCAP=0 -DUSE_LUA=1
+2. Use the -plugin option to specify the location of your plugin.  There is a demo plugin in myapp.cpp which can be used the create libmyapp.so
+3. The demo plugin adds functionality to interpret the new sipp flags -lua_file and -pid to record the pid of the file and to specify which lua script will be used 
+4. The xml to call the lua script and retrieve values can be found in the xml file uas_w_script.xml
+
+
diff --git a/docs/sipp_demo.sh b/docs/sipp_demo.sh
new file mode 100755
index 000000000..35d430eaf
--- /dev/null
+++ b/docs/sipp_demo.sh
@@ -0,0 +1,75 @@
+#!/bin/bash
+#
+# sipp remote_host[:remote_port] [options]
+# 
+# - m <n> 	   : Stop the call after n calls are processed
+# -r               : Set the call rate (in calls per seconds). 
+# -l               : Set the maximum number of simultaneous calls. Once this
+#                      limit is reached, traffic is decreased until the number
+#                      of open calls goes down. Default:
+#                        (3 * call_duration (s) * rate).
+# -p               : Set the local port number.
+# -s               : Set the username part of the resquest URI. Default is
+#                       'service'.
+# -sf              : Loads an alternate xml scenario file.  To learn more
+#                       about XML scenario syntax, use the -sd option to dump
+#                       embedded scenarios. They contain all the necessary help.
+# -inf             : Inject values from an external CSV file during calls into
+#                      the scenarios.
+#                      First line of this file say whether the data is to be
+#                      read in sequence (SEQUENTIAL), random (RANDOM), or user
+#                      (USER) order.
+#                      Each line corresponds to one call and has one or more
+#                      ';' delimited data fields. Those fields can be referred
+#                      as [field0], [field1], ... in the xml scenario file.
+#                      Several CSV files can be used simultaneously (syntax:
+#                      -inf f1.csv -inf f2.csv ...)
+#-nd              : No Default. Disable all default behavior of SIPp which
+#                      are the following:
+#                      - On UDP retransmission timeout, abort the call by
+#                        sending a BYE or a CANCEL
+#                      - On receive timeout with no ontimeout attribute, abort
+#                        the call by sending a BYE or a CANCEL
+#                      - On unexpected BYE send a 200 OK and close the call
+#                      - On unexpected CANCEL send a 200 OK and close the call
+#                      - On unexpected PING send a 200 OK and continue the call
+#                      - On any other unexpected message, abort the call by
+#                        sending a BYE or a CANCEL
+#
+#-rp              : Specify the rate period for the call rate.  Default is 1
+#                      second and default unit is milliseconds.  This allows
+#                      you to have n calls every m milliseconds (by using -r n
+#                      -rp m).
+#                      Example: -r 7 -rp 2000 ==> 7 calls every 2 seconds.
+#                               -r 10 -rp 5s => 10 calls every 5 seconds.
+# -aa              : Enable automatic 200 OK answer for INFO, UPDATE and NOTIFY messages.
+#
+#
+
+
+
+
+ulimit -n 65533
+# These should be set in the environment
+LOGDIR=./
+REMOTEHOST=172.29.31.14
+LOCALIP=172.20.2.35
+
+pidfile="$RUNDIR/sipp.pid"
+logfiles="-ringbuffer_files 1000 -ringbuffer_size 50000000 -trace_msg -trace_logs -trace_err -message_file $LOGDIR/sipp_message.log  -message_overwrite false -error_file $LOGDIR/sipp_error.log -error_overwrite false -calldebug_file $LOGDIR/sipp_debug.log -calldebug_overwrite false -log_file $LOGDIR/sipp.log -log_overwrite false "
+
+remotehost=$REMOTEHOST
+username=demo
+srchost=$LOCALIP
+srcport=5060
+
+if [ $# -eq 1 ] && [ $1 = "stop" ]
+then
+/bin/cat $pidfile | xargs kill -9
+exit
+fi
+
+#
+# Execute with custom script
+#
+sipp  -plugin libmyapp.so -lua_file sipp_demo.lua -pid_file $pidfile -aa  $logfiles -m 1000000 -l 1 -i $srchost -p $srcport -s $username -nd -sf ./uas_w_script.xml $remotehost 
diff --git a/docs/uas_w_script.xml b/docs/uas_w_script.xml
new file mode 100644
index 000000000..e180b6251
--- /dev/null
+++ b/docs/uas_w_script.xml
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE scenario SYSTEM "sipp.dtd">
+
+<!-- This program is free software; you can redistribute it and/or      -->
+<!-- modify it under the terms of the GNU General Public License as     -->
+<!-- published by the Free Software Foundation; either version 2 of the -->
+<!-- License, or (at your option) any later version.                    -->
+<!--                                                                    -->
+<!-- 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  -->
+<!-- along with this program; if not, write to the                      -->
+<!-- Free Software Foundation, Inc.,                                    -->
+<!-- 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA             -->
+<!--                                                                    -->
+<!--                 Sipp default 'uas' scenario.                       -->
+<!--                                                                    -->
+
+<scenario name="Basic UAS responder">
+  <!-- By adding rrs="true" (Record Route Sets), the route sets         -->
+  <!-- are saved and used for following messages sent. Useful to test   -->
+  <!-- against stateful SIP proxies/B2BUAs.                             -->
+  <!-- Adding ignoresdp="true" here would ignore the SDP data: that     -->
+  <!-- can be useful if you want to reject reINVITEs and keep the       -->
+  <!-- media stream flowing.                                            -->
+  <recv request="INVITE" crlf="true">
+	   <action>
+         <ereg regexp="sip:[+1]*(.*?)\@([0123456789.a-zA-Z]*)" search_in="hdr" header="To:" assign_to="1,2,3" />
+         <log message="To Match on [$1] - User is [$2] Domain is [$3] "/>
+         <ereg regexp="sip:[+1]*([0-9a-zA-Z]*)?\@([0-9.a-zA-Z]*)" search_in="hdr" header="From:" assign_to="4,5,6" />
+         <log message="From Match on [$4] - User is [$5] Domain is [$6] "/>
+	</action>
+
+  </recv>
+
+  <!-- The '[last_*]' keyword is replaced automatically by the          -->
+  <!-- specified header if it was present in the last message received  -->
+  <!-- (except if it was a retransmission). If the header was not       -->
+  <!-- present or if no message has been received, the '[last_*]'       -->
+  <!-- keyword is discarded, and all bytes until the end of the line    -->
+  <!-- are also discarded.                                              -->
+  <!--                                                                  -->
+  <!-- If the specified header was present several times in the         -->
+  <!-- message, all occurrences are concatenated (CRLF separated)       -->
+  <!-- to be used in place of the '[last_*]' keyword.                   -->
+
+  <send>
+    <![CDATA[
+
+      SIP/2.0 180 Ringing
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Length: 0
+
+    ]]>
+      <action>
+        <assignstr assign_to="calling" value=""/>
+        <assignstr assign_to="called" value=""/>
+        <assignstr assign_to="msgDone" value="0"/>
+        <assignstr assign_to="counter" value="0"/>
+	<log message="executing lua function my_lua_func calling [$5] called [$2]" />
+	<exec command="luathread@my_lua_func calling [$5] called [$2] msgDone 0" />
+        <log  message="retkey [$retkey] calling = [$calling] called = [$called]"/>
+    </action>
+
+  </send>
+
+
+  <!-- Do a loop looking for the data to be done -->
+
+ <label id="start_of_loop"/>
+    <pause milliseconds="100" />
+    <!-- retrieve our variables back from our previous read -->
+    <nop>
+             <action>
+                <log message="luaread@[$retkey] 0" />
+                <exec command="luaread@[$retkey] 0" />
+                <strcmp assign_to="result" variable="msgDone" value="0" />
+                <log message="result for msgDone  check = [$msgDone]"/>
+                <!-- <log  message="retkey = [$retkey] calling = [$calling] called = [$called]"/> -->
+             </action>
+   </nop>
+
+  <!-- When we're done processing jump to finished else keep looping -->
+  <nop next="finished" test="result"/>
+
+  <!-- Increment the counter and continue looping up to 10 times-->
+  <nop>
+    <action>
+      <add assign_to="counter" value="1"/>
+      <test assign_to="flag_limit" variable="counter"
+                compare="greater_than_equal" value="100"/>
+        <log message="flag_limit=([$flag_limit])" />
+    </action>
+  </nop>
+
+  <nop next="finished" test="flag_limit" />
+
+  <nop next="start_of_loop"/>
+
+ <label id="finished" />
+
+    <nop>
+        <action>
+                <!-- Delete the shared memory because we're done -->
+                <log message="finished!" />
+                <log message="luaread@[$retkey] 1" />
+                <exec command="luaread@[$retkey] 1" />
+        </action>
+  </nop>
+
+  <!-- Send the answer with a translated called number in a custom header -->
+
+  <send retrans="500">
+    <![CDATA[
+
+      SIP/2.0 200 OK
+      [last_Via:]
+      [last_From:]
+      [last_To:];tag=[pid]SIPpTag01[call_number]
+      [last_Call-ID:]
+      [last_CSeq:]
+      X-Translated-Called: [$called]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Type: application/sdp
+      Content-Length: [len]
+
+      v=0
+      o=user1 53655765 2353687637 IN IP[local_ip_type] [local_ip]
+      s=-
+      c=IN IP[media_ip_type] [media_ip]
+      t=0 0
+      m=audio [media_port] RTP/AVP 0
+      a=rtpmap:0 PCMU/8000
+
+    ]]>
+  </send>
+
+  <recv request="ACK"
+        optional="true"
+        rtd="true"
+        crlf="true">
+  </recv>
+
+  <recv request="BYE">
+  </recv>
+
+  <send>
+    <![CDATA[
+
+      SIP/2.0 200 OK
+      [last_Via:]
+      [last_From:]
+      [last_To:]
+      [last_Call-ID:]
+      [last_CSeq:]
+      Contact: <sip:[local_ip]:[local_port];transport=[transport]>
+      Content-Length: 0
+
+    ]]>
+  </send>
+
+  <!-- Keep the call open for a while in case the 200 is lost to be     -->
+  <!-- able to retransmit it if we receive the BYE again.               -->
+  <timewait milliseconds="4000"/>
+
+
+  <!-- definition of the response time repartition table (unit is ms)   -->
+  <ResponseTimeRepartition value="10, 20, 30, 40, 50, 100, 150, 200"/>
+
+  <!-- definition of the call length repartition table (unit is ms)     -->
+  <CallLengthRepartition value="10, 50, 100, 500, 1000, 5000, 10000"/>
+
+</scenario>
+

From 5a0007ab427345cd034780fd088d78daf9232cd3 Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan.franzmeier@sky-networks.com>
Date: Tue, 29 Mar 2022 17:13:03 +0000
Subject: [PATCH 8/9] 1. Moved the init function to after the fork so
 backgrounding doesn't affect any threads started in the plugin 2. Changes
 some fprintf stderr's to ERROR messages in myapp.cpp

---
 src/myapp.cpp | 10 +++++-----
 src/sipp.cpp  | 46 ++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/src/myapp.cpp b/src/myapp.cpp
index 77d9b05d8..c42d98f7f 100644
--- a/src/myapp.cpp
+++ b/src/myapp.cpp
@@ -674,22 +674,22 @@ void rpc_thread(void* param)
                 exit(1);
         }
         if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_UDP)) {
-                fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
+                ERROR( "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
                 exit(1);
         }
 
         transp = svctcp_create(RPC_ANYSOCK, 0, 0);
         if (transp == NULL) {
-                fprintf (stderr, "%s", "cannot create tcp service.");
+               ERROR( "%s", "cannot create tcp service.");
                 exit(1);
         }
         if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_TCP)) {
-                fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
+                ERROR( "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
                 exit(1);
         }
 
         svc_run ();
-        fprintf (stderr, "%s", "svc_run returned");
+        ERROR( "rpc_thread svc_run returned\n");
         pthread_exit(NULL); // 2/8/2022 - NVF Added
         //exit (1);
         /* NOTREACHED */
@@ -728,7 +728,7 @@ extern "C" int init(void *handle,int argc, char *argv[]) {
 	// Enable the rpc thread
     	if (pthread_create(&pthread4_id, NULL,
             (void *(*)(void *)) rpc_thread, NULL) == -1) {
-                ERROR_NO("Unable to create video RTP echo thread");
+                ERROR_NO("Unable to create rpc thread");
         }
 	// Get the name of the lua file
 	for (int i=0;i<argc;i++) {
diff --git a/src/sipp.cpp b/src/sipp.cpp
index 4233f2a01..007aa19f4 100644
--- a/src/sipp.cpp
+++ b/src/sipp.cpp
@@ -1361,6 +1361,8 @@ int main(int argc, char *argv[])
     bool                 slave_masterSet = false;
     void* handle 	= NULL;  // Plugin handle
     char *plugin_name	= NULL;  // Plugin name
+    int (*init)(void *, int, char **); // Plugin init function
+    bool                 plugin_enabled = false;
 
     generic[0] = NULL;
 
@@ -1416,6 +1418,34 @@ int main(int argc, char *argv[])
     ERROR("Missing argument for param '%s'.\nUse 'sipp -h' for details",  argv[argi - 1]); }
 #define CHECK_PASS() if (option->pass != pass) { break; }
 
+    /* checking if we need to launch the tool in background mode */
+    if (backgroundMode == true) {
+        pid_t l_pid;
+        switch (l_pid = fork()) {
+        case -1:
+            // error when forking !
+            ERROR_NO("Forking error");
+            exit(EXIT_FATAL_ERROR);
+        case 0:
+            // child process - poursuing the execution
+            // close all of our file descriptors
+        {
+            int nullfd = open("/dev/null", O_RDWR);
+
+            dup2(nullfd, fileno(stdin));
+            dup2(nullfd, fileno(stdout));
+            dup2(nullfd, fileno(stderr));
+
+            close(nullfd);
+        }
+        break;
+        default:
+            // parent process - killing the parent - the child get the parent pid
+            printf("Background mode - PID=[%ld]\n", (long) l_pid);
+            exit(EXIT_OTHER);
+        }
+    }
+
     for (int pass = 0; pass <= 3; pass++) {
         for(argi = 1; argi < argc; argi++) {
             struct sipp_option *option = find_option(argv[argi]);
@@ -1910,22 +1940,22 @@ int main(int argc, char *argv[])
                 if (!handle) {
                     ERROR("Could not open plugin %s: %s", argv[argi], dlerror());
                 }
-
-                int (*init)(void *, int, char **);
-                init = (int (*)(void *,int, char **))dlsym(handle, "init");
                 //void* funcptr = dlsym(handle, "init");
                 /* http://stackoverflow.com/questions/1096341/function-pointers-casting-in-c */
                 //*reinterpret_cast<void**>(&init)(void *) = funcptr; // yuck
-
+                init = (int (*)(void *,int, char **))dlsym(handle, "init");
                 const char* error;
                 if ((error = dlerror())) {
                     ERROR("Could not locate init function in %s: %s", argv[argi], error);
                 }
+		plugin_enabled = true;
+#if 0		// Moved this to after the fork so everything will still work even if we start threads in the plugin
 
                 ret = init(handle,argc,argv);
                 if (ret != 0) {
                     ERROR("Plugin %s initialization failed.", argv[argi]);
                 }
+#endif
             }
             break;
 
@@ -2167,6 +2197,14 @@ int main(int argc, char *argv[])
             exit(EXIT_OTHER);
         }
     }
+    // Run the plugin from in the child - did this so any threads we run will stay running after backgrounding
+    if (plugin_enabled) {
+                int ret;
+                ret = init(handle,argc,argv);
+                if (ret != 0) {
+                    ERROR("Plugin %s initialization failed.", plugin_name);
+                }
+    }
 
     sipp_usleep(sleeptime * 1000);
 

From ff45d77b12b7689fd0614f289f413b28ab55e59f Mon Sep 17 00:00:00 2001
From: nfranzmeier <nathan.franzmeier@sky-networks.com>
Date: Fri, 8 Apr 2022 20:54:10 +0000
Subject: [PATCH 9/9] 1. Added the capability to override the automatic
 handling of messages so sipp can be customized more 2. Added an example to
 match the rpc code in myapp.cpp so rpc commands can be exercised from the
 command line to get call stats and set logging options

---
 example/rpc/Makefile.sipp-rpc     |  47 +++++++
 example/rpc/readme.txt            |  13 ++
 example/rpc/sipp-rpc.h            |  72 ++++++++++
 example/rpc/sipp-rpc.x            |  19 +++
 example/rpc/sipp-rpc_client.c     |  84 ++++++++++++
 example/rpc/sipp-rpc_client.c.bak |  84 ++++++++++++
 example/rpc/sipp-rpc_clnt.c       |  37 ++++++
 example/rpc/sipp-rpc_server.c     |  55 ++++++++
 example/rpc/sipp-rpc_server.c.bak |  55 ++++++++
 example/rpc/sipp-rpc_svc.c        | 111 ++++++++++++++++
 example/rpc/sipp-rpc_xdr.c        |  71 ++++++++++
 include/call.hpp                  |  41 +++++-
 include/sipp-rpc.h                |   6 +-
 include/sipp.hpp                  |   1 +
 src/call.cpp                      |  21 ++-
 src/myapp.cpp                     | 212 +++++++++++++++++++++++++++++-
 src/sipp.cpp                      |   4 +-
 17 files changed, 925 insertions(+), 8 deletions(-)
 create mode 100644 example/rpc/Makefile.sipp-rpc
 create mode 100644 example/rpc/readme.txt
 create mode 100644 example/rpc/sipp-rpc.h
 create mode 100644 example/rpc/sipp-rpc.x
 create mode 100644 example/rpc/sipp-rpc_client.c
 create mode 100644 example/rpc/sipp-rpc_client.c.bak
 create mode 100644 example/rpc/sipp-rpc_clnt.c
 create mode 100644 example/rpc/sipp-rpc_server.c
 create mode 100644 example/rpc/sipp-rpc_server.c.bak
 create mode 100644 example/rpc/sipp-rpc_svc.c
 create mode 100644 example/rpc/sipp-rpc_xdr.c

diff --git a/example/rpc/Makefile.sipp-rpc b/example/rpc/Makefile.sipp-rpc
new file mode 100644
index 000000000..99f628bf0
--- /dev/null
+++ b/example/rpc/Makefile.sipp-rpc
@@ -0,0 +1,47 @@
+
+# This is a template Makefile generated by rpcgen
+
+# Parameters
+
+CLIENT = sipp-rpc_client
+SERVER = sipp-rpc_server
+
+SOURCES_CLNT.c = 
+SOURCES_CLNT.h = 
+SOURCES_SVC.c = 
+SOURCES_SVC.h = 
+SOURCES.x = sipp-rpc.x
+
+TARGETS_SVC.c = sipp-rpc_svc.c sipp-rpc_server.c sipp-rpc_xdr.c 
+TARGETS_CLNT.c = sipp-rpc_clnt.c sipp-rpc_client.c sipp-rpc_xdr.c 
+TARGETS = sipp-rpc.h sipp-rpc_xdr.c sipp-rpc_clnt.c sipp-rpc_svc.c sipp-rpc_client.c sipp-rpc_server.c
+
+OBJECTS_CLNT = $(SOURCES_CLNT.c:%.c=%.o) $(TARGETS_CLNT.c:%.c=%.o)
+OBJECTS_SVC = $(SOURCES_SVC.c:%.c=%.o) $(TARGETS_SVC.c:%.c=%.o)
+# Compiler flags 
+
+CPPFLAGS += -D_REENTRANT
+CFLAGS += -g 
+LDLIBS += -lnsl -lpthread 
+ RPCGENFLAGS = 
+
+# Targets 
+
+all : $(CLIENT) $(SERVER)
+
+$(TARGETS) : $(SOURCES.x) 
+	rpcgen $(RPCGENFLAGS) $(SOURCES.x)
+
+$(OBJECTS_CLNT) : $(SOURCES_CLNT.c) $(SOURCES_CLNT.h) $(TARGETS_CLNT.c) 
+
+$(OBJECTS_SVC) : $(SOURCES_SVC.c) $(SOURCES_SVC.h) $(TARGETS_SVC.c) 
+
+$(CLIENT) : $(OBJECTS_CLNT) 
+	$(LINK.c) -o $(CLIENT) $(OBJECTS_CLNT) $(LDLIBS) 
+
+$(SERVER) : $(OBJECTS_SVC) 
+	$(LINK.c) -o $(SERVER) $(OBJECTS_SVC) $(LDLIBS)
+
+ clean:
+	 $(RM) core $(TARGETS) $(OBJECTS_CLNT) $(OBJECTS_SVC) $(CLIENT) $(SERVER)
+
diff --git a/example/rpc/readme.txt b/example/rpc/readme.txt
new file mode 100644
index 000000000..383110680
--- /dev/null
+++ b/example/rpc/readme.txt
@@ -0,0 +1,13 @@
+################################################################
+#Instructions to build rpc interface
+#you will need the client sa_ctl to send rpc commands to sipp
+#Example: sa_ctl get_callcount will get the current call count
+#
+Steps to regenerate the files:: 
+0. Make a new .x file with whatever commands you're trying to implement
+1. Install the portmap service which is required for rpc services - apt-get install portmap
+2. Start clean -  make clean
+3. Backup any mods you might have made - cp sipp-rpc_client.c sipp-rpc_client.c.bak
+4. Regenerate a new raw client  - rpcgen -M -C -a sipp-rpc.x
+5. Restore your old mods, or modify the client as needed - cp sipp-rpc_client.c.bak sipp-rpc_client.c
+6. Build it - make - this will build a client and server for testing or use the client to try your new commands out on a compatible server process - like sipp!
diff --git a/example/rpc/sipp-rpc.h b/example/rpc/sipp-rpc.h
new file mode 100644
index 000000000..ac29fdbda
--- /dev/null
+++ b/example/rpc/sipp-rpc.h
@@ -0,0 +1,72 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#ifndef _SIPP-RPC_H_RPCGEN
+#define _SIPP-RPC_H_RPCGEN
+
+#include <rpc/rpc.h>
+
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct callcounter {
+	int incomingcalls;
+	int outgoingcalls;
+	int successcalls;
+	int failurecalls;
+};
+typedef struct callcounter callcounter;
+
+typedef callcounter callcounter_t;
+
+#define SIPPRPCPROG 0x20000002
+#define SIPPRPCVERS 1
+
+#if defined(__STDC__) || defined(__cplusplus)
+#define GETCALLCOUNTER 1
+extern  enum clnt_stat getcallcounter_1(callcounter_t *, callcounter_t *, CLIENT *);
+extern  bool_t getcallcounter_1_svc(callcounter_t *, callcounter_t *, struct svc_req *);
+#define ENABLELOG4AUTOANSWER 2
+extern  enum clnt_stat enablelog4autoanswer_1(void *, bool_t *, CLIENT *);
+extern  bool_t enablelog4autoanswer_1_svc(void *, bool_t *, struct svc_req *);
+#define DISABLELOG4AUTOANSWER 3
+extern  enum clnt_stat disablelog4autoanswer_1(void *, bool_t *, CLIENT *);
+extern  bool_t disablelog4autoanswer_1_svc(void *, bool_t *, struct svc_req *);
+extern int sipprpcprog_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
+
+#else /* K&R C */
+#define GETCALLCOUNTER 1
+extern  enum clnt_stat getcallcounter_1();
+extern  bool_t getcallcounter_1_svc();
+#define ENABLELOG4AUTOANSWER 2
+extern  enum clnt_stat enablelog4autoanswer_1();
+extern  bool_t enablelog4autoanswer_1_svc();
+#define DISABLELOG4AUTOANSWER 3
+extern  enum clnt_stat disablelog4autoanswer_1();
+extern  bool_t disablelog4autoanswer_1_svc();
+extern int sipprpcprog_1_freeresult ();
+#endif /* K&R C */
+
+/* the xdr functions */
+
+#if defined(__STDC__) || defined(__cplusplus)
+extern  bool_t xdr_callcounter (XDR *, callcounter*);
+extern  bool_t xdr_callcounter_t (XDR *, callcounter_t*);
+
+#else /* K&R C */
+extern bool_t xdr_callcounter ();
+extern bool_t xdr_callcounter_t ();
+
+#endif /* K&R C */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_SIPP-RPC_H_RPCGEN */
diff --git a/example/rpc/sipp-rpc.x b/example/rpc/sipp-rpc.x
new file mode 100644
index 000000000..396bf9972
--- /dev/null
+++ b/example/rpc/sipp-rpc.x
@@ -0,0 +1,19 @@
+struct callcounter
+{
+    int      incomingcalls;
+    int      outgoingcalls;
+    int      successcalls;
+    int      failurecalls;
+};
+
+typedef struct callcounter callcounter_t;
+
+program SIPPRPCPROG
+{
+    version SIPPRPCVERS
+        {
+            callcounter_t GETCALLCOUNTER(callcounter_t)    = 1;
+            bool ENABLELOG4AUTOANSWER()    = 2;
+            bool DISABLELOG4AUTOANSWER()    = 3;
+        } = 1;
+} = 0x20000002;
diff --git a/example/rpc/sipp-rpc_client.c b/example/rpc/sipp-rpc_client.c
new file mode 100644
index 000000000..284af95bd
--- /dev/null
+++ b/example/rpc/sipp-rpc_client.c
@@ -0,0 +1,84 @@
+/*
+ * This is sample code generated by rpcgen.
+ * These are only templates and you can use them
+ * as a guideline for developing your own functions.
+ */
+
+#include "sipp-rpc.h"
+
+
+void
+sipprpcprog_1(char *command)
+{
+	char *host = "127.0.0.1";
+	CLIENT *clnt;
+	enum clnt_stat retval_1;
+	callcounter_t result_1;
+	callcounter_t  getcallcounter_1_arg;
+	enum clnt_stat retval_2;
+	bool_t result_2;
+	char *enablelog4autoanswer_1_arg;
+	enum clnt_stat retval_3;
+	bool_t result_3;
+	char *disablelog4autoanswer_1_arg;
+
+#ifndef	DEBUG
+	clnt = clnt_create (host, SIPPRPCPROG, SIPPRPCVERS, "udp");
+	if (clnt == NULL) {
+		clnt_pcreateerror (host);
+		exit (1);
+	}
+#endif	/* DEBUG */
+
+	if (strcmp(command,"get_callcount") ==0 ) {
+		retval_1 = getcallcounter_1(&getcallcounter_1_arg, &result_1, clnt);
+		if (retval_1 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Total incoming calls: %d\n",result_1.incomingcalls);
+			printf("Total outgoing calls: %d\n",result_1.outgoingcalls);
+			printf("Total success calls: %d\n",result_1.successcalls);
+			printf("Total failure calls: %d\n",result_1.failurecalls);
+		}
+	}
+	if (strcmp(command,"enable_log4aa") ==0 ) {
+		retval_2 = enablelog4autoanswer_1((void*)&enablelog4autoanswer_1_arg, &result_2, clnt);
+		if (retval_2 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Error log for auto response enabled.\n");
+		}
+	}
+	if (strcmp(command,"disable_log4aa") ==0 ) {
+		retval_3 = disablelog4autoanswer_1((void*)&disablelog4autoanswer_1_arg, &result_3, clnt);
+		if (retval_3 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Error log for auto response disabled.\n");
+		}
+	}
+#ifndef	DEBUG
+	clnt_destroy (clnt);
+#endif	 /* DEBUG */
+}
+
+
+int
+main (int argc, char *argv[])
+{
+	char *command;
+
+	if (argc < 2) {
+		printf ("usage: %s [get_callcount|enable_log4aa|disable_log4aa]\n", argv[0]);
+		exit (1);
+	}
+	command = argv[1];
+	if (strcmp(command,"get_callcount") != 0 &&
+	    strcmp(command,"enable_log4aa") != 0 &&
+	    strcmp(command,"disable_log4aa") != 0 ) {
+		printf ("usage: %s [get_callcount|enable_log4aa|disable_log4aa]\n", argv[0]);
+		exit (1);
+	}
+	sipprpcprog_1 (command);
+exit (0);
+}
diff --git a/example/rpc/sipp-rpc_client.c.bak b/example/rpc/sipp-rpc_client.c.bak
new file mode 100644
index 000000000..284af95bd
--- /dev/null
+++ b/example/rpc/sipp-rpc_client.c.bak
@@ -0,0 +1,84 @@
+/*
+ * This is sample code generated by rpcgen.
+ * These are only templates and you can use them
+ * as a guideline for developing your own functions.
+ */
+
+#include "sipp-rpc.h"
+
+
+void
+sipprpcprog_1(char *command)
+{
+	char *host = "127.0.0.1";
+	CLIENT *clnt;
+	enum clnt_stat retval_1;
+	callcounter_t result_1;
+	callcounter_t  getcallcounter_1_arg;
+	enum clnt_stat retval_2;
+	bool_t result_2;
+	char *enablelog4autoanswer_1_arg;
+	enum clnt_stat retval_3;
+	bool_t result_3;
+	char *disablelog4autoanswer_1_arg;
+
+#ifndef	DEBUG
+	clnt = clnt_create (host, SIPPRPCPROG, SIPPRPCVERS, "udp");
+	if (clnt == NULL) {
+		clnt_pcreateerror (host);
+		exit (1);
+	}
+#endif	/* DEBUG */
+
+	if (strcmp(command,"get_callcount") ==0 ) {
+		retval_1 = getcallcounter_1(&getcallcounter_1_arg, &result_1, clnt);
+		if (retval_1 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Total incoming calls: %d\n",result_1.incomingcalls);
+			printf("Total outgoing calls: %d\n",result_1.outgoingcalls);
+			printf("Total success calls: %d\n",result_1.successcalls);
+			printf("Total failure calls: %d\n",result_1.failurecalls);
+		}
+	}
+	if (strcmp(command,"enable_log4aa") ==0 ) {
+		retval_2 = enablelog4autoanswer_1((void*)&enablelog4autoanswer_1_arg, &result_2, clnt);
+		if (retval_2 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Error log for auto response enabled.\n");
+		}
+	}
+	if (strcmp(command,"disable_log4aa") ==0 ) {
+		retval_3 = disablelog4autoanswer_1((void*)&disablelog4autoanswer_1_arg, &result_3, clnt);
+		if (retval_3 != RPC_SUCCESS) {
+			clnt_perror (clnt, "call failed");
+		} else {
+			printf("Error log for auto response disabled.\n");
+		}
+	}
+#ifndef	DEBUG
+	clnt_destroy (clnt);
+#endif	 /* DEBUG */
+}
+
+
+int
+main (int argc, char *argv[])
+{
+	char *command;
+
+	if (argc < 2) {
+		printf ("usage: %s [get_callcount|enable_log4aa|disable_log4aa]\n", argv[0]);
+		exit (1);
+	}
+	command = argv[1];
+	if (strcmp(command,"get_callcount") != 0 &&
+	    strcmp(command,"enable_log4aa") != 0 &&
+	    strcmp(command,"disable_log4aa") != 0 ) {
+		printf ("usage: %s [get_callcount|enable_log4aa|disable_log4aa]\n", argv[0]);
+		exit (1);
+	}
+	sipprpcprog_1 (command);
+exit (0);
+}
diff --git a/example/rpc/sipp-rpc_clnt.c b/example/rpc/sipp-rpc_clnt.c
new file mode 100644
index 000000000..5342bf936
--- /dev/null
+++ b/example/rpc/sipp-rpc_clnt.c
@@ -0,0 +1,37 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include <memory.h> /* for memset */
+#include "sipp-rpc.h"
+
+/* Default timeout can be changed using clnt_control() */
+static struct timeval TIMEOUT = { 25, 0 };
+
+enum clnt_stat 
+getcallcounter_1(callcounter_t *argp, callcounter_t *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, GETCALLCOUNTER,
+		(xdrproc_t) xdr_callcounter_t, (caddr_t) argp,
+		(xdrproc_t) xdr_callcounter_t, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+enablelog4autoanswer_1(void *argp, bool_t *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, ENABLELOG4AUTOANSWER,
+		(xdrproc_t) xdr_void, (caddr_t) argp,
+		(xdrproc_t) xdr_bool, (caddr_t) clnt_res,
+		TIMEOUT));
+}
+
+enum clnt_stat 
+disablelog4autoanswer_1(void *argp, bool_t *clnt_res, CLIENT *clnt)
+{
+	return (clnt_call(clnt, DISABLELOG4AUTOANSWER,
+		(xdrproc_t) xdr_void, (caddr_t) argp,
+		(xdrproc_t) xdr_bool, (caddr_t) clnt_res,
+		TIMEOUT));
+}
diff --git a/example/rpc/sipp-rpc_server.c b/example/rpc/sipp-rpc_server.c
new file mode 100644
index 000000000..9dbfd1914
--- /dev/null
+++ b/example/rpc/sipp-rpc_server.c
@@ -0,0 +1,55 @@
+/*
+ * This is sample code generated by rpcgen.
+ * These are only templates and you can use them
+ * as a guideline for developing your own functions.
+ */
+
+#include "sipp-rpc.h"
+
+bool_t
+getcallcounter_1_svc(callcounter_t *argp, callcounter_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+bool_t
+enablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+bool_t
+disablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+int
+sipprpcprog_1_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+	xdr_free (xdr_result, result);
+
+	/*
+	 * Insert additional freeing code here, if needed
+	 */
+
+	return 1;
+}
diff --git a/example/rpc/sipp-rpc_server.c.bak b/example/rpc/sipp-rpc_server.c.bak
new file mode 100644
index 000000000..9dbfd1914
--- /dev/null
+++ b/example/rpc/sipp-rpc_server.c.bak
@@ -0,0 +1,55 @@
+/*
+ * This is sample code generated by rpcgen.
+ * These are only templates and you can use them
+ * as a guideline for developing your own functions.
+ */
+
+#include "sipp-rpc.h"
+
+bool_t
+getcallcounter_1_svc(callcounter_t *argp, callcounter_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+bool_t
+enablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+bool_t
+disablelog4autoanswer_1_svc(void *argp, bool_t *result, struct svc_req *rqstp)
+{
+	bool_t retval;
+
+	/*
+	 * insert server code here
+	 */
+
+	return retval;
+}
+
+int
+sipprpcprog_1_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
+{
+	xdr_free (xdr_result, result);
+
+	/*
+	 * Insert additional freeing code here, if needed
+	 */
+
+	return 1;
+}
diff --git a/example/rpc/sipp-rpc_svc.c b/example/rpc/sipp-rpc_svc.c
new file mode 100644
index 000000000..40d136400
--- /dev/null
+++ b/example/rpc/sipp-rpc_svc.c
@@ -0,0 +1,111 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "sipp-rpc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <rpc/pmap_clnt.h>
+#include <string.h>
+#include <memory.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#ifndef SIG_PF
+#define SIG_PF void(*)(int)
+#endif
+
+static void
+sipprpcprog_1(struct svc_req *rqstp, register SVCXPRT *transp)
+{
+	union {
+		callcounter_t getcallcounter_1_arg;
+	} argument;
+	union {
+		callcounter_t getcallcounter_1_res;
+		bool_t enablelog4autoanswer_1_res;
+		bool_t disablelog4autoanswer_1_res;
+	} result;
+	bool_t retval;
+	xdrproc_t _xdr_argument, _xdr_result;
+	bool_t (*local)(char *, void *, struct svc_req *);
+
+	switch (rqstp->rq_proc) {
+	case NULLPROC:
+		(void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
+		return;
+
+	case GETCALLCOUNTER:
+		_xdr_argument = (xdrproc_t) xdr_callcounter_t;
+		_xdr_result = (xdrproc_t) xdr_callcounter_t;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))getcallcounter_1_svc;
+		break;
+
+	case ENABLELOG4AUTOANSWER:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_bool;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))enablelog4autoanswer_1_svc;
+		break;
+
+	case DISABLELOG4AUTOANSWER:
+		_xdr_argument = (xdrproc_t) xdr_void;
+		_xdr_result = (xdrproc_t) xdr_bool;
+		local = (bool_t (*) (char *, void *,  struct svc_req *))disablelog4autoanswer_1_svc;
+		break;
+
+	default:
+		svcerr_noproc (transp);
+		return;
+	}
+	memset ((char *)&argument, 0, sizeof (argument));
+	if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+		svcerr_decode (transp);
+		return;
+	}
+	retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
+	if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
+		svcerr_systemerr (transp);
+	}
+	if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
+		fprintf (stderr, "%s", "unable to free arguments");
+		exit (1);
+	}
+	if (!sipprpcprog_1_freeresult (transp, _xdr_result, (caddr_t) &result))
+		fprintf (stderr, "%s", "unable to free results");
+
+	return;
+}
+
+int
+main (int argc, char **argv)
+{
+	register SVCXPRT *transp;
+
+	pmap_unset (SIPPRPCPROG, SIPPRPCVERS);
+
+	transp = svcudp_create(RPC_ANYSOCK);
+	if (transp == NULL) {
+		fprintf (stderr, "%s", "cannot create udp service.");
+		exit(1);
+	}
+	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_UDP)) {
+		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, udp).");
+		exit(1);
+	}
+
+	transp = svctcp_create(RPC_ANYSOCK, 0, 0);
+	if (transp == NULL) {
+		fprintf (stderr, "%s", "cannot create tcp service.");
+		exit(1);
+	}
+	if (!svc_register(transp, SIPPRPCPROG, SIPPRPCVERS, sipprpcprog_1, IPPROTO_TCP)) {
+		fprintf (stderr, "%s", "unable to register (SIPPRPCPROG, SIPPRPCVERS, tcp).");
+		exit(1);
+	}
+
+	svc_run ();
+	fprintf (stderr, "%s", "svc_run returned");
+	exit (1);
+	/* NOTREACHED */
+}
diff --git a/example/rpc/sipp-rpc_xdr.c b/example/rpc/sipp-rpc_xdr.c
new file mode 100644
index 000000000..9dd8e3835
--- /dev/null
+++ b/example/rpc/sipp-rpc_xdr.c
@@ -0,0 +1,71 @@
+/*
+ * Please do not edit this file.
+ * It was generated using rpcgen.
+ */
+
+#include "sipp-rpc.h"
+
+bool_t
+xdr_callcounter (XDR *xdrs, callcounter *objp)
+{
+	register int32_t *buf;
+
+
+	if (xdrs->x_op == XDR_ENCODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->incomingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->outgoingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->successcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->failurecalls))
+				 return FALSE;
+		} else {
+			IXDR_PUT_LONG(buf, objp->incomingcalls);
+			IXDR_PUT_LONG(buf, objp->outgoingcalls);
+			IXDR_PUT_LONG(buf, objp->successcalls);
+			IXDR_PUT_LONG(buf, objp->failurecalls);
+		}
+		return TRUE;
+	} else if (xdrs->x_op == XDR_DECODE) {
+		buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT);
+		if (buf == NULL) {
+			 if (!xdr_int (xdrs, &objp->incomingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->outgoingcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->successcalls))
+				 return FALSE;
+			 if (!xdr_int (xdrs, &objp->failurecalls))
+				 return FALSE;
+		} else {
+			objp->incomingcalls = IXDR_GET_LONG(buf);
+			objp->outgoingcalls = IXDR_GET_LONG(buf);
+			objp->successcalls = IXDR_GET_LONG(buf);
+			objp->failurecalls = IXDR_GET_LONG(buf);
+		}
+	 return TRUE;
+	}
+
+	 if (!xdr_int (xdrs, &objp->incomingcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->outgoingcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->successcalls))
+		 return FALSE;
+	 if (!xdr_int (xdrs, &objp->failurecalls))
+		 return FALSE;
+	return TRUE;
+}
+
+bool_t
+xdr_callcounter_t (XDR *xdrs, callcounter_t *objp)
+{
+	register int32_t *buf;
+
+	 if (!xdr_callcounter (xdrs, objp))
+		 return FALSE;
+	return TRUE;
+}
diff --git a/include/call.hpp b/include/call.hpp
index 7f5924665..38f5ffaff 100644
--- a/include/call.hpp
+++ b/include/call.hpp
@@ -95,12 +95,51 @@ class call : virtual public task, virtual public listener, public virtual socket
         E_AM_OOCALL
     };
 
+    // Access functions
     void setLastMsg(const char *msg);
     bool  automaticResponseMode(T_AutoMode P_case, const char* P_recv);
-    const char *getLastReceived() {
+
+    char *getLastReceived() {
         return last_recv_msg;
     };
 
+    void setLastReceived(char *msg){
+	    last_recv_msg = msg;
+    }
+    void set_realloc_ptr(char *ptr){
+	    realloc_ptr = ptr;
+    }
+    char *get_realloc_ptr(){
+	    return realloc_ptr;
+    }
+    int get_msg_index() {
+	    return msg_index;
+    }
+
+    void   public_sendBuffer(char *buf, int len = 0){     // send a message out of a scenario
+	sendBuffer(buf, len);
+    }
+    void increment_call_scenario_unexpected_count() {
+	     call_scenario->messages[msg_index] -> nb_unexp++;
+    }
+    char *get_id(){
+	    return id;
+    }
+    char* public_createSendingMessage(SendingMessage *src, int P_index, int *msgLen=NULL){
+	    return createSendingMessage(src,P_index,msgLen);
+    }
+    char* public_createSendingMessage(char * src, int P_index, bool skip_sanity = false){
+    	    return createSendingMessage(src,P_index, skip_sanity);
+    }
+
+    int   public_sendCmdBuffer(char* cmd){
+	        return  sendCmdBuffer(cmd);
+    }
+    void public_computeStat (CStat::E_Action P_action){
+      	computeStat (P_action);
+    }
+    
+
 private:
     /* This is the core constructor function. */
     void init(scenario * call_scenario, SIPpSocket *socket, struct sockaddr_storage *dest, const char * p_id, int userId, bool ipv6, bool isAutomatic, bool isInitCall);
diff --git a/include/sipp-rpc.h b/include/sipp-rpc.h
index ac29fdbda..cdbaaf4c8 100644
--- a/include/sipp-rpc.h
+++ b/include/sipp-rpc.h
@@ -3,8 +3,8 @@
  * It was generated using rpcgen.
  */
 
-#ifndef _SIPP-RPC_H_RPCGEN
-#define _SIPP-RPC_H_RPCGEN
+#ifndef _SIPP_RPC_H_RPCGEN
+#define _SIPP_RPC_H_RPCGEN
 
 #include <rpc/rpc.h>
 
@@ -69,4 +69,4 @@ extern bool_t xdr_callcounter_t ();
 }
 #endif
 
-#endif /* !_SIPP-RPC_H_RPCGEN */
+#endif /* !_SIPP_RPC_H_RPCGEN */
diff --git a/include/sipp.hpp b/include/sipp.hpp
index 21ebf2041..45c8adf83 100644
--- a/include/sipp.hpp
+++ b/include/sipp.hpp
@@ -437,6 +437,7 @@ MAYBE_EXTERN struct sockaddr_storage local_addr_storage;
 MAYBE_EXTERN SIPpSocket   *twinSippSocket               DEFVAL(NULL);
 MAYBE_EXTERN SIPpSocket   *localTwinSippSocket          DEFVAL(NULL);
 MAYBE_EXTERN struct sockaddr_storage twinSipp_sockaddr;
+MAYBE_EXTERN void *g_plugin_handle 		DEFVAL(NULL);  // Global Plugin handle - so we can use dlsym to call various predefined utility functions outside of main()
 
 /* 3pcc extended mode */
 typedef struct _T_peer_infos {
diff --git a/src/call.cpp b/src/call.cpp
index 9a711ad48..e7aaa0129 100644
--- a/src/call.cpp
+++ b/src/call.cpp
@@ -45,6 +45,7 @@
 #include <iterator>
 #include <sstream>
 #include <vector>
+#include <dlfcn.h>
 
 #include <assert.h>
 #include <stdarg.h>
@@ -3010,7 +3011,25 @@ bool call::process_incoming(const char* msg, const struct sockaddr_storage* src)
                 }
             } else {
                 // call aborted by automatic response mode if needed
-                return automaticResponseMode(L_case, msg);
+		//
+		int handled=0;
+		bool (*handle_auto_response)(T_AutoMode, const char* ,int *, call *); // Plugin function for auto response
+	        handle_auto_response = (bool (*)(T_AutoMode,const char* ,int *, call * ))dlsym(g_plugin_handle, "handle_auto_response");
+                const char* error;
+                if ((error = dlerror())) {
+                    ERROR("Could not locate handle_auto_response function in plugin: error:(%s)", error);
+                }else {
+
+			// If there's a hook, then run it to do whatever processing is defined in the plugin
+			// and if there's no more processing required, return something > 0
+			bool ret = handle_auto_response(L_case,msg,&handled,this);
+			if (handled > 0) {
+				return ret;
+			}else {
+                		return automaticResponseMode(L_case, msg);
+			}
+
+		}
             }
         }
     }
diff --git a/src/myapp.cpp b/src/myapp.cpp
index c42d98f7f..01beab80f 100644
--- a/src/myapp.cpp
+++ b/src/myapp.cpp
@@ -67,6 +67,19 @@
 #include "config.h"
 #include "version.h"
 #include "apifunc.h"
+#include "call.hpp"
+
+// From call.hpp
+  /* Automatic */
+    enum T_AutoMode {
+        E_AM_DEFAULT,
+        E_AM_UNEXP_BYE,
+        E_AM_UNEXP_CANCEL,
+        E_AM_PING,
+        E_AM_AA,
+        E_AM_OOCALL
+    };
+
 
 // For CURL support
 
@@ -712,16 +725,19 @@ extern "C" void appDllLoad(INT index)
 
 }
 
-// This hooks into the built-in plugin capability of sipp
+// This hooks into the built-in plugin capability of sipp and allows you to add EXEC commands
 
 extern "C" int init(void *handle,int argc, char *argv[]) {
 
+    	extern bool log4auto_answer;
+
 	   // 2/9/2022 NVF This has to be above the SIGPIPE handler (added to support mysqlclient multithreaded): https://dev.mysql.com/doc/c-api/8.0/en/c-api-threaded-clients.html
         if (mysql_library_init(0, NULL, NULL)) {
                 fprintf(stderr, "Warning: Could not initialize MySQL client library.  MySQL should not be used in a threaded call as a result\n");
                 exit(1);
         }
 
+	log4auto_answer = false;
 
 	curl_global_init(CURL_GLOBAL_DEFAULT);  // This is so we can use CURL inside our lua scripts in multi-threaded environments
 
@@ -782,3 +798,197 @@ extern "C" int app_shutdown(void *handle) {
 
 	return  EXIT_SUCCESS;
 }
+
+// Use this to override default SIPP handling of auto responses
+extern "C" bool handle_auto_response(T_AutoMode P_case, const char *P_recv,int *handled, call *call_ptr) {
+
+    int res ;
+    char * old_last_recv_msg = NULL;
+    bool last_recv_msg_saved = false;
+    char * last_recv_msg = call_ptr->getLastReceived();
+    int msg_index = call_ptr->get_msg_index();
+    char * id = call_ptr->get_id();
+    extern bool log4auto_answer;
+
+    *handled = 1; // Mark it as handled
+
+
+    WARNING("Processing auto_response for unexpected message\n");
+
+    switch (P_case) {
+    case E_AM_UNEXP_BYE: // response for an unexpected BYE
+        // usage of last_ keywords
+    	WARNING("Processing auto_response for unexpected BYE\n");
+        call_ptr->set_realloc_ptr ( (char *) realloc(last_recv_msg, strlen(P_recv) + 1));
+        if (call_ptr->get_realloc_ptr()) {
+            call_ptr->setLastReceived(call_ptr->get_realloc_ptr());
+        } else {
+            free(last_recv_msg);
+            ERROR("Out of memory!");
+            return false;
+        }
+
+
+        strcpy(call_ptr->getLastReceived(), P_recv);
+
+        // The BYE is unexpected, count it
+	call_ptr->increment_call_scenario_unexpected_count();
+        if (default_behaviors & DEFAULT_BEHAVIOR_ABORTUNEXP) {
+            WARNING("Aborting call on an unexpected BYE for call: %s", (id==NULL)?"none":id);
+            if (default_behaviors & DEFAULT_BEHAVIOR_BYE) {
+                call_ptr->public_sendBuffer(call_ptr->public_createSendingMessage(get_default_message("200"), -1));
+            }
+
+            // if twin socket call => reset the other part here
+            if (twinSippSocket && (msg_index > 0)) {
+                res = call_ptr->public_sendCmdBuffer(call_ptr->public_createSendingMessage(get_default_message("3pcc_abort"), -1));
+                if (res) {
+                    WARNING("sendCmdBuffer returned %d", res);
+                    return false;
+                }
+            }
+            call_ptr->public_computeStat(CStat::E_CALL_FAILED);
+            call_ptr->public_computeStat(CStat::E_FAILED_UNEXPECTED_MSG);
+            delete call_ptr;
+        } else {
+            WARNING("Continuing call on an unexpected BYE for call: %s", (id==NULL)?"none":id);
+        }
+        break ;
+
+    case E_AM_UNEXP_CANCEL: // response for an unexpected cancel
+    	WARNING("Processing auto_response for unexpected CANCEL\n");
+        // usage of last_ keywords
+	call_ptr->set_realloc_ptr ( (char *) realloc(last_recv_msg, strlen(P_recv) + 1));
+        if (call_ptr->get_realloc_ptr()) {
+            call_ptr->setLastReceived(call_ptr->get_realloc_ptr());
+        } else {
+            free(last_recv_msg);
+            ERROR("Out of memory!");
+            return false;
+        }
+
+
+        strcpy(call_ptr->getLastReceived(), P_recv);
+
+        // The CANCEL is unexpected, count it
+	call_ptr->increment_call_scenario_unexpected_count();
+        if (default_behaviors & DEFAULT_BEHAVIOR_ABORTUNEXP) {
+            WARNING("Aborting call on an unexpected CANCEL for call: %s", (id==NULL)?"none":id);
+            if (default_behaviors & DEFAULT_BEHAVIOR_BYE) {
+                call_ptr->public_sendBuffer(call_ptr->public_createSendingMessage(get_default_message("200"), -1));
+            }
+
+            // if twin socket call => reset the other part here
+            if (twinSippSocket && (msg_index > 0)) {
+                res = call_ptr->public_sendCmdBuffer(call_ptr->public_createSendingMessage(get_default_message("3pcc_abort"), -1));
+                if (res) {
+                    WARNING("sendCmdBuffer returned %d", res);
+                    return false;
+                }
+            }
+
+            call_ptr->public_computeStat(CStat::E_CALL_FAILED);
+            call_ptr->public_computeStat(CStat::E_FAILED_UNEXPECTED_MSG);
+            delete call_ptr;
+        } else {
+            WARNING("Continuing call on unexpected CANCEL for call: %s", (id==NULL)?"none":id);
+        }
+        break ;
+
+    case E_AM_PING: // response for a random ping
+        // usage of last_ keywords
+    	WARNING("Processing auto_response for unexpected PING\n");
+	call_ptr->set_realloc_ptr ( (char *) realloc(last_recv_msg, strlen(P_recv) + 1));
+        if (call_ptr->get_realloc_ptr()) {
+            call_ptr->setLastReceived(call_ptr->get_realloc_ptr());
+        } else {
+            free(last_recv_msg);
+            ERROR("Out of memory!");
+            return false;
+        }
+
+
+        strcpy(call_ptr->getLastReceived(), P_recv);
+
+        if (default_behaviors & DEFAULT_BEHAVIOR_PINGREPLY) {
+            WARNING("Automatic response mode for an unexpected PING for call: %s", (id==NULL)?"none":id);
+            call_ptr->public_sendBuffer(call_ptr->public_createSendingMessage(get_default_message("200"), -1));
+            // Note: the call ends here but it is not marked as bad. PING is a
+            //       normal message.
+            // if twin socket call => reset the other part here
+            if (twinSippSocket && (msg_index > 0)) {
+                res = call_ptr->public_sendCmdBuffer(call_ptr->public_createSendingMessage(get_default_message("3pcc_abort"), -1));
+                if (res) {
+                    WARNING("sendCmdBuffer returned %d", res);
+                    return false;
+                }
+            }
+
+            CStat::globalStat(CStat::E_AUTO_ANSWERED);
+            delete call_ptr;
+        } else {
+            WARNING("Do not answer on an unexpected PING for call: %s", (id==NULL)?"none":id);
+        }
+        break ;
+
+    case E_AM_AA: // response for a random INFO, NOTIFY, OPTIONS or UPDATE
+        // store previous last msg if msg is INFO, NOTIFY, OPTIONS or UPDATE
+        // restore last_recv_msg to previous one
+        // after sending ok
+    	WARNING("Processing auto_response for unexpected INFO, NOTIFY, OPTIONS or UPDATE\n");
+        old_last_recv_msg = NULL;
+        if (last_recv_msg != NULL) {
+            last_recv_msg_saved = true;
+            old_last_recv_msg = (char *) malloc(strlen(last_recv_msg)+1);
+            strcpy(old_last_recv_msg, last_recv_msg);
+        }
+        // usage of last_ keywords
+        call_ptr->set_realloc_ptr ( (char *) realloc(last_recv_msg, strlen(P_recv) + 1));
+        if (call_ptr->get_realloc_ptr()) {
+            call_ptr->setLastReceived(call_ptr->get_realloc_ptr());
+        } else {
+            free(last_recv_msg);
+            free(old_last_recv_msg);
+            ERROR("Out of memory!");
+            return false;
+        }
+
+
+        strcpy(call_ptr->getLastReceived(), P_recv);
+	if (log4auto_answer) {
+        	WARNING("Automatic response mode for an unexpected INFO, NOTIFY, OPTIONS or UPDATE for call: %s",
+                	(id == NULL) ? "none" : id);
+	}
+        call_ptr->public_sendBuffer(call_ptr->public_createSendingMessage(get_default_message("200"), -1));
+
+        // restore previous last msg
+        if (last_recv_msg_saved == true) {
+            call_ptr->set_realloc_ptr((char *) realloc(call_ptr->getLastReceived(), strlen(old_last_recv_msg) + 1));
+            if (call_ptr->get_realloc_ptr()) {
+		 call_ptr->setLastReceived(call_ptr->get_realloc_ptr());
+            } else {
+                free(call_ptr->getLastReceived());
+                ERROR("Out of memory!");
+                return false;
+            }
+
+
+            strcpy(call_ptr->getLastReceived(), old_last_recv_msg);
+
+            if (old_last_recv_msg != NULL) {
+                free(old_last_recv_msg);
+                old_last_recv_msg = NULL;
+            }
+        }
+        CStat::globalStat(CStat::E_AUTO_ANSWERED);
+        delete call_ptr;  // 2/16/2022 - NVF Added this for auto response messages as it looked like it wasn't being done otherwise - resulting in a memory leak
+        return true;
+        break;
+
+    default:
+        ERROR("Internal error for automaticResponseMode - mode %d is not implemented!", P_case);
+        break ;
+    }
+
+    return false;
+}
diff --git a/src/sipp.cpp b/src/sipp.cpp
index 007aa19f4..ff4eaa5d7 100644
--- a/src/sipp.cpp
+++ b/src/sipp.cpp
@@ -62,7 +62,7 @@ extern char** environ;
 
 #ifdef USE_LUA
 #include "lua.hpp"
-lua_State *L = luaL_newstate();
+lua_State *L = luaL_newstate();   // This is a throwaway - we don't actually use this but it forces the lua shared lib to be loaded.
 #endif
 
 
@@ -1935,7 +1935,7 @@ int main(int argc, char *argv[])
                 REQUIRE_ARG();
                 CHECK_PASS();
 
-                handle = dlopen(argv[argi], RTLD_NOW);
+                g_plugin_handle = handle = dlopen(argv[argi], RTLD_NOW);
 		plugin_name = argv[argi];
                 if (!handle) {
                     ERROR("Could not open plugin %s: %s", argv[argi], dlerror());