jh163888/xrdp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

got XFree86 4.6 and Xorg 6.9.0 compiling

Browse Source
This commit is contained in:
jsorg71 2006-09-04 21:47:21 +00:00
parent 909c06c781
commit d221fea7fc
6 changed files with 681 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Xserver/hw/rdp/Makefile
View File

@ -11,13 +11,15 @@ CFLAGS += -I../../../../../include
CFLAGS += -I/usr/local/include
CFLAGS += -I../../../.././ -I../../../../exports/include
CFLAGS += -I../../../../include/extensions
CFLAGS += -I../../dbe
CFLAGS += -I../../record
CFLAGS += -I../../render
CFLAGS += -Dlinux -D__i386__
CFLAGS += -D_POSIX_C_SOURCE=199309L
CFLAGS += -D_POSIX_SOURCE -D_XOPEN_SOURCE=500L
CFLAGS += -D_BSD_SOURCE -D_SVID_SOURCE -D_REENTRANT
CFLAGS += -DSHAPE -DXKB -DBIGREQS -DGLXEXT -DGLX_USE_MESA -DMITMISC -DXTEST
CFLAGS += -DSHAPE -DBIGREQS -DGLXEXT -DGLX_USE_MESA -DMITMISC -DXTEST
CFLAGS += -DPANORAMIX -DRANDR -DRENDER -DXCMISC -DXSYNC -DXRECORD
CFLAGS += -D_GNU_SOURCE -DLBX -DXAPPGROUP -DXCSECURITY -DTOGCUP
@ -26,11 +28,15 @@ CFLAGS += -DXFree86Server -DXvMCExtension -DSMART_SCHEDULE -DXResExtension
CFLAGS += -DX_BYTE_ORDER=X_LITTLE_ENDIAN -DXTRAP -DMITSHM -DDBE -DEVI
CFLAGS += -DSCREENSAVER -DXV -DXVMC -DFONTCACHE
#CFLAGS += -DXINPUT
#CFLAGS += -DXINPUT -DXKB
CFLAGS += -DGCCUSESGAS -DSTATIC_COLOR -DAVOID_GLYPHBLT -DPIXPRIV
CFLAGS += -DNDEBUG -DFUNCPROTO=15 -DNARROWPROTO -DDDXOSINIT
CFLAGS += -DSERVER_LOCK -DDDXOSFATALERROR -DDDXTIME -DPART_NET
CFLAGS += -DSERVER_LOCK -DDDXOSFATALERROR -DPART_NET
CFLAGS += -DDDXTIME
CFLAGS += -D_HAVE_XALLOC_DECLS
#CFLAGS += -DXVNCRELEASE=\"tight1.2.9\"
all: rdp

14
Xserver/hw/rdp/rdp.h
View File

@ -53,6 +53,20 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "picturestr.h"
#include <netinet/tcp.h>
/* test to see if this is xorg source or xfree86 */
#ifdef XORGSERVER
# define RDP_IS_XORG
#else
# include <xf86Version.h>
# if (XF86_VERSION_MAJOR == 4 && XF86_VERSION_MINOR > 3)
# define RDP_IS_XFREE86
# elif (XF86_VERSION_MAJOR > 4)
# define RDP_IS_XFREE86
# else
# define RDP_IS_XORG
# endif
#endif
/* Per-screen (framebuffer) structure. There is only one of these, since we
don't allow the X server to have multiple screens. */
typedef struct

12
Xserver/hw/rdp/rdpmain.c
View File

