int tele_receive_reply(ggi_visual *vis, TeleEvent *ev,
long type, long seq)
{
ggi_tele_priv *priv = TELE_PRIV(vis);
ev->size = 0;
priv->wait_event = ev;
priv->wait_type = type;
priv->wait_sequence = seq;
DPRINT_EVENTS("display-tele: WAITING FOR (type=0x%08lx "
"seq=0x%08lx)\n", type, seq);
for (;;) {
struct timeval tv;
tv.tv_sec = tv.tv_usec = 0;
GII_tele_poll(priv->input, NULL);
if (ev->size != 0) {
break;
}
ggUSleep(MINSLEEPTIME);
}
DPRINT_EVENTS("display-tele: WAIT OVER (type=0x%08lx "
"seq=0x%08lx)\n", type, seq);
priv->wait_event = NULL;
return 0;
}
void ggLock(void *lock)
{
int *lck = lock;
int i = 0;
while (testandset(lck)) {
if (i < GGLOCK_COUNT) {
i++;
#ifdef HAVE_SCHED_YIELD
sched_yield();
#endif
} else {
#ifdef HAVE_NANOSLEEP
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = (GGLOCK_SLEEP_US*1000);
nanosleep(&ts, NULL);
#else
ggUSleep(GGLOCK_SLEEP_US);
#endif
i = 0;
}
}
return;
}
static void testcase1(const char *desc)
{
ggi_visual_t vis;
ggi_color green, back;
int err;
printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc);
if (dontrun) return;
err = ggiInit();
printassert(err == GGI_OK, "ggiInit failed with %i\n", err);
vis = ggiOpen(NULL);
printassert(vis != NULL, "ggiOpen() failed\n");
err = ggiSetGraphMode(vis, GGI_AUTO, GGI_AUTO, GGI_AUTO, GGI_AUTO, GT_8BIT);
if(err < 0) {
printassert(0, "Palettized mode not available.\n");
printsuccess();
ggiClose(vis);
ggiExit();
return;
}
green.r = 100;
green.g = 40000;
green.b = 4000;
err = ggiSetPalette(vis, GGI_PALETTE_DONTCARE, 1, &green);
if (err < 0) {
printfailure("Unable to install colormap with one entry.\n");
ggiClose(vis);
ggiExit();
return;
}
printassert(err == (int)ggiMapColor(vis, &green),
"ggiMapColor inconsistent with retval of ggiSetPalette.\n");
ggiUnmapPixel(vis, err, &back);
if(green.r != back.r || green.g != back.g || green.b != back.b) {
printfailure("Unexpected color from ggiUnmapPixel.\n");
ggiClose(vis);
ggiExit();
return;
}
ggiSetGCForeground(vis, err);
ggiDrawBox(vis, 0, 0, 3000, 3000);
ggiFlush(vis);
/* You should see a green square, how to test this? */
ggUSleep(5000000);
printsuccess();
ggiClose(vis);
ggiExit();
}
/* Uninterruptible sleep is now easily implemented based on the above work. */
void ggUSlumber(int32_t usecs) {
struct timeval tv1, tv2;
ggCurTime(&tv1);
while (ggUSleep(usecs)) {
ggCurTime(&tv2);
TVDIF(tv1, tv2);
if (tv2.tv_sec > usecs / 1000000) return;
if (tv2.tv_sec) usecs -= 1000000 * tv2.tv_sec;
if (tv2.tv_usec > usecs) return;
usecs -= tv2.tv_usec;
ggCurTime(&tv1);
}
}
int main(int argc, const char *argv[])
{
ggi_visual_t vis;
ggi_mode mode;
int i, j, cx, cy, c;
char buf[80];
/* Set up the random number generator */
srandom((unsigned)time(NULL));
/* Initialize LibGGI */
if (giiInit() < 0) {
fprintf(stderr, "Cannot initialize LibGII!\n");
return 1;
}
if (ggiInit() < 0) {
fprintf(stderr, "Cannot initialize LibGGI!\n");
giiExit();
return 1;
}
vis = ggNewStem(NULL);
if (!vis) {
fprintf(stderr, "Cannot open create stem!\n");
ggiExit();
giiExit();
return 1;
}
if (giiAttach(vis) < 0) {
fprintf(stderr, "Cannot attach LibGII!\n");
ggDelStem(vis);
ggiExit();
giiExit();
return 1;
}
if (ggiAttach(vis) < 0) {
fprintf(stderr, "Cannot attach LibGGI!\n");
ggDelStem(vis);
ggiExit();
giiExit();
return 1;
}
/* Open default visual */
if (ggiOpen(vis, NULL) < 0) {
fprintf(stderr, "Cannot open default visual!\n");
ggDelStem(vis);
ggiExit();
giiExit();
return 1;
}
/* Set visual to async mode (drawing not immediate) */
ggiSetFlags(vis, GGIFLAG_ASYNC);
/* Set default mode, but with multiple buffering */
if (argc > 1) {
ggiParseMode(argv[1], &mode);
} else {
ggiParseMode("", &mode);
if (mode.frames < 2) mode.frames = 2;
}
if (ggiSetMode(vis, &mode)) {
fprintf(stderr, "Cannot set mode!\n");
ggDelStem(vis);
ggiExit();
giiExit();
return 1;
}
ggiGetCharSize(vis, &cx, &cy);
/* Setup palette */
if (GT_SCHEME(mode.graphtype) == GT_PALETTE) {
ggiSetColorfulPalette(vis);
}
/* Write something into each frame */
for (i = 0; i < mode.frames; i++) {
if (ggiSetWriteFrame(vis, i)) {
fprintf(stderr, "Cannot set write frame!\n");
ggDelStem(vis);
ggiExit();
giiExit();
return 1;
}
ggiSetGCBackground(vis, ggiMapColor(vis, &white));
ggiSetGCForeground(vis, ggiMapColor(vis, &white));
ggiFillscreen(vis);
}
/* Clip a small border so that clipping can be verified. */
ggiSetGCClipping(vis, 5, 5, mode.virt.x - 5, mode.virt.y - 5);
/* Write something into each frame */
for (i = 0; i < mode.frames; i++) {
ggiSetWriteFrame(vis, i);
ggiSetGCBackground(vis, ggiMapColor(vis, &black));
ggiSetGCForeground(vis, ggiMapColor(vis, &black));
ggiFillscreen(vis);
snprintf(buf, sizeof(buf), "Hello World #%d!", i);
for (j = 0; j < mode.virt.y; j += cy) {
ggi_color col;
int x = random() % mode.virt.x;
int h = (random() & 0x7fff) + 0x8000;
int l = (random() & 0x7fff);
/* Use different colors for different frames */
col.r = ((i + 1) & 1) ? h : l;
col.g = ((i + 1) & 2) ? h : l;
col.b = ((i + 1) & 4) ? h : l;
ggiSetGCForeground(vis, ggiMapColor(vis, &col));
ggiPuts(vis, x, j, buf);
}
/* Flush commands before proceeding to the next frame */
ggiFlush(vis);
}
/* Cycle through frames */
i = 0;
j = 0;
do {
if (ggiSetDisplayFrame(vis, i)) {
ggPanic("Cannot set display frame!\n");
}
/* Wait */
c = GIIK_VOID;
do {
struct timeval tv = { 0, 0 };
int key;
/* Flush command before waiting for input */
ggiFlush(vis);
key = giiEventPoll(vis, emKeyPress, &tv);
if (key & emKeyPress)
c = giiGetc(vis);
ggUSleep(50000);
animate(vis, &mode, j);
j++;
} while (c == GIIK_VOID || GII_KTYP(c) == GII_KT_MOD);
i = (i + 1) % mode.frames;
} while (c != 'q' && c != 'Q' && c != 'x' && c != 'X' &&
c != GIIUC_Escape);
ggiClose(vis);
ggDelStem(vis);
ggiExit();
giiExit();
return 0;
}
static int GGIopen(struct ggi_visual *vis, struct ggi_dlhandle *dlh,
const char *args, void *argptr, uint32_t_t_t *dlret)
{
ggi_mode mode;
void *memptr=NULL;
suid_hook *priv;
int x, err = GGI_ENOMEM;
LIBGGI_GC(vis) = malloc(sizeof(ggi_gc));
if (LIBGGI_GC(vis) == NULL) {
return GGI_ENOMEM;
}
priv = LIBGGI_PRIVATE(vis) = malloc(sizeof(suid_hook));
if (priv == NULL) {
goto out_freegc;
}
priv->is_up=0;
priv->dev_mem=_suidtarget_dev_mem=-1;
priv->mmap_length=0;
/* Open GII for input */
vis->input = giiOpen("input-linux-kbd", NULL);
if (vis->input == NULL) {
fprintf(stderr, "display-suidkgi: Couldn't open kbd.\n");
goto out_freepriv;
}
/* Has mode management */
vis->opdisplay->getmode=GGI_suidkgi_getmode;
vis->opdisplay->setmode=GGI_suidkgi_setmode;
vis->opdisplay->checkmode=GGI_suidkgi_checkmode;
vis->opdisplay->flush=GGI_suidkgi_flush;
vis->opdisplay->kgicommand=GGI_suidkgi_kgicommand;
vis->opdisplay->setflags=GGI_suidkgi_setflags;
vis->opdraw->setorigin=GGI_suidkgi_setorigin;
vis->w_frame = malloc(sizeof(ggi_directbuffer)); /* FIXME ! */
vis->r_frame = malloc(sizeof(ggi_directbuffer)); /* FIXME ! */
LIBGGI_CURWRITE(vis)=NULL;
LIBGGI_CURREAD(vis)=NULL;
if (iopl(3)) {perror("iopl");exit(2); }
DPRINT("IOPL is here.\n");
if (-1 == (priv->dev_mem = _suidtarget_dev_mem = open("/dev/mem",O_RDWR))) { perror("opening /dev/mem");exit(3); }
memptr=mmap(NULL,64*1024,PROT_READ|PROT_WRITE,MAP_SHARED,priv->dev_mem,0xa0000);
DPRINT("Have mmap at %p.\n",memptr);
/* law_base=0xf3000000; */
if (suidkgi_init_module()) {DPRINT("Init has failed. Tough luck.\n");exit(1); }
DPRINT("Init was o.k.\n");
signal(SIGSEGV,get_killed);
signal(SIGINT,get_killed);
signal(SIGTERM,get_killed);
priv->is_up=1;
#if 1
/* Not sure, if this is needed, but ... */
mode.frames=1;
mode.graphtype=GT_TEXT16;
mode.visible.x=mode.virt.x=80;
mode.visible.y=mode.virt.y=25;
mode.dpp.x = 8;mode.dpp.y =16;
x=GGI_suidkgi_checkmode(vis,&mode);
DPRINT("TESTMODE1 says %d.\n",x);
x=GGI_suidkgi_setmode(vis,&mode);
DPRINT("SETMODE1 says %d.\n",x);
#endif
#undef TESTING_THE_SUID_TARGET
#ifdef TESTING_THE_SUID_TARGET
#ifdef GoneByeBye
for(x=0;x<480;x++)
{
GGI_suidkgi_setsplitline(vis, x);
ggUSleep(100000);
}
#endif
mode.frames=1;
mode.graphtype=GT_8BIT;
mode.visible.x=mode.virt.x=320;
mode.visible.y=mode.virt.y=200;
mode.dpp.x =mode.dpp.y =1;
x=ggiCheckMode(vis,&mode);
DPRINT("TESTMODE3 says %d.\n",x);
x=ggiSetMode(vis,&mode);
DPRINT("SETMODE3 says %d.\n",x);
sleep(1);
{ int y;
for(y=0;y<200;y++)
{
for(x=0;x<320;x++)
{
*((unsigned char *)memptr+x+y*320)=x+y;
}
ggUSleep(1);
}
}
sleep(1);
mode.frames=1;
mode.graphtype=GT_TEXT16;
mode.visible.x=mode.virt.x=80;
mode.visible.y=mode.virt.y=25;
mode.dpp.x = 8;mode.dpp.y =16;
x=GGI_suidkgi_checkmode(vis,&mode);
DPRINT("TESTMODE4 says %d.\n",x);
x=GGI_suidkgi_setmode(vis,&mode);
DPRINT("SETMODE4 says %d.\n",x);
sleep(1);
suidkgi_cleanup_module();
DPRINT("Cleanup went well.\n");
close(priv->dev_mem);
exit(1);
#endif
*dlret = GGI_DL_OPDISPLAY|GGI_DL_OPDRAW;
return 0;
out_freepriv:
free(priv);
out_freegc:
free(LIBGGI_GC(vis);
return err;
}
int main(int argc, char *argv[])
{
struct timeval cur_time;
struct timeval flush_time;
/* initialize */
if (handle_args(argc, argv) < 0) {
return 1;
}
/* open visual */
if (ggiInit() < 0) {
fprintf(stderr, "teleserver: Error initializing GGI.\n");
return 1;
}
if (tserver_init(&serv, display_num) < 0) {
ggiExit();
return 3;
}
ggCurTime(&flush_time);
printf("TeleServer Ready.\n");
fflush(stdout);
/* main loop */
for (quit=0; !quit; ) {
struct timeval tv;
int millies;
busy=0;
/* check for incoming connections */
if (tserver_check(&serv)) {
handle_connection();
busy++;
}
/* check for user input */
tv.tv_sec = tv.tv_usec = 0;
if (mode_up && (ggiEventPoll(vis, emAll, &tv) != 0)) {
handle_event();
busy++;
}
/* check for client commands */
if (user) {
check_command(user);
}
if (! busy) {
ggUSleep(TSERVER_SLEEP_TIME * 1000);
}
ggCurTime(&cur_time);
millies = (cur_time.tv_sec - flush_time.tv_sec) * 1000 +
(cur_time.tv_usec - flush_time.tv_usec) / 1000;
if (millies >= TSERVER_FLUSH_TIME) {
if (mode_up) {
ggiFlush(vis);
}
flush_time = cur_time;
}
}
/* shut down */
tserver_exit(&serv);
ggiExit();
return 0;
}
