int
shutdown_reaper(Service *, int pid, int status)
{
reaper(NULL,pid,status);
startd_check_free();
return TRUE;
}
TEST_F(KVDropPendingIdentReaperTest,
AddDropPendingIdentWithDuplicateDropTimestampButDifferentIdent) {
auto engine = getEngine();
KVDropPendingIdentReaper reaper(engine);
Timestamp dropTimestamp{Seconds(100), 0};
NamespaceString nss1("test.foo");
constexpr auto ident1 = "ident1"_sd;
NamespaceString nss2("test.bar");
constexpr auto ident2 = "ident2"_sd;
reaper.addDropPendingIdent(dropTimestamp, nss1, ident1);
reaper.addDropPendingIdent(dropTimestamp, nss2, ident2);
// getAllIdents() returns a set of drop-pending idents known to the reaper.
auto dropPendingIdents = reaper.getAllIdents();
ASSERT_EQUALS(2U, dropPendingIdents.size());
ASSERT(dropPendingIdents.find(ident1.toString()) != dropPendingIdents.cend());
ASSERT(dropPendingIdents.find(ident2.toString()) != dropPendingIdents.cend());
// Check earliest drop timestamp.
ASSERT_EQUALS(dropTimestamp, *reaper.getEarliestDropTimestamp());
// This should have no effect.
auto opCtx = makeOpCtx();
reaper.dropIdentsOlderThan(opCtx.get(), dropTimestamp);
ASSERT_EQUALS(0U, engine->droppedIdents.size());
// Drop all idents managed by reaper and confirm number of drops.
reaper.dropIdentsOlderThan(opCtx.get(), makeTimestampWithNextInc(dropTimestamp));
ASSERT_EQUALS(2U, engine->droppedIdents.size());
ASSERT_EQUALS(ident1, engine->droppedIdents.front());
ASSERT_EQUALS(ident2, engine->droppedIdents.back());
}
TEST_F(KVDropPendingIdentReaperTest, AddDropPendingIdentAcceptsNullDropTimestamp) {
Timestamp nullDropTimestamp;
NamespaceString nss("test.foo");
constexpr auto ident = "myident"_sd;
auto engine = getEngine();
KVDropPendingIdentReaper reaper(engine);
reaper.addDropPendingIdent(nullDropTimestamp, nss, ident);
ASSERT_EQUALS(nullDropTimestamp, *reaper.getEarliestDropTimestamp());
auto opCtx = makeOpCtx();
reaper.dropIdentsOlderThan(opCtx.get(), {Seconds(100), 0});
ASSERT_EQUALS(1U, engine->droppedIdents.size());
ASSERT_EQUALS(ident, engine->droppedIdents.front());
}
TEST_F(KVDropPendingIdentReaperTest, GetEarliestDropTimestampReturnsBoostNoneOnEmptyIdents) {
KVDropPendingIdentReaper reaper(nullptr);
ASSERT_FALSE(reaper.getEarliestDropTimestamp());
}
status_t Harness::testStateTransitions(
const char *componentName, const char *componentRole) {
if (strncmp(componentName, "OMX.", 4)) {
// Non-OMX components, i.e. software decoders won't execute this
// test.
return OK;
}
sp<MemoryDealer> dealer = new MemoryDealer(16 * 1024 * 1024, "OMXHarness");
IOMX::node_id node;
status_t err =
mOMX->allocateNode(componentName, this, &node);
EXPECT_SUCCESS(err, "allocateNode");
NodeReaper reaper(this, node);
err = setRole(node, componentRole);
EXPECT_SUCCESS(err, "setRole");
// Initiate transition Loaded->Idle
err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateIdle);
EXPECT_SUCCESS(err, "sendCommand(go-to-Idle)");
omx_message msg;
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
// Make sure node doesn't just transition to idle before we are done
// allocating all input and output buffers.
EXPECT(err == TIMED_OUT,
"Component must not transition from loaded to idle before "
"all input and output buffers are allocated.");
// Now allocate buffers.
Vector<Buffer> inputBuffers;
err = allocatePortBuffers(dealer, node, 0, &inputBuffers);
EXPECT_SUCCESS(err, "allocatePortBuffers(input)");
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
CHECK_EQ(err, TIMED_OUT);
Vector<Buffer> outputBuffers;
err = allocatePortBuffers(dealer, node, 1, &outputBuffers);
EXPECT_SUCCESS(err, "allocatePortBuffers(output)");
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
EXPECT(err == OK
&& msg.type == omx_message::EVENT
&& msg.u.event_data.event == OMX_EventCmdComplete
&& msg.u.event_data.data1 == OMX_CommandStateSet
&& msg.u.event_data.data2 == OMX_StateIdle,
"Component did not properly transition to idle state "
"after all input and output buffers were allocated.");
// Initiate transition Idle->Executing
err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateExecuting);
EXPECT_SUCCESS(err, "sendCommand(go-to-Executing)");
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
EXPECT(err == OK
&& msg.type == omx_message::EVENT
&& msg.u.event_data.event == OMX_EventCmdComplete
&& msg.u.event_data.data1 == OMX_CommandStateSet
&& msg.u.event_data.data2 == OMX_StateExecuting,
"Component did not properly transition from idle to "
"executing state.");
for (size_t i = 0; i < outputBuffers.size(); ++i) {
err = mOMX->fillBuffer(node, outputBuffers[i].mID);
EXPECT_SUCCESS(err, "fillBuffer");
outputBuffers.editItemAt(i).mFlags |= kBufferBusy;
}
err = mOMX->sendCommand(node, OMX_CommandFlush, 1);
EXPECT_SUCCESS(err, "sendCommand(flush-output-port)");
err = dequeueMessageForNodeIgnoringBuffers(
node, &inputBuffers, &outputBuffers, &msg, DEFAULT_TIMEOUT);
EXPECT(err == OK
&& msg.type == omx_message::EVENT
&& msg.u.event_data.event == OMX_EventCmdComplete
&& msg.u.event_data.data1 == OMX_CommandFlush
&& msg.u.event_data.data2 == 1,
"Component did not properly acknowledge flushing the output port.");
for (size_t i = 0; i < outputBuffers.size(); ++i) {
EXPECT((outputBuffers[i].mFlags & kBufferBusy) == 0,
"Not all output buffers have been returned to us by the time "
"we received the flush-complete notification.");
}
for (size_t i = 0; i < outputBuffers.size(); ++i) {
err = mOMX->fillBuffer(node, outputBuffers[i].mID);
EXPECT_SUCCESS(err, "fillBuffer");
outputBuffers.editItemAt(i).mFlags |= kBufferBusy;
}
// Initiate transition Executing->Idle
err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateIdle);
EXPECT_SUCCESS(err, "sendCommand(go-to-Idle)");
err = dequeueMessageForNodeIgnoringBuffers(
node, &inputBuffers, &outputBuffers, &msg, DEFAULT_TIMEOUT);
EXPECT(err == OK
&& msg.type == omx_message::EVENT
&& msg.u.event_data.event == OMX_EventCmdComplete
&& msg.u.event_data.data1 == OMX_CommandStateSet
&& msg.u.event_data.data2 == OMX_StateIdle,
"Component did not properly transition to from executing to "
"idle state.");
for (size_t i = 0; i < inputBuffers.size(); ++i) {
EXPECT((inputBuffers[i].mFlags & kBufferBusy) == 0,
"Not all input buffers have been returned to us by the "
"time we received the transition-to-idle complete "
"notification.");
}
for (size_t i = 0; i < outputBuffers.size(); ++i) {
EXPECT((outputBuffers[i].mFlags & kBufferBusy) == 0,
"Not all output buffers have been returned to us by the "
"time we received the transition-to-idle complete "
"notification.");
}
// Initiate transition Idle->Loaded
err = mOMX->sendCommand(node, OMX_CommandStateSet, OMX_StateLoaded);
EXPECT_SUCCESS(err, "sendCommand(go-to-Loaded)");
// Make sure node doesn't just transition to loaded before we are done
// freeing all input and output buffers.
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
CHECK_EQ(err, TIMED_OUT);
for (size_t i = 0; i < inputBuffers.size(); ++i) {
err = mOMX->freeBuffer(node, 0, inputBuffers[i].mID);
EXPECT_SUCCESS(err, "freeBuffer");
}
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
CHECK_EQ(err, TIMED_OUT);
for (size_t i = 0; i < outputBuffers.size(); ++i) {
err = mOMX->freeBuffer(node, 1, outputBuffers[i].mID);
EXPECT_SUCCESS(err, "freeBuffer");
}
err = dequeueMessageForNode(node, &msg, DEFAULT_TIMEOUT);
EXPECT(err == OK
&& msg.type == omx_message::EVENT
&& msg.u.event_data.event == OMX_EventCmdComplete
&& msg.u.event_data.data1 == OMX_CommandStateSet
&& msg.u.event_data.data2 == OMX_StateLoaded,
"Component did not properly transition to from idle to "
"loaded state after freeing all input and output buffers.");
err = mOMX->freeNode(node);
EXPECT_SUCCESS(err, "freeNode");
reaper.disarm();
node = 0;
return OK;
}
int main (int argc,char **argv) {
if (argc == 2) {
signal(SIGCHLD,reaper);
mount(argv[1]);
struct inodo in;
if (leer_inodo(&in, 0) < 0) {
printf("ERROR (simulacion.c -> mi_stat(/)): Error al leer el estado\n");
}
struct superbloque SB;
if (bread(0, (char *)&SB) < 0) {
printf("ERROR (simulacion.c -> error al leer el superbloque)\n");
}
if (in.t_bytes > 0) {
vaciar();
initSB(SB.n_bloques, argv[1]);
initMB(SB.n_bloques);
initAI(SB.n_bloques);
}
int i;
for (i = 0; i < N_PROCESOS; i++) {
int hilo = fork();
if (hilo == 0) {
if (proceso(i) < 0) {
printf("ERROR (simulacion.c): Error al crear el proceso %d.\n", i);
return (-1);
}
exit(0);
}
else if (hilo < 0) {
i--;
printf("Llamamos al reaper, hilo = %d\n", hilo);
reaper();
}
sleep(1);
}
while (acabados < N_PROCESOS) {
pause();
}
unmount(argv[1]);
}
else {
printf("ERROR (simulacion.c): Error, parámetros != de 2 (%d).\n", argc);
return (-1);
}
return (0);
}
int main (int argc, char *argv [])
{
po::options_description desc ("Command-line options");
po::variables_map vm;
std::string filename;
std::string user;
int64_t inflight_size;
uint64_t ack_timeout, reaper_frequency;
std::string receiver_dsn, sender_dsn, monitor_dsn, peer_uuid;
desc.add_options ()
("help", "produce help message");
desc.add_options()
("database",
po::value<std::string> (&filename)->default_value ("/tmp/sink.kch"),
"Database sink file location")
;
desc.add_options()
("ack-timeout",
po::value<uint64_t> (&ack_timeout)->default_value (5000000),
"How long to wait for ACK before resending message (microseconds)")
;
desc.add_options()
("reaper-frequency",
po::value<uint64_t> (&reaper_frequency)->default_value (2500000),
"How often to clean up expired messages (microseconds)")
;
desc.add_options()
("hard-sync",
"If enabled the data is flushed to disk on every sync")
;
desc.add_options()
("background",
"Run in daemon mode")
;
desc.add_options()
("inflight-size",
po::value<int64_t> (&inflight_size)->default_value (31457280),
"Maximum size in bytes for the in-flight messages database. Full database causes LRU collection")
;
desc.add_options()
("user",
po::value<std::string> (&user)->default_value (""),
"User the process should run under")
;
desc.add_options()
("receive-dsn",
po::value<std::string> (&receiver_dsn)->default_value ("tcp://*:11131"),
"The DSN for the receive socket")
;
desc.add_options()
("send-dsn",
po::value<std::string> (&sender_dsn)->default_value ("tcp://*:11132"),
"The DSN for the backend client communication socket")
;
desc.add_options()
("monitor-dsn",
po::value<std::string> (&monitor_dsn)->default_value ("ipc:///tmp/pzq-monitor"),
"The DSN for the monitoring socket")
;
try {
po::store (po::parse_command_line (argc, argv, desc), vm);
po::notify (vm);
} catch (po::error &e) {
std::cerr << "Error parsing command-line options: " << e.what () << std::endl;
std::cerr << desc << std::endl;
return 1;
}
if (vm.count ("help")) {
std::cerr << desc << std::endl;
return 1;
}
if (vm.count ("user") && user.length() != 0) {
struct passwd *res_user;
res_user = getpwnam( user.c_str() );
if ( !res_user ) {
std::cerr << "Could not find user " << user << std::endl;
exit(1);
}
if ( !drop_privileges ( res_user->pw_uid, res_user->pw_gid ) ) {
std::cerr << "Failed to become user" << user << std::endl;
exit(1);
}
}
// Background
if (vm.count ("background")) {
if (daemonize () == -1) {
exit (1);
}
} else {
signal (SIGINT, time_to_go);
signal (SIGHUP, time_to_go);
signal (SIGTERM, time_to_go);
}
// Init new zeromq context
zmq::context_t context (1);
{
int linger = 1000;
uint64_t in_hwm = 10, out_hwm = 1;
boost::shared_ptr<pzq::datastore_t> store (new pzq::datastore_t ());
store.get ()->open (filename, inflight_size);
store.get ()->set_ack_timeout (ack_timeout);
boost::shared_ptr<pzq::socket_t> in_socket (new pzq::socket_t (context, ZMQ_ROUTER));
in_socket.get ()->setsockopt (ZMQ_LINGER, &linger, sizeof (int));
in_socket.get ()->setsockopt (ZMQ_HWM, &in_hwm, sizeof (uint64_t));
in_socket.get ()->bind (receiver_dsn.c_str ());
boost::shared_ptr<pzq::socket_t> out_socket (new pzq::socket_t (context, ZMQ_DEALER));
out_socket.get ()->setsockopt (ZMQ_LINGER, &linger, sizeof (int));
out_socket.get ()->setsockopt (ZMQ_HWM, &out_hwm, sizeof (uint64_t));
out_socket.get ()->bind (sender_dsn.c_str ());
boost::shared_ptr<pzq::socket_t> monitor (new pzq::socket_t (context, ZMQ_ROUTER));
monitor.get ()->setsockopt (ZMQ_LINGER, &linger, sizeof (int));
monitor.get ()->setsockopt (ZMQ_HWM, &out_hwm, sizeof (uint64_t));
monitor.get ()->bind (monitor_dsn.c_str ());
try {
// Start the store manager
pzq::manager_t manager;
// Reaper for expired messages
pzq::expiry_reaper_t reaper (store);
reaper.set_frequency (reaper_frequency);
reaper.set_ack_timeout (ack_timeout);
reaper.start ();
manager.set_datastore (store);
manager.set_ack_timeout (ack_timeout);
manager.set_sockets (in_socket, out_socket, monitor);
manager.start ();
while (keep_running)
{
boost::this_thread::sleep (
boost::posix_time::seconds (1)
);
}
manager.stop ();
reaper.stop ();
} catch (std::exception &e) {
pzq::log ("Error running store manager: %s", e.what ());
return 1;
}
}
pzq::log ("Terminating");
return 0;
}
int main(int argc, char **argv)
{
short revents;
int i, listenfd, sockfd;
int ret = 0;
struct link *ln;
struct addrinfo *server_ai = NULL;
struct addrinfo *local_ai = NULL;
struct addrinfo hint;
check_ss_option(argc, argv, "client");
memset(&hint, 0, sizeof(hint));
hint.ai_family = AF_UNSPEC;
hint.ai_socktype = SOCK_STREAM;
ret = getaddrinfo(ss_opt.server_addr, ss_opt.server_port,
&hint, &server_ai);
if (ret != 0) {
pr_warn("getaddrinfo error: %s\n", gai_strerror(ret));
goto out;
}
pr_ai_notice(server_ai, "server address");
ret = getaddrinfo(ss_opt.local_addr, ss_opt.local_port, &hint, &local_ai);
if (ret != 0) {
pr_warn("getaddrinfo error: %s\n", gai_strerror(ret));
goto out;
}
pr_ai_notice(local_ai, "listening address");
if (crypto_init(ss_opt.password, ss_opt.method) == -1) {
ret = -1;
goto out;
}
ss_init();
listenfd = do_listen(local_ai, "tcp");
clients[0].fd = listenfd;
clients[0].events = POLLIN;
while (1) {
pr_debug("start polling\n");
ret = poll(clients, nfds, TCP_INACTIVE_TIMEOUT * 1000);
if (ret == -1)
err_exit("poll error");
else if (ret == 0) {
reaper();
continue;
}
if (clients[0].revents & POLLIN) {
sockfd = accept(clients[0].fd, NULL, NULL);
if (sockfd == -1) {
pr_warn("accept error\n");
} else if (poll_set(sockfd, POLLIN) == -1) {
close(sockfd);
} else {
ln = create_link(sockfd, "client");
if (ln == NULL) {
poll_del(sockfd);
close(sockfd);
} else {
ln->server = server_ai;
}
}
}
for (i = 1; i < nfds; i++) {
sockfd = clients[i].fd;
if (sockfd == -1)
continue;
revents = clients[i].revents;
if (revents == 0)
continue;
ln = get_link(sockfd);
if (ln == NULL) {
sock_warn(sockfd, "close: can't get link");
close(sockfd);
continue;
}
if (revents & POLLIN) {
client_do_pollin(sockfd, ln);
}
if (revents & POLLOUT) {
client_do_pollout(sockfd, ln);
}
/* suppress the noise */
/* if (revents & POLLPRI) { */
/* sock_warn(sockfd, "POLLPRI"); */
/* } else if (revents & POLLERR) { */
/* sock_warn(sockfd, "POLLERR"); */
/* } else if (revents & POLLHUP) { */
/* sock_warn(sockfd, "POLLHUP"); */
/* } else if (revents & POLLNVAL) { */
/* sock_warn(sockfd, "POLLNVAL"); */
/* } */
}
reaper();
}
out:
crypto_exit();
if (server_ai)
freeaddrinfo(server_ai);
if (local_ai)
freeaddrinfo(local_ai);
ss_exit();
if (ret == -1)
exit(EXIT_FAILURE);
else
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int length, frame_shift = FRAME_SHIFT, atype = ATYPE, otype = OTYPE;
double *x, thresh_rapt = THRESH_RAPT, thresh_swipe =
THRESH_SWIPE, thresh_reaper = THRESH_REAPER, sample_freq = SAMPLE_FREQ,
L = LOW, H = HIGH;
FILE *fp = stdin;
float_list *top, *cur, *prev;
void rapt(float_list * flist, int length, double sample_freq,
int frame_shift, double min, double max, double threshold,
int otype);
void swipe(float_list * input, int length, double sample_freq,
int frame_shift, double min, double max, double threshold,
int otype);
void reaper(float_list * input, int length, double sample_freq,
int frame_shift, double min, double max, double threshold,
int otype);
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'a':
atype = atoi(*++argv);
--argc;
break;
case 's':
sample_freq = atof(*++argv);
--argc;
break;
case 'p':
frame_shift = atoi(*++argv);
--argc;
break;
case 't':
if ((*(*argv + 2)) == '0') {
thresh_rapt = atof(*++argv);
--argc;
} else if ((*(*argv + 2)) == '1') {
thresh_swipe = atof(*++argv);
--argc;
} else {
thresh_reaper = atof(*++argv);
--argc;
}
break;
case 'L':
L = atof(*++argv);
--argc;
break;
case 'H':
H = atof(*++argv);
--argc;
break;
case 'o':
otype = atoi(*++argv);
--argc;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else {
fp = getfp(*argv, "rb");
}
sample_freq *= 1000.0;
x = dgetmem(1);
top = prev = (float_list *) malloc(sizeof(float_list));
length = 0;
prev->next = NULL;
while (freadf(x, sizeof(*x), 1, fp) == 1) {
cur = (float_list *) malloc(sizeof(float_list));
cur->f = (float) x[0];
length++;
prev->next = cur;
cur->next = NULL;
prev = cur;
}
if (atype == 0) {
rapt(top->next, length, sample_freq, frame_shift, L, H, thresh_rapt,
otype);
} else if (atype == 1) {
swipe(top->next, length, sample_freq, frame_shift, L, H, thresh_swipe,
otype);
} else {
reaper(top->next, length, sample_freq, frame_shift, L, H, thresh_reaper,
otype);
}
return (0);
}
int
start(int argc,char **argv)
{
GR_EVENT event; /* current event */
struct app_info * act;
int width, height;
#ifdef USE_WEIRD_POINTER
GR_BITMAP bitmap1fg[7]; /* bitmaps for first cursor */
GR_BITMAP bitmap1bg[7];
#endif
for(act = Apps; act->app_id[0] != '\0'; act++, num_apps++);
if (GrOpen() < 0) {
printf("cannot open graphics\n");
exit(1);
}
GrGetScreenInfo(&si);
//signal(SIGCHLD, &reaper);
gc = GrNewGC();
bgc = GrNewGC();
GrSetGCForeground(bgc, GRAY);
GrSetGCFont(gc, GrCreateFontEx((GR_CHAR *)GR_FONT_SYSTEM_FIXED, 0, 0, NULL));
GrGetGCTextSize(gc, "A", 1, GR_TFASCII, &fwidth, &fheight, &fbase);
width = fwidth * 8 + 4;
height = (fheight) * num_apps + 4;
w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 5, 5, width,
height, 1, WHITE, BLACK);
GrSelectEvents(w1, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_BUTTON_DOWN
| GR_EVENT_MASK_CLOSE_REQ);
GrSelectEvents(GR_ROOT_WINDOW_ID, GR_EVENT_MASK_EXPOSURE |
GR_EVENT_MASK_CHLD_UPDATE);
GrMapWindow(w1);
#ifdef USE_WEIRD_POINTER
bitmap1bg[0] = MASK(_,_,X,X,X,_,_);
bitmap1bg[1] = MASK(_,X,X,X,X,X,_);
bitmap1bg[2] = MASK(_,X,X,X,X,X,_);
bitmap1bg[3] = MASK(_,X,X,X,X,X,_);
bitmap1bg[4] = MASK(_,X,X,X,X,X,_);
bitmap1bg[5] = MASK(_,X,X,X,X,X,_);
bitmap1bg[6] = MASK(X,X,X,X,X,X,X);
bitmap1fg[0] = MASK(_,_,_,_,_,_,_);
bitmap1fg[1] = MASK(_,_,_,X,_,_,_);
bitmap1fg[2] = MASK(_,_,X,X,X,_,_);
bitmap1fg[3] = MASK(_,_,X,X,X,_,_);
bitmap1fg[4] = MASK(_,_,X,X,X,_,_);
bitmap1fg[5] = MASK(_,_,X,X,X,_,_);
bitmap1fg[6] = MASK(_,X,X,X,X,X,_);
GrSetCursor(w1, 7, 7, 3, 3, WHITE, BLACK, bitmap1fg, bitmap1bg);
#endif
GrFillRect(GR_ROOT_WINDOW_ID, bgc, 0, 0, si.cols, si.rows);
GrSetGCForeground(gc, BLACK);
GrSetGCBackground(gc, WHITE);
while (1) {
GrGetNextEvent(&event);
reaper();
switch (event.type) {
case GR_EVENT_TYPE_EXPOSURE:
do_exposure(&event.exposure);
break;
case GR_EVENT_TYPE_BUTTON_DOWN:
do_buttondown(&event.button);
break;
case GR_EVENT_TYPE_BUTTON_UP:
do_buttonup(&event.button);
break;
case GR_EVENT_TYPE_UPDATE:
do_update(&event.update);
break;
case GR_EVENT_TYPE_MOUSE_POSITION:
do_mouse(&event.mouse);
break;
case GR_EVENT_TYPE_CLOSE_REQ:
GrClose();
exit(0);
}
}
}
static RETSIGTYPE serv_sigchld(int sig)
{
reaper();
resetservtraps();
}