@ -385,7 +385,8 @@ OsVendorInit(void)
/*ErrorF("hi OsVendorInit\n");*/
}
#if 0
#ifdef RDP_IS_XORG
/******************************************************************************/
CARD32
GetTimeInMillis(void)
@ -396,6 +397,13 @@ GetTimeInMillis(void)
X_GETTIMEOFDAY(&tp);
return (tp.tv_sec * 1000) + (tp.tv_usec / 1000);
}
/* ddxInitGlobals - called by |InitGlobals| from os/util.c */
void
ddxInitGlobals(void)
{
}
#endif
/* Common pixmap formats */
@ -537,7 +545,7 @@ void
ddxUseMsg(void)
{
ErrorF("\n");
ErrorF("Xrdp specific options\n");
ErrorF("X11rdp specific options\n");
ErrorF("-geometry WxH set framebuffer width & height\n");
ErrorF("-depth D set framebuffer depth\n");
ErrorF("\n");

605
Xserver/hw/rdp/rdpmisc.c
View File

@ -379,3 +379,608 @@ g_tcp_listen(int sck)
{
return listen(sck, 2);
}
/*
stub for XpClient* functions.
*/
/*****************************************************************************/
Bool
XpClientIsBitmapClient(ClientPtr client)
{
return 1;
}
/*****************************************************************************/
Bool
XpClientIsPrintClient(ClientPtr client, FontPathElementPtr fpe)
{
return 0;
}
/*****************************************************************************/
int
PrinterOptions(int argc, char** argv, int i)
{
return i;
}
/*****************************************************************************/
void
PrinterInitOutput(ScreenInfo* pScreenInfo, int argc, char** argv)
{
}
/*****************************************************************************/
void PrinterUseMsg(void)
{
}
/*****************************************************************************/
void PrinterInitGlobals(void)
{
}
#ifdef RDP_IS_XORG
#define NEED_XF86_TYPES
#include <xf86_libc.h>
#define XF86FILE_magic 0x58464856 /* "XFHV" */
typedef struct _xf86_file_
{
INT32 fileno;
INT32 magic;
FILE* filehnd;
char* fname;
} XF86FILE_priv;
XF86FILE_priv stdhnd[3] =
{
{ 0, XF86FILE_magic, NULL, "$stdinp$" },
{ 0, XF86FILE_magic, NULL, "$stdout$" },
{ 0, XF86FILE_magic, NULL, "$stderr$" }
};
XF86FILE* xf86stdin = (XF86FILE*)&stdhnd[0];
XF86FILE* xf86stdout = (XF86FILE*)&stdhnd[1];
XF86FILE* xf86stderr = (XF86FILE*)&stdhnd[2];
double xf86HUGE_VAL;
int xf86errno;
Bool noFontCacheExtension = 1;
#define mapnum(e) case (xf86_##e): err = e; break;
/*****************************************************************************/
static int
xf86GetErrno(void)
{
int err;
switch (errno)
{
case 0:
return 0;
mapnum(EACCES);
mapnum(EAGAIN);
mapnum(EBADF);
mapnum(EEXIST);
mapnum(EFAULT);
mapnum(EINTR);
mapnum(EINVAL);
mapnum(EISDIR);
mapnum(ELOOP); /* not POSIX 1 */
mapnum(EMFILE);
mapnum(ENAMETOOLONG);
mapnum(ENFILE);
mapnum(ENOENT);
mapnum(ENOMEM);
mapnum(ENOSPC);
mapnum(ENOTDIR);
mapnum(EPIPE);
mapnum(EROFS);
mapnum(ETXTBSY); /* not POSIX 1 */
mapnum(ENOTTY);
mapnum(EBUSY);
mapnum(ENODEV);
mapnum(EIO);
default:
return xf86_UNKNOWN;
}
return (int)strerror(err);
}
/*****************************************************************************/
static void
_xf86checkhndl(XF86FILE_priv* f, const char* func)
{
if (!f || f->magic != XF86FILE_magic ||
!f->filehnd || !f->fname)
{
FatalError("libc_wrapper error: passed invalid FILE handle to %s", func);
exit(42);
}
}
/*****************************************************************************/
void
xf86WrapperInit(void)
{
if (stdhnd[0].filehnd == NULL)
{
stdhnd[0].filehnd = stdin;
}
if (stdhnd[1].filehnd == NULL)
{
stdhnd[1].filehnd = stdout;
}
if (stdhnd[2].filehnd == NULL)
{
stdhnd[2].filehnd = stderr;
}
xf86HUGE_VAL = HUGE_VAL;
}
/*****************************************************************************/
int
xf86strcmp(const char* s1, const char* s2)
{
return strcmp(s1, s2);
}
/*****************************************************************************/
char*
xf86strchr(const char* s, int c)
{
return strchr(s, c);
}
/*****************************************************************************/
double
xf86fabs(double x)
{
return fabs(x);
}
/*****************************************************************************/
double
xf86exp(double x)
{
return exp(x);
}
/*****************************************************************************/
double
xf86log(double x)
{
return log(x);
}
/*****************************************************************************/
double
xf86sin(double x)
{
return sin(x);
}
/*****************************************************************************/
double
xf86cos(double x)
{
return cos(x);
}
/*****************************************************************************/
double
xf86sqrt(double x)
{
return sqrt(x);
}
/*****************************************************************************/
double
xf86floor(double x)
{
return floor(x);
}
/*****************************************************************************/
void
xf86free(void* p)
{
xfree(p);
}
/*****************************************************************************/
int
xf86fclose(XF86FILE* f)
{
XF86FILE_priv* fp = (XF86FILE_priv*)f;
int ret;
_xf86checkhndl(fp, "xf86fclose");
/* somewhat bad check */
if (fp->fileno < 3 && fp->fname[0] == '$')
{
/* assume this is stdin/out/err, don't dispose */
ret = fclose(fp->filehnd);
}
else
{
ret = fclose(fp->filehnd);
fp->magic = 0; /* invalidate */
xfree(fp->fname);
xfree(fp);
}
return ret ? -1 : 0;
}
/*****************************************************************************/
int
xf86fflush(XF86FILE* f)
{
XF86FILE_priv* fp = (XF86FILE_priv*)f;
_xf86checkhndl(fp,"xf86fflush");
return fflush(fp->filehnd);
}
/*****************************************************************************/
int
xf86fprintf(XF86FILE* f, const char *format, ...)
{
XF86FILE_priv* fp = (XF86FILE_priv*)f;
int ret;
va_list args;
va_start(args, format);
#ifdef DEBUG
ErrorF("xf86fprintf for XF86FILE %p\n", fp);
#endif
_xf86checkhndl(fp,"xf86fprintf");
ret = vfprintf(fp->filehnd,format,args);
va_end(args);
return ret;
}
/*****************************************************************************/
char*
xf86strdup(const char* s)
{
return xstrdup(s);
}
/*****************************************************************************/
XF86FILE*
xf86fopen(const char* fn, const char* mode)
{
XF86FILE_priv* fp;
FILE* f = fopen(fn, mode);
xf86errno = xf86GetErrno();
if (!f)
{
return 0;
}
fp = (XF86FILE_priv*)xalloc(sizeof(XF86FILE_priv));
fp->magic = XF86FILE_magic;
fp->filehnd = f;
fp->fileno = fileno(f);
fp->fname = (char*)xf86strdup(fn);
#ifdef DEBUG
ErrorF("xf86fopen(%s,%s) yields FILE %p XF86FILE %p\n",
fn,mode,f,fp);
#endif
return (XF86FILE*)fp;
}
/*****************************************************************************/
int
xf86sprintf(char* s, const char* format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = vsprintf(s, format, args);
va_end(args);
return ret;
}
/*****************************************************************************/
double
xf86atof(const char* s)
{
return atof(s);
}
/*****************************************************************************/
xf86size_t
xf86strlen(const char* s)
{
return (xf86size_t)strlen(s);
}
/*****************************************************************************/
void
xf86exit(int ex)
{
ErrorF("Module called exit() function with value=%d\n", ex);
exit(ex);
}
/*****************************************************************************/
int
xf86vsprintf(char* s, const char* format, va_list ap)
{
return vsprintf(s, format, ap);
}
/*****************************************************************************/
double
xf86frexp(double x, int* exp)
{
return frexp(x, exp);
}
/*****************************************************************************/
void*
xf86memcpy(void* dest, const void* src, xf86size_t n)
{
return memcpy(dest,src,(size_t)n);
}
/*****************************************************************************/
int
xf86memcmp(const void* s1, const void* s2, xf86size_t n)
{
return memcmp(s1,s2,(size_t)n);
}
/*****************************************************************************/
int
xf86ffs(int mask)
{
int n;
if (mask == 0)
{
return 0;
}
for (n = 1; (mask & 1) == 0; n++)
{
mask >>= 1;
}
return n;
}
/*****************************************************************************/
void
xf86abort(void)
{
ErrorF("Module called abort() function\n");
abort();
}
/*****************************************************************************/
double
xf86ldexp(double x, int exp)
{
return ldexp(x, exp);
}
/*****************************************************************************/
char*
xf86getenv(const char* a)
{
/* Only allow this when the real and effective uids are the same */
if (getuid() != geteuid())
{
return NULL;
}
else
{
return getenv(a);
}
}
/*****************************************************************************/
void*
xf86memset(void* s, int c, xf86size_t n)
{
return memset(s, c, (size_t)n);
}
/*****************************************************************************/
void*
xf86malloc(xf86size_t n)
{
return (void*)xalloc((size_t)n);
}
/*****************************************************************************/
void*
xf86calloc(xf86size_t sz, xf86size_t n)
{
return (void*)xcalloc((size_t)sz, (size_t)n);
}
/*****************************************************************************/
double
xf86pow(double x, double y)
{
return pow(x, y);
}
/*****************************************************************************/
int
xf86vsnprintf(char* s, xf86size_t len, const char* format, va_list ap)
{
return vsnprintf(s, (size_t)len, format, ap);
}
/*****************************************************************************/
char*
xf86strstr(const char* s1, const char* s2)
{
return strstr(s1, s2);
}
/*****************************************************************************/
char*
xf86strncat(char* dest, const char* src, xf86size_t n)
{
return strncat(dest, src, (size_t)n);
}
/*****************************************************************************/
char*
xf86strcpy(char* dest, const char* src)
{
return strcpy(dest, src);
}
/*****************************************************************************/
char*
xf86strncpy(char* dest, const char* src, xf86size_t n)
{
return strncpy(dest, src, (size_t)n);
}
/*****************************************************************************/
int
xf86strncmp(const char* s1, const char* s2, xf86size_t n)
{
return strncmp(s1, s2, (size_t)n);
}
/*****************************************************************************/
double
xf86strtod(const char* s, char** end)
{
return strtod(s, end);
}
/*****************************************************************************/
int
xf86printf(const char* format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = printf(format, args);
va_end(args);
return ret;
}
/*****************************************************************************/
void*
xf86realloc(void* p, xf86size_t n)
{
return (void*)xrealloc(p, n);
}
/*****************************************************************************/
int
xf86atoi(const char* s)
{
return atoi(s);
}
/*****************************************************************************/
int
xf86vfprintf(XF86FILE* f, const char *format, va_list ap)
{
XF86FILE_priv* fp = (XF86FILE_priv*)f;
#ifdef DEBUG
ErrorF("xf86vfprintf for XF86FILE %p\n", fp);
#endif
_xf86checkhndl(fp,"xf86vfprintf");
return vfprintf(fp->filehnd, format, ap);
}
/*****************************************************************************/
void*
xf86bsearch(const void* key, const void* base, xf86size_t nmemb,
xf86size_t size, int (*compar)(const void*, const void*))
{
return bsearch(key, base, (size_t)nmemb, (size_t)size, compar);
}
/*****************************************************************************/
int
xf86sscanf(char* s, const char* format, ...)
{
int ret;
va_list args;
va_start(args, format);
ret = vsscanf(s,format,args);
va_end(args);
return ret;
}
/*****************************************************************************/
char*
xf86strtok(char* s1, const char* s2)
{
return strtok(s1, s2);
}
/*****************************************************************************/
char*
xf86strcat(char* dest, const char* src)
{
return strcat(dest, src);
}
/*****************************************************************************/
xf86size_t
xf86strcspn(const char* s1, const char* s2)
{
return (xf86size_t)strcspn(s1, s2);
}
/*****************************************************************************/
int
xf86abs(int x)
{
return abs(x);
}
/*****************************************************************************/
double
xf86atan2(double x, double y)
{
return atan2(x, y);
}
/*****************************************************************************/
void*
xf86memmove(void* dest, const void* src, xf86size_t n)
{
return memmove(dest, src, (size_t)n);
}
/*****************************************************************************/
void
xf86bzero(void* s, unsigned int n)
{
memset(s, 0, n);
}
/* other, what is this? */
/*****************************************************************************/
void
FontCacheExtensionInit(INITARGS)
{
}
#endif

19
Xserver/makefile_rdp
View File

@ -989,7 +989,8 @@ INSTPGMFLAGS =
LIBCWRAPPER = os/libcwrapper.o
XPFBLIBS = dix/libxpstubs.a
# XPFBLIBS = dix/libxpstubs.a
XPFBLIBS =
RENDERDIR = render
RENDERLIB = $(RENDERDIR)/librender.a
@ -1182,20 +1183,20 @@ XRDP = $(OTHEREXTS) hw/rdp/librdp.a $(RDPLIBS) $(OTHEREXTS)
XRDPLIBS = $(DIX) $(OS) $(XPDDX) $(XRDP) $(MFB) $(FB) $(MFB) $(XPFBLIBS) $(MI) $(EXTENSIONS)
XRDPSYSLIBS = $(FONTLIBS) $(SYSLIBS) $(RDPSYSLIBS) $(LOADABLEEXTS)
all:: Xrdp
Xrdp: $(XRDPDIRS) $(XRDPOBJS) $(XRDPLIBS)
all:: X11rdp
X11rdp: $(XRDPDIRS) $(XRDPOBJS) $(XRDPLIBS)
-@if [ -f $@ ]; then set -x; \
$(MV) $@ $@.bak; else exit 0; fi
$(CCLINK) -o $@ $(LDOPTIONS) $(XRDPOBJS) $(XRDPLIBS) $(LDLIBS) $(XRDPSYSLIBS) $(FONTLIBS) -L/usr/local/lib $(EXTRA_LOAD_FLAGS)
loadXrdp:
-@if [ -f Xrdp ]; then set -x; \
$(MV) Xrdp Xrdp.bak; else exit 0; fi
$(CCLINK) -o Xrdp $(LDOPTIONS) $(XRDPOBJS) $(XRDPLIBS) $(LDLIBS) $(XRDPSYSLIBS) $(FONTLIBS) -L/usr/local/lib $(EXTRA_LOAD_FLAGS)
-@if [ -f X11rdp ]; then set -x; \
$(MV) X11rdp X11rdp.bak; else exit 0; fi
$(CCLINK) -o X11rdp $(LDOPTIONS) $(XRDPOBJS) $(XRDPLIBS) $(LDLIBS) $(XRDPSYSLIBS) $(FONTLIBS) -L/usr/local/lib $(EXTRA_LOAD_FLAGS)
loadX:: loadXrdp
install:: Xrdp
install:: X11rdp
@if [ -d $(DESTDIR)$(BINDIR) ]; then \
set +x; \
else \
@ -1204,10 +1205,10 @@ install:: Xrdp
fi; \
(set -x; $(MKDIRHIER) $(DESTDIR)$(BINDIR)); \
fi
$(INSTALL) $(INSTALLFLAGS) $(INSTPGMFLAGS) $(_NOOP_) Xrdp $(DESTDIR)$(BINDIR)/Xrdp
$(INSTALL) $(INSTALLFLAGS) $(INSTPGMFLAGS) $(_NOOP_) X11rdp $(DESTDIR)$(BINDIR)/X11rdp
cleandir::
$(RM) Xrdp
$(RM) X11rdp
CFBSUBDIRS = $(CFB8SUBDIR) $(CFB16SUBDIR) $(CFB24SUBDIR) $(CFB32SUBDIR)
MIEXTDIRS = $(SHADOWDIR) $(LAYERDIR) $(ROOTLESSDIR)

32
Xserver/makefile_x11rdp Normal file
View File

@ -0,0 +1,32 @@
LDFLAGS = -L../../lib/Xau -L../../lib/Xdmcp
LIBS = dbe/libdbe.a \
dix/libdix.a \
fb/libfb.a \
GL/glx/libglx.a \
GL/mesa/GLcore/libGLcore.a \
hw/rdp/librdp.a \
lbx/liblbx.a \
mfb/libmfb.a \
mi/libmi.a \
os/libos.a \
randr/librandr.a \
record/librecord.a \
render/librender.a \
Xext/libexts.a \
Xext/libext.a \
xkb/libxkb.a \
Xi/libxinput.a \
XTrap/libxtrap.a \
../../lib/lbxutil/liblbxutil.a \
../../lib/font/libXfont.a \
-lfreetype -lz -lm -lXau -lXdmcp
# dix/libxpstubs.a \
all: x11rdp
x11rdp:
make -C hw/rdp
$(CC) $(LDFLAGS) -o X11rdp $(LIBS) $(LIBS)