自学教程：C++ vbglR3DoIOCtl函数代码示例

int vbglR3GRPerform(VMMDevRequestHeader *pReq){    PVBGLREQHDR    pReqHdr = (PVBGLREQHDR)pReq;    uint32_t const cbReq   = pReqHdr->cbIn;    Assert(pReqHdr->cbOut == 0 || pReqHdr->cbOut == cbReq);    pReqHdr->cbOut = cbReq;    if (pReq->size < _1K)        return vbglR3DoIOCtl(VBGL_IOCTL_VMMDEV_REQUEST(cbReq), pReqHdr, cbReq);    return vbglR3DoIOCtl(VBGL_IOCTL_VMMDEV_REQUEST_BIG, pReqHdr, cbReq);}

/** * Wait for the host to signal one or more events and return which. * * The events will only be delivered by the host if they have been enabled * previously using @a VbglR3CtlFilterMask.  If one or several of the events * have already been signalled but not yet waited for, this function will return * immediately and return those events. * * @returns IPRT status code. * * @param   fMask       The events we want to wait for, or-ed together. * @param   cMillies    How long to wait before giving up and returning *                      (VERR_TIMEOUT). Use RT_INDEFINITE_WAIT to wait until we *                      are interrupted or one of the events is signalled. * @param   pfEvents    Where to store the events signalled. Optional. */VBGLR3DECL(int) VbglR3WaitEvent(uint32_t fMask, uint32_t cMillies, uint32_t *pfEvents){    LogFlow(("VbglR3WaitEvent: fMask=0x%x, cMillies=%u, pfEvents=%p/n",             fMask, cMillies, pfEvents));    AssertReturn((fMask & ~VMMDEV_EVENT_VALID_EVENT_MASK) == 0, VERR_INVALID_PARAMETER);    AssertPtrNullReturn(pfEvents, VERR_INVALID_POINTER);    VBoxGuestWaitEventInfo waitEvent;    waitEvent.u32TimeoutIn = cMillies;    waitEvent.u32EventMaskIn = fMask;    waitEvent.u32Result = VBOXGUEST_WAITEVENT_ERROR;    waitEvent.u32EventFlagsOut = 0;    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent));    if (RT_SUCCESS(rc))    {        /*         * If a guest requests for an event which is not available on the host side         * (because of an older host version, a disabled feature or older Guest Additions),         * don't trigger an assertion here even in debug builds - would be annoying.         */#if 0        AssertMsg(waitEvent.u32Result == VBOXGUEST_WAITEVENT_OK, ("%d rc=%Rrc/n", waitEvent.u32Result, rc));#endif        if (pfEvents)            *pfEvents = waitEvent.u32EventFlagsOut;    }    LogFlow(("VbglR3WaitEvent: rc=%Rrc, u32EventFlagsOut=0x%x. u32Result=%d/n",             rc, waitEvent.u32EventFlagsOut, waitEvent.u32Result));    return rc;}

VBGLR3DECL(int) VbglR3DnDConnect(uint32_t *pu32ClientId){    /* Validate input */    AssertPtrReturn(pu32ClientId, VERR_INVALID_POINTER);    /* Initialize header */    VBoxGuestHGCMConnectInfo Info;    RT_ZERO(Info.Loc.u);    Info.result      = VERR_WRONG_ORDER;    Info.u32ClientID = UINT32_MAX;  /* try make valgrind shut up. */    /* Initialize parameter */    Info.Loc.type    = VMMDevHGCMLoc_LocalHost_Existing;    int rc = RTStrCopy(Info.Loc.u.host.achName, sizeof(Info.Loc.u.host.achName), "VBoxDragAndDropSvc");    if (RT_FAILURE(rc)) return rc;    /* Do request */    rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CONNECT, &Info, sizeof(Info));    if (RT_SUCCESS(rc))    {        rc = Info.result;        if (RT_SUCCESS(rc))            *pu32ClientId = Info.u32ClientID;    }    if (rc == VERR_HGCM_SERVICE_NOT_FOUND)        rc = VINF_PERMISSION_DENIED;    return rc;}

static int vbglR3DnDQueryNextHostMessageType(uint32_t uClientId, uint32_t *puMsg, uint32_t *pcParms, bool fWait){    /* Validate input */    AssertPtrReturn(puMsg,   VERR_INVALID_POINTER);    AssertPtrReturn(pcParms, VERR_INVALID_POINTER);    /* Initialize header */    DragAndDropSvc::VBOXDNDNEXTMSGMSG Msg;    RT_ZERO(Msg);    Msg.hdr.result      = VERR_WRONG_ORDER;    Msg.hdr.u32ClientID = uClientId;    Msg.hdr.u32Function = DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG;    Msg.hdr.cParms      = 3;    /* Initialize parameter */    Msg.msg.SetUInt32(0);    Msg.num_parms.SetUInt32(0);    Msg.block.SetUInt32(fWait);    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))    {        rc = Msg.hdr.result;        if (RT_SUCCESS(rc))        {            /* Fetch results */            rc = Msg.msg.GetUInt32(puMsg);         AssertRC(rc);            rc = Msg.num_parms.GetUInt32(pcParms); AssertRC(rc);        }    }    return rc;}

