add xmlrpc-c 1.03.14 to in tree libs

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@3772 d0543943-73ff-0310-b7d9-9358b9ac24b2

libs/xmlrpc-c/src/cpp/server_abyss.cpp

@@ -0,0 +1,196 @@
+#include <cassert>
+#include <string>
+#include <memory>
+#include <signal.h>
+#include <sys/wait.h>
+
+#include "xmlrpc-c/girerr.hpp"
+using girerr::error;
+#include "xmlrpc-c/base.h"
+#include "xmlrpc-c/base.hpp"
+#include "xmlrpc-c/server_abyss.h"
+#include "xmlrpc-c/registry.hpp"
+#include "xmlrpc-c/server_abyss.hpp"
+
+using namespace std;
+using namespace xmlrpc_c;
+
+namespace xmlrpc_c {
+
+serverAbyss::serverAbyss(
+    xmlrpc_c::registry const& registry,
+    unsigned int       const  portNumber,
+    string             const& logFileName,
+    unsigned int       const  keepaliveTimeout,
+    unsigned int       const  keepaliveMaxConn,
+    unsigned int       const  timeout,
+    bool               const  dontAdvertise) {
+   
+    this->registryP = &registry;
+    this->logFileName = logFileName;
+    this->keepaliveTimeout = keepaliveTimeout;
+    this->keepaliveMaxConn = keepaliveMaxConn;
+    this->timeout = timeout;
+    this->dontAdvertise = dontAdvertise;
+    
+    if (portNumber > 0xffff)
+        throw(error("Port number exceeds the maximum possible port number "
+                    "(65535)"));
+    else {
+        this->portNumber = portNumber;
+    }
+}
+
+
+serverAbyss::~serverAbyss() {
+}
+
+
+
+namespace {
+
+
+static void 
+sigterm(int const sig) {
+    TraceExit("Signal %d received. Exiting...\n",sig);
+}
+
+
+static void 
+sigchld(int const sig) {
+/*----------------------------------------------------------------------------
+   This is a signal handler for a SIGCHLD signal (which informs us that
+   one of our child processes has terminated).
+
+   We respond by reaping the zombie process.
+
+   Implementation note: In some systems, just setting the signal handler
+   to SIG_IGN (ignore signal) does this.  In others, it doesn't.
+-----------------------------------------------------------------------------*/
+#ifndef _WIN32
+    /* Reap zombie children until there aren't any more. */
+
+    bool zombiesExist;
+    bool error;
+
+    assert(sig == SIGCHLD);
+    
+    zombiesExist = true;  // initial assumption
+    error = false;  // no error yet
+    while (zombiesExist && !error) {
+        int status;
+        pid_t const pid = waitpid((pid_t) -1, &status, WNOHANG);
+    
+        if (pid == 0)
+            zombiesExist = false;
+        else if (pid < 0) {
+            /* because of ptrace */
+            if (errno == EINTR) {
+                // This is OK - it's a ptrace notification
+            } else
+                error = true;
+        }
+    }
+#endif /* _WIN32 */
+}
+
+void
+setupSignalHandlers(void) {
+#ifndef _WIN32
+    struct sigaction mysigaction;
+   
+    sigemptyset(&mysigaction.sa_mask);
+    mysigaction.sa_flags = 0;
+
+    /* These signals abort the program, with tracing */
+    mysigaction.sa_handler = sigterm;
+    sigaction(SIGTERM, &mysigaction, NULL);
+    sigaction(SIGINT,  &mysigaction, NULL);
+    sigaction(SIGHUP,  &mysigaction, NULL);
+    sigaction(SIGUSR1, &mysigaction, NULL);
+
+    /* This signal indicates connection closed in the middle */
+    mysigaction.sa_handler = SIG_IGN;
+    sigaction(SIGPIPE, &mysigaction, NULL);
+   
+    /* This signal indicates a child process (request handler) has died */
+    mysigaction.sa_handler = sigchld;
+    sigaction(SIGCHLD, &mysigaction, NULL);
+#endif
+}    
+
+
+static void
+setAdditionalServerParms(
+    unsigned int       const keepaliveTimeout,
+    unsigned int       const keepaliveMaxConn,
+    unsigned int       const timeout,
+    bool               const dontAdvertise,
+    TServer *          const srvP) {
+
+    /* The following ought to be parameters on ServerCreate(), but it
+       looks like plugging them straight into the TServer structure is
+       the only way to set them.  
+    */
+
+    if (keepaliveTimeout > 0)
+        srvP->keepalivetimeout = keepaliveTimeout;
+    if (keepaliveMaxConn > 0)
+        srvP->keepalivemaxconn = keepaliveMaxConn;
+    if (timeout > 0)
+        srvP->timeout = timeout;
+    srvP->advertise = !dontAdvertise;
+}
+
+
+} // namespace
+
+
+
+void
+serverAbyss::run() {
+
+    xmlrpc_env env;
+    xmlrpc_env_init(&env);
+    
+    DateInit();
+    MIMETypeInit();
+    
+    TServer srv;
+
+    const char * const logfileArg(this->logFileName.length() == 0 ?
+                                  NULL : this->logFileName.c_str());
+
+    ServerCreate(&srv, "XmlRpcServer", this->portNumber,
+                 DEFAULT_DOCS, logfileArg);
+
+    setAdditionalServerParms(
+        this->keepaliveTimeout, this->keepaliveMaxConn, this->timeout,
+        this->dontAdvertise, &srv);
+                             
+    xmlrpc_c::server_abyss_set_handlers(&srv, *this->registryP);
+    
+    ServerInit(&srv);
+    
+    setupSignalHandlers();
+       
+    ServerRun(&srv);
+
+    /* We can't exist here because ServerRun doesn't return */
+    assert(false);
+}
+ 
+
+
+void
+server_abyss_set_handlers(TServer *          const  srvP,
+                          xmlrpc_c::registry const& registry) {
+    
+
+    xmlrpc_server_abyss_set_handlers(srvP, registry.c_registry());
+}
+
+
+
+} // namespace
+