1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/* A simple standalone XML-RPC server program based on Abyss that contains a
simple one-thread request processing loop.
This uses the "provide your own Abyss server" mode of operation.
xmlrpc_sample_add_server.c is a server that does the same thing, but
does it by running a full Abyss daemon in the background, so it has
less control over how the requests are served.
*/
#define _XOPEN_SOURCE 600
#define WIN32_LEAN_AND_MEAN /* required by xmlrpc-c/server_abyss.h */
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#ifndef _WIN32
#include <sys/socket.h>
#include <netinet/in.h>
#endif
#include <xmlrpc-c/base.h>
#include <xmlrpc-c/abyss.h>
#include <xmlrpc-c/server.h>
#include <xmlrpc-c/server_abyss.h>
#include "config.h" /* information about this build environment */
static void
setupSignalHandlers(void) {
/* In UNIX, when you try to write to a socket that has been closed
from the other end, your write fails, but you also get a SIGPIPE
signal. That signal will kill you before you even have a chance
to see the write fail unless you catch, block, or ignore it.
If a client should connect to us and then disconnect before we've
sent our response, we see this socket-closed behavior. We
obviously don't want to die just because a client didn't complete
an RPC, so we ignore SIGPIPE.
*/
#ifndef _WIN32
struct sigaction mysigaction;
sigemptyset(&mysigaction.sa_mask);
mysigaction.sa_flags = 0;
mysigaction.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &mysigaction, NULL);
#endif
}
static void
printPeerIpAddr(TSession * const abyssSessionP) {
#ifdef _WIN32
struct abyss_win_chaninfo * channelInfoP;
#else
struct abyss_unix_chaninfo * channelInfoP;
#endif
struct sockaddr_in * sockAddrInP;
unsigned char * ipAddr; /* 4 byte array */
SessionGetChannelInfo(abyssSessionP, (void*)&channelInfoP);
sockAddrInP = (struct sockaddr_in *) &channelInfoP->peerAddr;
ipAddr = (unsigned char *)&sockAddrInP->sin_addr.s_addr;
printf("RPC is from IP address %u.%u.%u.%u\n",
ipAddr[0], ipAddr[1], ipAddr[2], ipAddr[3]);
}
static xmlrpc_value *
sample_add(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo,
void * const channelInfo) {
xmlrpc_int x, y, z;
printPeerIpAddr(channelInfo);
/* Parse our argument array. */
xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);
if (envP->fault_occurred)
return NULL;
/* Add our two numbers. */
z = x + y;
/* Return our result. */
return xmlrpc_build_value(envP, "i", z);
}
static xmlrpc_server_shutdown_fn requestShutdown;
static void
requestShutdown(xmlrpc_env * const faultP,
void * const context,
const char * const comment,
void * const callInfo) {
/* You make this run by executing the system method 'system.shutdown'.
This function is registered in the method registry as the thing to call
for that.
*/
int * const terminationRequestedP = context;
TSession * const abyssSessionP = callInfo;
xmlrpc_env_init(faultP);
fprintf(stderr, "Termination requested: %s\n", comment);
printPeerIpAddr(abyssSessionP);
*terminationRequestedP = 1;
}
int
main(int const argc,
const char ** const argv) {
struct xmlrpc_method_info3 const methodInfo = {
.methodName = "sample.add",
.methodFunction = &sample_add,
.serverInfo = NULL
};
TServer abyssServer;
xmlrpc_registry * registryP;
xmlrpc_env env;
int terminationRequested; /* A boolean value */
const char * error;
if (argc-1 != 1) {
fprintf(stderr, "You must specify 1 argument: The TCP port number "
"on which to listen for XML-RPC calls. "
"You specified %d.\n", argc-1);
exit(1);
}
AbyssInit(&error);
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
xmlrpc_registry_set_shutdown(registryP,
&requestShutdown, &terminationRequested);
ServerCreate(&abyssServer, "XmlRpcServer", atoi(argv[1]), NULL, NULL);
xmlrpc_server_abyss_set_handlers2(&abyssServer, "/RPC2", registryP);
ServerInit(&abyssServer);
setupSignalHandlers();
terminationRequested = 0;
while (!terminationRequested) {
printf("Waiting for next RPC...\n");
ServerRunOnce(&abyssServer);
/* This waits for the next connection, accepts it, reads the
HTTP POST request, executes the indicated RPC, and closes
the connection.
*/
}
ServerFree(&abyssServer);
AbyssTerm();
return 0;
}
|