/** * Get a host message. * * This will block until a message becomes available. * * @returns VBox status code. * @param   u32ClientId     The client id returned by VbglR3ClipboardConnect(). * @param   pMsg            Where to store the message id. * @param   pfFormats       Where to store the format(s) the message applies to. */VBGLR3DECL(int) VbglR3ClipboardGetHostMsg(uint32_t u32ClientId, uint32_t *pMsg, uint32_t *pfFormats){    VBoxClipboardGetHostMsg Msg;    Msg.hdr.result = VERR_WRONG_ORDER;    Msg.hdr.u32ClientID = u32ClientId;    Msg.hdr.u32Function = VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG;    Msg.hdr.cParms = 2;    VbglHGCMParmUInt32Set(&Msg.msg, 0);    VbglHGCMParmUInt32Set(&Msg.formats, 0);    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))    {        rc = Msg.hdr.result;        if (RT_SUCCESS(rc))        {            uint32_t u32Msg;            rc = VbglHGCMParmUInt32Get(&Msg.msg, &u32Msg);            if (RT_SUCCESS(rc))            {                uint32_t fFormats;                rc = VbglHGCMParmUInt32Get(&Msg.formats, &fFormats);                if (RT_SUCCESS(rc))                {                    *pMsg = u32Msg;                    *pfFormats = fFormats;                    return Msg.hdr.result;                }            }        }    }    return rc;}

VBGLR3DECL(int) VbglR3HostChannelRecv(uint32_t u32ChannelHandle,                                      uint32_t u32HGCMClientId,                                      void *pvData,                                      uint32_t cbData,                                      uint32_t *pu32SizeReceived,                                      uint32_t *pu32SizeRemaining){    VBoxHostChannelRecv parms;    parms.hdr.result = VERR_WRONG_ORDER;    parms.hdr.u32ClientID = u32HGCMClientId;    parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_RECV;    parms.hdr.cParms = 4;    VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);    VbglHGCMParmPtrSet(&parms.data, pvData, cbData);    VbglHGCMParmUInt32Set(&parms.sizeReceived, 0);    VbglHGCMParmUInt32Set(&parms.sizeRemaining, 0);    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));    if (RT_SUCCESS(rc))    {        rc = parms.hdr.result;        if (RT_SUCCESS(rc))        {            *pu32SizeReceived = parms.sizeReceived.u.value32;            *pu32SizeRemaining = parms.sizeRemaining.u.value32;        }    }    return rc;}

static int vbglR3DnDHGProcessMoreDataMessageInternal(uint32_t  uClientId,                                                     void     *pvData,                                                     uint32_t  cbData,                                                     uint32_t *pcbDataRecv){    /* Validate input */    AssertPtrReturn(pvData,      VERR_INVALID_POINTER);    AssertReturn(cbData,         VERR_INVALID_PARAMETER);    AssertPtrReturn(pcbDataRecv, VERR_INVALID_POINTER);    /* Initialize header */    DragAndDropSvc::VBOXDNDHGSENDMOREDATAMSG Msg;    RT_ZERO(Msg);    Msg.hdr.u32ClientID = g_clientId;    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_SND_MORE_DATA;    Msg.hdr.cParms      = 2;    /* Initialize parameter */    Msg.pvData.SetPtr(pvData, cbData);    Msg.cData.SetUInt32(0);    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))    {        rc = Msg.hdr.result;        if (   RT_SUCCESS(rc)            || rc == VERR_BUFFER_OVERFLOW)        {            /* Fetch results */            rc = Msg.cData.GetUInt32(pcbDataRecv); AssertRC(rc);            /* A little bit paranoia */            AssertReturn(cbData >= *pcbDataRecv, VERR_TOO_MUCH_DATA);        }    }    return rc;}

static int vbglR3DnDGHProcessRequestPendingMessage(uint32_t  uClientId,                                                   uint32_t *puScreenId){    /* Validate input */    AssertPtrReturn(puScreenId, VERR_INVALID_POINTER);    /* Initialize header */    DragAndDropSvc::VBOXDNDGHREQPENDINGMSG Msg;    RT_ZERO(Msg);    Msg.hdr.u32ClientID = uClientId;    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_GH_REQ_PENDING;    Msg.hdr.cParms      = 1;    /* Initialize parameter */    Msg.uScreenId.SetUInt32(0);    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))    {        rc = Msg.hdr.result;        if (RT_SUCCESS(rc))        {            /* Fetch results */            rc = Msg.uScreenId.GetUInt32(puScreenId); AssertRC(rc);        }    }    return rc;}

