char *
sample_send(void *arg, const gchar *fcall_str,
size_t fcall_len, size_t *ret_len)
{
cl_assert_ (strcmp(arg, "test") == 0, arg);
char *ret;
/* directly call in memory, instead of send via network */
gchar *temp = g_strdup(fcall_str);
ret = searpc_server_call_function ("test", temp, fcall_len, ret_len);
g_free (temp);
return ret;
}
int
sample_async_send (void *arg, gchar *fcall_str,
size_t fcall_len, void *rpc_priv)
{
cl_assert (strcmp(arg, "test_async") == 0);
char *ret;
size_t ret_len;
gchar *temp = g_strdup(fcall_str);
ret = searpc_server_call_function ("test", temp, fcall_len, &ret_len);
g_free (temp);
searpc_client_generic_callback (ret, ret_len, rpc_priv, NULL);
return 0;
}
static void* named_pipe_client_handler(void *arg)
{
ServerHandlerData *data = arg;
// SearpcNamedPipeServer *server = data->server;
SearpcNamedPipe connfd = data->connfd;
size_t len;
size_t bufsize = 4096;
char *buf = g_malloc(bufsize);
g_debug ("start to serve on pipe client\n");
while (1) {
len = 0;
if (pipe_read_n(connfd, &len, sizeof(uint32_t)) < 0) {
g_warning("failed to read rpc request size: %s", strerror(errno));
break;
}
if (len == 0) {
g_debug("EOF reached, pipe connection lost");
break;
}
while (bufsize < len) {
bufsize *= 2;
buf = realloc(buf, bufsize);
}
if (pipe_read_n(connfd, buf, len) < 0 || len == 0) {
g_warning("failed to read rpc request: %s", strerror(errno));
g_free (buf);
break;
}
char *service, *body;
if (request_from_json (buf, len, &service, &body) < 0) {
break;
}
size_t ret_len;
char *ret_str = searpc_server_call_function (service, body, strlen(body), &ret_len);
g_free (service);
g_free (body);
if (pipe_write_n(connfd, &ret_len, sizeof(uint32_t)) < 0) {
g_warning("failed to send rpc response(%s): %s", ret_str, strerror(errno));
g_free (ret_str);
break;
}
if (pipe_write_n(connfd, ret_str, ret_len) < 0) {
g_warning("failed to send rpc response: %s", strerror(errno));
g_free (ret_str);
break;
}
g_free (ret_str);
}
#if !defined(WIN32)
close(connfd);
#else // !defined(WIN32)
DisconnectNamedPipe(connfd);
CloseHandle(connfd);
#endif // !defined(WIN32)
return NULL;
}
int
main(int argc, char *argv[])
{
int listenfd, connfd;
int ret;
struct sockaddr_in client_addr, server_addr;
socklen_t clilen;
char buf[BUFLEN];
packet *pac, *pac_ret;
g_type_init();
#ifdef WIN32
WSADATA wsadata;
WSAStartup(0x0101, &wsadata);
#endif
start_rpc_service();
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd < 0) {
fprintf(stderr, "socket failed: %s\n", strerror(errno));
exit(-1);
}
int on = 1;
if (setsockopt (listenfd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)) < 0) {
fprintf (stderr, "setsockopt of SO_REUSEADDR error: %s\n", strerror(errno));
exit(-1);
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(12345);
ret = bind(listenfd, (struct sockaddr *)&server_addr,
sizeof(server_addr));
if (ret < 0) {
fprintf(stderr, "bind failed: %s\n", strerror(errno));
exit(-1);
}
ret = listen(listenfd, 5);
if (ret < 0) {
fprintf(stderr, "listen failed: %s\n", strerror(errno));
exit(-1);
}
while (1) {
GError *error = NULL;
clilen = sizeof(client_addr);
connfd = accept(listenfd, (struct sockaddr *)&client_addr, &clilen);
if (connfd < 0) {
fprintf(stderr, "accept failed: %s\n", strerror(errno));
continue;
}
/* read the header packet */
pac = read_packet(connfd, buf);
if (pac == NULL) {
fprintf(stderr, "read packet failed: %s\n", strerror(errno));
exit(-1);
}
gsize ret_len;
int fcall_len = ntohs(pac->length);
/* Execute the RPC function */
char *res = searpc_server_call_function ("searpc-demo", pac->data, fcall_len,
&ret_len);
pac_ret = (packet *)buf;
pac_ret->length = htons((uint16_t)ret_len);
memcpy(pac_ret->data, res, ret_len);
/* send the ret packet */
if (writen (connfd, buf, PACKET_HEADER_LENGTH + ret_len) == -1) {
fprintf (stderr, "write packet failed: %s\n", strerror(errno));
exit(-1);
}
}
return 0;
}
