You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
xrdp-proprietary/xorg/X11R7.6/rdp/rdpmain.c

721 lines
18 KiB

/*
Copyright 2005-2012 Jay Sorg
Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This is the main file called from main.c
Sets up the functions
*/
#include "rdp.h"
#include "rdprandr.h"
#if 1
#define DEBUG_OUT(arg)
#else
#define DEBUG_OUT(arg) ErrorF arg
#endif
rdpScreenInfoRec g_rdpScreen; /* the one screen */
ScreenPtr g_pScreen = 0;
DevPrivateKeyRec g_rdpGCIndex;
DevPrivateKeyRec g_rdpWindowIndex;
DevPrivateKeyRec g_rdpPixmapIndex;
/* main mouse and keyboard devices */
DeviceIntPtr g_pointer = 0;
DeviceIntPtr g_keyboard = 0;
Bool g_wrapWindow = 0;
Bool g_wrapPixmap = 1;
/* if true, use a unix domain socket instead of a tcp socket */
int g_use_uds = 0;
char g_uds_data[256] = ""; /* data */
char g_uds_cont[256] = ""; /* control */
/* set all these at once, use function set_bpp */
int g_bpp = 16;
int g_Bpp = 2;
int g_Bpp_mask = 0xffff;
static int g_firstTime = 1;
static int g_redBits = 5;
static int g_greenBits = 6;
static int g_blueBits = 5;
static int g_initOutputCalled = 0;
/* Common pixmap formats */
static PixmapFormatRec g_formats[MAXFORMATS] =
{
{ 1, 1, BITMAP_SCANLINE_PAD },
{ 4, 8, BITMAP_SCANLINE_PAD },
{ 8, 8, BITMAP_SCANLINE_PAD },
{ 15, 16, BITMAP_SCANLINE_PAD },
{ 16, 16, BITMAP_SCANLINE_PAD },
{ 24, 32, BITMAP_SCANLINE_PAD },
{ 32, 32, BITMAP_SCANLINE_PAD },
};
static int g_numFormats = 7;
static miPointerSpriteFuncRec g_rdpSpritePointerFuncs =
{
/* these are in rdpinput.c */
rdpSpriteRealizeCursor,
rdpSpriteUnrealizeCursor,
rdpSpriteSetCursor,
13 years ago
rdpSpriteMoveCursor,
rdpSpriteDeviceCursorInitialize,
rdpSpriteDeviceCursorCleanup
};
static miPointerScreenFuncRec g_rdpPointerCursorFuncs =
{
/* these are in rdpinput.c */
rdpCursorOffScreen,
rdpCrossScreen,
13 years ago
rdpPointerWarpCursor,
rdpPointerEnqueueEvent,
rdpPointerNewEventScreen
};
/******************************************************************************/
/* returns error, zero is good */
static int
set_bpp(int bpp)
{
int rv;
rv = 0;
g_bpp = bpp;
if (g_bpp == 8)
{
g_Bpp = 1;
g_Bpp_mask = 0xff;
g_redBits = 3;
g_greenBits = 3;
g_blueBits = 2;
}
else if (g_bpp == 15)
{
g_Bpp = 2;
g_Bpp_mask = 0x7fff;
g_redBits = 5;
g_greenBits = 5;
g_blueBits = 5;
}
else if (g_bpp == 16)
{
g_Bpp = 2;
g_Bpp_mask = 0xffff;
g_redBits = 5;
g_greenBits = 6;
g_blueBits = 5;
}
else if (g_bpp == 24)
{
g_Bpp = 4;
g_Bpp_mask = 0xffffff;
g_redBits = 8;
g_greenBits = 8;
g_blueBits = 8;
}
else if (g_bpp == 32)
{
g_Bpp = 4;
g_Bpp_mask = 0xffffff;
g_redBits = 8;
g_greenBits = 8;
g_blueBits = 8;
}
else
{
rv = 1;
}
return rv;
}
/******************************************************************************/
static void
rdpWakeupHandler(int i, pointer blockData, unsigned long err,
pointer pReadmask)
{
g_pScreen->WakeupHandler = g_rdpScreen.WakeupHandler;
g_pScreen->WakeupHandler(i, blockData, err, pReadmask);
g_pScreen->WakeupHandler = rdpWakeupHandler;
}
/******************************************************************************/
static void
rdpBlockHandler1(pointer blockData, OSTimePtr pTimeout, pointer pReadmask)
{
}
/******************************************************************************/
static void
rdpWakeupHandler1(pointer blockData, int result, pointer pReadmask)
{
rdpup_check();
}
13 years ago
#if 0
13 years ago
/******************************************************************************/
static Bool
rdpDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
ErrorF("rdpDeviceCursorInitializeProcPtr:\n");
return 1;
}
/******************************************************************************/
static void
rdpDeviceCursorCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
{
ErrorF("rdpDeviceCursorCleanupProcPtr:\n");
}
13 years ago
#endif
#if 0
/******************************************************************************/
Bool
rdpCreateColormap(ColormapPtr pCmap)
{
ErrorF("rdpCreateColormap:\n");
return 1;
}
/******************************************************************************/
static void
rdpDestroyColormap(ColormapPtr pColormap)
{
ErrorF("rdpDestroyColormap:\n");
}
#endif
13 years ago
/******************************************************************************/
/* returns boolean, true if everything is ok */
static Bool
rdpScreenInit(int index, ScreenPtr pScreen, int argc, char** argv)
{
int dpix;
int dpiy;
int ret;
Bool vis_found;
VisualPtr vis;
PictureScreenPtr ps;
rrScrPrivPtr pRRScrPriv;
g_pScreen = pScreen;
/*dpix = 75;
dpiy = 75;*/
dpix = PixelDPI;
dpiy = PixelDPI;
if (monitorResolution != 0)
{
dpix = monitorResolution;
dpiy = monitorResolution;
}
g_rdpScreen.paddedWidthInBytes = PixmapBytePad(g_rdpScreen.width,
g_rdpScreen.depth);
g_rdpScreen.bitsPerPixel = rdpBitsPerPixel(g_rdpScreen.depth);
ErrorF("\n");
ErrorF("X11rdp, an X server for xrdp\n");
ErrorF("Version %s\n", X11RDPVER);
13 years ago
ErrorF("Copyright (C) 2005-2012 Jay Sorg\n");
ErrorF("See http://xrdp.sf.net for information on xrdp.\n");
#if defined(XORG_VERSION_CURRENT) && defined (XVENDORNAME)
ErrorF("Underlying X server release %d, %s\n",
XORG_VERSION_CURRENT, XVENDORNAME);
#endif
#if defined(XORG_RELEASE)
ErrorF("Xorg %s\n", XORG_RELEASE);
#endif
ErrorF("Screen width %d height %d depth %d bpp %d\n", g_rdpScreen.width,
g_rdpScreen.height, g_rdpScreen.depth, g_rdpScreen.bitsPerPixel);
ErrorF("dpix %d dpiy %d\n", dpix, dpiy);
if (g_rdpScreen.pfbMemory == 0)
{
g_rdpScreen.sizeInBytes =
(g_rdpScreen.paddedWidthInBytes * g_rdpScreen.height);
ErrorF("buffer size %d\n", g_rdpScreen.sizeInBytes);
g_rdpScreen.pfbMemory = (char*)g_malloc(2048 * 2048 * 4, 1);
}
if (g_rdpScreen.pfbMemory == 0)
{
rdpLog("rdpScreenInit g_malloc failed\n");
return 0;
}
miClearVisualTypes();
if (defaultColorVisualClass == -1)
{
defaultColorVisualClass = TrueColor;
}
if (!miSetVisualTypes(g_rdpScreen.depth,
miGetDefaultVisualMask(g_rdpScreen.depth),
8, defaultColorVisualClass))
{
rdpLog("rdpScreenInit miSetVisualTypes failed\n");
return 0;
}
miSetPixmapDepths();
switch (g_rdpScreen.bitsPerPixel)
{
case 8:
ret = fbScreenInit(pScreen, g_rdpScreen.pfbMemory,
g_rdpScreen.width, g_rdpScreen.height,
dpix, dpiy, g_rdpScreen.paddedWidthInBytes, 8);
break;
case 16:
ret = fbScreenInit(pScreen, g_rdpScreen.pfbMemory,
g_rdpScreen.width, g_rdpScreen.height,
dpix, dpiy, g_rdpScreen.paddedWidthInBytes / 2, 16);
break;
case 32:
ret = fbScreenInit(pScreen, g_rdpScreen.pfbMemory,
g_rdpScreen.width, g_rdpScreen.height,
dpix, dpiy, g_rdpScreen.paddedWidthInBytes / 4, 32);
break;
default:
13 years ago
ErrorF("rdpScreenInit: error\n");
return 0;
}
if (!ret)
{
13 years ago
ErrorF("rdpScreenInit: error\n");
return 0;
}
miInitializeBackingStore(pScreen);
/* this is for rgb, not bgr, just doing rgb for now */
vis = g_pScreen->visuals + (g_pScreen->numVisuals - 1);
while (vis >= pScreen->visuals)
{
if ((vis->class | DynamicClass) == DirectColor)
{
vis->offsetBlue = 0;
vis->blueMask = (1 << g_blueBits) - 1;
vis->offsetGreen = g_blueBits;
vis->greenMask = ((1 << g_greenBits) - 1) << vis->offsetGreen;
vis->offsetRed = g_blueBits + g_greenBits;
vis->redMask = ((1 << g_redBits) - 1) << vis->offsetRed;
}
vis--;
}
if (g_rdpScreen.bitsPerPixel > 4)
{
fbPictureInit(pScreen, 0, 0);
}
if (!dixRegisterPrivateKey(&g_rdpGCIndex, PRIVATE_GC, sizeof(rdpGCRec)))
{
FatalError("rdpScreenInit: dixRegisterPrivateKey PRIVATE_GC failed\n");
}
if (!dixRegisterPrivateKey(&g_rdpWindowIndex, PRIVATE_WINDOW, sizeof(rdpWindowRec)))
{
FatalError("rdpScreenInit: dixRegisterPrivateKey PRIVATE_WINDOW failed\n");
}
if (!dixRegisterPrivateKey(&g_rdpPixmapIndex, PRIVATE_PIXMAP, sizeof(rdpPixmapRec)))
{
FatalError("rdpScreenInit: dixRegisterPrivateKey PRIVATE_PIXMAP failed\n");
}
/* Random screen procedures */
g_rdpScreen.CloseScreen = pScreen->CloseScreen;
/* GC procedures */
g_rdpScreen.CreateGC = pScreen->CreateGC;
/* Pixmap procudures */
g_rdpScreen.CreatePixmap = pScreen->CreatePixmap;
g_rdpScreen.DestroyPixmap = pScreen->DestroyPixmap;
/* Window Procedures */
g_rdpScreen.CreateWindow = pScreen->CreateWindow;
g_rdpScreen.DestroyWindow = pScreen->DestroyWindow;
g_rdpScreen.CopyWindow = pScreen->CopyWindow;
g_rdpScreen.ClearToBackground = pScreen->ClearToBackground;
/* Backing store procedures */
g_rdpScreen.RestoreAreas = pScreen->RestoreAreas;
g_rdpScreen.WakeupHandler = pScreen->WakeupHandler;
13 years ago
g_rdpScreen.CreateColormap = pScreen->CreateColormap;
g_rdpScreen.DestroyColormap = pScreen->DestroyColormap;
ps = GetPictureScreenIfSet(pScreen);
if (ps)
{
g_rdpScreen.Composite = ps->Composite;
g_rdpScreen.Glyphs = ps->Glyphs;
}
pScreen->blackPixel = g_rdpScreen.blackPixel;
pScreen->whitePixel = g_rdpScreen.whitePixel;
/* Random screen procedures */
pScreen->CloseScreen = rdpCloseScreen;
pScreen->WakeupHandler = rdpWakeupHandler;
if (ps)
{
ps->Composite = rdpComposite;
ps->Glyphs = rdpGlyphs;
}
pScreen->SaveScreen = rdpSaveScreen;
/* GC procedures */
pScreen->CreateGC = rdpCreateGC;
if (g_wrapPixmap)
{
/* Pixmap procedures */
pScreen->CreatePixmap = rdpCreatePixmap;
pScreen->DestroyPixmap = rdpDestroyPixmap;
}
if (g_wrapWindow)
{
/* Window Procedures */
pScreen->CreateWindow = rdpCreateWindow;
pScreen->DestroyWindow = rdpDestroyWindow;
}
pScreen->CopyWindow = rdpCopyWindow;
pScreen->ClearToBackground = rdpClearToBackground;
/* Backing store procedures */
pScreen->RestoreAreas = rdpRestoreAreas;
13 years ago
13 years ago
#if 0
pScreen->CreateColormap = rdpCreateColormap;
pScreen->DestroyColormap = rdpDestroyColormap;
#endif
miPointerInitialize(pScreen, &g_rdpSpritePointerFuncs,
&g_rdpPointerCursorFuncs, 1);
13 years ago
#if 0
pScreen->DeviceCursorInitialize = rdpDeviceCursorInitialize;
pScreen->DeviceCursorCleanup = rdpDeviceCursorCleanup;
#endif
13 years ago
vis_found = 0;
vis = g_pScreen->visuals + (g_pScreen->numVisuals - 1);
while (vis >= pScreen->visuals)
{
if (vis->vid == pScreen->rootVisual)
{
vis_found = 1;
}
vis--;
}
if (!vis_found)
{
rdpLog("rdpScreenInit: couldn't find root visual\n");
exit(1);
}
13 years ago
ret = 1;
if (ret)
{
13 years ago
ret = fbCreateDefColormap(pScreen);
13 years ago
if (!ret)
{
ErrorF("rdpScreenInit: fbCreateDefColormap failed\n");
}
}
if (ret)
{
ret = rdpup_init();
13 years ago
if (!ret)
{
ErrorF("rdpScreenInit: rdpup_init failed\n");
}
}
if (ret)
{
RegisterBlockAndWakeupHandlers(rdpBlockHandler1, rdpWakeupHandler1, NULL);
}
if (!RRScreenInit(pScreen))
{
ErrorF("rdpmain.c: RRScreenInit: screen init failed\n");
}
else
{
pRRScrPriv = rrGetScrPriv(pScreen);
ErrorF("pRRScrPriv %p\n", pRRScrPriv);
pRRScrPriv->rrSetConfig = rdpRRSetConfig;
pRRScrPriv->rrGetInfo = rdpRRGetInfo;
pRRScrPriv->rrScreenSetSize = rdpRRScreenSetSize;
pRRScrPriv->rrCrtcSet = rdpRRCrtcSet;
pRRScrPriv->rrCrtcGetGamma = rdpRRCrtcGetGamma;
pRRScrPriv->rrCrtcSetGamma = rdpRRCrtcSetGamma;
pRRScrPriv->rrOutputSetProperty = rdpRROutputSetProperty;
pRRScrPriv->rrOutputValidateMode = rdpRROutputValidateMode;
pRRScrPriv->rrModeDestroy = rdpRRModeDestroy;
pRRScrPriv->rrOutputGetProperty = rdpRROutputGetProperty;
pRRScrPriv->rrGetPanning = rdpRRGetPanning;
pRRScrPriv->rrSetPanning = rdpRRSetPanning;
}
13 years ago
ErrorF("rdpScreenInit: ret %d\n", ret);
return ret;
}
/******************************************************************************/
/* this is the first function called, it can be called many times
returns the number or parameters processed
if it dosen't apply to the rdp part, return 0 */
int
ddxProcessArgument(int argc, char** argv, int i)
{
if (g_firstTime)
{
memset(&g_rdpScreen, 0, sizeof(g_rdpScreen));
g_rdpScreen.width = 1024;
g_rdpScreen.height = 768;
g_rdpScreen.depth = 24;
set_bpp(24);
g_rdpScreen.blackPixel = 1;
g_firstTime = 0;
RRExtensionInit();
}
if (strcmp(argv[i], "-geometry") == 0)
{
if (i + 1 >= argc)
{
UseMsg();
}
if (sscanf(argv[i + 1], "%dx%d", &g_rdpScreen.width,
&g_rdpScreen.height) != 2)
{
ErrorF("Invalid geometry %s\n", argv[i + 1]);
UseMsg();
}
return 2;
}
if (strcmp(argv[i], "-depth") == 0)
{
if (i + 1 >= argc)
{
UseMsg();
}
g_rdpScreen.depth = atoi(argv[i + 1]);
if (set_bpp(g_rdpScreen.depth) != 0)
{
UseMsg();
}
return 2;
}
if (strcmp(argv[i], "-uds") == 0)
{
g_use_uds = 1;
return 1;
}
return 0;
}
/******************************************************************************/
void
OsVendorInit(void)
{
}
/******************************************************************************/
/* ddxInitGlobals - called by |InitGlobals| from os/util.c */
void
ddxInitGlobals(void)
{
}
/******************************************************************************/
int
XkbDDXSwitchScreen(DeviceIntPtr dev, KeyCode key, XkbAction* act)
{
13 years ago
ErrorF("XkbDDXSwitchScreen:\n");
return 1;
}
/******************************************************************************/
int
XkbDDXPrivate(DeviceIntPtr dev, KeyCode key, XkbAction* act)
{
13 years ago
ErrorF("XkbDDXPrivate:\n");
return 0;
}
/******************************************************************************/
int
XkbDDXTerminateServer(DeviceIntPtr dev, KeyCode key, XkbAction* act)
{
13 years ago
ErrorF("XkbDDXTerminateServer:\n");
GiveUp(1);
return 0;
}
/******************************************************************************/
/* InitOutput is called every time the server resets. It should call
AddScreen for each screen (but we only ever have one), and in turn this
will call rdpScreenInit. */
void
InitOutput(ScreenInfo* screenInfo, int argc, char** argv)
{
int i;
13 years ago
ErrorF("InitOutput:\n");
g_initOutputCalled = 1;
/* initialize pixmap formats */
screenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
screenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
screenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
screenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
screenInfo->numPixmapFormats = g_numFormats;
for (i = 0; i < g_numFormats; i++)
{
screenInfo->formats[i] = g_formats[i];
}
if (!AddCallback(&ClientStateCallback, rdpClientStateChange, NULL))
{
rdpLog("InitOutput: AddCallback failed\n");
return;
}
/* initialize screen */
if (AddScreen(rdpScreenInit, argc, argv) == -1)
{
FatalError("Couldn't add screen\n");
}
13 years ago
ErrorF("InitOutput: out\n");
}
/******************************************************************************/
void
InitInput(int argc, char** argv)
{
int rc;
13 years ago
ErrorF("InitInput:\n");
rc = AllocDevicePair(serverClient, "X11rdp", &g_pointer, &g_keyboard,
rdpMouseProc, rdpKeybdProc, 0);
if (rc != Success)
{
FatalError("Failed to init X11rdp default devices.\n");
}
13 years ago
mieqInit();
}
/******************************************************************************/
void
ddxGiveUp(void)
{
char unixSocketName[128];
13 years ago
ErrorF("ddxGiveUp:\n");
g_free(g_rdpScreen.pfbMemory);
if (g_initOutputCalled)
{
sprintf(unixSocketName, "/tmp/.X11-unix/X%s", display);
unlink(unixSocketName);
sprintf(unixSocketName, "/tmp/.xrdp/xrdp_disconnect_display_%s", display);
unlink(unixSocketName);
if(g_uds_data[0] != 0)
{
unlink(g_uds_data);
}
}
}
/******************************************************************************/
Bool
LegalModifier(unsigned int key, DeviceIntPtr pDev)
{
return 1; /* true */
}
/******************************************************************************/
void
ProcessInputEvents(void)
{
mieqProcessInputEvents();
}
/******************************************************************************/
/* needed for some reason? todo
needs to be rfb */
void
rfbRootPropertyChange(PropertyPtr pProp)
{
}
/******************************************************************************/
void
AbortDDX(void)
{
ddxGiveUp();
}
/******************************************************************************/
void
OsVendorFatalError(void)
{
}
/******************************************************************************/
/* print the command list parameters and exit the program */
void
ddxUseMsg(void)
{
ErrorF("\n");
ErrorF("X11rdp specific options\n");
ErrorF("-geometry WxH set framebuffer width & height\n");
ErrorF("-depth D set framebuffer depth\n");
ErrorF("-uds create and listen on /tmp/.xrdp/xrdp_display_x\n");
ErrorF("\n");
exit(1);
}
/******************************************************************************/
void
OsVendorPreInit(void)
{
}
13 years ago
/******************************************************************************/
void
CloseInput(void)
{
ErrorF("CloseInput\n");
}
/******************************************************************************/
void
DDXRingBell(int volume, int pitch, int duration)
{
ErrorF("DDXRingBell\n");
}
/******************************************************************************/
void
DeleteInputDeviceRequest(DeviceIntPtr dev)
{
ErrorF("DeleteInputDeviceRequest\n");
}