/** * Change the IRQ filter mask. * * @returns IPRT status code. * @param   fOr     The OR mask. * @param   fNo     The NOT mask. */VBGLR3DECL(int) VbglR3CtlFilterMask(uint32_t fOr, uint32_t fNot){    VBoxGuestFilterMaskInfo Info;    Info.u32OrMask = fOr;    Info.u32NotMask = fNot;    return vbglR3DoIOCtl(VBOXGUEST_IOCTL_CTL_FILTER_MASK, &Info, sizeof(Info));}

/** * Write guest core dump. * * @returns IPRT status code. */VBGLR3DECL(int) VbglR3WriteCoreDump(void){    VBGLIOCWRITECOREDUMP Req;    VBGLREQHDR_INIT(&Req.Hdr, WRITE_CORE_DUMP);    Req.u.In.fFlags = 0;    return vbglR3DoIOCtl(VBGL_IOCTL_WRITE_CORE_DUMP, &Req.Hdr, sizeof(Req));}

/** * Write to the backdoor logger from ring 3 guest code. * * @returns IPRT status code. * * @param   pch     The string to log.  Does not need to be terminated. * @param   cch     The number of chars (bytes) to log. * * @remarks This currently does not accept more than 255 bytes of data at *          one time. It should probably be rewritten to use pass a pointer *          in the IOCtl. */VBGLR3DECL(int) VbglR3WriteLog(const char *pch, size_t cch){    /*     * Quietly skip NULL strings.     * (Happens in the RTLogBackdoorPrintf case.)     */    if (!cch)        return VINF_SUCCESS;    if (!VALID_PTR(pch))        return VERR_INVALID_POINTER;#ifdef RT_OS_WINDOWS    /*     * Duplicate the string as it may be read only (a C string).     */    void *pvTmp = RTMemDup(pch, cch);    if (!pvTmp)        return VERR_NO_MEMORY;    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_LOG(cch), pvTmp, cch);    RTMemFree(pvTmp);    return rc;#elif 0 /** @todo Several OSes could take this route (solaris and freebsd for instance). */    /*     * Handle the entire request in one go.     */    return vbglR3DoIOCtl(VBOXGUEST_IOCTL_LOG(cch), pvTmp, cch);#else    /*     * *BSD does not accept more than 4KB per ioctl request, while     * Linux can't express sizes above 8KB, so, split it up into 2KB chunks.     */# define STEP 2048    int rc = VINF_SUCCESS;    for (size_t off = 0; off < cch && RT_SUCCESS(rc); off += STEP)    {        size_t cbStep = RT_MIN(cch - off, STEP);        rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_LOG(cbStep), (char *)pch + off, cbStep);    }# undef STEP    return rc;#endif}

static int vbglR3DnDHGProcessActionMessage(uint32_t  uClientId,                                           uint32_t  uMsg,                                           uint32_t *puScreenId,                                           uint32_t *puX,                                           uint32_t *puY,                                           uint32_t *puDefAction,                                           uint32_t *puAllActions,                                           char     *pszFormats,                                           uint32_t  cbFormats,                                           uint32_t *pcbFormatsRecv){    /* Validate input */    AssertPtrReturn(puScreenId,     VERR_INVALID_POINTER);    AssertPtrReturn(puX,            VERR_INVALID_POINTER);    AssertPtrReturn(puY,            VERR_INVALID_POINTER);    AssertPtrReturn(puDefAction,    VERR_INVALID_POINTER);    AssertPtrReturn(puAllActions,   VERR_INVALID_POINTER);    AssertPtrReturn(pszFormats,     VERR_INVALID_POINTER);    AssertReturn(cbFormats,         VERR_INVALID_PARAMETER);    AssertPtrReturn(pcbFormatsRecv, VERR_INVALID_POINTER);    /* Initialize header */    DragAndDropSvc::VBOXDNDHGACTIONMSG Msg;    RT_ZERO(Msg);    Msg.hdr.u32ClientID = uClientId;    Msg.hdr.u32Function = uMsg;    Msg.hdr.cParms      = 7;    /* Initialize parameter */    Msg.uScreenId.SetUInt32(0);    Msg.uX.SetUInt32(0);    Msg.uY.SetUInt32(0);    Msg.uDefAction.SetUInt32(0);    Msg.uAllActions.SetUInt32(0);    Msg.pvFormats.SetPtr(pszFormats, cbFormats);    Msg.cFormats.SetUInt32(0);    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))    {        rc = Msg.hdr.result;        if (RT_SUCCESS(rc))        {            /* Fetch results */            rc = Msg.uScreenId.GetUInt32(puScreenId);     AssertRC(rc);            rc = Msg.uX.GetUInt32(puX);                   AssertRC(rc);            rc = Msg.uY.GetUInt32(puY);                   AssertRC(rc);            rc = Msg.uDefAction.GetUInt32(puDefAction);   AssertRC(rc);            rc = Msg.uAllActions.GetUInt32(puAllActions); AssertRC(rc);            rc = Msg.cFormats.GetUInt32(pcbFormatsRecv);  AssertRC(rc);            /* A little bit paranoia */            AssertReturn(cbFormats >= *pcbFormatsRecv, VERR_TOO_MUCH_DATA);        }    }    return rc;}

