Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 703 insertions, 0 deletions

diff --git a/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c b/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c
new file mode 100644
index 000000000..1eec4e02b
--- /dev/null
+++ b/xorg-server/hw/kdrive/ephyr/ephyrhostglx.c
@@ -0,0 +1,703 @@
+/*
+ * Xephyr - A kdrive X server thats runs in a host X window.
+ *          Authored by Matthew Allum <mallum@openedhand.com>
+ * 
+ * Copyright © 2007 OpenedHand Ltd 
+ *
+ * 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, and that the name of OpenedHand Ltd not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. OpenedHand Ltd makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ * a lots of the content of this file has been adapted from the mesa source
+ * code.
+ * Authors:
+ *    Dodji Seketeli <dodji@openedhand.com>
+ */
+#ifdef HAVE_CONFIG_H
+#include <kdrive-config.h>
+#endif
+
+/*
+ * including some server headers (like kdrive-config.h)
+ * might define the macro _XSERVER64
+ * on 64 bits machines. That macro must _NOT_ be defined for Xlib
+ * client code, otherwise bad things happen.
+ * So let's undef that macro if necessary.
+ */
+#ifdef _XSERVER64
+#undef _XSERVER64
+#endif
+
+#include <X11/Xlibint.h>
+#include <GL/glx.h>
+#include <GL/internal/glcore.h>
+#include <GL/glxproto.h>
+#include <GL/glxint.h>
+#include "ephyrhostglx.h"
+#define _HAVE_XALLOC_DECLS
+#include "ephyrlog.h"
+#include "hostx.h"
+
+#ifdef XEPHYR_DRI
+enum VisualConfRequestType {
+    EPHYR_GET_FB_CONFIG,
+    EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
+    EPHYR_GET_VISUAL_CONFIGS
+
+};
+
+static Bool ephyrHostGLXGetVisualConfigsInternal
+                                        (enum VisualConfRequestType a_type,
+                                         int32_t a_screen,
+                                         int32_t *a_num_visuals,
+                                         int32_t *a_num_props,
+                                         int32_t *a_props_buf_size,
+                                         int32_t **a_props_buf);
+Bool
+ephyrHostGLXGetMajorOpcode (int *a_opcode)
+{
+    Bool is_ok=FALSE ;
+    Display *dpy=hostx_get_display () ;
+    static int opcode ;
+    int first_event_return=0, first_error_return=0;
+
+    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+    EPHYR_LOG ("enter\n") ;
+    if (!opcode) {
+        if (!XQueryExtension (dpy, GLX_EXTENSION_NAME, &opcode,
+                              &first_event_return, &first_error_return)) {
+            EPHYR_LOG_ERROR ("XQueryExtension() failed\n") ;
+            goto out ;
+        }
+    }
+    *a_opcode = opcode ;
+    is_ok = TRUE ;
+out:
+    EPHYR_LOG ("release\n") ;
+    return is_ok ;
+}
+
+Bool
+ephyrHostGLXQueryVersion (int *a_major, int *a_minor)
+{
+    Bool is_ok = FALSE ;
+    Display *dpy = hostx_get_display () ;
+    int major_opcode=0;
+    xGLXQueryVersionReq *req=NULL;
+    xGLXQueryVersionReply reply;
+
+    EPHYR_RETURN_VAL_IF_FAIL (a_major && a_minor, FALSE) ;
+    EPHYR_LOG ("enter\n") ;
+
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+    EPHYR_LOG ("major opcode: %d\n", major_opcode) ;
+
+    /* Send the glXQueryVersion request */
+    memset (&reply, 0, sizeof (reply)) ;
+    LockDisplay (dpy);
+    GetReq (GLXQueryVersion, req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLXQueryVersion;
+    req->majorVersion = 2;
+    req->minorVersion = 1;
+    _XReply(dpy, (xReply*) &reply, 0, False);
+    UnlockDisplay (dpy);
+    SyncHandle ();
+
+    *a_major = reply.majorVersion ;
+    *a_minor = reply.minorVersion ;
+
+    EPHYR_LOG ("major:%d, minor:%d\n", *a_major, *a_minor) ;
+
+    is_ok = TRUE ;
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+/**
+ * GLX protocol structure for the ficticious "GXLGenericGetString" request.
+ * 
+ * This is a non-existant protocol packet.  It just so happens that all of
+ * the real protocol packets used to request a string from the server have
+ * an identical binary layout.  The only difference between them is the
+ * meaning of the \c for_whom field and the value of the \c glxCode.
+ * (this has been copied from the mesa source code)
+ */
+typedef struct GLXGenericGetString {
+    CARD8 reqType;
+    CARD8 glxCode;
+    CARD16 length B16;
+    CARD32 for_whom B32;
+    CARD32 name B32;
+} xGLXGenericGetStringReq;
+
+/* These defines are only needed to make the GetReq macro happy.
+ */
+#define sz_xGLXGenericGetStringReq 12
+#define X_GLXGenericGetString 0
+
+Bool
+ephyrHostGLXGetStringFromServer (int a_screen_number,
+                                 int a_string_name,
+                                 enum EphyrHostGLXGetStringOps a_op,
+                                 char **a_string)
+{
+    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display () ;
+    int default_screen = DefaultScreen (dpy);
+    xGLXGenericGetStringReq *req=NULL;
+    xGLXSingleReply reply;
+    int length=0, numbytes=0, major_opcode=0, get_string_op=0;
+
+    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_string, FALSE) ;
+
+    EPHYR_LOG ("enter\n") ;
+    switch (a_op) {
+        case EPHYR_HOST_GLX_QueryServerString:
+            get_string_op = X_GLXQueryServerString;
+            break ;
+        case EPHYR_HOST_GLX_GetString:
+            get_string_op = X_GLsop_GetString;
+            EPHYR_LOG ("Going to glXGetString. strname:%#x, ctxttag:%d\n",
+                       a_string_name, a_screen_number) ;
+            break ;
+        default:
+            EPHYR_LOG_ERROR ("unknown EphyrHostGLXGetStringOp:%d\n", a_op) ;
+            goto out ;
+    }
+
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+    EPHYR_LOG ("major opcode: %d\n", major_opcode) ;
+
+    LockDisplay (dpy);
+
+    /* All of the GLX protocol requests for getting a string from the server
+     * look the same.  The exact meaning of the a_for_whom field is usually
+     * either the screen number (for glXQueryServerString) or the context tag
+     * (for GLXSingle).
+     */
+    GetReq (GLXGenericGetString, req);
+    req->reqType = major_opcode;
+    req->glxCode = get_string_op;
+    req->for_whom = default_screen;
+    req->name = a_string_name;
+
+    _XReply (dpy, (xReply *)&reply, 0, False);
+
+    length = reply.length * 4;
+    if (!length) {
+        numbytes = 0;
+    } else {
+        numbytes = reply.size;
+    }
+    EPHYR_LOG ("going to get a string of size:%d\n", numbytes) ;
+
+    *a_string = (char *) Xmalloc (numbytes +1);
+    if (!a_string) {
+        EPHYR_LOG_ERROR ("allocation failed\n") ;
+        goto out;
+    }
+
+    memset (*a_string, 0, numbytes+1) ;
+    if (_XRead (dpy, *a_string, numbytes)) {
+        UnlockDisplay (dpy);
+        SyncHandle ();
+        EPHYR_LOG_ERROR ("read failed\n") ;
+        goto out ;
+    }
+    length -= numbytes;
+    _XEatData (dpy, length) ;
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    EPHYR_LOG ("strname:%#x, strvalue:'%s', strlen:%d\n",
+               a_string_name, *a_string, numbytes) ;
+
+    is_ok = TRUE ;
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+static Bool
+ephyrHostGLXGetVisualConfigsInternal (enum VisualConfRequestType a_type,
+                                      int32_t a_screen,
+                                      int32_t *a_num_visuals,
+                                      int32_t *a_num_props,
+                                      int32_t *a_props_buf_size,
+                                      int32_t **a_props_buf)
+{
+    Bool is_ok = FALSE ;
+    Display *dpy = hostx_get_display () ;
+    xGLXGetVisualConfigsReq *req;
+    xGLXGetFBConfigsReq *fb_req;
+    xGLXVendorPrivateWithReplyReq *vpreq;
+    xGLXGetFBConfigsSGIXReq *sgi_req;
+    xGLXGetVisualConfigsReply reply;
+    char *server_glx_version=NULL,
+         *server_glx_extensions=NULL ;
+    int j=0,
+        screens=0,
+        major_opcode=0,
+        num_props=0,
+        num_visuals=0,
+        props_buf_size=0,
+        props_per_visual_size=0;
+    int32_t *props_buf=NULL;
+
+    EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
+
+    screens = ScreenCount (dpy);
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get opcode\n") ;
+        goto out ;
+    }
+
+    LockDisplay(dpy);
+    switch (a_type) {
+        case EPHYR_GET_FB_CONFIG:
+        GetReq(GLXGetFBConfigs,fb_req);
+        fb_req->reqType = major_opcode;
+        fb_req->glxCode = X_GLXGetFBConfigs;
+        fb_req->screen = DefaultScreen (dpy);
+        break;
+
+        case EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX:
+        GetReqExtra(GLXVendorPrivateWithReply,
+                    sz_xGLXGetFBConfigsSGIXReq
+                         -
+                    sz_xGLXVendorPrivateWithReplyReq,
+                    vpreq);
+        sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
+        sgi_req->reqType = major_opcode;
+        sgi_req->glxCode = X_GLXVendorPrivateWithReply;
+        sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
+        sgi_req->screen = DefaultScreen (dpy);
+        break;
+
+        case EPHYR_GET_VISUAL_CONFIGS:
+        GetReq(GLXGetVisualConfigs,req);
+        req->reqType = major_opcode;
+        req->glxCode = X_GLXGetVisualConfigs;
+        req->screen = DefaultScreen (dpy);
+        break;
+    }
+
+    if (!_XReply(dpy, (xReply*) &reply, 0, False)) {
+        EPHYR_LOG_ERROR ("unknown error\n") ;
+        UnlockDisplay(dpy);
+        goto out ;
+    }
+   if (!reply.numVisuals) {
+        EPHYR_LOG_ERROR ("screen does not support GL rendering\n") ;
+        UnlockDisplay(dpy);
+        goto out ;
+    }
+   num_visuals = reply.numVisuals ;
+
+    /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for
+     * FIXME: FBconfigs? 
+     */
+    /* Check number of properties */
+    num_props = reply.numProps;
+    if ((num_props < __GLX_MIN_CONFIG_PROPS) ||
+        (num_props > __GLX_MAX_CONFIG_PROPS)) {
+        /* Huh?  Not in protocol defined limits.  Punt */
+        EPHYR_LOG_ERROR ("got a bad reply to request\n") ;
+        UnlockDisplay(dpy);
+        goto out ;
+    }
+
+    if (a_type != EPHYR_GET_VISUAL_CONFIGS) {
+        num_props *= 2;
+    }
+    props_per_visual_size = num_props * __GLX_SIZE_INT32;
+    props_buf_size = props_per_visual_size * reply.numVisuals;
+    props_buf = malloc (props_buf_size) ;
+    for (j = 0; j < reply.numVisuals; j++) {
+        if (_XRead (dpy,
+                    &((char*)props_buf)[j*props_per_visual_size],
+                    props_per_visual_size) != Success) {
+            EPHYR_LOG_ERROR ("read failed\n") ;
+        }
+    }
+    UnlockDisplay(dpy);
+
+    *a_num_visuals = num_visuals ;
+    *a_num_props = reply.numProps ;
+    *a_props_buf_size = props_buf_size ;
+    *a_props_buf = props_buf ;
+    is_ok = TRUE ;
+
+out:
+    if (server_glx_version) {
+        XFree (server_glx_version) ;
+        server_glx_version = NULL ;
+    }
+    if (server_glx_extensions) {
+        XFree (server_glx_extensions) ;
+        server_glx_extensions = NULL ;
+    }
+    SyncHandle () ;
+    return is_ok;
+}
+
+Bool
+ephyrHostGLXGetVisualConfigs (int32_t a_screen,
+                              int32_t *a_num_visuals,
+                              int32_t *a_num_props,
+                              int32_t *a_props_buf_size,
+                              int32_t **a_props_buf)
+{
+    Bool is_ok = FALSE;
+
+    EPHYR_LOG ("enter\n") ;
+    is_ok = ephyrHostGLXGetVisualConfigsInternal (EPHYR_GET_VISUAL_CONFIGS,
+                                                  a_screen,
+                                                  a_num_visuals,
+                                                  a_num_props,
+                                                  a_props_buf_size,
+                                                  a_props_buf) ;
+
+    EPHYR_LOG ("leave:%d\n", is_ok) ;
+    return is_ok;
+}
+
+Bool
+ephyrHostGLXVendorPrivGetFBConfigsSGIX (int a_screen,
+                                        int32_t *a_num_visuals,
+                                        int32_t *a_num_props,
+                                        int32_t *a_props_buf_size,
+                                        int32_t **a_props_buf)
+{
+    Bool is_ok=FALSE ;
+    EPHYR_LOG ("enter\n") ;
+    is_ok = ephyrHostGLXGetVisualConfigsInternal
+                                        (EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
+                                         a_screen,
+                                         a_num_visuals,
+                                         a_num_props,
+                                         a_props_buf_size,
+                                         a_props_buf) ;
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+Bool
+ephyrHostGLXSendClientInfo (int32_t a_major, int32_t a_minor,
+                            const char* a_extension_list)
+{
+    Bool is_ok = FALSE ;
+    Display *dpy = hostx_get_display () ;
+    xGLXClientInfoReq *req;
+    int size;
+    int32_t major_opcode=0 ;
+
+    EPHYR_RETURN_VAL_IF_FAIL (dpy && a_extension_list, FALSE) ;
+
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+
+    LockDisplay (dpy);
+
+    GetReq (GLXClientInfo,req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLXClientInfo;
+    req->major = a_major;
+    req->minor = a_minor;
+
+    size = strlen (a_extension_list) + 1;
+    req->length += (size + 3) >> 2;
+    req->numbytes = size;
+    Data (dpy, a_extension_list, size);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    is_ok=TRUE ;
+
+out:
+    return is_ok ;
+}
+
+Bool
+ephyrHostGLXCreateContext (int a_screen,
+                           int a_visual_id,
+                           int a_context_id,
+                           int a_share_list_ctxt_id,
+                           Bool a_direct)
+{
+    Bool is_ok = FALSE;
+    Display *dpy = hostx_get_display ();
+    int major_opcode=0, remote_context_id=0;
+    xGLXCreateContextReq *req;
+
+    EPHYR_LOG ("enter. screen:%d, visual:%d, contextid:%d, direct:%d\n",
+               a_screen, a_visual_id, a_context_id, a_direct) ;
+
+    if (!hostx_allocate_resource_id_peer (a_context_id, &remote_context_id)) {
+        EPHYR_LOG_ERROR ("failed to peer the context id %d host X",
+                         remote_context_id) ;
+        goto out ;
+    }
+
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+
+    LockDisplay (dpy) ;
+
+    /* Send the glXCreateContext request */
+    GetReq(GLXCreateContext,req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLXCreateContext;
+    req->context = remote_context_id;
+    req->visual = a_visual_id;
+    req->screen = DefaultScreen (dpy);
+    req->shareList = a_share_list_ctxt_id;
+    req->isDirect = a_direct;
+
+    UnlockDisplay (dpy);
+    SyncHandle ();
+
+    is_ok = TRUE ;
+
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+Bool
+ephyrHostDestroyContext (int a_ctxt_id)
+{
+    Bool is_ok=FALSE;
+    Display *dpy=hostx_get_display ();
+    int major_opcode=0, remote_ctxt_id=0 ;
+    xGLXDestroyContextReq *req=NULL;
+
+    EPHYR_LOG ("enter:%d\n", a_ctxt_id) ;
+
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+    if (!hostx_get_resource_id_peer (a_ctxt_id, &remote_ctxt_id)) {
+        EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
+        goto out ;
+    }
+    EPHYR_LOG ("host context id:%d\n", remote_ctxt_id) ;
+
+    LockDisplay (dpy);
+    GetReq (GLXDestroyContext,req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLXDestroyContext;
+    req->context = remote_ctxt_id;
+    UnlockDisplay (dpy);
+    SyncHandle ();
+
+    is_ok = TRUE ;
+
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+Bool
+ephyrHostGLXMakeCurrent (int a_drawable,
+                         int a_glx_ctxt_id,
+                         int a_old_ctxt_tag,
+                         int *a_ctxt_tag)
+{
+    Bool is_ok=FALSE ;
+    Display *dpy = hostx_get_display () ;
+    int32_t major_opcode=0 ;
+    int remote_glx_ctxt_id=0 ;
+    xGLXMakeCurrentReq *req;
+    xGLXMakeCurrentReply reply;
+
+    EPHYR_RETURN_VAL_IF_FAIL (a_ctxt_tag, FALSE) ;
+
+    EPHYR_LOG ("enter. drawable:%d, context:%d, oldtag:%d\n",
+               a_drawable, a_glx_ctxt_id, a_old_ctxt_tag) ;
+
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+    if (!hostx_get_resource_id_peer (a_glx_ctxt_id, &remote_glx_ctxt_id)) {
+        EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
+        goto out ;
+    }
+
+    LockDisplay (dpy);
+
+    GetReq (GLXMakeCurrent,req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLXMakeCurrent;
+    req->drawable = a_drawable;
+    req->context = remote_glx_ctxt_id;
+    req->oldContextTag = a_old_ctxt_tag;
+
+    memset (&reply, 0, sizeof (reply)) ;
+    if (!_XReply (dpy, (xReply*)&reply, 0, False)) {
+        EPHYR_LOG_ERROR ("failed to get reply from host\n") ;
+        UnlockDisplay (dpy);
+        SyncHandle ();
+        goto out ;
+    }
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    *a_ctxt_tag = reply.contextTag ;
+    EPHYR_LOG ("context tag:%d\n", *a_ctxt_tag) ;
+    is_ok = TRUE ;
+
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+#define X_GLXSingle 0
+
+#define __EPHYR_GLX_SINGLE_PUT_CHAR(offset,a) \
+    *((INT8 *) (pc + offset)) = a
+
+#define EPHYR_GLX_SINGLE_PUT_SHORT(offset,a) \
+    *((INT16 *) (pc + offset)) = a
+
+#define EPHYR_GLX_SINGLE_PUT_LONG(offset,a) \
+    *((INT32 *) (pc + offset)) = a
+
+#define EPHYR_GLX_SINGLE_PUT_FLOAT(offset,a) \
+    *((FLOAT32 *) (pc + offset)) = a
+
+#define EPHYR_GLX_SINGLE_READ_XREPLY()       \
+    (void) _XReply(dpy, (xReply*) &reply, 0, False)
+
+#define EPHYR_GLX_SINGLE_GET_RETVAL(a,cast) \
+    a = (cast) reply.retval
+
+#define EPHYR_GLX_SINGLE_GET_SIZE(a) \
+    a = (GLint) reply.size
+
+#define EPHYR_GLX_SINGLE_GET_CHAR(p) \
+    *p = *(GLbyte *)&reply.pad3;
+
+#define EPHYR_GLX_SINGLE_GET_SHORT(p) \
+    *p = *(GLshort *)&reply.pad3;
+
+#define EPHYR_GLX_SINGLE_GET_LONG(p) \
+    *p = *(GLint *)&reply.pad3;
+
+#define EPHYR_GLX_SINGLE_GET_FLOAT(p) \
+    *p = *(GLfloat *)&reply.pad3;
+
+Bool
+ephyrHostGetIntegerValue (int a_current_context_tag, int a_int, int *a_val)
+{
+    Bool is_ok=FALSE;
+    Display *dpy = hostx_get_display () ;
+    int major_opcode=0, size=0;
+    xGLXSingleReq *req=NULL;
+    xGLXSingleReply reply;
+    unsigned char* pc=NULL ;
+
+    EPHYR_RETURN_VAL_IF_FAIL (a_val, FALSE) ;
+
+    EPHYR_LOG ("enter\n") ;
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+    LockDisplay (dpy) ;
+    GetReqExtra (GLXSingle, 4, req) ;
+    req->reqType = major_opcode ;
+    req->glxCode = X_GLsop_GetIntegerv ;
+    req->contextTag = a_current_context_tag;
+    pc = ((unsigned char *)(req) + sz_xGLXSingleReq) ;
+    EPHYR_GLX_SINGLE_PUT_LONG (0, a_int) ;
+    EPHYR_GLX_SINGLE_READ_XREPLY () ;
+    EPHYR_GLX_SINGLE_GET_SIZE (size) ;
+    if (!size) {
+        UnlockDisplay (dpy) ;
+        SyncHandle () ;
+        EPHYR_LOG_ERROR ("X_GLsop_GetIngerv failed\n") ;
+        goto out ;
+    }
+    EPHYR_GLX_SINGLE_GET_LONG (a_val) ;
+    UnlockDisplay (dpy) ;
+    SyncHandle () ;
+    is_ok = TRUE ;
+
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+Bool
+ephyrHostIsContextDirect (int a_ctxt_id,
+                          int *a_is_direct)
+{
+    Bool is_ok=FALSE;
+    Display *dpy = hostx_get_display () ;
+    xGLXIsDirectReq *req=NULL;
+    xGLXIsDirectReply reply;
+    int major_opcode=0, remote_glx_ctxt_id=0;
+
+    EPHYR_LOG ("enter\n") ;
+    if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
+        EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
+        goto out ;
+    }
+    if (!hostx_get_resource_id_peer (a_ctxt_id, &remote_glx_ctxt_id)) {
+        EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
+        goto out ;
+    }
+    memset (&reply, 0, sizeof (reply)) ;
+
+    /* Send the glXIsDirect request */
+    LockDisplay (dpy);
+    GetReq (GLXIsDirect,req);
+    req->reqType = major_opcode;
+    req->glxCode = X_GLXIsDirect;
+    req->context = remote_glx_ctxt_id;
+    if (!_XReply (dpy, (xReply*) &reply, 0, False)) {
+        EPHYR_LOG_ERROR ("fail in reading reply from host\n") ;
+        UnlockDisplay (dpy);
+        SyncHandle ();
+        goto out ;
+    }
+    UnlockDisplay (dpy);
+    SyncHandle ();
+    *a_is_direct = reply.isDirect ;
+    is_ok = TRUE ;
+
+out:
+    EPHYR_LOG ("leave\n") ;
+    return is_ok ;
+}
+
+#endif /*XEPHYR_DRI*/
+