Changeset 58212 in vbox for trunk/src/VBox/HostServices/DragAndDrop
- Timestamp:
- Oct 13, 2015 11:49:33 AM (9 years ago)
- svn:sync-xref-src-repo-rev:
- 103344
- Location:
- trunk/src/VBox/HostServices/DragAndDrop
- Files:
-
- 2 edited
-
dndmanager.cpp (modified) (4 diffs)
-
service.cpp (modified) (27 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/HostServices/DragAndDrop/dndmanager.cpp
r57372 r58212 84 84 } 85 85 86 case DragAndDropSvc::HOST_DND_HG_SND_DATA_HDR: 87 { 88 LogFlowFunc(("HOST_DND_HG_SND_DATA_HDR\n")); 89 break; 90 } 91 86 92 case DragAndDropSvc::HOST_DND_HG_SND_DATA: 87 93 { … … 116 122 { 117 123 LogFlowFunc(("HOST_DND_GH_REQ_PENDING\n")); 118 119 /* Verify parameter count and types. */120 if ( cParms != 1121 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* screen id */)122 {123 rc = VERR_INVALID_PARAMETER;124 }125 124 break; 126 125 } … … 129 128 { 130 129 LogFlowFunc(("HOST_DND_GH_EVT_DROPPED\n")); 131 132 /* Verify parameter count and types. */133 if ( cParms != 3134 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* format */135 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* format size */136 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* action */)137 {138 rc = VERR_INVALID_PARAMETER;139 }140 130 break; 141 131 } … … 147 137 } 148 138 149 if (!pMessage) /* Generic message needed? */ 150 pMessage = new DnDGenericMessage(uMsg, cParms, paParms); 151 152 if (fAppend) 153 m_dndMessageQueue.append(pMessage); 154 else 155 m_dndMessageQueue.prepend(pMessage); 139 if (RT_SUCCESS(rc)) 140 { 141 if (!pMessage) /* Generic message needed? */ 142 pMessage = new DnDGenericMessage(uMsg, cParms, paParms); 143 144 if (fAppend) 145 m_dndMessageQueue.append(pMessage); 146 else 147 m_dndMessageQueue.prepend(pMessage); 148 } 156 149 } 157 150 catch(std::bad_alloc &) -
trunk/src/VBox/HostServices/DragAndDrop/service.cpp
r57760 r58212 16 16 */ 17 17 18 /** @page pg_svc_guest_control Guest ControlHGCM Service18 /** @page pg_svc_guest_control Drag and drop HGCM Service 19 19 * 20 * This service acts as a proxy for handling and buffering host command requests 21 * and clients on the guest. It tries to be as transparent as possible to let 22 * the guest (client) and host side do their protocol handling as desired. 23 * 24 * The following terms are used: 25 * - Host: A host process (e.g. VBoxManage or another tool utilizing the Main API) 26 * which wants to control something on the guest. 27 * - Client: A client (e.g. VBoxService) running inside the guest OS waiting for 28 * new host commands to perform. There can be multiple clients connected 29 * to a service. A client is represented by its HGCM client ID. 30 * - Context ID: An (almost) unique ID automatically generated on the host (Main API) 31 * to not only distinguish clients but individual requests. Because 32 * the host does not know anything about connected clients it needs 33 * an indicator which it can refer to later. This context ID gets 34 * internally bound by the service to a client which actually processes 35 * the command in order to have a relationship between client<->context ID(s). 36 * 37 * The host can trigger commands which get buffered by the service (with full HGCM 38 * parameter info). As soon as a client connects (or is ready to do some new work) 39 * it gets a buffered host command to process it. This command then will be immediately 40 * removed from the command list. If there are ready clients but no new commands to be 41 * processed, these clients will be set into a deferred state (that is being blocked 42 * to return until a new command is available). 43 * 44 * If a client needs to inform the host that something happened, it can send a 45 * message to a low level HGCM callback registered in Main. This callback contains 46 * the actual data as well as the context ID to let the host do the next necessary 47 * steps for this context. This context ID makes it possible to wait for an event 48 * inside the host's Main API function (like starting a process on the guest and 49 * wait for getting its PID returned by the client) as well as cancelling blocking 50 * host calls in order the client terminated/crashed (HGCM detects disconnected 51 * clients and reports it to this service's callback). 20 * TODO 52 21 */ 53 22 … … 63 32 #include <map> 64 33 34 #include <VBox/GuestHost/DragAndDrop.h> 35 #include <VBox/HostServices/Service.h> 36 #include <VBox/HostServices/DragAndDropSvc.h> 37 65 38 #include "dndmanager.h" 66 39 40 using namespace DragAndDropSvc; 67 41 68 42 /********************************************************************************************************************************* … … 158 132 { 159 133 AssertMsgFailed(("Maximum number of clients reached\n")); 160 return VERR_ BUFFER_OVERFLOW;134 return VERR_MAX_PROCS_REACHED; 161 135 } 162 136 … … 263 237 switch (u32Function) 264 238 { 265 case DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG:239 case GUEST_DND_GET_NEXT_HOST_MSG: 266 240 { 267 241 if (modeGet() != VBOX_DRAG_AND_DROP_MODE_OFF) … … 277 251 } 278 252 279 /* N ote: New since protocol version2. */280 case DragAndDropSvc::GUEST_DND_CONNECT:253 /* New since protocol v2. */ 254 case GUEST_DND_CONNECT: 281 255 { 282 256 /* … … 288 262 break; 289 263 } 290 case DragAndDropSvc::GUEST_DND_HG_ACK_OP:264 case GUEST_DND_HG_ACK_OP: 291 265 /* Fall through is intentional. */ 292 case DragAndDropSvc::GUEST_DND_HG_REQ_DATA:266 case GUEST_DND_HG_REQ_DATA: 293 267 /* Fall through is intentional. */ 294 case DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS:268 case GUEST_DND_HG_EVT_PROGRESS: 295 269 { 296 270 if ( modeGet() == VBOX_DRAG_AND_DROP_MODE_BIDIRECTIONAL … … 304 278 } 305 279 306 case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING: 307 case DragAndDropSvc::GUEST_DND_GH_SND_DATA: 308 case DragAndDropSvc::GUEST_DND_GH_SND_DIR: 309 case DragAndDropSvc::GUEST_DND_GH_SND_FILE_HDR: 310 case DragAndDropSvc::GUEST_DND_GH_SND_FILE_DATA: 311 case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR: 280 case GUEST_DND_GH_ACK_PENDING: 281 case GUEST_DND_GH_SND_DATA_HDR: 282 case GUEST_DND_GH_SND_DATA: 283 case GUEST_DND_GH_SND_DIR: 284 case GUEST_DND_GH_SND_FILE_HDR: 285 case GUEST_DND_GH_SND_FILE_DATA: 286 case GUEST_DND_GH_EVT_ERROR: 312 287 { 313 288 #ifdef VBOX_WITH_DRAG_AND_DROP_GH … … 347 322 HGCM::Client *pClient = itClient->second; 348 323 AssertPtr(pClient); 324 325 LogFlowFunc(("Client %RU32: Protocol v%RU32\n", pClient->clientId(), pClient->protocol())); 326 327 rc = VERR_INVALID_PARAMETER; /* Play safe. */ 349 328 350 329 switch (u32Function) … … 357 336 * handle HOST_DND_GH_REQ_PENDING. 358 337 */ 359 case DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG:338 case GUEST_DND_GET_NEXT_HOST_MSG: 360 339 { 361 340 LogFlowFunc(("GUEST_DND_GET_NEXT_HOST_MSG\n")); 362 if ( cParms != 3 363 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* message */ 364 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* parameter count */ 365 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* blocking */) 366 { 367 rc = VERR_INVALID_PARAMETER; 368 } 369 else 341 if (cParms == 3) 370 342 { 371 343 rc = m_pManager->nextMessageInfo(&paParms[0].u.uint32 /* uMsg */, &paParms[1].u.uint32 /* cParms */); … … 374 346 if (m_pfnHostCallback) /* Try asking the host. */ 375 347 { 376 DragAndDropSvc::VBOXDNDCBHGGETNEXTHOSTMSG data;377 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG;348 VBOXDNDCBHGGETNEXTHOSTMSG data; 349 data.hdr.u32Magic = CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG; 378 350 rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data)); 379 351 if (RT_SUCCESS(rc)) … … 405 377 break; 406 378 } 407 case DragAndDropSvc::GUEST_DND_CONNECT:379 case GUEST_DND_CONNECT: 408 380 { 409 381 LogFlowFunc(("GUEST_DND_CONNECT\n")); 410 if ( cParms != 2 411 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* protocol version */ 412 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* additional connection flags */) 413 rc = VERR_INVALID_PARAMETER; 414 else 382 if (cParms == 2) 415 383 { 416 384 uint32_t uProtocol; … … 420 388 if (RT_SUCCESS(rc)) 421 389 { 390 LogFlowFunc(("Client %RU32 is now using protocol v%RU32\n", pClient->clientId(), pClient->protocol())); 422 391 /** @todo Handle connection flags (paParms[1]). */ 423 392 } … … 428 397 break; 429 398 } 430 case DragAndDropSvc::GUEST_DND_HG_ACK_OP:399 case GUEST_DND_HG_ACK_OP: 431 400 { 432 401 LogFlowFunc(("GUEST_DND_HG_ACK_OP\n")); 433 if ( cParms != 1 434 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* action */) 435 rc = VERR_INVALID_PARAMETER; 436 else 437 { 438 DragAndDropSvc::VBOXDNDCBHGACKOPDATA data; 439 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_ACK_OP; 402 if (cParms == 1) 403 { 404 VBOXDNDCBHGACKOPDATA data; 405 data.hdr.u32Magic = CB_MAGIC_DND_HG_ACK_OP; 440 406 rc = paParms[0].getUInt32(&data.uAction); /* Get drop action. */ 441 407 DO_HOST_CALLBACK(); … … 443 409 break; 444 410 } 445 case DragAndDropSvc::GUEST_DND_HG_REQ_DATA:411 case GUEST_DND_HG_REQ_DATA: 446 412 { 447 413 LogFlowFunc(("GUEST_DND_HG_REQ_DATA\n")); 448 if ( cParms != 1 449 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* format */) 450 rc = VERR_INVALID_PARAMETER; 451 else 452 { 453 DragAndDropSvc::VBOXDNDCBHGREQDATADATA data; 454 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_REQ_DATA; 414 if (cParms == 1) 415 { 416 VBOXDNDCBHGREQDATADATA data; 417 data.hdr.u32Magic = CB_MAGIC_DND_HG_REQ_DATA; 455 418 rc = paParms[0].getPointer((void**)&data.pszFormat, &data.cbFormat); 456 419 DO_HOST_CALLBACK(); … … 458 421 break; 459 422 } 460 case DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS:423 case GUEST_DND_HG_EVT_PROGRESS: 461 424 { 462 425 LogFlowFunc(("GUEST_DND_HG_EVT_PROGRESS\n")); 463 if ( cParms != 3 464 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* status */ 465 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* percent */ 466 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* rc */) 467 rc = VERR_INVALID_PARAMETER; 468 else 469 { 470 DragAndDropSvc::VBOXDNDCBHGEVTPROGRESSDATA data; 471 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_EVT_PROGRESS; 426 if (cParms == 3) 427 { 428 VBOXDNDCBHGEVTPROGRESSDATA data; 429 data.hdr.u32Magic = CB_MAGIC_DND_HG_EVT_PROGRESS; 472 430 rc = paParms[0].getUInt32(&data.uStatus); 473 431 if (RT_SUCCESS(rc)) … … 480 438 } 481 439 #ifdef VBOX_WITH_DRAG_AND_DROP_GH 482 case DragAndDropSvc::GUEST_DND_GH_ACK_PENDING:440 case GUEST_DND_GH_ACK_PENDING: 483 441 { 484 442 LogFlowFunc(("GUEST_DND_GH_ACK_PENDING\n")); 485 if ( cParms != 3 486 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* defaction */ 487 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* alloctions */ 488 || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* format */) 489 rc = VERR_INVALID_PARAMETER; 490 else 491 { 492 DragAndDropSvc::VBOXDNDCBGHACKPENDINGDATA data; 493 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_ACK_PENDING; 443 if (cParms == 3) 444 { 445 VBOXDNDCBGHACKPENDINGDATA data; 446 data.hdr.u32Magic = CB_MAGIC_DND_GH_ACK_PENDING; 494 447 rc = paParms[0].getUInt32(&data.uDefAction); 495 448 if (RT_SUCCESS(rc)) … … 501 454 break; 502 455 } 503 case DragAndDropSvc::GUEST_DND_GH_SND_DATA: 456 /* New since protocol v3. */ 457 case GUEST_DND_GH_SND_DATA_HDR: 458 { 459 LogFlowFunc(("GUEST_DND_GH_SND_DATA_HDR\n")); 460 if (cParms == 12) 461 { 462 VBOXDNDCBSNDDATAHDRDATA data; 463 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DATA_HDR; 464 rc = paParms[0].getUInt32(&data.hdr.u32ContextID); 465 if (RT_SUCCESS(rc)) 466 rc = paParms[1].getUInt32(&data.data.uFlags); 467 if (RT_SUCCESS(rc)) 468 rc = paParms[2].getUInt32(&data.data.uScreenId); 469 if (RT_SUCCESS(rc)) 470 rc = paParms[3].getUInt64(&data.data.cbTotal); 471 if (RT_SUCCESS(rc)) 472 rc = paParms[4].getUInt32(&data.data.cbMeta); 473 if (RT_SUCCESS(rc)) 474 rc = paParms[5].getPointer(&data.data.pvMetaFmt, &data.data.cbMetaFmt); 475 if (RT_SUCCESS(rc)) 476 rc = paParms[6].getUInt32(&data.data.cbMetaFmt); 477 if (RT_SUCCESS(rc)) 478 rc = paParms[7].getUInt64(&data.data.cObjects); 479 if (RT_SUCCESS(rc)) 480 rc = paParms[8].getUInt32(&data.data.enmCompression); 481 if (RT_SUCCESS(rc)) 482 rc = paParms[9].getUInt32((uint32_t *)&data.data.enmChecksumType); 483 if (RT_SUCCESS(rc)) 484 rc = paParms[10].getPointer(&data.data.pvChecksum, &data.data.cbChecksum); 485 if (RT_SUCCESS(rc)) 486 rc = paParms[11].getUInt32(&data.data.cbChecksum); 487 488 LogFlowFunc(("fFlags=0x%x, cbTotalSize=%RU64, cObj=%RU64\n", 489 data.data.uFlags, data.data.cbTotal, data.data.cObjects)); 490 DO_HOST_CALLBACK(); 491 } 492 break; 493 } 494 case GUEST_DND_GH_SND_DATA: 504 495 { 505 496 LogFlowFunc(("GUEST_DND_GH_SND_DATA\n")); 506 if ( cParms != 2 507 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* data */ 508 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* size */) 509 rc = VERR_INVALID_PARAMETER; 510 else 511 { 512 DragAndDropSvc::VBOXDNDCBSNDDATADATA data; 513 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_DATA; 514 rc = paParms[0].getPointer((void**)&data.pvData, &data.cbData); 515 if (RT_SUCCESS(rc)) 516 rc = paParms[1].getUInt32(&data.cbTotalSize); 517 DO_HOST_CALLBACK(); 518 } 519 break; 520 } 521 case DragAndDropSvc::GUEST_DND_GH_SND_DIR: 497 switch (pClient->protocol()) 498 { 499 case 3: 500 { 501 if (cParms == 5) 502 { 503 VBOXDNDCBSNDDATADATA data; 504 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DATA; 505 rc = paParms[0].getUInt32(&data.hdr.u32ContextID); 506 if (RT_SUCCESS(rc)) 507 rc = paParms[1].getPointer((void**)&data.data.u.v3.pvData, &data.data.u.v3.cbData); 508 if (RT_SUCCESS(rc)) 509 rc = paParms[2].getUInt32(&data.data.u.v3.cbData); 510 if (RT_SUCCESS(rc)) 511 rc = paParms[3].getPointer((void**)&data.data.u.v3.pvChecksum, &data.data.u.v3.cbChecksum); 512 if (RT_SUCCESS(rc)) 513 rc = paParms[4].getUInt32(&data.data.u.v3.cbChecksum); 514 DO_HOST_CALLBACK(); 515 } 516 break; 517 } 518 519 case 2: 520 default: 521 { 522 if (cParms == 2) 523 { 524 VBOXDNDCBSNDDATADATA data; 525 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DATA; 526 rc = paParms[0].getPointer((void**)&data.data.u.v1.pvData, &data.data.u.v1.cbData); 527 if (RT_SUCCESS(rc)) 528 rc = paParms[1].getUInt32(&data.data.u.v1.cbTotalSize); 529 DO_HOST_CALLBACK(); 530 } 531 break; 532 } 533 } 534 break; 535 } 536 case GUEST_DND_GH_SND_DIR: 522 537 { 523 538 LogFlowFunc(("GUEST_DND_GH_SND_DIR\n")); 524 if ( cParms != 3 525 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */ 526 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* path length */ 527 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* creation mode */) 528 rc = VERR_INVALID_PARAMETER; 529 else 530 { 531 DragAndDropSvc::VBOXDNDCBSNDDIRDATA data; 532 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_DIR; 539 if (cParms == 3) 540 { 541 VBOXDNDCBSNDDIRDATA data; 542 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DIR; 533 543 uint32_t cTmp; 534 544 rc = paParms[0].getPointer((void**)&data.pszPath, &cTmp); … … 543 553 break; 544 554 } 545 /* N ote: Since protocol v2 (>= VBox 5.0). */546 case DragAndDropSvc::GUEST_DND_GH_SND_FILE_HDR:555 /* New since protocol v2 (>= VBox 5.0). */ 556 case GUEST_DND_GH_SND_FILE_HDR: 547 557 { 548 558 LogFlowFunc(("GUEST_DND_GH_SND_FILE_HDR\n")); 549 if ( cParms != 6 550 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* context ID */ 551 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* file path */ 552 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* file path length */ 553 || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */ 554 || paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT /* file mode */ 555 || paParms[5].type != VBOX_HGCM_SVC_PARM_64BIT /* file size */) 556 rc = VERR_INVALID_PARAMETER; 557 else 558 { 559 DragAndDropSvc::VBOXDNDCBSNDFILEHDRDATA data; 560 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE_HDR; 559 if (cParms == 6) 560 { 561 VBOXDNDCBSNDFILEHDRDATA data; 562 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_HDR; 561 563 uint32_t cTmp; 562 564 /* paParms[0] is context ID; unused yet. */ … … 577 579 break; 578 580 } 579 case DragAndDropSvc::GUEST_DND_GH_SND_FILE_DATA:581 case GUEST_DND_GH_SND_FILE_DATA: 580 582 { 581 583 LogFlowFunc(("GUEST_DND_GH_SND_FILE_DATA\n")); … … 583 585 switch (pClient->protocol()) 584 586 { 585 case 2: /* Protocol version 2 only sends the next data chunks to reduce traffic. */ 587 /* Protocol v3 adds (optional) checksums. */ 588 case 3: 586 589 { 587 if ( cParms != 3 588 /* paParms[0] is context ID; unused yet. */ 589 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* file data */ 590 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* file data length */) 590 if (cParms == 5) 591 591 { 592 rc = VERR_INVALID_PARAMETER; 592 VBOXDNDCBSNDFILEDATADATA data; 593 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_DATA; 594 rc = paParms[0].getUInt32(&data.hdr.u32ContextID); 595 if (RT_SUCCESS(rc)) 596 rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData); 597 if (RT_SUCCESS(rc)) 598 rc = paParms[2].getUInt32(&data.cbData); 599 if (RT_SUCCESS(rc)) 600 rc = paParms[3].getPointer((void**)&data.u.v3.pvChecksum, &data.u.v3.cbChecksum); 601 if (RT_SUCCESS(rc)) 602 rc = paParms[4].getUInt32(&data.u.v3.cbChecksum); 603 604 LogFlowFunc(("pvData=0x%p, cbData=%RU32\n", data.pvData, data.cbData)); 605 DO_HOST_CALLBACK(); 593 606 } 594 else 607 break; 608 } 609 /* Protocol v2 only sends the next data chunks to reduce traffic. */ 610 case 2: 611 { 612 if (cParms == 3) 595 613 { 596 DragAndDropSvc::VBOXDNDCBSNDFILEDATADATA data; 597 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE_DATA; 598 /* paParms[0] is context ID; unused yet. */ 599 rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData); 614 VBOXDNDCBSNDFILEDATADATA data; 615 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_DATA; 616 rc = paParms[0].getUInt32(&data.hdr.u32ContextID); 617 if (RT_SUCCESS(rc)) 618 rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData); 600 619 if (RT_SUCCESS(rc)) 601 620 rc = paParms[2].getUInt32(&data.cbData); … … 606 625 break; 607 626 } 627 /* Protocol v1 sends the file path and attributes for every file chunk (!). */ 608 628 default: 609 629 { 610 if ( cParms != 5 611 || paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* file path */ 612 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* file path length */ 613 || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* file data */ 614 || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* file data length */ 615 || paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT /* creation mode */) 630 if (cParms == 5) 616 631 { 617 rc = VERR_INVALID_PARAMETER; 618 } 619 else 620 { 621 DragAndDropSvc::VBOXDNDCBSNDFILEDATADATA data; 622 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_SND_FILE_DATA; 632 VBOXDNDCBSNDFILEDATADATA data; 633 data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_DATA; 623 634 uint32_t cTmp; 624 635 rc = paParms[0].getPointer((void**)&data.u.v1.pszFilePath, &cTmp); … … 641 652 break; 642 653 } 643 case DragAndDropSvc::GUEST_DND_GH_EVT_ERROR:654 case GUEST_DND_GH_EVT_ERROR: 644 655 { 645 656 LogFlowFunc(("GUEST_DND_GH_EVT_ERROR\n")); 646 if ( cParms != 1 647 || paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* rc */) 648 rc = VERR_INVALID_PARAMETER; 649 else 650 { 651 DragAndDropSvc::VBOXDNDCBEVTERRORDATA data; 652 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_GH_EVT_ERROR; 657 if (cParms == 1) 658 { 659 VBOXDNDCBEVTERRORDATA data; 660 data.hdr.u32Magic = CB_MAGIC_DND_GH_EVT_ERROR; 653 661 654 662 uint32_t rcOp; … … 670 678 if (m_pfnHostCallback) 671 679 { 672 DragAndDropSvc::VBOXDNDCBHGGETNEXTHOSTMSGDATA data;673 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG_DATA;680 VBOXDNDCBHGGETNEXTHOSTMSGDATA data; 681 data.hdr.u32Magic = CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG_DATA; 674 682 data.uMsg = u32Function; 675 683 data.cParms = cParms; … … 728 736 729 737 int rc; 730 if (u32Function == DragAndDropSvc::HOST_DND_SET_MODE)738 if (u32Function == HOST_DND_SET_MODE) 731 739 { 732 740 if (cParms != 1) … … 755 763 */ 756 764 uint32_t uMsg = pClient->message(); 757 if (uMsg == DragAndDropSvc::GUEST_DND_GET_NEXT_HOST_MSG)765 if (uMsg == GUEST_DND_GET_NEXT_HOST_MSG) 758 766 { 759 767 LogFlowFunc(("Client %RU32 is waiting for next host msg\n", pClient->clientId())); … … 822 830 uStatus, uPercentage, rc)); 823 831 824 DragAndDropSvc::VBOXDNDCBHGEVTPROGRESSDATA data;825 data.hdr.u32Magic = DragAndDropSvc::CB_MAGIC_DND_HG_EVT_PROGRESS;832 VBOXDNDCBHGEVTPROGRESSDATA data; 833 data.hdr.u32Magic = CB_MAGIC_DND_HG_EVT_PROGRESS; 826 834 data.uPercentage = RT_MIN(uPercentage, 100); 827 835 data.uStatus = uStatus; … … 829 837 830 838 return pSelf->m_pfnHostCallback(pSelf->m_pvHostData, 831 DragAndDropSvc::GUEST_DND_HG_EVT_PROGRESS,839 GUEST_DND_HG_EVT_PROGRESS, 832 840 &data, sizeof(data)); 833 841 }
Note:
See TracChangeset
for help on using the changeset viewer.
