static TBOOL region_andrect_internal(struct RectList *temp,
struct Region *region, TINT s[], TINT dx, TINT dy)
{
struct RectPool *pool = region->rg_Pool;
struct TNode *next, *node = region->rg_Rects.rl_List.tlh_Head;
TBOOL success = TTRUE;
TINT s0 = s[0] + dx;
TINT s1 = s[1] + dy;
TINT s2 = s[2] + dx;
TINT s3 = s[3] + dy;
for (; success && (next = node->tln_Succ); node = next)
{
struct RectNode *dr = (struct RectNode *) node;
TINT x0 = dr->rn_Rect[0];
TINT y0 = dr->rn_Rect[1];
TINT x1 = dr->rn_Rect[2];
TINT y1 = dr->rn_Rect[3];
if (OVERLAP(x0, y0, x1, y1, s0, s1, s2, s3))
{
success = region_insertrect(pool, temp,
TMAX(x0, s0), TMAX(y0, s1), TMIN(x1, s2), TMIN(y1, s3));
}
}
if (!success)
region_freerects(pool, temp);
return success;
}
static int ScaleImg3(unsigned char *pSrc, int srcWidth, int srcHeight,
int srcWidthStep,
unsigned char *pDst, int dstWidth, int dstHeight,
int dstWidthStep)
{
int w,h, index_x, index_y;
float scale_x, scale_y;
unsigned char *pData;
if((TNull == pSrc)||(TNull == pDst))
return -1;
scale_x = srcWidth*1.0f/dstWidth;
scale_y = srcHeight*1.0f/dstHeight;
pData = pDst;
for(h=0; h<dstHeight; h++)
{
index_y = (int)(h*scale_y/* + 0.5f*/); //the same to opencv CV_INTER_NN
index_y = TMIN(index_y, srcHeight-1);
for(w=0; w<dstWidth; w++)
{
index_x = (int)(w*scale_x/* + 0.5f*/);
index_x = TMIN(index_x, srcWidth-1);
pData[3*w] = pSrc[index_y*srcWidthStep + index_x*3];
pData[3*w+1] = pSrc[index_y*srcWidthStep + index_x*3+1];
pData[3*w+2] = pSrc[index_y*srcWidthStep + index_x*3+2];
}
pData += dstWidthStep;
}
return 0;
}
static void rfb_drawpointer(struct rfb_Display *mod)
{
TINT x0 = mod->rfb_MouseX - mod->rfb_MouseHotX;
TINT y0 = mod->rfb_MouseY - mod->rfb_MouseHotY;
if (mod->rfb_Flags & RFBFL_PTR_VISIBLE)
{
if (x0 == mod->rfb_PtrBackBuffer.rect[0] &&
y0 == mod->rfb_PtrBackBuffer.rect[1])
return;
rfb_restorebackbuf(mod, &mod->rfb_PtrBackBuffer);
}
TINT s0 = 0;
TINT s1 = 0;
TINT s2 = mod->rfb_Width - 1;
TINT s3 = mod->rfb_Height - 1;
TINT x1 = x0 + mod->rfb_PtrWidth - 1;
TINT y1 = y0 + mod->rfb_PtrHeight - 1;
if (REGION_OVERLAP(s0, s1, s2, s3, x0, y0, x1, y1))
{
struct TVPixBuf dst = mod->rfb_DevBuf;
x0 = TMAX(x0, s0);
y0 = TMAX(y0, s1);
x1 = TMIN(x1, s2);
y1 = TMIN(y1, s3);
rfb_storebackbuf(mod, &mod->rfb_PtrBackBuffer, x0, y0, x1, y1);
pixconv_convert(&mod->rfb_PtrImage, &dst, x0, y0, x1, y1, 0, 0,
TTRUE, TFALSE);
}
mod->rfb_Flags |= RFBFL_PTR_VISIBLE;
}
TLIBAPI TBOOL region_orrectlist(struct RectPool *pool, struct RectList *list,
TINT s[4], TBOOL opportunistic)
{
if (list->rl_NumNodes > 0)
{
TINT x0 = s[0];
TINT y0 = s[1];
TINT x1 = s[2];
TINT y1 = s[3];
TUINT64 area = 0;
struct TNode *next, *node = list->rl_List.tlh_Head;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *rn = (struct RectNode *) node;
TINT *r = rn->rn_Rect;
if (s[0] >= r[0] && s[1] >= r[1] &&
s[2] <= r[2] && s[3] <= r[3])
return TTRUE;
if (!opportunistic)
continue;
area += (r[2] - r[0] + 1) * (r[3] - r[1] + 1);
x0 = TMIN(x0, r[0]);
y0 = TMIN(y0, r[1]);
x1 = TMAX(x1, r[2]);
y1 = TMAX(y1, r[3]);
}
if (opportunistic)
{
TUINT64 area2 = (x1 - x0 + 1) * (y1 - y0 + 1);
if (area2 < OPPORTUNISTIC_MERGE_THRESHOLD ||
(area * 256 / area2) > OPPORTUNISTIC_MERGE_RATIO)
{
/* merge list into a single rectangle */
TDBPRINTF(TDB_TRACE,("merge %d rects\n",
list->rl_NumNodes + 1));
region_freerects(pool, list);
assert(list->rl_NumNodes == 0);
return region_insertrect(pool, list, x0, y0, x1, y1);
}
}
}
struct RectList temp;
region_initrectlist(&temp);
if (region_cutrectlist(pool, list, &temp, s))
{
if (region_insertrect(pool, &temp, s[0], s[1], s[2], s[3]))
{
region_freerects(pool, list);
region_relinkrects(list, &temp);
return TTRUE;
}
}
region_freerects(pool, &temp);
return TFALSE;
}
LOCAL void
dfb_setattrs(DFBDISPLAY *mod, struct TVRequest *req)
{
struct attrdata data;
struct THook hook;
DFBWINDOW *v = req->tvr_Op.SetAttrs.Window;
data.v = v;
data.num = 0;
data.mod = mod;
data.sizechanged = TFALSE;
TInitHook(&hook, setattrfunc, &data);
TForEachTag(req->tvr_Op.SetAttrs.Tags, &hook);
req->tvr_Op.SetAttrs.Num = data.num;
if (data.sizechanged)
{
TIMSG *imsg;
v->wminwidth = v->wminwidth <= 0 ? 1 : v->wminwidth;
v->wminheight = v->wminheight <= 0 ? 1 : v->wminheight;
v->wmaxwidth = v->wmaxwidth <= 0 ? 1000000 : v->wmaxwidth;
v->wmaxheight = v->wmaxheight <= 0 ? 1000000 : v->wmaxheight;
if (v->wmaxwidth > 0)
v->winwidth = TMIN(v->winwidth, v->wmaxwidth);
if (v->wmaxheight > 0)
v->winheight = TMIN(v->winheight, v->wmaxheight);
if (v->wminwidth > 0)
v->winwidth = TMAX(v->winwidth, v->wminwidth);
if (v->wminheight > 0)
v->winheight = TMAX(v->winheight, v->wminheight);
v->window->Resize(v->window, v->winwidth, v->winheight);
if ((v->eventmask & TITYPE_NEWSIZE) &&
getimsg(mod, v, &imsg, TITYPE_NEWSIZE))
{
imsg->timsg_Width = v->winwidth;
imsg->timsg_Height = v->winheight;
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
if ((v->eventmask & TITYPE_REFRESH) &&
getimsg(mod, v, &imsg, TITYPE_REFRESH))
{
imsg->timsg_X = v->winleft;
imsg->timsg_Y = v->wintop;
imsg->timsg_Width = v->winwidth;
imsg->timsg_Height = v->winheight;
TAddTail(&v->imsgqueue, &imsg->timsg_Node);
}
}
}
TLIBAPI TBOOL region_intersect(TINT *d, TINT *s)
{
if (OVERLAP(d[0], d[1], d[2], d[3], s[0], s[1], s[2], s[3]))
{
d[0] = TMAX(d[0], s[0]);
d[1] = TMAX(d[1], s[1]);
d[2] = TMIN(d[2], s[2]);
d[3] = TMIN(d[3], s[3]);
return TTRUE;
}
return TFALSE;
}
TLIBAPI struct TModule *TNewInstance(struct TModule *mod, TSIZE possize,
TSIZE negsize)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TAPTR inst = TAlloc(TNULL, possize + negsize);
if (inst)
{
TSIZE size = TMIN(((struct TModule *) mod)->tmd_NegSize, negsize);
inst = (TINT8 *) inst + negsize;
if (size > 0)
TCopyMem((TINT8 *) mod - size, (TINT8 *) inst - size, size);
size = TMIN(((struct TModule *) mod)->tmd_PosSize, possize);
TCopyMem(mod, inst, size);
((struct TModule *) inst)->tmd_PosSize = possize;
((struct TModule *) inst)->tmd_NegSize = negsize;
((struct TModule *) inst)->tmd_InitTask = TFindTask(TNULL);
}
return inst;
}
TLIBAPI TAPTR
TNewInstance(TAPTR mod, TUINT possize, TUINT negsize)
{
TAPTR exec = TGetExecBase(mod);
TAPTR inst = TExecAlloc(exec, TNULL, possize + negsize);
if (inst)
{
TUINT size = TMIN(((struct TModule *) mod)->tmd_NegSize, negsize);
inst = (TINT8 *) inst + negsize;
if (size > 0)
TExecCopyMem(exec, (TINT8 *) mod - size, (TINT8 *) inst - size,
size);
size = TMIN(((struct TModule *) mod)->tmd_PosSize, possize);
TExecCopyMem(exec, mod, inst, size);
((struct TModule *) inst)->tmd_PosSize = possize;
((struct TModule *) inst)->tmd_NegSize = negsize;
((struct TModule *) inst)->tmd_InitTask = TExecFindTask(exec, TNULL);
}
return inst;
}
static int lib_overlap(lua_State *L)
{
TINT d0 = luaL_checkinteger(L, 1);
TINT d1 = luaL_checkinteger(L, 2);
TINT d2 = luaL_checkinteger(L, 3);
TINT d3 = luaL_checkinteger(L, 4);
TINT s0 = luaL_checkinteger(L, 5);
TINT s1 = luaL_checkinteger(L, 6);
TINT s2 = luaL_checkinteger(L, 7);
TINT s3 = luaL_checkinteger(L, 8);
if (OVERLAP(d0, d1, d2, d3, s0, s1, s2, s3))
{
lua_pushinteger(L, TMAX(s0, d0));
lua_pushinteger(L, TMAX(s1, d1));
lua_pushinteger(L, TMIN(s2, d2));
lua_pushinteger(L, TMIN(s3, d3));
return 4;
}
return 0;
}
LOCAL TBOOL rfb_resizewinbuffer(struct rfb_Display *mod, struct rfb_Window *v,
TINT oldw, TINT oldh, TINT w, TINT h)
{
if (oldw == w && oldh == h)
return TTRUE;
TAPTR TExecBase = TGetExecBase(mod);
struct TVPixBuf newbuf = v->rfbw_PixBuf;
TUINT pixfmt = v->rfbw_PixBuf.tpb_Format;
newbuf.tpb_BytesPerLine = TVPIXFMT_BYTES_PER_PIXEL(pixfmt) * w;
newbuf.tpb_Data = TAlloc(mod->rfb_MemMgr, newbuf.tpb_BytesPerLine * h);
if (!newbuf.tpb_Data)
return TFALSE;
TINT cw = TMIN(oldw, w);
TINT ch = TMIN(oldh, h);
pixconv_convert(&v->rfbw_PixBuf, &newbuf,
0, 0, cw - 1, ch - 1, 0, 0, TFALSE, TFALSE);
TFree(v->rfbw_PixBuf.tpb_Data);
v->rfbw_PixBuf = newbuf;
return TTRUE;
}
static int region_overlaprect(lua_State *L)
{
struct RectNode *rn = lua_touserdata(L, 2);
TINT s0 = lua_tointeger(L, 3);
TINT s1 = lua_tointeger(L, 4);
TINT s2 = lua_tointeger(L, 5);
TINT s3 = lua_tointeger(L, 6);
TINT d0 = rn->rn_Rect[0];
TINT d1 = rn->rn_Rect[1];
TINT d2 = rn->rn_Rect[2];
TINT d3 = rn->rn_Rect[3];
if (OVERLAP(d0, d1, d2, d3, s0, s1, s2, s3))
{
lua_pushinteger(L, TMAX(s0, d0));
lua_pushinteger(L, TMAX(s1, d1));
lua_pushinteger(L, TMIN(s2, d2));
lua_pushinteger(L, TMIN(s3, d3));
return 4;
}
return 0;
}
TLIBAPI TBOOL region_getminmax(struct RectPool *pool, struct Region *region,
TINT *minmax)
{
if (region_isempty(pool, region))
return TFALSE;
TINT minx = 1000000;
TINT miny = 1000000;
TINT maxx = 0;
TINT maxy = 0;
struct TNode *next, *node = region->rg_Rects.rl_List.tlh_Head;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *rn = (struct RectNode *) node;
minx = TMIN(minx, rn->rn_Rect[0]);
miny = TMIN(miny, rn->rn_Rect[1]);
maxx = TMAX(maxx, rn->rn_Rect[2]);
maxy = TMAX(maxy, rn->rn_Rect[3]);
}
minmax[0] = minx;
minmax[1] = miny;
minmax[2] = maxx;
minmax[3] = maxy;
return TTRUE;
}
static int visual_io_readline(struct LineReader *r, char **line, size_t *len)
{
int c;
while (r->ReadBytes > 0 || r->BufBytes > 0)
{
if (r->BufBytes == 0)
{
int rdlen = TMIN(sizeof(r->ReadBuf), r->ReadBytes);
rdlen = read(r->File, r->ReadBuf, rdlen);
r->BufPos = 0;
r->BufBytes = rdlen;
r->ReadBytes -= rdlen;
}
c = r->ReadBuf[r->BufPos++];
r->BufBytes--;
if (c == '\r')
continue;
if (c == '\n')
{
if (r->State != 0)
{
r->State = 0;
continue;
}
c = 0;
}
else if ((*r->ReadCharFunc)(r, c) == 0)
continue;
if (c == 0)
{
*line = r->Buffer;
*len = r->Pos;
r->Pos = 0;
return 1;
}
}
return 0;
}
LOCAL void fbp_drawtriangle(struct rfb_Display *mod, struct rfb_Window *v,
TINT x0, TINT y0, TINT x1, TINT y1, TINT x2, TINT y2, struct rfb_Pen *pen)
{
struct Coord res[MAX_VERT];
TINT outlen;
struct Region R;
if (!rfb_getlayermask(mod, &R, v->rfbw_ClipRect.r, v, 0, 0))
return;
TUINT p = pixconv_rgbfmt(v->rfbw_PixBuf.tpb_Format, pen->rgb);
struct TNode *next, *node = R.rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *rn = (struct RectNode *) node;
TINT *r = rn->rn_Rect;
if (!clippoly(res, &outlen, x0, y0, x1, y1, x2, y2,
r[0], r[1], r[2], r[3]))
continue;
TINT d[4];
if (outlen == 1)
{
d[0] = res[0].x;
d[1] = res[0].y;
d[2] = res[0].x;
d[3] = res[0].y;
rfb_markdirty(mod, v, d);
pixconv_setpixelbuf(&v->rfbw_PixBuf, res[0].x, res[0].y, p);
}
else if (outlen == 2)
{
TINT rect[4] = { res[0].x, res[0].y, res[1].x, res[1].y };
rfb_markdirty(mod, v, rect);
fbp_drawline(mod, v, rect, pen);
}
else
{
TINT i;
d[0] = TMIN(TMIN(res[0].x, res[1].x), res[2].x);
d[1] = TMIN(TMIN(res[0].y, res[1].y), res[2].y);
d[2] = TMAX(TMAX(res[0].x, res[1].x), res[2].x);
d[3] = TMAX(TMAX(res[0].y, res[1].y), res[2].y);
rfb_markdirty(mod, v, d);
rendertriangle(v, res[0], res[1], res[2], p);
for (i = 2; i < outlen; i++)
{
if ((i + 1) < outlen)
rendertriangle(v, res[0], res[i], res[i + 1], p);
}
}
}
region_free(&mod->rfb_RectPool, &R);
}
LOCAL void
dfb_openvisual(DFBDISPLAY *mod, struct TVRequest *req)
{
TTAGITEM *tags = req->tvr_Op.OpenWindow.Tags;
TAPTR exec = TGetExecBase(mod);
DFBWINDOW *v;
DFBWindowDescription wdsc;
struct FontNode *fn;
v = TExecAlloc0(exec, mod->dfb_MemMgr, sizeof(DFBWINDOW));
req->tvr_Op.OpenWindow.Window = v;
if (v == TNULL) return;
v->userdata = TGetTag(tags, TVisual_UserData, TNULL);
v->eventmask = (TUINT) TGetTag(tags, TVisual_EventMask, 0);
TInitList(&v->penlist);
v->bgpen = TVPEN_UNDEFINED;
v->fgpen = TVPEN_UNDEFINED;
TInitList(&v->imsgqueue);
v->imsgport = req->tvr_Op.OpenWindow.IMsgPort;
v->title = (TSTRPTR)
TGetTag(tags, TVisual_Title, (TTAG) "TEKlib visual");
/* size/position calculation: */
v->winwidth = (TINT) TGetTag(tags,
TVisual_Width,
(TTAG) TMIN(mod->dfb_ScrWidth, DEF_WINWIDTH));
v->winheight = (TINT) TGetTag(tags,
TVisual_Height,
(TTAG) TMIN(mod->dfb_ScrHeight, DEF_WINHEIGHT));
if (TGetTag(tags, TVisual_Center, TFALSE))
{
v->winleft = (mod->dfb_ScrWidth - v->winwidth) / 2;
v->wintop = (mod->dfb_ScrHeight - v->winheight) / 2;
}
else if (TGetTag(tags, TVisual_FullScreen, TFALSE))
{
v->winwidth = mod->dfb_ScrWidth;
v->winheight = mod->dfb_ScrHeight;
v->winleft = 0;
v->wintop = 0;
}
else
{
v->winleft = (TINT) TGetTag(tags, TVisual_WinLeft, (TTAG) -1);
v->wintop = (TINT) TGetTag(tags, TVisual_WinTop, (TTAG) -1);
}
if (!TGetTag(tags, TVisual_Borderless, TFALSE))
{
v->wminwidth = (TINT) TGetTag(tags, TVisual_MinWidth, (TTAG) -1);
v->wminheight = (TINT) TGetTag(tags, TVisual_MinHeight, (TTAG) -1);
v->wmaxwidth = (TINT) TGetTag(tags, TVisual_MaxWidth, (TTAG) -1);
v->wmaxheight = (TINT) TGetTag(tags, TVisual_MaxHeight, (TTAG) -1);
if (v->wmaxwidth > 0)
v->winwidth = TMIN(v->winwidth, v->wmaxwidth);
if (v->wmaxheight > 0)
v->winheight = TMIN(v->winheight, v->wmaxheight);
if (v->wminwidth > 0)
v->winwidth = TMAX(v->winwidth, v->wminwidth);
if (v->wminheight > 0)
v->winheight = TMAX(v->winheight, v->wminheight);
v->wminwidth = v->wminwidth <= 0 ? 1 : v->wminwidth;
v->wminheight = v->wminheight <= 0 ? 1 : v->wminheight;
v->wmaxwidth = v->wmaxwidth <= 0 ? 1000000 : v->wmaxwidth;
v->wmaxheight = v->wmaxheight <= 0 ? 1000000 : v->wmaxheight;
}
v->winleft = TMAX(v->winleft, 0);
v->wintop = TMAX(v->wintop, 0);
if (TGetTag(tags, TVisual_Borderless, TFALSE))
v->borderless = TTRUE;
wdsc.flags = (DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT);
wdsc.posx = v->winleft;
wdsc.posy = v->wintop;
wdsc.width = v->winwidth;
wdsc.height = v->winheight;
if (mod->dfb_Layer->CreateWindow(mod->dfb_Layer, &wdsc, &v->window) == DFB_OK)
{
v->window->GetSurface(v->window, &v->winsurface);
v->window->SetOpacity(v->window, 0xFF);
v->window->GetID(v->window, &v->winid);
v->window->AttachEventBuffer(v->window, mod->dfb_Events);
v->window->RequestFocus(v->window);
v->window->RaiseToTop(v->window);
if (!v->borderless)
{
/* generate focus events */
genimsg(mod, (DFBWINDOW *)mod->dfb_Focused, v, TITYPE_FOCUS);
mod->dfb_Focused = (TAPTR) v;
}
v->winsurface->SetColor(v->winsurface, 0x00, 0x00, 0xff, 0xff);
v->winsurface->DrawRectangle(v->winsurface, 0, 0, wdsc.width, wdsc.height);
v->winsurface->SetColor(v->winsurface, 0x80, 0x80, 0x80, 0xff);
v->winsurface->FillRectangle(v->winsurface, 1, 1, wdsc.width-2, wdsc.height-2);
v->winsurface->Flip(v->winsurface, NULL, 0);
/* init default font */
fn = mod->dfb_fm.deffont;
v->curfont = fn;
mod->dfb_fm.defref++;
if (v->winsurface->SetFont(v->winsurface, fn->font) == DFB_OK)
{
if (v->winsurface->SetFont(v->winsurface, fn->font) == DFB_OK)
{
TDBPRINTF(TDB_TRACE,("Add window: %p\n", v->window));
TAddHead(&mod->dfb_vlist, &v->node);
/* success: */
return;
}
}
}
TExecFree(exec, v);
/* failure: */
TDBPRINTF(TDB_ERROR,("Open failed\n"));
req->tvr_Op.OpenWindow.Window = TNULL;
}
LOCAL TAPTR fb_hostqueryfonts(WINDISPLAY *mod, TTAGITEM *tags)
{
struct TExecBase *TExecBase = TGetExecBase(mod);
TSTRPTR names;
LOGFONT logfont;
char *namebuf = logfont.lfFaceName;
struct FontQueryHandle *fqh;
fqh = TAlloc0(TNULL, sizeof(struct FontQueryHandle));
if (fqh == TNULL)
return TNULL;
fqh->handle.thn_Owner = mod;
TInitHook(&fqh->handle.thn_Hook, fqhdestroy, fqh);
TInitList(&fqh->reslist);
fqh->fpxsize = (TINT) TGetTag(tags, TVisual_FontPxSize, (TTAG) FNTQUERY_UNDEFINED);
fqh->fitalic = (TBOOL) TGetTag(tags, TVisual_FontItalic, (TTAG) FNTQUERY_UNDEFINED);
fqh->fbold = (TBOOL) TGetTag(tags, TVisual_FontBold, (TTAG) FNTQUERY_UNDEFINED);
fqh->fscale = (TBOOL) TGetTag(tags, TVisual_FontScaleable, (TTAG) FNTQUERY_UNDEFINED);
fqh->fnum = (TINT) TGetTag(tags, TVisual_FontNumResults, (TTAG) INT_MAX);
fqh->success = TTRUE;
names = (TSTRPTR) TGetTag(tags, TVisual_FontName, TNULL);
if (names == TNULL)
names = "";
for (;;)
{
TSTRPTR p = strchr(names, ',');
if (p)
{
size_t len2 = TMIN(p - names, LF_FACESIZE - 1);
memcpy(namebuf, names, len2);
namebuf[len2] = 0;
names += p - names + 1;
}
else
{
size_t len = strlen(names);
size_t len2 = TMIN(len, LF_FACESIZE - 1);
memcpy(namebuf, names, len2);
namebuf[len2] = 0;
names += len;
}
logfont.lfCharSet = ANSI_CHARSET;
logfont.lfPitchAndFamily = 0;
TDBPRINTF(TDB_INFO,("query font: %s\n", namebuf));
if (strcmp(namebuf, "") == 0)
fqh->match_depth = 0; /* find font first */
else
fqh->match_depth = 1; /* find style */
EnumFontFamiliesEx(
mod->fbd_DeviceHDC,
&logfont,
(FONTENUMPROCA) fontenumcb,
(LPARAM) fqh, 0);
if (strlen(names) == 0)
break;
}
fqh->nptr = &fqh->reslist.tlh_Head;
if (fqh->success)
return fqh;
TDestroy(&fqh->handle);
return TNULL;
}
int processPacket( char *packet, metaData_t *meta, void *flowdata )
{
int i;
struct timeval rtt;
struct moduleData *data;
struct icmp_echo_hdr *hdr;
if ((meta->layers[2] != T_ICMP) && (meta->layers[2] != T_ICMP6)) { // only use ICMP packets!
return 0;
}
data = (struct moduleData *) flowdata;
hdr = (struct icmp_echo_hdr *) (&packet[meta->offs[2]]); /* skip layer 1 and 2 */
// only want echo request and reply
if ((hdr->type != 8) && (hdr->type != 0)) {
return 0;
}
// dont want "unreachable" replies
if (hdr->code != 0) {
return 0;
}
if (hdr->type == 8 ) { /* ICMP echo */
/* find new unused entry - if possible */
data->curr = 0;
if (data->free > 0) {
while (data->list[data->curr].id != 0) {
data->curr += 1;
}
}
data->list[data->curr].id = hdr->id;
data->list[data->curr].seqno = hdr->seqno;
data->list[data->curr].tstamp.tv_sec = meta->tv_sec;
data->list[data->curr].tstamp.tv_usec = meta->tv_usec;
if (data->free > 0) {
data->free -= 1;
}
} else { /* ICMP reply */
for ( i = 0; i < data->lsize; i++ ) {
if (data->list[i].id == 0) {
continue; /* unused list entry */
}
if ((data->list[i].id == hdr->id) && (data->list[i].seqno == hdr->seqno)) {
rtt.tv_sec = meta->tv_sec - data->list[i].tstamp.tv_sec;
rtt.tv_usec = meta->tv_usec - data->list[i].tstamp.tv_usec;
if (rtt.tv_usec < 0) {
rtt.tv_usec += 1000000;
rtt.tv_sec -= 1;
}
/*fprintf( stderr, "%ld %ld \n", rtt.tv_sec, rtt.tv_usec );*/
data->min = TMIN( data->min, rtt );
data->max = TMAX( data->max, rtt );
data->sum.tv_usec += (unsigned long long) rtt.tv_usec;
data->sum.tv_sec += (unsigned long long) rtt.tv_sec;
if (data->sum.tv_usec > 1000000) {
data->sum.tv_usec -= 1000000;
data->sum.tv_sec += 1;
}
data->list[i].id = 0;
data->free += 1;
data->matches += 1;
if (data->matches == 1 ) {
data->min = rtt;
}
}
}
}
return 0;
}
LOCAL void x11_taskfunc(struct TTask *task)
{
TAPTR TExecBase = TGetExecBase(task);
struct X11Display *inst = TGetTaskData(task);
TUINT sig = 0;
fd_set rset;
struct TVRequest *req;
TIMSG *imsg;
char buf[256];
struct timeval tv, *ptv;
struct TMsgPort *cmdport = TGetUserPort(task);
TUINT cmdportsignal = TGetPortSignal(cmdport);
TUINT ireplysignal = TGetPortSignal(inst->x11_IReplyPort);
TUINT waitsigs = cmdportsignal | ireplysignal | TTASK_SIG_ABORT;
/* interval time: 1/50s: */
TTIME intt = { 20000 };
/* next absolute time to send interval message: */
TTIME nextt;
TTIME waitt, nowt;
TDBPRINTF(TDB_INFO, ("Device instance running\n"));
TGetSystemTime(&nowt);
nextt = nowt;
TAddTime(&nextt, &intt);
do
{
if (sig & ireplysignal)
{
while ((imsg = TGetMsg(inst->x11_IReplyPort)))
{
/* returned input message */
if (imsg->timsg_Type == TITYPE_REQSELECTION)
{
XSelectionEvent *reply =
(XSelectionEvent *) imsg->timsg_Requestor;
struct TTagItem *replytags =
(struct TTagItem *) imsg->timsg_ReplyData;
size_t len =
TGetTag(replytags, TIMsgReply_UTF8SelectionLen, 0);
TUINT8 *xdata = (TUINT8 *) TGetTag(replytags,
TIMsgReply_UTF8Selection, TNULL);
XChangeProperty(inst->x11_Display, reply->requestor,
reply->property, XA_ATOM, 8, PropModeReplace,
(unsigned char *) xdata, len);
XSendEvent(inst->x11_Display, reply->requestor, 0,
NoEventMask, (XEvent *) reply);
XSync(inst->x11_Display, False);
TFree((TAPTR) imsg->timsg_Requestor);
TFree(xdata);
/* reqselect roundtrip ended */
}
TFree(imsg);
}
}
if (sig & cmdportsignal)
{
while (inst->x11_RequestInProgress == TNULL &&
(req = TGetMsg(cmdport)))
{
x11_docmd(inst, req);
if (inst->x11_RequestInProgress)
break;
TReplyMsg(req);
}
}
XFlush(inst->x11_Display);
FD_ZERO(&rset);
FD_SET(inst->x11_fd_display, &rset);
FD_SET(inst->x11_fd_sigpipe_read, &rset);
TGetSystemTime(&nowt);
if (inst->x11_NumInterval > 0 || inst->x11_RequestInProgress)
{
if (TCmpTime(&nowt, &nextt) >= 0)
{
/* expired; send interval: */
struct TNode *next, *node = inst->x11_vlist.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct X11Window *v = (struct X11Window *) node;
TIMSG *imsg;
if ((v->eventmask & TITYPE_INTERVAL) &&
x11_getimsg(inst, v, &imsg, TITYPE_INTERVAL))
TPutMsg(v->imsgport, TNULL, imsg);
}
TAddTime(&nextt, &intt);
}
/* calculate new wait time: */
waitt = nextt;
TSubTime(&waitt, &nowt);
if (waitt.tdt_Int64 <= 0 || waitt.tdt_Int64 > 20000)
{
nextt = nowt;
TAddTime(&nextt, &intt);
waitt = nextt;
TSubTime(&waitt, &nowt);
}
tv.tv_sec = waitt.tdt_Int64 / 1000000;
tv.tv_usec = waitt.tdt_Int64 % 1000000;
ptv = &tv;
}
else
ptv = NULL;
/* wait for display, signal fd and timeout: */
if (select(inst->x11_fd_max, &rset, NULL, NULL, ptv) > 0)
{
int nbytes;
/* consume signal: */
if (FD_ISSET(inst->x11_fd_sigpipe_read, &rset))
{
ioctl(inst->x11_fd_sigpipe_read, FIONREAD, &nbytes);
if (nbytes > 0)
if (read(inst->x11_fd_sigpipe_read, buf,
TMIN(sizeof(buf), (size_t) nbytes)) != nbytes)
TDBPRINTF(TDB_ERROR,
("could not read wakeup signal\n"));
}
}
/* process input messages: */
x11_processevent(inst);
/* send out input messages to owners: */
x11_sendimessages(inst);
/* get signal state: */
sig = TSetSignal(0, waitsigs);
}
while (!(sig & TTASK_SIG_ABORT));
TDBPRINTF(TDB_INFO, ("Device instance exit\n"));
x11_exitinstance(inst);
}
static void tek_lib_visual_io_task(struct TTask *task)
{
struct TExecBase *TExecBase = TGetExecBase(task);
struct IOData *iodata = TGetTaskData(task);
TEKVisual *vis = iodata->vis;
TIMSG *imsg;
TUINT sig;
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
char buf[256];
fd_set rset;
#endif
do
{
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
FD_ZERO(&rset);
FD_SET(iodata->fd_pipe[0], &rset);
#endif
#if defined(ENABLE_FILENO)
if (iodata->fd_stdin != -1)
FD_SET(iodata->fd_stdin, &rset);
#endif
#if defined(ENABLE_DGRAM)
FD_SET(iodata->fd_dgram, &rset);
#endif
#if defined(ENABLE_FILENO) || defined(ENABLE_DGRAM)
if (select(iodata->fdmax, &rset, NULL, NULL, NULL) > 0)
{
int nbytes = 0;
/* consume signal: */
if (FD_ISSET(iodata->fd_pipe[0], &rset))
{
ioctl(iodata->fd_pipe[0], FIONREAD, &nbytes);
if (nbytes > 0)
if (read(iodata->fd_pipe[0], buf,
TMIN(sizeof(buf), (size_t) nbytes)) != nbytes)
TDBPRINTF(TDB_ERROR,("Error reading from selfpipe\n"));
}
#if defined(ENABLE_FILENO)
/* stdin line reader: */
if (iodata->fd_stdin >= 0 && FD_ISSET(iodata->fd_stdin, &rset))
{
if (ioctl(iodata->fd_stdin, FIONREAD, &nbytes) == 0)
{
if (nbytes == 0)
iodata->fd_stdin = -1; /* stop processing */
else
{
char *line;
size_t len;
visual_io_reader_addbytes(&iodata->linereader, nbytes);
while (visual_io_readline(&iodata->linereader, &line,
&len))
{
if (getusermsg(vis, &imsg, TITYPE_USER, len))
{
memcpy((void *) (imsg + 1), line, len);
TPutMsg(vis->vis_IMsgPort, TNULL,
&imsg->timsg_Node);
}
}
}
}
else
iodata->fd_stdin = -1; /* stop processing */
}
#endif
#if defined(ENABLE_DGRAM)
if (iodata->fd_dgram >= 0 && FD_ISSET(iodata->fd_dgram, &rset))
{
char umsg[IOMAXMSGSIZE];
TIMSG *imsg;
ssize_t len = recv(iodata->fd_dgram, umsg, sizeof umsg, 0);
if (len >= 0 && getusermsg(vis, &imsg, TITYPE_USER, len))
{
memcpy((void *) (imsg + 1), umsg, len);
TPutMsg(vis->vis_IMsgPort, TNULL, &imsg->timsg_Node);
}
}
#endif
}
sig = TSetSignal(0, TTASK_SIG_ABORT | TTASK_SIG_USER);
#else
sig = TWait(TTASK_SIG_ABORT | TTASK_SIG_USER);
#endif
if (sig & TTASK_SIG_USER)
{
TAPTR msg, uport = TGetUserPort(TNULL);
while ((msg = TGetMsg(uport)))
{
TSIZE len = TGetSize(msg);
/* repackage into user input message */
if (getusermsg(vis, &imsg, TITYPE_USER, len))
{
memcpy((void *) (imsg + 1), msg, len);
TPutMsg(vis->vis_IMsgPort, TNULL, &imsg->timsg_Node);
}
TAckMsg(msg);
}
}
} while (!(sig & TTASK_SIG_ABORT));
tek_lib_visual_io_exit(task);
}
static TINT rfb_cmdrectaffected(struct rfb_Display *mod, struct TVRequest *req,
TINT result[4], TBOOL source_affect)
{
struct rfb_Window *v = TNULL;
TINT *rect = TNULL;
TINT *xywh = TNULL;
TINT temprect[4];
switch (req->tvr_Req.io_Command)
{
default:
/* not affected, no rect */
return 0;
case TVCMD_FLUSH:
case TVCMD_SETATTRS:
case TVCMD_CLOSEWINDOW:
/* yes, affected, but no rect */
return -1;
/* window rect: */
case TVCMD_DRAWSTRIP:
v = req->tvr_Op.Strip.Window;
break;
case TVCMD_DRAWFAN:
v = req->tvr_Op.Fan.Window;
break;
case TVCMD_TEXT:
v = req->tvr_Op.Text.Window;
break;
/* specific rect: */
case TVCMD_RECT:
v = req->tvr_Op.Rect.Window;
xywh = req->tvr_Op.Rect.Rect;
break;
case TVCMD_FRECT:
v = req->tvr_Op.FRect.Window;
xywh = req->tvr_Op.FRect.Rect;
break;
case TVCMD_LINE:
v = req->tvr_Op.Line.Window;
xywh = req->tvr_Op.Line.Rect;
break;
case TVCMD_DRAWBUFFER:
v = req->tvr_Op.DrawBuffer.Window;
xywh = req->tvr_Op.DrawBuffer.RRect;
break;
case TVCMD_COPYAREA:
{
v = req->tvr_Op.CopyArea.Window;
TINT *s = req->tvr_Op.CopyArea.Rect;
TINT dx0 = req->tvr_Op.CopyArea.DestX;
TINT dy0 = req->tvr_Op.CopyArea.DestY;
TINT sx0 = s[0];
TINT sy0 = s[1];
TINT sx1 = s[0] + s[2] - 1;
TINT sy1 = s[1] + s[3] - 1;
TINT dx = dx0 - sx0;
TINT dy = dy0 - sy0;
TINT dx1 = sx1 + dx;
TINT dy1 = sy1 + dy;
rect = temprect;
if (source_affect)
{
rect[0] = TMIN(sx0, dx0);
rect[1] = TMIN(sy0, dy0);
rect[2] = TMAX(sx1, dx1);
rect[3] = TMAX(sy1, dy1);
break;
}
rect[0] = dx0;
rect[1] = dy0;
rect[2] = dx1;
rect[3] = dy1;
break;
}
case TVCMD_PLOT:
v = req->tvr_Op.Plot.Window;
rect = temprect;
rect[0] = req->tvr_Op.Plot.Rect[0];
rect[1] = req->tvr_Op.Plot.Rect[1];
rect[2] = req->tvr_Op.Plot.Rect[0];
rect[3] = req->tvr_Op.Plot.Rect[1];
break;
}
if (v->rfbw_ClipRect.r[0] == -1)
return 0;
if (xywh)
{
rect = temprect;
rect[0] = xywh[0];
rect[1] = xywh[1];
rect[2] = xywh[0] + xywh[2] - 1;
rect[3] = xywh[1] + xywh[3] - 1;
}
if (rect)
{
result[0] = rect[0] + v->rfbw_WinRect.r[0];
result[1] = rect[1] + v->rfbw_WinRect.r[1];
result[2] = rect[2] + v->rfbw_WinRect.r[0];
result[3] = rect[3] + v->rfbw_WinRect.r[1];
}
else
memcpy(result, v->rfbw_WinRect.r, 16);
return region_intersect(result, v->rfbw_ClipRect.r);
}
