[93369] | 1 | /* $Id: display-ipc.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
[93423] | 3 | * Guest Additions - DRM IPC communication core functions.
|
---|
[93369] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2017-2023 Oracle and/or its affiliates.
|
---|
[93369] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[93369] | 26 | */
|
---|
| 27 |
|
---|
| 28 | /*
|
---|
| 29 | * This module implements connection handling routine which is common for
|
---|
| 30 | * both IPC server and client (see vbDrmIpcConnectionHandler()). This function
|
---|
| 31 | * at first tries to read incoming command from IPC socket and if no data has
|
---|
| 32 | * arrived within VBOX_DRMIPC_RX_TIMEOUT_MS, it checks is there is some data in
|
---|
| 33 | * TX queue and sends it. TX queue and IPC connection handle is unique per IPC
|
---|
| 34 | * client and handled in a separate thread of either server or client process.
|
---|
| 35 | *
|
---|
| 36 | * Logging is implemented in a way that errors are always printed out,
|
---|
| 37 | * VBClLogVerbose(2) is used for debugging purposes and reflects what is related to
|
---|
| 38 | * IPC communication. In order to see logging on a host side it is enough to do:
|
---|
| 39 | *
|
---|
| 40 | * echo 1 > /sys/module/vboxguest/parameters/r3_log_to_host.
|
---|
| 41 | */
|
---|
| 42 |
|
---|
| 43 | #include "VBoxClient.h"
|
---|
| 44 | #include "display-ipc.h"
|
---|
| 45 |
|
---|
| 46 | #include <VBox/VBoxGuestLib.h>
|
---|
| 47 |
|
---|
| 48 | #include <iprt/localipc.h>
|
---|
| 49 | #include <iprt/err.h>
|
---|
| 50 | #include <iprt/crc.h>
|
---|
| 51 | #include <iprt/mem.h>
|
---|
| 52 | #include <iprt/asm.h>
|
---|
| 53 | #include <iprt/critsect.h>
|
---|
| 54 | #include <iprt/assert.h>
|
---|
| 55 |
|
---|
| 56 | #include <grp.h>
|
---|
| 57 | #include <pwd.h>
|
---|
| 58 | #include <errno.h>
|
---|
| 59 | #include <limits.h>
|
---|
| 60 | #include <unistd.h>
|
---|
| 61 |
|
---|
| 62 | /**
|
---|
| 63 | * Calculate size of TX list entry.
|
---|
| 64 | *
|
---|
| 65 | * TX list entry consists of RTLISTNODE, DRM IPC message header and message payload.
|
---|
| 66 | * Given IpcCmd already includes message header and payload. So, TX list entry size
|
---|
| 67 | * equals to size of IpcCmd plus size of RTLISTNODE.
|
---|
| 68 | *
|
---|
| 69 | * @param IpcCmd A structure which represents DRM IPC command.
|
---|
| 70 | */
|
---|
| 71 | #define DRMIPCCOMMAND_TX_LIST_ENTRY_SIZE(IpcCmd) (sizeof(IpcCmd) + RT_UOFFSETOF(VBOX_DRMIPC_TX_LIST_ENTRY, Hdr))
|
---|
| 72 |
|
---|
| 73 | /**
|
---|
| 74 | * Initialize IPC client private data.
|
---|
[93383] | 75 | *
|
---|
[93369] | 76 | * @return IPRT status code.
|
---|
| 77 | * @param pClient IPC client private data to be initialized.
|
---|
| 78 | * @param hThread A thread which server IPC client connection.
|
---|
| 79 | * @param hClientSession IPC session handle obtained from RTLocalIpcSessionXXX().
|
---|
| 80 | * @param cTxListCapacity Maximum number of messages which can be queued for TX for this IPC session.
|
---|
[93380] | 81 | * @param pfnRxCb IPC RX callback function pointer.
|
---|
[93369] | 82 | */
|
---|
| 83 | RTDECL(int) vbDrmIpcClientInit(PVBOX_DRMIPC_CLIENT pClient, RTTHREAD hThread, RTLOCALIPCSESSION hClientSession,
|
---|
| 84 | uint32_t cTxListCapacity, PFNDRMIPCRXCB pfnRxCb)
|
---|
| 85 | {
|
---|
| 86 | AssertReturn(pClient, VERR_INVALID_PARAMETER);
|
---|
| 87 | AssertReturn(hThread, VERR_INVALID_PARAMETER);
|
---|
| 88 | AssertReturn(hClientSession, VERR_INVALID_PARAMETER);
|
---|
| 89 | AssertReturn(cTxListCapacity, VERR_INVALID_PARAMETER);
|
---|
| 90 | AssertReturn(pfnRxCb, VERR_INVALID_PARAMETER);
|
---|
| 91 |
|
---|
| 92 | pClient->hThread = hThread;
|
---|
| 93 | pClient->hClientSession = hClientSession;
|
---|
| 94 |
|
---|
| 95 | RT_ZERO(pClient->TxList);
|
---|
| 96 | RTListInit(&pClient->TxList.Node);
|
---|
| 97 |
|
---|
| 98 | pClient->cTxListCapacity = cTxListCapacity;
|
---|
| 99 | ASMAtomicWriteU32(&pClient->cTxListSize, 0);
|
---|
| 100 |
|
---|
| 101 | pClient->pfnRxCb = pfnRxCb;
|
---|
| 102 |
|
---|
| 103 | return RTCritSectInit(&pClient->CritSect);
|
---|
| 104 | }
|
---|
| 105 |
|
---|
| 106 | /**
|
---|
| 107 | * Releases IPC client private data resources.
|
---|
| 108 | *
|
---|
| 109 | * @return IPRT status code.
|
---|
| 110 | * @param pClient IPC session private data to be initialized.
|
---|
| 111 | */
|
---|
| 112 | RTDECL(int) vbDrmIpcClientReleaseResources(PVBOX_DRMIPC_CLIENT pClient)
|
---|
| 113 | {
|
---|
| 114 | PVBOX_DRMIPC_TX_LIST_ENTRY pEntry, pNextEntry;
|
---|
| 115 | int rc;
|
---|
| 116 |
|
---|
| 117 | pClient->hClientSession = 0;
|
---|
| 118 |
|
---|
| 119 | rc = RTCritSectEnter(&pClient->CritSect);
|
---|
| 120 | if (RT_SUCCESS(rc))
|
---|
| 121 | {
|
---|
| 122 | if (!RTListIsEmpty(&pClient->TxList.Node))
|
---|
| 123 | {
|
---|
| 124 | RTListForEachSafe(&pClient->TxList.Node, pEntry, pNextEntry, VBOX_DRMIPC_TX_LIST_ENTRY, Node)
|
---|
| 125 | {
|
---|
| 126 | RTListNodeRemove(&pEntry->Node);
|
---|
| 127 | RTMemFree(pEntry);
|
---|
| 128 | ASMAtomicDecU32(&pClient->cTxListSize);
|
---|
| 129 | }
|
---|
| 130 | }
|
---|
| 131 |
|
---|
| 132 | rc = RTCritSectLeave(&pClient->CritSect);
|
---|
| 133 | if (RT_SUCCESS(rc))
|
---|
| 134 | {
|
---|
| 135 | rc = RTCritSectDelete(&pClient->CritSect);
|
---|
| 136 | if (RT_FAILURE(rc))
|
---|
| 137 | VBClLogError("vbDrmIpcClientReleaseResources: unable to delete critical section, rc=%Rrc\n", rc);
|
---|
| 138 | }
|
---|
| 139 | else
|
---|
| 140 | VBClLogError("vbDrmIpcClientReleaseResources: unable to leave critical section, rc=%Rrc\n", rc);
|
---|
| 141 | }
|
---|
| 142 | else
|
---|
| 143 | VBClLogError("vbDrmIpcClientReleaseResources: unable to enter critical section, rc=%Rrc\n", rc);
|
---|
| 144 |
|
---|
| 145 | Assert(ASMAtomicReadU32(&pClient->cTxListSize) == 0);
|
---|
| 146 |
|
---|
| 147 | RT_ZERO(*pClient);
|
---|
| 148 |
|
---|
| 149 | return rc;
|
---|
| 150 | }
|
---|
| 151 |
|
---|
| 152 | /**
|
---|
| 153 | * Add message to IPC session TX queue.
|
---|
| 154 | *
|
---|
| 155 | * @return IPRT status code.
|
---|
| 156 | * @param pClient IPC session private data.
|
---|
| 157 | * @param pEntry Pointer to the message.
|
---|
| 158 | */
|
---|
| 159 | static int vbDrmIpcSessionScheduleTx(PVBOX_DRMIPC_CLIENT pClient, PVBOX_DRMIPC_TX_LIST_ENTRY pEntry)
|
---|
| 160 | {
|
---|
| 161 | int rc;
|
---|
| 162 |
|
---|
| 163 | AssertReturn(pClient, VERR_INVALID_PARAMETER);
|
---|
| 164 | AssertReturn(pEntry, VERR_INVALID_PARAMETER);
|
---|
| 165 |
|
---|
| 166 | rc = RTCritSectEnter(&pClient->CritSect);
|
---|
| 167 | if (RT_SUCCESS(rc))
|
---|
| 168 | {
|
---|
| 169 | if (pClient->cTxListSize < pClient->cTxListCapacity)
|
---|
| 170 | {
|
---|
| 171 | RTListAppend(&pClient->TxList.Node, &pEntry->Node);
|
---|
| 172 | pClient->cTxListSize++;
|
---|
| 173 | }
|
---|
| 174 | else
|
---|
| 175 | VBClLogError("vbDrmIpcSessionScheduleTx: TX queue is full\n");
|
---|
| 176 |
|
---|
| 177 | int rc2 = RTCritSectLeave(&pClient->CritSect);
|
---|
| 178 | if (RT_FAILURE(rc2))
|
---|
| 179 | VBClLogError("vbDrmIpcSessionScheduleTx: cannot leave critical section, rc=%Rrc\n", rc2);
|
---|
| 180 | }
|
---|
| 181 | else
|
---|
| 182 | VBClLogError("vbDrmIpcSessionScheduleTx: cannot enter critical section, rc=%Rrc\n", rc);
|
---|
| 183 |
|
---|
| 184 | return rc;
|
---|
| 185 | }
|
---|
| 186 |
|
---|
| 187 | /**
|
---|
| 188 | * Pick up message from TX queue if available.
|
---|
| 189 | *
|
---|
| 190 | * @return Pointer to list entry or NULL if queue is empty.
|
---|
| 191 | */
|
---|
| 192 | static PVBOX_DRMIPC_TX_LIST_ENTRY vbDrmIpcSessionPickupTxMessage(PVBOX_DRMIPC_CLIENT pClient)
|
---|
| 193 | {
|
---|
| 194 | PVBOX_DRMIPC_TX_LIST_ENTRY pEntry = NULL;
|
---|
| 195 | int rc;
|
---|
| 196 |
|
---|
| 197 | AssertReturn(pClient, NULL);
|
---|
| 198 |
|
---|
| 199 | rc = RTCritSectEnter(&pClient->CritSect);
|
---|
| 200 | if (RT_SUCCESS(rc))
|
---|
| 201 | {
|
---|
| 202 | if (!RTListIsEmpty(&pClient->TxList.Node))
|
---|
| 203 | {
|
---|
| 204 | pEntry = (PVBOX_DRMIPC_TX_LIST_ENTRY)RTListRemoveFirst(&pClient->TxList.Node, VBOX_DRMIPC_TX_LIST_ENTRY, Node);
|
---|
| 205 | pClient->cTxListSize--;
|
---|
| 206 | Assert(pEntry);
|
---|
| 207 | }
|
---|
| 208 |
|
---|
| 209 | int rc2 = RTCritSectLeave(&pClient->CritSect);
|
---|
| 210 | if (RT_FAILURE(rc2))
|
---|
| 211 | VBClLogError("vbDrmIpcSessionPickupTxMessage: cannot leave critical section, rc=%Rrc\n", rc2);
|
---|
| 212 | }
|
---|
| 213 | else
|
---|
| 214 | VBClLogError("vbDrmIpcSessionPickupTxMessage: cannot enter critical section, rc=%Rrc\n", rc);
|
---|
| 215 |
|
---|
| 216 | return pEntry;
|
---|
| 217 | }
|
---|
| 218 |
|
---|
| 219 | RTDECL(int) vbDrmIpcAuth(RTLOCALIPCSESSION hClientSession)
|
---|
| 220 | {
|
---|
| 221 | int rc = VERR_ACCESS_DENIED;
|
---|
| 222 | RTUID uUid;
|
---|
| 223 | struct group *pAllowedGroup;
|
---|
| 224 |
|
---|
| 225 | AssertReturn(hClientSession, VERR_INVALID_PARAMETER);
|
---|
| 226 |
|
---|
| 227 | /* Get DRM IPC user group entry from system database. */
|
---|
| 228 | pAllowedGroup = getgrnam(VBOX_DRMIPC_USER_GROUP);
|
---|
| 229 | if (!pAllowedGroup)
|
---|
| 230 | return RTErrConvertFromErrno(errno);
|
---|
| 231 |
|
---|
| 232 | /* Get remote user ID and check if it is in allowed user group. */
|
---|
| 233 | rc = RTLocalIpcSessionQueryUserId(hClientSession, &uUid);
|
---|
| 234 | if (RT_SUCCESS(rc))
|
---|
| 235 | {
|
---|
| 236 | /* Get user record from system database and look for it in group's members list. */
|
---|
| 237 | struct passwd *UserRecord = getpwuid(uUid);
|
---|
| 238 |
|
---|
| 239 | if (UserRecord && UserRecord->pw_name)
|
---|
| 240 | {
|
---|
| 241 | while (*pAllowedGroup->gr_mem)
|
---|
| 242 | {
|
---|
[93386] | 243 | if (RTStrNCmp(*pAllowedGroup->gr_mem, UserRecord->pw_name, LOGIN_NAME_MAX) == 0)
|
---|
[93369] | 244 | return VINF_SUCCESS;
|
---|
| 245 |
|
---|
| 246 | pAllowedGroup->gr_mem++;
|
---|
| 247 | }
|
---|
| 248 | }
|
---|
| 249 | }
|
---|
| 250 |
|
---|
| 251 | return rc;
|
---|
| 252 | }
|
---|
| 253 |
|
---|
| 254 | RTDECL(int) vbDrmIpcSetPrimaryDisplay(PVBOX_DRMIPC_CLIENT pClient, uint32_t idDisplay)
|
---|
| 255 | {
|
---|
| 256 | int rc = VERR_GENERAL_FAILURE;
|
---|
| 257 |
|
---|
| 258 | PVBOX_DRMIPC_TX_LIST_ENTRY pTxListEntry =
|
---|
| 259 | (PVBOX_DRMIPC_TX_LIST_ENTRY)RTMemAllocZ(DRMIPCCOMMAND_TX_LIST_ENTRY_SIZE(VBOX_DRMIPC_COMMAND_SET_PRIMARY_DISPLAY));
|
---|
| 260 |
|
---|
| 261 | if (pTxListEntry)
|
---|
| 262 | {
|
---|
| 263 | PVBOX_DRMIPC_COMMAND_SET_PRIMARY_DISPLAY pCmd = (PVBOX_DRMIPC_COMMAND_SET_PRIMARY_DISPLAY)(&pTxListEntry->Hdr);
|
---|
| 264 |
|
---|
| 265 | pCmd->Hdr.idCmd = VBOXDRMIPCCLTCMD_SET_PRIMARY_DISPLAY;
|
---|
| 266 | pCmd->Hdr.cbData = sizeof(VBOX_DRMIPC_COMMAND_SET_PRIMARY_DISPLAY);
|
---|
| 267 | pCmd->idDisplay = idDisplay;
|
---|
| 268 | pCmd->Hdr.u64Crc = RTCrc64(pCmd, pCmd->Hdr.cbData);
|
---|
| 269 | Assert(pCmd->Hdr.u64Crc);
|
---|
| 270 |
|
---|
| 271 | /* Put command into queue and trigger TX. */
|
---|
| 272 | rc = vbDrmIpcSessionScheduleTx(pClient, pTxListEntry);
|
---|
| 273 | if (RT_SUCCESS(rc))
|
---|
| 274 | {
|
---|
| 275 | VBClLogVerbose(2, "vbDrmIpcSetPrimaryDisplay: %u bytes scheduled for TX, crc=0x%x\n", pCmd->Hdr.cbData, pCmd->Hdr.u64Crc);
|
---|
| 276 | }
|
---|
| 277 | else
|
---|
| 278 | {
|
---|
| 279 | RTMemFree(pTxListEntry);
|
---|
| 280 | VBClLogError("vbDrmIpcSetPrimaryDisplay: unable to schedule TX, rc=%Rrc\n", rc);
|
---|
| 281 | }
|
---|
| 282 | }
|
---|
| 283 | else
|
---|
| 284 | {
|
---|
| 285 | VBClLogInfo("cannot allocate SET_PRIMARY_DISPLAY command\n");
|
---|
| 286 | rc = VERR_NO_MEMORY;
|
---|
| 287 | }
|
---|
| 288 |
|
---|
| 289 | return rc;
|
---|
| 290 | }
|
---|
| 291 |
|
---|
| 292 | /**
|
---|
| 293 | * Report to IPC server that display layout offsets have been changed (called by IPC client).
|
---|
| 294 | *
|
---|
| 295 | * @return IPRT status code.
|
---|
| 296 | * @param pClient IPC session private data.
|
---|
[94076] | 297 | * @param cDisplays Number of monitors which have offsets changed.
|
---|
| 298 | * @param aDisplays Offsets data.
|
---|
[93369] | 299 | */
|
---|
[94076] | 300 | RTDECL(int) vbDrmIpcReportDisplayOffsets(PVBOX_DRMIPC_CLIENT pClient, uint32_t cDisplays, struct VBOX_DRMIPC_VMWRECT *aDisplays)
|
---|
[93369] | 301 | {
|
---|
| 302 | int rc = VERR_GENERAL_FAILURE;
|
---|
| 303 |
|
---|
| 304 | PVBOX_DRMIPC_TX_LIST_ENTRY pTxListEntry =
|
---|
| 305 | (PVBOX_DRMIPC_TX_LIST_ENTRY)RTMemAllocZ(
|
---|
| 306 | DRMIPCCOMMAND_TX_LIST_ENTRY_SIZE(VBOX_DRMIPC_COMMAND_REPORT_DISPLAY_OFFSETS));
|
---|
| 307 |
|
---|
| 308 | if (pTxListEntry)
|
---|
| 309 | {
|
---|
| 310 | PVBOX_DRMIPC_COMMAND_REPORT_DISPLAY_OFFSETS pCmd = (PVBOX_DRMIPC_COMMAND_REPORT_DISPLAY_OFFSETS)(&pTxListEntry->Hdr);
|
---|
| 311 |
|
---|
| 312 | pCmd->Hdr.idCmd = VBOXDRMIPCSRVCMD_REPORT_DISPLAY_OFFSETS;
|
---|
| 313 | pCmd->Hdr.cbData = sizeof(VBOX_DRMIPC_COMMAND_REPORT_DISPLAY_OFFSETS);
|
---|
[94076] | 314 | pCmd->cDisplays = cDisplays;
|
---|
| 315 | memcpy(pCmd->aDisplays, aDisplays, cDisplays * sizeof(struct VBOX_DRMIPC_VMWRECT));
|
---|
[93369] | 316 | pCmd->Hdr.u64Crc = RTCrc64(pCmd, pCmd->Hdr.cbData);
|
---|
| 317 | Assert(pCmd->Hdr.u64Crc);
|
---|
| 318 |
|
---|
| 319 | /* Put command into queue and trigger TX. */
|
---|
| 320 | rc = vbDrmIpcSessionScheduleTx(pClient, pTxListEntry);
|
---|
| 321 | if (RT_SUCCESS(rc))
|
---|
| 322 | {
|
---|
| 323 | VBClLogVerbose(2, "vbDrmIpcReportDisplayOffsets: %u bytes scheduled for TX, crc=0x%x\n", pCmd->Hdr.cbData, pCmd->Hdr.u64Crc);
|
---|
| 324 | }
|
---|
| 325 | else
|
---|
| 326 | {
|
---|
| 327 | RTMemFree(pTxListEntry);
|
---|
| 328 | VBClLogError("vbDrmIpcReportDisplayOffsets: unable to schedule TX, rc=%Rrc\n", rc);
|
---|
| 329 | }
|
---|
| 330 | }
|
---|
| 331 | else
|
---|
| 332 | {
|
---|
| 333 | VBClLogInfo("cannot allocate REPORT_DISPLAY_OFFSETS command\n");
|
---|
| 334 | rc = VERR_NO_MEMORY;
|
---|
| 335 | }
|
---|
| 336 |
|
---|
| 337 | return rc;
|
---|
| 338 | }
|
---|
| 339 |
|
---|
| 340 | /**
|
---|
| 341 | * Common function for both IPC server and client which is responsible
|
---|
| 342 | * for handling IPC communication flow.
|
---|
| 343 | *
|
---|
| 344 | * @return IPRT status code.
|
---|
| 345 | * @param pClient IPC connection private data.
|
---|
| 346 | */
|
---|
| 347 | RTDECL(int) vbDrmIpcConnectionHandler(PVBOX_DRMIPC_CLIENT pClient)
|
---|
| 348 | {
|
---|
| 349 | int rc;
|
---|
| 350 | static uint8_t aInputBuf[VBOX_DRMIPC_RX_BUFFER_SIZE];
|
---|
| 351 | size_t cbRead = 0;
|
---|
| 352 | PVBOX_DRMIPC_TX_LIST_ENTRY pTxListEntry;
|
---|
| 353 |
|
---|
| 354 | AssertReturn(pClient, VERR_INVALID_PARAMETER);
|
---|
| 355 |
|
---|
| 356 | /* Make sure we are still connected to IPC server. */
|
---|
| 357 | if (!pClient->hClientSession)
|
---|
| 358 | {
|
---|
| 359 | VBClLogVerbose(2, "connection to IPC server lost\n");
|
---|
| 360 | return VERR_NET_CONNECTION_RESET_BY_PEER;
|
---|
| 361 | }
|
---|
| 362 |
|
---|
| 363 | AssertReturn(pClient->pfnRxCb, VERR_INVALID_PARAMETER);
|
---|
| 364 |
|
---|
| 365 | /* Make sure we have valid connection handle. By reporting VERR_BROKEN_PIPE,
|
---|
| 366 | * we trigger reconnect to IPC server. */
|
---|
| 367 | if (!RT_VALID_PTR(pClient->hClientSession))
|
---|
| 368 | return VERR_BROKEN_PIPE;
|
---|
| 369 |
|
---|
| 370 | rc = RTLocalIpcSessionWaitForData(pClient->hClientSession, VBOX_DRMIPC_RX_TIMEOUT_MS);
|
---|
| 371 | if (RT_SUCCESS(rc))
|
---|
| 372 | {
|
---|
| 373 | /* Read IPC message header. */
|
---|
| 374 | rc = RTLocalIpcSessionRead(pClient->hClientSession, aInputBuf, sizeof(VBOX_DRMIPC_COMMAND_HEADER), &cbRead);
|
---|
| 375 | if (RT_SUCCESS(rc))
|
---|
| 376 | {
|
---|
| 377 | if (cbRead == sizeof(VBOX_DRMIPC_COMMAND_HEADER))
|
---|
| 378 | {
|
---|
| 379 | PVBOX_DRMIPC_COMMAND_HEADER pHdr = (PVBOX_DRMIPC_COMMAND_HEADER)aInputBuf;
|
---|
| 380 | if (pHdr)
|
---|
| 381 | {
|
---|
| 382 | AssertReturn(pHdr->cbData <= sizeof(aInputBuf) - sizeof(VBOX_DRMIPC_COMMAND_HEADER), VERR_INVALID_PARAMETER);
|
---|
| 383 |
|
---|
| 384 | /* Read the rest of a message. */
|
---|
| 385 | rc = RTLocalIpcSessionRead(pClient->hClientSession, aInputBuf + sizeof(VBOX_DRMIPC_COMMAND_HEADER), pHdr->cbData - sizeof(VBOX_DRMIPC_COMMAND_HEADER), &cbRead);
|
---|
| 386 | AssertRCReturn(rc, rc);
|
---|
| 387 | AssertReturn(cbRead == (pHdr->cbData - sizeof(VBOX_DRMIPC_COMMAND_HEADER)), VERR_INVALID_PARAMETER);
|
---|
| 388 |
|
---|
| 389 | uint64_t u64Crc = pHdr->u64Crc;
|
---|
| 390 |
|
---|
| 391 | /* Verify checksum. */
|
---|
| 392 | pHdr->u64Crc = 0;
|
---|
| 393 | if (u64Crc != 0 && RTCrc64(pHdr, pHdr->cbData) == u64Crc)
|
---|
| 394 | {
|
---|
| 395 | /* Restore original CRC. */
|
---|
| 396 | pHdr->u64Crc = u64Crc;
|
---|
| 397 |
|
---|
| 398 | /* Trigger RX callback. */
|
---|
| 399 | rc = pClient->pfnRxCb(pHdr->idCmd, (void *)pHdr, pHdr->cbData);
|
---|
| 400 | VBClLogVerbose(2, "command 0x%X executed, rc=%Rrc\n", pHdr->idCmd, rc);
|
---|
| 401 | }
|
---|
| 402 | else
|
---|
| 403 | {
|
---|
| 404 | VBClLogError("unable to read from IPC: CRC mismatch, provided crc=0x%X, cmd=0x%X\n", u64Crc, pHdr->idCmd);
|
---|
| 405 | rc = VERR_NOT_EQUAL;
|
---|
| 406 | }
|
---|
| 407 | }
|
---|
| 408 | else
|
---|
| 409 | {
|
---|
| 410 | VBClLogError("unable to read from IPC: zero data received\n");
|
---|
| 411 | rc = VERR_INVALID_PARAMETER;
|
---|
| 412 | }
|
---|
| 413 | }
|
---|
| 414 | else
|
---|
| 415 | {
|
---|
| 416 | VBClLogError("received partial IPC message header (%u bytes)\n", cbRead);
|
---|
| 417 | rc = VERR_INVALID_PARAMETER;
|
---|
| 418 | }
|
---|
| 419 |
|
---|
| 420 | VBClLogVerbose(2, "received %u bytes from IPC\n", cbRead);
|
---|
| 421 | }
|
---|
| 422 | else
|
---|
| 423 | {
|
---|
| 424 | VBClLogError("unable to read from IPC, rc=%Rrc\n", rc);
|
---|
| 425 | }
|
---|
| 426 | }
|
---|
| 427 |
|
---|
| 428 | /* Check if TX queue has some messages to transfer. */
|
---|
| 429 | while ((pTxListEntry = vbDrmIpcSessionPickupTxMessage(pClient)) != NULL)
|
---|
| 430 | {
|
---|
| 431 | PVBOX_DRMIPC_COMMAND_HEADER pMessageHdr = (PVBOX_DRMIPC_COMMAND_HEADER)(&pTxListEntry->Hdr);
|
---|
| 432 | Assert(pMessageHdr);
|
---|
| 433 |
|
---|
| 434 | rc = RTLocalIpcSessionWrite(
|
---|
| 435 | pClient->hClientSession, (void *)(&pTxListEntry->Hdr), pMessageHdr->cbData);
|
---|
| 436 | if (RT_SUCCESS(rc))
|
---|
| 437 | {
|
---|
| 438 | rc = RTLocalIpcSessionFlush(pClient->hClientSession);
|
---|
| 439 | if (RT_SUCCESS(rc))
|
---|
| 440 | VBClLogVerbose(2, "vbDrmIpcConnectionHandler: transferred %u bytes\n", pMessageHdr->cbData);
|
---|
| 441 | else
|
---|
| 442 | VBClLogError("vbDrmIpcConnectionHandler: cannot flush IPC connection, transfer of %u bytes failed\n", pMessageHdr->cbData);
|
---|
| 443 | }
|
---|
| 444 | else
|
---|
| 445 | VBClLogError("vbDrmIpcConnectionHandler: cannot TX, rc=%Rrc\n", rc);
|
---|
| 446 |
|
---|
| 447 | RTMemFree(pTxListEntry);
|
---|
| 448 | }
|
---|
| 449 |
|
---|
| 450 | return rc;
|
---|
| 451 | }
|
---|