/** * Disconnect from an HGCM service. * * @returns VBox status code. * @param   idClient        The client id returned by VbglR3InfoSvcConnect(). */VBGLR3DECL(int) VbglR3HGCMDisconnect(HGCMCLIENTID idClient){    VBoxGuestHGCMDisconnectInfo Info;    Info.result = VERR_WRONG_ORDER;    Info.u32ClientID = idClient;    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));    if (RT_SUCCESS(rc))        rc = Info.result;    return rc;}

/** * Disconnect from the shared folder service. * * @returns VBox status code. * @param   u32ClientId     The client id returned by VbglR3InfoSvcConnect(). */VBGLR3DECL(int) VbglR3SharedFolderDisconnect(uint32_t u32ClientId){    VBoxGuestHGCMDisconnectInfo Info;    Info.result = VERR_WRONG_ORDER;    Info.u32ClientID = u32ClientId;    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));    if (RT_SUCCESS(rc))        rc = Info.result;    return rc;}

VBGLR3DECL(int) VbglR3DnDDisconnect(uint32_t u32ClientId){    /* Initialize header */    VBoxGuestHGCMDisconnectInfo Info;    Info.result      = VERR_WRONG_ORDER;    Info.u32ClientID = u32ClientId;    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));    if (RT_SUCCESS(rc))        rc = Info.result;    return rc;}

static int vbglR3DnDHGProcessCancelMessage(uint32_t uClientId){    /* Initialize header */    DragAndDropSvc::VBOXDNDHGCANCELMSG Msg;    RT_ZERO(Msg);    Msg.hdr.u32ClientID = uClientId;    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_EVT_CANCEL;    Msg.hdr.cParms      = 0;    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))        rc = Msg.hdr.result;    return rc;}

static int vbglR3DnDHGProcessSendFileMessage(uint32_t  uClientId,                                             char     *pszFilename,                                             uint32_t  cbFilename,                                             uint32_t *pcbFilenameRecv,                                             void     *pvData,                                             uint32_t  cbData,                                             uint32_t *pcbDataRecv,                                             uint32_t *pfMode){    /* Validate input */    AssertPtrReturn(pszFilename,     VERR_INVALID_POINTER);    AssertReturn(cbFilename,         VERR_INVALID_PARAMETER);    AssertPtrReturn(pcbFilenameRecv, VERR_INVALID_POINTER);    AssertPtrReturn(pvData,          VERR_INVALID_POINTER);    AssertReturn(cbData,             VERR_INVALID_PARAMETER);    AssertPtrReturn(pcbDataRecv,     VERR_INVALID_POINTER);    AssertPtrReturn(pfMode,          VERR_INVALID_POINTER);    /* Initialize header */    DragAndDropSvc::VBOXDNDHGSENDFILEMSG Msg;    RT_ZERO(Msg);    Msg.hdr.u32ClientID = uClientId;    Msg.hdr.u32Function = DragAndDropSvc::HOST_DND_HG_SND_FILE;    Msg.hdr.cParms      = 5;    /* Initialize parameter */    Msg.pvName.SetPtr(pszFilename, cbFilename);    Msg.cName.SetUInt32(0);    Msg.pvData.SetPtr(pvData, cbData);    Msg.cData.SetUInt32(0);    Msg.fMode.SetUInt32(0);    /* Do request */    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));    if (RT_SUCCESS(rc))    {        rc = Msg.hdr.result;        if (RT_SUCCESS(rc))        {            /* Fetch results */            rc = Msg.cName.GetUInt32(pcbFilenameRecv); AssertRC(rc);            rc = Msg.cData.GetUInt32(pcbDataRecv);     AssertRC(rc);            rc = Msg.fMode.GetUInt32(pfMode);          AssertRC(rc);            /* A little bit paranoia */            AssertReturn(cbFilename >= *pcbFilenameRecv, VERR_TOO_MUCH_DATA);            AssertReturn(cbData     >= *pcbDataRecv,     VERR_TOO_MUCH_DATA);        }    }    return rc;}