/* 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 "benc/String.h"
#include "crypto/random/Random.h"
#include "util/events/EventBase.h"
#include "util/events/PipeServer.h"
#include "util/events/Pipe.h"
#include "util/events/Timeout.h"
#include "memory/Allocator.h"
#include "memory/MallocAllocator.h"
#include "util/events/Process.h"
#include "util/log/Log.h"
#include "util/log/FileWriterLog.h"
#include "util/CString.h"
#include "util/Assert.h"
#include "wire/Message.h"
#include "wire/Error.h"
#include
#include
#include
#include
#include
#include
#define MESSAGE "IT WORKS!"
#define MESSAGEB "INDEED"
struct Context {
struct Iface iface;
struct Allocator* alloc;
struct EventBase* base;
struct Log* log;
// Parent only
int fd;
// child only
char* name;
Identity
};
static void onConnectionParent(struct PipeServer* p, struct Sockaddr* addr)
{
struct Context* c = Identity_check((struct Context*) p->userData);
struct Allocator* alloc = Allocator_child(c->alloc);
struct Message* msg = Message_new(0, 256, alloc);
Er_assert(Message_epush(msg, MESSAGE, CString_strlen(MESSAGE) + 1));
Er_assert(AddrIface_pushAddr(msg, addr));
if (!Defined(win32)) {
Message_setAssociatedFd(msg, c->fd);
}
printf("Parent sending message [%s] len [%d]\n", MESSAGE, Message_getLength(msg));
Iface_send(&c->iface, msg);
Allocator_free(alloc);
}
static Iface_DEFUN receiveMessageParent(struct Message* msg, struct Iface* iface)
{
struct Context* c = Identity_check((struct Context*) iface);
Er_assert(AddrIface_popAddr(msg));
Assert_true(Message_getLength(msg) == (int)CString_strlen(MESSAGEB)+1);
Assert_true(!Bits_memcmp(msg->msgbytes, MESSAGEB, CString_strlen(MESSAGEB)+1));
Allocator_free(c->alloc);
return NULL;
}
static void timeout(void* vNULL)
{
Assert_true(!"timed out.");
}
static void onConnectionChild(struct Pipe* p, int status)
{
Assert_true(!status);
printf("Child connected\n");
}
static Iface_DEFUN receiveMessageChild(struct Message* msg, struct Iface* iface)
{
struct Context* c = Identity_check((struct Context*) iface);
struct Message* m = Message_clone(msg, c->alloc);
printf("Child received message\n");
Assert_true(Message_getLength(m) == (int)CString_strlen(MESSAGE)+1);
Assert_true(!Bits_memcmp(m->msgbytes, MESSAGE, CString_strlen(MESSAGE)+1));
if (!Defined(win32)) {
int fd = Message_getAssociatedFd(msg);
if (lseek(fd, 0, SEEK_SET) < 0) {
printf("lseek(%d) failed: errno %s\n", fd, strerror(errno));
Assert_failure("lseek()");
}
uint8_t* buf = Allocator_calloc(Message_getAlloc(msg), 2048, 1);
if (read(fd, buf, 1024) < 0) {
printf("read(%d) failed: errno %s\n", fd, strerror(errno));
Assert_failure("read()");
}
if (CString_strncmp(buf, c->name, 1024)) {
printf("want: %s\n"
"got: %s", c->name, buf);
Assert_failure("file content is wrong");
}
}
Er_assert(Message_eshift(m, -((int)CString_strlen(MESSAGE))));
Er_assert(Message_epush(m, MESSAGEB, CString_strlen(MESSAGEB)));
Iface_send(&c->iface, m);
// shutdown
Allocator_free(c->alloc);
return NULL;
}
static void child(char* name, struct Context* ctx)
{
struct Pipe* pipe = Er_assert(Pipe_named(name, ctx->base, ctx->log, ctx->alloc));
pipe->onConnection = onConnectionChild;
pipe->userData = ctx;
ctx->iface.send = receiveMessageChild;
ctx->name = name;
Iface_plumb(&ctx->iface, &pipe->iface);
Timeout_setTimeout(timeout, NULL, 2000, ctx->base, ctx->alloc);
EventBase_beginLoop(ctx->base);
}
int main(int argc, char** argv)
{
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct EventBase* eb = EventBase_new(alloc);
struct Log* log = FileWriterLog_new(stdout, alloc);
struct Context* ctx = Allocator_calloc(alloc, sizeof(struct Context), 1);
Identity_set(ctx);
ctx->alloc = alloc;
ctx->base = eb;
ctx->log = log;
ctx->iface.send = receiveMessageParent;
if (argc > 3 && !CString_strcmp("Process_test", argv[1]) && !CString_strcmp("child", argv[2])) {
child(argv[3], ctx);
return 0;
}
struct Random* rand = Random_new(alloc, log, NULL);
char randName[32] = {0};
Random_base32(rand, (uint8_t*)randName, 31);
String* name = String_printf(alloc, "%s%scjdns-test-%s", Pipe_PATH, Pipe_PATH_SEP, randName);
if (!Defined(win32)) {
String* textName =
String_printf(alloc, "%s%scjdns-test-%s.txt", Pipe_PATH, Pipe_PATH_SEP, randName);
int fd = open(textName->bytes, O_CREAT | O_TRUNC | O_RDWR, 0600);
Assert_true(fd >= 0);
Assert_true(write(fd, name->bytes, name->len) == ((ssize_t)name->len));
ctx->fd = fd;
unlink(textName->bytes);
}
struct PipeServer* pipe = PipeServer_named(name->bytes, eb, NULL, log, alloc);
pipe->userData = ctx;
pipe->onConnection = onConnectionParent;
Iface_plumb(&ctx->iface, &pipe->iface.iface);
char* path = Process_getPath(alloc);
Assert_true(path != NULL);
#ifdef win32
Assert_true(CString_strstr(path, ":\\") == path + 1); /* C:\ */
Assert_true(CString_strstr(path, ".exe"));
#elif openbsd
Assert_true(path[0] == 'b'); // Process_getPath returns relative paths on openbsd
#elif netbsd
Assert_true(path[0] == 'b'); // Process_getPath returns relative paths on netbsd too
#else
Assert_true(path[0] == '/');
#endif
char* args[] = { "Process_test", "child", name->bytes, NULL };
Assert_true(!Process_spawn(path, args, alloc, NULL));
Timeout_setTimeout(timeout, NULL, 2000, eb, alloc);
EventBase_beginLoop(eb);
unlink(name->bytes);
return 0;
}