static int pipe_echo_start(char* pipeName) {
int r;
#ifndef _WIN32
{
uv_fs_t req;
uv_fs_unlink(uv_default_loop(), &req, pipeName, NULL);
uv_fs_req_cleanup(&req);
}
#endif
server = (uv_handle_t*)&pipeServer;
serverType = PIPE;
r = uv_pipe_init(loop, &pipeServer, 0);
if (r) {
fprintf(stderr, "uv_pipe_init: %s\n", uv_strerror(r));
return 1;
}
r = uv_pipe_bind(&pipeServer, pipeName);
if (r) {
fprintf(stderr, "uv_pipe_bind: %s\n", uv_strerror(r));
return 1;
}
r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "uv_pipe_listen: %s\n", uv_strerror(r));
return 1;
}
return 0;
}
Status
api_init (Server *server)
{
Api *api = &server->api;
int rc = 0;
api->reusable_base = NULL;
api->base_alloc = false;
debug ("pipe unlink: %s", server->host_pipe);
uv_fs_t req;
uv_fs_unlink (server->loop, &req, server->host_pipe, NULL);
// ignore error if pipe doesn't already exist
debug ("pipe init");
rc = uv_pipe_init (server->loop, (uv_pipe_t *) api, 0);
if (rc < 0)
goto error;
debug ("pipe bind: %s", server->host_pipe);
rc = uv_pipe_bind ((uv_pipe_t *) api, server->host_pipe);
if (rc < 0)
goto error;
return G_OK;
error:
if (rc)
debug ("error: %s", uv_strerror (rc));
return G_ERR;
}
uv_stream_t* createPipeServer(uv_loop_t* pLoop, const std::string& name,
int mask, WebApplication* pWebApplication) {
// We own pWebApplication. It will be destroyed by the socket but if in
// the future we have failure cases that stop execution before we get
// that far, we MUST delete pWebApplication ourselves.
// Deletes itself when destroy() is called, which occurs in freeServer()
Socket* pSocket = new Socket();
// TODO: Handle error
uv_pipe_init(pLoop, &pSocket->handle.pipe, true);
pSocket->handle.isTcp = false;
pSocket->handle.stream.data = pSocket;
pSocket->pWebApplication = pWebApplication;
mode_t oldMask = 0;
if (mask >= 0)
oldMask = umask(mask);
int r = uv_pipe_bind(&pSocket->handle.pipe, name.c_str());
if (mask >= 0)
umask(oldMask);
if (r) {
pSocket->destroy();
return NULL;
}
r = uv_listen((uv_stream_t*)&pSocket->handle.stream, 128, &on_request);
if (r) {
pSocket->destroy();
return NULL;
}
return &pSocket->handle.stream;
}
int run_ipc_send_recv_helper(uv_loop_t* loop, int inprocess) {
int r;
is_in_process = inprocess;
memset(&ctx2, 0, sizeof(ctx2));
r = uv_pipe_init(loop, &ctx2.listen, 0);
ASSERT(r == 0);
r = uv_pipe_init(loop, &ctx2.channel, 1);
ASSERT(r == 0);
if (inprocess) {
r = uv_pipe_bind(&ctx2.listen, TEST_PIPENAME_3);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&ctx2.listen, SOMAXCONN, listen_cb);
ASSERT(r == 0);
} else {
r = uv_pipe_open(&ctx2.channel, 0);
ASSERT(r == 0);
send_recv_start();
}
r = uv_run(loop, UV_RUN_DEFAULT);
ASSERT(r == 0);
return 0;
}
static int run_worker(uv_loop_t *loop, struct engine *engine)
{
/* Control sockets or TTY */
auto_free char *sock_file = NULL;
uv_pipe_t pipe;
uv_pipe_init(loop, &pipe, 0);
pipe.data = engine;
if (g_interactive) {
printf("[system] interactive mode\n> ");
fflush(stdout);
uv_pipe_open(&pipe, 0);
uv_read_start((uv_stream_t*) &pipe, tty_alloc, tty_read);
} else {
(void) mkdir("tty", S_IRWXU|S_IRWXG);
sock_file = afmt("tty/%ld", getpid());
if (sock_file) {
uv_pipe_bind(&pipe, sock_file);
uv_listen((uv_stream_t *) &pipe, 16, tty_accept);
}
}
/* Run event loop */
uv_run(loop, UV_RUN_DEFAULT);
if (sock_file) {
unlink(sock_file);
}
return kr_ok();
}
/* Set up an IPC pipe server that hands out listen sockets to the worker
* threads. It's kind of cumbersome for such a simple operation, maybe we
* should revive uv_import() and uv_export().
*/
void start_connection_dispatching(uv_handle_type type, unsigned int num_servers, struct server_ctx* servers, char* listen_address, int listen_port)
{
int rc;
struct ipc_server_ctx ctx;
uv_loop_t* loop;
unsigned int i;
loop = uv_default_loop();
ctx.num_connects = num_servers;
if (type == UV_TCP)
{
uv_ip4_addr(listen_address, listen_port, &listen_addr);
rc = uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle);
rc = uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, (const struct sockaddr*)&listen_addr, 0);
printf("Listening on %s:%d\n", listen_address, listen_port);
}
rc = uv_pipe_init(loop, &ctx.ipc_pipe, 1);
rc = uv_pipe_bind(&ctx.ipc_pipe, "HAYWIRE_CONNECTION_DISPATCH_PIPE_NAME");
rc = uv_listen((uv_stream_t*) &ctx.ipc_pipe, 128, ipc_connection_cb);
for (i = 0; i < num_servers; i++)
uv_sem_post(&servers[i].semaphore);
rc = uv_run(loop, UV_RUN_DEFAULT);
uv_close((uv_handle_t*) &ctx.server_handle, NULL);
rc = uv_run(loop, UV_RUN_DEFAULT);
for (i = 0; i < num_servers; i++)
uv_sem_wait(&servers[i].semaphore);
}
static int pipe_echo_start(char* pipeName) {
int r;
server = (uv_handle_t*)&pipeServer;
serverType = PIPE;
r = uv_pipe_init(loop, &pipeServer);
if (r) {
fprintf(stderr, "uv_pipe_init: %s\n",
uv_strerror(uv_last_error(loop)));
return 1;
}
r = uv_pipe_bind(&pipeServer, pipeName);
if (r) {
fprintf(stderr, "uv_pipe_bind: %s\n",
uv_strerror(uv_last_error(loop)));
return 1;
}
r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "uv_pipe_listen: %s\n",
uv_strerror(uv_last_error(loop)));
return 1;
}
return 0;
}
/*
* Class: com_iwebpp_libuvpp_handles_PipeHandle
* Method: _bind
* Signature: (JLjava/lang/String;)I
*/
extern "C" JNIEXPORT jint JNICALL Java_com_iwebpp_libuvpp_handles_PipeHandle__1bind
(JNIEnv *env, jobject that, jlong pipe, jstring name) {
assert(pipe);
uv_pipe_t* handle = reinterpret_cast<uv_pipe_t*>(pipe);
const char* n = env->GetStringUTFChars(name, 0);
int r = uv_pipe_bind(handle, n);
if (r) {
ThrowException(env, handle->loop, "uv_pipe_bind", n);
}
env->ReleaseStringUTFChars(name, n);
return r;
}
static int run_ipc_send_recv_pipe(int inprocess) {
int r;
ctx.expected_type = UV_NAMED_PIPE;
r = uv_pipe_init(uv_default_loop(), &ctx.send.pipe, 1);
ASSERT(r == 0);
r = uv_pipe_bind(&ctx.send.pipe, TEST_PIPENAME);
ASSERT(r == 0);
r = uv_pipe_init(uv_default_loop(), &ctx.send2.pipe, 1);
ASSERT(r == 0);
r = uv_pipe_bind(&ctx.send2.pipe, TEST_PIPENAME_2);
ASSERT(r == 0);
r = run_test(inprocess);
ASSERT(r == 0);
MAKE_VALGRIND_HAPPY();
return 0;
}
void durotanInit() {
int err;
durotan = malloc(sizeof(uv_pipe_t));
uv_pipe_init(loop, durotan, 0);
uv_fs_t req;
uv_fs_unlink(loop, &req, SOCKET, NULL);
err = uv_pipe_bind(durotan, SOCKET);
if(err) ERROR("durotan bind", err);
err = uv_listen((uv_stream_t*) durotan, 128, durotanOnConnection);
if(err) ERROR("durotan listen", err);
printf("durotan: listening\n");
}
int main() {
loop = uv_default_loop();
uv_pipe_t server;
uv_pipe_init(loop, &server, 0);
signal(SIGINT, remove_sock);
int r;
if ((r = uv_pipe_bind(&server, "echo.sock"))) {
fprintf(stderr, "Bind error %s\n", uv_err_name(r));
return 1;
}
if ((r = uv_listen((uv_stream_t*) &server, 128, on_new_connection))) {
fprintf(stderr, "Listen error %s\n", uv_err_name(r));
return 2;
}
return uv_run(loop, UV_RUN_DEFAULT);
}
static PyObject *
Pipe_func_bind(Pipe *self, PyObject *args)
{
int r;
char *name;
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "s:bind", &name)) {
return NULL;
}
r = uv_pipe_bind((uv_pipe_t *)UV_HANDLE(self), name);
if (r != 0) {
RAISE_UV_EXCEPTION(UV_HANDLE_LOOP(self), PyExc_PipeError);
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
Pipe_func_bind(Pipe *self, PyObject *args)
{
int err;
char *name;
RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);
if (!PyArg_ParseTuple(args, "s:bind", &name)) {
return NULL;
}
err = uv_pipe_bind(&self->pipe_h, name);
if (err < 0) {
RAISE_UV_EXCEPTION(err, PyExc_PipeError);
return NULL;
}
Py_RETURN_NONE;
}
static bool caerOutputUnixSocketServerInit(caerModuleData moduleData) {
// First, always create all needed setting nodes, set their default values
// and add their listeners.
sshsNodeCreateString(moduleData->moduleNode, "socketPath", "/tmp/caer.sock", 2, PATH_MAX, SSHS_FLAGS_NORMAL,
"Unix Socket path for writing output data (server mode, create new socket).");
sshsNodeCreateInt(
moduleData->moduleNode, "backlogSize", 5, 1, 32, SSHS_FLAGS_NORMAL, "Maximum number of pending connections.");
sshsNodeCreateInt(moduleData->moduleNode, "concurrentConnections", 10, 1, 128, SSHS_FLAGS_NORMAL,
"Maximum number of concurrent active connections.");
// Allocate memory.
size_t numClients = (size_t) sshsNodeGetInt(moduleData->moduleNode, "concurrentConnections");
outputCommonNetIO streams = malloc(sizeof(*streams) + (numClients * sizeof(uv_stream_t *)));
if (streams == NULL) {
caerModuleLog(moduleData, CAER_LOG_ERROR, "Failed to allocate memory for streams structure.");
return (false);
}
streams->server = malloc(sizeof(uv_pipe_t));
if (streams->server == NULL) {
free(streams);
caerModuleLog(moduleData, CAER_LOG_ERROR, "Failed to allocate memory for network server.");
return (false);
}
// Initialize common info.
streams->isTCP = false;
streams->isUDP = false;
streams->isPipe = true;
streams->activeClients = 0;
streams->clientsSize = numClients;
for (size_t i = 0; i < streams->clientsSize; i++) {
streams->clients[i] = NULL;
}
// Remember address.
streams->address = sshsNodeGetString(moduleData->moduleNode, "socketPath");
streams->server->data = streams;
// Initialize loop and network handles.
int retVal = uv_loop_init(&streams->loop);
UV_RET_CHECK(retVal, moduleData->moduleSubSystemString, "uv_loop_init", free(streams->server);
free(streams->address); free(streams); return (false));
retVal = uv_pipe_init(&streams->loop, (uv_pipe_t *) streams->server, false);
UV_RET_CHECK(retVal, moduleData->moduleSubSystemString, "uv_pipe_init", uv_loop_close(&streams->loop);
free(streams->server); free(streams->address); free(streams); return (false));
retVal = uv_pipe_bind((uv_pipe_t *) streams->server, streams->address);
UV_RET_CHECK(retVal, moduleData->moduleSubSystemString, "uv_pipe_bind", libuvCloseLoopHandles(&streams->loop);
uv_loop_close(&streams->loop); free(streams->address); free(streams); return (false));
retVal = uv_listen(
streams->server, sshsNodeGetInt(moduleData->moduleNode, "backlogSize"), &caerOutputCommonOnServerConnection);
UV_RET_CHECK(retVal, moduleData->moduleSubSystemString, "uv_listen", libuvCloseLoopHandles(&streams->loop);
uv_loop_close(&streams->loop); free(streams->address); free(streams); return (false));
// Start.
if (!caerOutputCommonInit(moduleData, -1, streams)) {
libuvCloseLoopHandles(&streams->loop);
uv_loop_close(&streams->loop);
free(streams->address);
free(streams);
return (false);
}
return (true);
}
bool bind(const std::string& name)
{
return uv_pipe_bind(get(), name.c_str()) == 0;
}
extern "C" int
rust_uv_pipe_bind(uv_pipe_t *pipe, char *name) {
return uv_pipe_bind(pipe, name);
}