You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
800 lines
25 KiB
800 lines
25 KiB
/* Copyright (C) 2001 by First Peer, Inc. All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
** SUCH DAMAGE.
|
|
**
|
|
** There is more copyright information in the bottom half of this file.
|
|
** Please see it for more details. */
|
|
|
|
#include "xmlrpc_config.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "abyss.h"
|
|
|
|
#include "xmlrpc.h"
|
|
#include "xmlrpc_server.h"
|
|
#include "xmlrpc_int.h"
|
|
#include "xmlrpc_server_abyss.h"
|
|
#include "xmlrpc_server_abyss_int.h"
|
|
|
|
|
|
/*=========================================================================
|
|
** die_if_fault_occurred
|
|
**=========================================================================
|
|
** If certain kinds of out-of-memory errors occur during server setup,
|
|
** we want to quit and print an error.
|
|
*/
|
|
|
|
static void die_if_fault_occurred(xmlrpc_env *env) {
|
|
if (env->fault_occurred) {
|
|
fprintf(stderr, "Unexpected XML-RPC fault: %s (%d)\n",
|
|
env->fault_string, env->fault_code);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** send_xml_data
|
|
**=========================================================================
|
|
** Blast some XML data back to the client.
|
|
*/
|
|
|
|
static void
|
|
send_xml_data (TSession * const r,
|
|
char * const buffer,
|
|
uint64 const len) {
|
|
|
|
const char * const http_cookie = NULL;
|
|
/* This used to set http_cookie to getenv("HTTP_COOKIE"), but
|
|
that doesn't make any sense -- environment variables are not
|
|
appropriate for this. So for now, cookie code is disabled.
|
|
- Bryan 2004.10.03.
|
|
*/
|
|
|
|
/* fwrite(buffer, sizeof(char), len, stderr); */
|
|
|
|
/* XXX - Is it safe to chunk our response? */
|
|
ResponseChunked(r);
|
|
|
|
ResponseStatus(r, 200);
|
|
|
|
if (http_cookie) {
|
|
/* There's an auth cookie, so pass it back in the response. */
|
|
|
|
char *cookie_response;
|
|
|
|
cookie_response = malloc(10+strlen(http_cookie));
|
|
sprintf(cookie_response, "auth=%s", http_cookie);
|
|
|
|
/* Return abyss response. */
|
|
ResponseAddField(r, "Set-Cookie", cookie_response);
|
|
|
|
free(cookie_response);
|
|
}
|
|
|
|
|
|
ResponseContentType(r, "text/xml; charset=\"utf-8\"");
|
|
ResponseContentLength(r, len);
|
|
|
|
ResponseWrite(r);
|
|
|
|
HTTPWrite(r, buffer, len);
|
|
HTTPWriteEnd(r);
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** send_error
|
|
**=========================================================================
|
|
** Send an error back to the client.
|
|
*/
|
|
|
|
static void
|
|
send_error(TSession * const abyssSessionP,
|
|
unsigned int const status) {
|
|
|
|
ResponseStatus(abyssSessionP, (uint16) status);
|
|
ResponseError(abyssSessionP);
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** get_buffer_data
|
|
**=========================================================================
|
|
** Extract some data from the TConn's underlying input buffer. Do not
|
|
** extract more than 'max'.
|
|
*/
|
|
|
|
static void
|
|
get_buffer_data(TSession * const r,
|
|
int const max,
|
|
char ** const out_start,
|
|
int * const out_len) {
|
|
|
|
/* Point to the start of our data. */
|
|
*out_start = &r->conn->buffer[r->conn->bufferpos];
|
|
|
|
/* Decide how much data to retrieve. */
|
|
*out_len = r->conn->buffersize - r->conn->bufferpos;
|
|
if (*out_len > max)
|
|
*out_len = max;
|
|
|
|
/* Update our buffer position. */
|
|
r->conn->bufferpos += *out_len;
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** get_body
|
|
**=========================================================================
|
|
** Slurp the body of the request into an xmlrpc_mem_block.
|
|
*/
|
|
|
|
static void
|
|
getBody(xmlrpc_env * const envP,
|
|
TSession * const abyssSessionP,
|
|
unsigned int const contentSize,
|
|
xmlrpc_mem_block ** const bodyP) {
|
|
/*----------------------------------------------------------------------------
|
|
Get the entire body from the Abyss session and return it as the new
|
|
memblock *bodyP.
|
|
|
|
The first chunk of the body may already be in Abyss's buffer. We
|
|
retrieve that before reading more.
|
|
-----------------------------------------------------------------------------*/
|
|
xmlrpc_mem_block * body;
|
|
|
|
body = xmlrpc_mem_block_new(envP, 0);
|
|
if (!envP->fault_occurred) {
|
|
unsigned int bytesRead;
|
|
char * chunkPtr;
|
|
int chunkLen;
|
|
|
|
bytesRead = 0;
|
|
|
|
while (!envP->fault_occurred && bytesRead < contentSize) {
|
|
get_buffer_data(abyssSessionP, contentSize - bytesRead,
|
|
&chunkPtr, &chunkLen);
|
|
bytesRead += chunkLen;
|
|
|
|
XMLRPC_TYPED_MEM_BLOCK_APPEND(char, envP, body,
|
|
chunkPtr, chunkLen);
|
|
|
|
if (bytesRead < contentSize) {
|
|
/* Get the next chunk of data from the connection into the
|
|
buffer
|
|
*/
|
|
abyss_bool succeeded;
|
|
|
|
/* Reset our read buffer & flush data from previous reads. */
|
|
ConnReadInit(abyssSessionP->conn);
|
|
|
|
/* Read more network data into our buffer. If we encounter
|
|
a timeout, exit immediately. We're very forgiving about
|
|
the timeout here. We allow a full timeout per network
|
|
read, which would allow somebody to keep a connection
|
|
alive nearly indefinitely. But it's hard to do anything
|
|
intelligent here without very complicated code.
|
|
*/
|
|
succeeded = ConnRead(abyssSessionP->conn,
|
|
abyssSessionP->server->timeout);
|
|
if (!succeeded)
|
|
xmlrpc_env_set_fault_formatted(
|
|
envP, XMLRPC_TIMEOUT_ERROR, "Timed out waiting for "
|
|
"client to send its POST data");
|
|
}
|
|
}
|
|
if (envP->fault_occurred)
|
|
xmlrpc_mem_block_free(body);
|
|
else
|
|
*bodyP = body;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
storeCookies(TSession * const httpRequestP,
|
|
unsigned int * const httpErrorP) {
|
|
/*----------------------------------------------------------------------------
|
|
Get the cookie settings from the HTTP headers and remember them for
|
|
use in responses.
|
|
-----------------------------------------------------------------------------*/
|
|
const char * const cookie = RequestHeaderValue(httpRequestP, "cookie");
|
|
if (cookie) {
|
|
/*
|
|
Setting the value in an environment variable doesn't make
|
|
any sense. So for now, cookie code is disabled.
|
|
-Bryan 04.10.03.
|
|
|
|
setenv("HTTP_COOKIE", cookie, 1);
|
|
*/
|
|
}
|
|
/* TODO: parse HTTP_COOKIE to find auth pair, if there is one */
|
|
|
|
*httpErrorP = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
validateContentType(TSession * const httpRequestP,
|
|
unsigned int * const httpErrorP) {
|
|
/*----------------------------------------------------------------------------
|
|
If the client didn't specify a content-type of "text/xml", return
|
|
"400 Bad Request". We can't allow the client to default this header,
|
|
because some firewall software may rely on all XML-RPC requests
|
|
using the POST method and a content-type of "text/xml".
|
|
-----------------------------------------------------------------------------*/
|
|
const char * const content_type =
|
|
RequestHeaderValue(httpRequestP, "content-type");
|
|
if (content_type == NULL || strcmp(content_type, "text/xml") != 0)
|
|
*httpErrorP = 400;
|
|
else
|
|
*httpErrorP = 0;
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
processContentLength(TSession * const httpRequestP,
|
|
unsigned int * const inputLenP,
|
|
unsigned int * const httpErrorP) {
|
|
/*----------------------------------------------------------------------------
|
|
Make sure the content length is present and non-zero. This is
|
|
technically required by XML-RPC, but we only enforce it because we
|
|
don't want to figure out how to safely handle HTTP < 1.1 requests
|
|
without it. If the length is missing, return "411 Length Required".
|
|
-----------------------------------------------------------------------------*/
|
|
const char * const content_length =
|
|
RequestHeaderValue(httpRequestP, "content-length");
|
|
if (content_length == NULL)
|
|
*httpErrorP = 411;
|
|
else {
|
|
int const contentLengthValue = atoi(content_length);
|
|
if (contentLengthValue <= 0)
|
|
*httpErrorP = 400;
|
|
else {
|
|
*httpErrorP = 0;
|
|
*inputLenP = (unsigned int)contentLengthValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
Abyss handlers (to be registered with and called by Abyss)
|
|
****************************************************************************/
|
|
|
|
/* XXX - This variable is *not* currently threadsafe. Once the server has
|
|
** been started, it must be treated as read-only. */
|
|
static xmlrpc_registry *global_registryP;
|
|
|
|
static const char * trace_abyss;
|
|
|
|
static void
|
|
processCall(TSession * const abyssSessionP,
|
|
int const inputLen) {
|
|
/*----------------------------------------------------------------------------
|
|
Handle an RPC request. This is an HTTP request that has the proper form
|
|
to be one of our RPCs.
|
|
-----------------------------------------------------------------------------*/
|
|
xmlrpc_env env;
|
|
|
|
if (trace_abyss)
|
|
fprintf(stderr, "xmlrpc_server_abyss RPC2 handler processing RPC.\n");
|
|
|
|
xmlrpc_env_init(&env);
|
|
|
|
/* SECURITY: Make sure our content length is legal.
|
|
XXX - We can cast 'inputLen' because we know it's >= 0, yes?
|
|
*/
|
|
if ((size_t) inputLen > xmlrpc_limit_get(XMLRPC_XML_SIZE_LIMIT_ID))
|
|
xmlrpc_env_set_fault_formatted(
|
|
&env, XMLRPC_LIMIT_EXCEEDED_ERROR,
|
|
"XML-RPC request too large (%d bytes)", inputLen);
|
|
else {
|
|
xmlrpc_mem_block *body;
|
|
/* Read XML data off the wire. */
|
|
getBody(&env, abyssSessionP, inputLen, &body);
|
|
if (!env.fault_occurred) {
|
|
xmlrpc_mem_block * output;
|
|
/* Process the RPC. */
|
|
output = xmlrpc_registry_process_call(
|
|
&env, global_registryP, NULL,
|
|
XMLRPC_MEMBLOCK_CONTENTS(char, body),
|
|
XMLRPC_MEMBLOCK_SIZE(char, body));
|
|
if (!env.fault_occurred) {
|
|
/* Send our the result. */
|
|
send_xml_data(abyssSessionP,
|
|
XMLRPC_MEMBLOCK_CONTENTS(char, output),
|
|
XMLRPC_MEMBLOCK_SIZE(char, output));
|
|
|
|
XMLRPC_MEMBLOCK_FREE(char, output);
|
|
}
|
|
XMLRPC_MEMBLOCK_FREE(char, body);
|
|
}
|
|
}
|
|
if (env.fault_occurred) {
|
|
if (env.fault_code == XMLRPC_TIMEOUT_ERROR)
|
|
send_error(abyssSessionP, 408); /* 408 Request Timeout */
|
|
else
|
|
send_error(abyssSessionP, 500); /* 500 Internal Server Error */
|
|
}
|
|
|
|
xmlrpc_env_clean(&env);
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** xmlrpc_server_abyss_rpc2_handler
|
|
**=========================================================================
|
|
** This handler processes all requests to '/RPC2'. See the header for
|
|
** more documentation.
|
|
*/
|
|
|
|
xmlrpc_bool
|
|
xmlrpc_server_abyss_rpc2_handler (TSession * const r) {
|
|
|
|
xmlrpc_bool retval;
|
|
|
|
if (trace_abyss)
|
|
fprintf(stderr, "xmlrpc_server_abyss RPC2 handler called.\n");
|
|
|
|
/* We handle only requests to /RPC2, the default XML-RPC URL.
|
|
Everything else we pass through to other handlers.
|
|
*/
|
|
if (strcmp(r->uri, "/RPC2") != 0)
|
|
retval = FALSE;
|
|
else {
|
|
retval = TRUE;
|
|
|
|
/* We understand only the POST HTTP method. For anything else, return
|
|
"405 Method Not Allowed".
|
|
*/
|
|
if (r->method != m_post)
|
|
send_error(r, 405);
|
|
else {
|
|
unsigned int httpError;
|
|
storeCookies(r, &httpError);
|
|
if (httpError)
|
|
send_error(r, httpError);
|
|
else {
|
|
unsigned int httpError;
|
|
validateContentType(r, &httpError);
|
|
if (httpError)
|
|
send_error(r, httpError);
|
|
else {
|
|
unsigned int httpError;
|
|
int inputLen;
|
|
|
|
processContentLength(r, &inputLen, &httpError);
|
|
if (httpError)
|
|
send_error(r, httpError);
|
|
|
|
processCall(r, inputLen);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (trace_abyss)
|
|
fprintf(stderr, "xmlrpc_server_abyss RPC2 handler returning.\n");
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** xmlrpc_server_abyss_default_handler
|
|
**=========================================================================
|
|
** This handler returns a 404 Not Found for all requests. See the header
|
|
** for more documentation.
|
|
*/
|
|
|
|
xmlrpc_bool
|
|
xmlrpc_server_abyss_default_handler (TSession * const r) {
|
|
send_error(r, 404);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
|
**
|
|
** The code below was adapted from the main.c file of the Abyss webserver
|
|
** project. In addition to the other copyrights on this file, the following
|
|
** code is also under this copyright:
|
|
**
|
|
** Copyright (C) 2000 by Moez Mahfoudh <mmoez@bigfoot.com>.
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
** SUCH DAMAGE.
|
|
**
|
|
**************************************************************************/
|
|
|
|
#include <time.h>
|
|
#include <fcntl.h>
|
|
|
|
#ifdef _WIN32
|
|
#include <io.h>
|
|
#else
|
|
/* Must check this
|
|
#include <sys/io.h>
|
|
*/
|
|
#endif /* _WIN32 */
|
|
|
|
#ifdef _UNIX
|
|
#include <sys/signal.h>
|
|
#include <sys/wait.h>
|
|
#include <grp.h>
|
|
#endif
|
|
|
|
|
|
#ifdef _UNIX
|
|
static void
|
|
sigterm(int const sig) {
|
|
TraceExit("Signal %d received. Exiting...\n",sig);
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef _UNIX
|
|
static void
|
|
sigchld(int const sig ATTR_UNUSED) {
|
|
/*----------------------------------------------------------------------------
|
|
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.
|
|
-----------------------------------------------------------------------------*/
|
|
pid_t pid;
|
|
int status;
|
|
|
|
/* Reap defunct children until there aren't any more. */
|
|
for (;;) {
|
|
pid = waitpid( (pid_t) -1, &status, WNOHANG );
|
|
|
|
/* none left */
|
|
if (pid==0)
|
|
break;
|
|
|
|
if (pid<0) {
|
|
/* because of ptrace */
|
|
if (errno==EINTR)
|
|
continue;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif /* _UNIX */
|
|
|
|
static TServer globalSrv;
|
|
/* When you use the old interface (xmlrpc_server_abyss_init(), etc.),
|
|
this is the Abyss server to which they refer. Obviously, there can be
|
|
only one Abyss server per program using this interface.
|
|
*/
|
|
|
|
|
|
void
|
|
xmlrpc_server_abyss_init(int const flags ATTR_UNUSED,
|
|
const char * const config_file) {
|
|
|
|
DateInit();
|
|
MIMETypeInit();
|
|
|
|
ServerCreate(&globalSrv, "XmlRpcServer", 8080, DEFAULT_DOCS, NULL);
|
|
|
|
ConfReadServerFile(config_file, &globalSrv);
|
|
|
|
xmlrpc_server_abyss_init_registry();
|
|
/* Installs /RPC2 handler and default handler that use the
|
|
built-in registry.
|
|
*/
|
|
|
|
ServerInit(&globalSrv);
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
setupSignalHandlers(void) {
|
|
#ifdef _UNIX
|
|
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
|
|
runServer(TServer * const srvP,
|
|
runfirstFn const runfirst,
|
|
void * const runfirstArg) {
|
|
|
|
setupSignalHandlers();
|
|
|
|
#ifdef _UNIX
|
|
/* Become a daemon */
|
|
switch (fork()) {
|
|
case 0:
|
|
break;
|
|
case -1:
|
|
TraceExit("Unable to become a daemon");
|
|
default:
|
|
exit(0);
|
|
};
|
|
|
|
setsid();
|
|
|
|
/* Change the current user if we are root */
|
|
if (getuid()==0) {
|
|
if (srvP->uid == (uid_t)-1)
|
|
TraceExit("Can't run under root privileges. "
|
|
"Please add a User option in your "
|
|
"Abyss configuration file.");
|
|
|
|
#ifdef HAVE_SETGROUPS
|
|
if (setgroups(0,NULL)==(-1))
|
|
TraceExit("Failed to setup the group.");
|
|
if (srvP->gid != (gid_t)-1)
|
|
if (setgid(srvP->gid)==(-1))
|
|
TraceExit("Failed to change the group.");
|
|
#endif
|
|
|
|
if (setuid(srvP->uid) == -1)
|
|
TraceExit("Failed to change the user.");
|
|
};
|
|
|
|
if (srvP->pidfile!=(-1)) {
|
|
char z[16];
|
|
|
|
sprintf(z,"%d",getpid());
|
|
FileWrite(&srvP->pidfile,z,strlen(z));
|
|
FileClose(&srvP->pidfile);
|
|
};
|
|
#endif
|
|
|
|
/* We run the user supplied runfirst after forking, but before accepting
|
|
connections (helpful when running with threads)
|
|
*/
|
|
if (runfirst)
|
|
runfirst(runfirstArg);
|
|
|
|
ServerRun(srvP);
|
|
|
|
/* We can't exist here because ServerRun doesn't return */
|
|
XMLRPC_ASSERT(FALSE);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
xmlrpc_server_abyss_run_first(runfirstFn const runfirst,
|
|
void * const runfirstArg) {
|
|
|
|
runServer(&globalSrv, runfirst, runfirstArg);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
xmlrpc_server_abyss_run(void) {
|
|
runServer(&globalSrv, NULL, NULL);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
xmlrpc_server_abyss_set_handlers(TServer * const srvP,
|
|
xmlrpc_registry * const registryP) {
|
|
|
|
/* Abyss ought to have a way to register with a handler an argument
|
|
that gets passed to the handler every time it is called. That's
|
|
where we should put the registry handle. But we don't find such
|
|
a thing in Abyss, so we use the global variable 'global_registryP'.
|
|
*/
|
|
global_registryP = registryP;
|
|
|
|
trace_abyss = getenv("XMLRPC_TRACE_ABYSS");
|
|
|
|
ServerAddHandler(srvP, xmlrpc_server_abyss_rpc2_handler);
|
|
ServerDefaultHandler(srvP, xmlrpc_server_abyss_default_handler);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
xmlrpc_server_abyss(xmlrpc_env * const envP,
|
|
const xmlrpc_server_abyss_parms * const parmsP,
|
|
unsigned int const parm_size) {
|
|
|
|
XMLRPC_ASSERT_ENV_OK(envP);
|
|
|
|
if (parm_size < XMLRPC_APSIZE(registryP))
|
|
xmlrpc_env_set_fault_formatted(
|
|
envP, XMLRPC_INTERNAL_ERROR,
|
|
"You must specify members at least up through "
|
|
"'registryP' in the server parameters argument. "
|
|
"That would mean the parameter size would be >= %u "
|
|
"but you specified a size of %u",
|
|
XMLRPC_APSIZE(registryP), parm_size);
|
|
else {
|
|
TServer srv;
|
|
runfirstFn runfirst;
|
|
void * runfirstArg;
|
|
|
|
DateInit();
|
|
MIMETypeInit();
|
|
|
|
ServerCreate(&srv, "XmlRpcServer", 8080, DEFAULT_DOCS, NULL);
|
|
|
|
ConfReadServerFile(parmsP->config_file_name, &srv);
|
|
|
|
xmlrpc_server_abyss_set_handlers(&srv, parmsP->registryP);
|
|
|
|
ServerInit(&srv);
|
|
|
|
if (parm_size >= XMLRPC_APSIZE(runfirst_arg)) {
|
|
runfirst = parmsP->runfirst;
|
|
runfirstArg = parmsP->runfirst_arg;
|
|
} else {
|
|
runfirst = NULL;
|
|
runfirstArg = NULL;
|
|
}
|
|
runServer(&srv, runfirst, runfirstArg);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*=========================================================================
|
|
** XML-RPC Server Method Registry
|
|
**=========================================================================
|
|
** A simple front-end to our method registry.
|
|
*/
|
|
|
|
/* XXX - This variable is *not* currently threadsafe. Once the server has
|
|
** been started, it must be treated as read-only. */
|
|
static xmlrpc_registry *builtin_registryP;
|
|
|
|
void
|
|
xmlrpc_server_abyss_init_registry(void) {
|
|
|
|
/* This used to just create the registry and Caller would be
|
|
responsible for adding the handlers that use it.
|
|
|
|
But that isn't very modular -- the handlers and registry go
|
|
together; there's no sense in using the built-in registry and
|
|
not the built-in handlers because if you're custom building
|
|
something, you can just make your own regular registry. So now
|
|
we tie them together, and we don't export our handlers.
|
|
*/
|
|
xmlrpc_env env;
|
|
|
|
xmlrpc_env_init(&env);
|
|
builtin_registryP = xmlrpc_registry_new(&env);
|
|
die_if_fault_occurred(&env);
|
|
xmlrpc_env_clean(&env);
|
|
|
|
xmlrpc_server_abyss_set_handlers(&globalSrv, builtin_registryP);
|
|
}
|
|
|
|
|
|
|
|
xmlrpc_registry *
|
|
xmlrpc_server_abyss_registry(void) {
|
|
|
|
/* This is highly deprecated. If you want to mess with a registry,
|
|
make your own with xmlrpc_registry_new() -- don't mess with the
|
|
internal one.
|
|
*/
|
|
return builtin_registryP;
|
|
}
|
|
|
|
|
|
|
|
/* A quick & easy shorthand for adding a method. */
|
|
void
|
|
xmlrpc_server_abyss_add_method (char * const method_name,
|
|
xmlrpc_method const method,
|
|
void * const user_data) {
|
|
xmlrpc_env env;
|
|
|
|
xmlrpc_env_init(&env);
|
|
xmlrpc_registry_add_method(&env, builtin_registryP, NULL, method_name,
|
|
method, user_data);
|
|
die_if_fault_occurred(&env);
|
|
xmlrpc_env_clean(&env);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
xmlrpc_server_abyss_add_method_w_doc (char * const method_name,
|
|
xmlrpc_method const method,
|
|
void * const user_data,
|
|
char * const signature,
|
|
char * const help) {
|
|
|
|
xmlrpc_env env;
|
|
xmlrpc_env_init(&env);
|
|
xmlrpc_registry_add_method_w_doc(
|
|
&env, builtin_registryP, NULL, method_name,
|
|
method, user_data, signature, help);
|
|
die_if_fault_occurred(&env);
|
|
xmlrpc_env_clean(&env);
|
|
}
|