xref: /xsrc/external/mit/xorg-server.old/dist/hw/kdrive/ephyr/ephyrhostglx.c

/*
 * 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"

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 += bytes_to_int32(size);
    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 ;
}