/* vim: set expandtab ts=4 sw=4: */
/*
* You may redistribute this program and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation,
* either version 3 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, see .
*/
#include "util/events/libuv/UvWrapper.h"
#include "benc/String.h"
#include "exception/Er.h"
#include "memory/Allocator.h"
#include "util/events/Pipe.h"
#include "util/events/PipeServer.h"
#include "util/events/libuv/Pipe_pvt.h"
#include "util/events/libuv/EventBase_pvt.h"
#include "util/log/Log.h"
#include "util/Identity.h"
#include "util/CString.h"
#include "wire/Message.h"
#include "wire/Error.h"
#include
#include
#include
#include
#include
struct PipeServer_pvt;
struct Client
{
struct Iface iface;
struct Pipe* pipe;
struct PipeServer_pvt* psp;
struct Allocator* alloc;
struct Sockaddr addr;
Identity
};
#define Map_NAME Clients
#define Map_ENABLE_HANDLES
#define Map_VALUE_TYPE struct Client*
#include "util/Map.h"
struct PipeServer_pvt
{
struct PipeServer pub;
uv_pipe_t server;
struct Map_Clients clients;
struct Allocator_OnFreeJob* closeHandlesOnFree;
struct Allocator* alloc;
struct EventBase_pvt* base;
struct Log* log;
uint32_t nextHandle;
Identity
};
static Iface_DEFUN sendMessage(struct Message* m, struct Iface* iface)
{
struct PipeServer_pvt* psp = Identity_check((struct PipeServer_pvt*) iface);
struct Sockaddr* addr = Er_assert(AddrIface_popAddr(m));
uint32_t handle = Sockaddr_addrHandle(addr);
int idx = Map_Clients_indexForHandle(handle, &psp->clients);
if (idx < 0) {
Log_warn(psp->log, "Attempted to send a message to client [0x%x] which is gone", handle);
return Error(m, "UNHANDLED");
}
struct Client* cli = psp->clients.values[idx];
return Iface_next(&cli->iface, m);
}
static Iface_DEFUN incomingFromClient(struct Message* msg, struct Iface* iface)
{
struct Client* cli = Identity_containerOf(iface, struct Client, iface);
struct PipeServer_pvt* psp = Identity_check(cli->psp);
Er_assert(AddrIface_pushAddr(msg, &cli->addr));
return Iface_next(&psp->pub.iface.iface, msg);
}
/** Asynchronous allocator freeing. */
static void onClose(uv_handle_t* handle)
{
struct PipeServer_pvt* psp = Identity_check((struct PipeServer_pvt*)handle->data);
handle->data = NULL;
if (psp->closeHandlesOnFree && !psp->server.data) {
Allocator_onFreeComplete((struct Allocator_OnFreeJob*) psp->closeHandlesOnFree);
}
}
static struct Pipe* getPipe(struct PipeServer_pvt* psp, struct Allocator* alloc)
{
struct Er_Ret* er = NULL;
struct Pipe* out = Er_check(&er, Pipe_serverAccept(
&psp->server, psp->pub.fullName, &psp->base->pub, psp->log, alloc));
if (er) {
Log_warn(psp->log, "failed to connect to client on pipe [%s] [%s]",
psp->pub.fullName, er->message);
}
return out;
}
static int removeClientOnFree(struct Allocator_OnFreeJob* job)
{
struct Client* cli = Identity_check((struct Client*)job->userData);
struct PipeServer_pvt* psp = Identity_check(cli->psp);
uint32_t handle = Sockaddr_addrHandle(&cli->addr);
int idx = Map_Clients_indexForHandle(handle, &psp->clients);
if (idx > -1) {
Map_Clients_remove(idx, &psp->clients);
}
return 0;
}
static void pipeOnClose(struct Pipe* p, int status)
{
struct Client* cli = Identity_check((struct Client*) p->userData);
struct PipeServer_pvt* psp = Identity_check(cli->psp);
if (psp->pub.onDisconnection) {
psp->pub.onDisconnection(&psp->pub, &cli->addr);
}
Allocator_free(cli->alloc);
}
static void listenCallback(uv_stream_t* server, int status)
{
uv_pipe_t* pServer = (uv_pipe_t*) server;
struct PipeServer_pvt* psp = Identity_containerOf(pServer, struct PipeServer_pvt, server);
if (status == -1) {
Log_info(psp->log, "failed to accept pipe connection [%s] [%s]",
psp->pub.fullName, uv_strerror(status));
return;
}
struct Allocator* pipeAlloc = Allocator_child(psp->alloc);
struct Pipe* p = getPipe(psp, pipeAlloc);
if (p == NULL) {
Allocator_free(pipeAlloc);
return;
}
struct Client* cli = Allocator_calloc(pipeAlloc, sizeof(struct Client), 1);
cli->iface.send = incomingFromClient;
Iface_plumb(&cli->iface, &p->iface);
cli->alloc = pipeAlloc;
cli->pipe = p;
cli->psp = psp;
p->userData = cli;
Identity_set(cli);
int idx = Map_Clients_put(&cli, &psp->clients);
uint32_t handle = psp->clients.handles[idx];
Sockaddr_addrFromHandle(&cli->addr, handle);
{
// assertions
Assert_true(handle == Sockaddr_addrHandle(&cli->addr));
//printf("Handle is %x index is %d\n", handle, idx);
int idx2 = Map_Clients_indexForHandle(handle, &psp->clients);
Assert_true(idx2 == idx);
}
Allocator_onFree(pipeAlloc, removeClientOnFree, cli);
if (psp->pub.onConnection) {
psp->pub.onConnection(&psp->pub, &cli->addr);
}
cli->pipe->onClose = pipeOnClose;
}
static int closeHandlesOnFree(struct Allocator_OnFreeJob* job)
{
struct PipeServer_pvt* psp = Identity_check((struct PipeServer_pvt*)job->userData);
psp->closeHandlesOnFree = job;
if (psp->server.data) {
uv_close((uv_handle_t*) &psp->server, onClose);
return Allocator_ONFREE_ASYNC;
}
return 0;
}
static struct PipeServer_pvt* newPipeAny(struct EventBase* eb,
const char* fullPath,
struct Except* eh,
struct Log* log,
struct Allocator* userAlloc)
{
struct EventBase_pvt* ctx = EventBase_privatize(eb);
struct Allocator* alloc = Allocator_child(userAlloc);
struct PipeServer_pvt* psp = Allocator_clone(alloc, (&(struct PipeServer_pvt) {
.pub = {
.iface = {
.iface = {
.send = sendMessage
},
.alloc = alloc,
},
.fullName = CString_strdup(fullPath, alloc),
},
.clients = {
.allocator = alloc
},
.base = ctx,
.alloc = alloc,
.log = log,
}));
int ret = uv_pipe_init(ctx->loop, &psp->server, 0);
if (ret) {
Except_throw(eh, "uv_pipe_init() failed [%s]", uv_strerror(ret));
}
Allocator_onFree(alloc, closeHandlesOnFree, psp);
psp->server.data = psp;
//out->out = &out->peer;
Identity_set(psp);
return psp;
}
struct PipeServer* PipeServer_named(const char* fullPath,
struct EventBase* eb,
struct Except* eh,
struct Log* log,
struct Allocator* userAlloc)
{
struct PipeServer_pvt* out = newPipeAny(eb, fullPath, eh, log, userAlloc);
int ret = uv_pipe_bind(&out->server, out->pub.fullName);
if (ret) {
Except_throw(eh, "uv_pipe_bind() failed [%s] for pipe [%s]",
uv_strerror(ret), out->pub.fullName);
}
ret = uv_listen((uv_stream_t*) &out->server, 1, listenCallback);
if (ret) {
Except_throw(eh, "uv_listen() failed [%s] for pipe [%s]",
uv_strerror(ret), out->pub.fullName);
}
return &out->pub;
}