VirtualBox

Ignore:
Timestamp:
Oct 15, 2015 8:31:46 AM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
103438
Message:

DnD: Added context IDs for all HGCM messages.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostServices/DragAndDrop/service.cpp

    r58231 r58257  
    347347                        {
    348348                            VBOXDNDCBHGGETNEXTHOSTMSG data;
    349                             data.hdr.u32Magic = CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG;
     349                            RT_ZERO(data);
     350                            data.hdr.uMagic = CB_MAGIC_DND_HG_GET_NEXT_HOST_MSG;
    350351                            rc = m_pfnHostCallback(m_pvHostData, u32Function, &data, sizeof(data));
    351352                            if (RT_SUCCESS(rc))
    … …  
    380381            {
    381382                LogFlowFunc(("GUEST_DND_CONNECT\n"));
    382                 if (cParms == 2)
    383                 {
     383                if (cParms >= 2)
     384                {
     385                    const uint8_t idxProto = cParms >= 3 ? 1 : 0;
     386
    384387                    VBOXDNDCBCONNECTMSGDATA data;
    385                     data.hdr.u32Magic = CB_MAGIC_DND_CONNECT;
    386                     rc = paParms[0].getUInt32(&data.uProtocol);
    387                     if (RT_SUCCESS(rc))
    388                         rc = paParms[1].getUInt32(&data.uFlags);
     388                    RT_ZERO(data);
     389                    data.hdr.uMagic = CB_MAGIC_DND_CONNECT;
     390                    if (cParms >= 3)
     391                        rc = paParms[0].getUInt32(&data.hdr.uContextID);
     392                    if (RT_SUCCESS(rc))
     393                        rc = paParms[idxProto].getUInt32(&data.uProtocol);
     394                    if (RT_SUCCESS(rc))
     395                        rc = paParms[idxProto + 1].getUInt32(&data.uFlags);
    389396                    if (RT_SUCCESS(rc))
    390397                        rc = pClient->setProtocol(data.uProtocol);
    … …  
    400407            {
    401408                LogFlowFunc(("GUEST_DND_HG_ACK_OP\n"));
    402                 if (cParms == 1)
    403                 {
    404                     VBOXDNDCBHGACKOPDATA data;
    405                     data.hdr.u32Magic = CB_MAGIC_DND_HG_ACK_OP;
    406                     rc = paParms[0].getUInt32(&data.uAction); /* Get drop action. */
    407                     DO_HOST_CALLBACK();
    408                 }
     409
     410                VBOXDNDCBHGACKOPDATA data;
     411                RT_ZERO(data);
     412                data.hdr.uMagic = CB_MAGIC_DND_HG_ACK_OP;
     413
     414                switch (pClient->protocol())
     415                {
     416                    case 3:
     417                    {
     418                        if (cParms == 2)
     419                        {
     420                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
     421                            if (RT_SUCCESS(rc))
     422                                rc = paParms[1].getUInt32(&data.uAction); /* Get drop action. */
     423                        }
     424                        break;
     425                    }
     426
     427                    case 2:
     428                    default:
     429                    {
     430                        if (cParms == 1)
     431                            rc = paParms[0].getUInt32(&data.uAction); /* Get drop action. */
     432                        break;
     433                    }
     434                }
     435
     436                DO_HOST_CALLBACK();
    409437                break;
    410438            }
    … …  
    412440            {
    413441                LogFlowFunc(("GUEST_DND_HG_REQ_DATA\n"));
    414                 if (cParms == 1)
    415                 {
    416                     VBOXDNDCBHGREQDATADATA data;
    417                     data.hdr.u32Magic = CB_MAGIC_DND_HG_REQ_DATA;
    418                     rc = paParms[0].getPointer((void**)&data.pszFormat, &data.cbFormat);
    419                     DO_HOST_CALLBACK();
    420                 }
     442
     443                VBOXDNDCBHGREQDATADATA data;
     444                RT_ZERO(data);
     445                data.hdr.uMagic = CB_MAGIC_DND_HG_REQ_DATA;
     446
     447                switch (pClient->protocol())
     448                {
     449                    case 3:
     450                    {
     451                        if (cParms == 3)
     452                        {
     453                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
     454                            if (RT_SUCCESS(rc))
     455                                rc = paParms[1].getPointer((void **)&data.pszFormat, &data.cbFormat);
     456                            if (RT_SUCCESS(rc))
     457                                rc = paParms[2].getUInt32(&data.cbFormat);
     458                        }
     459                        break;
     460                    }
     461
     462                    case 2:
     463                    default:
     464                    {
     465                        if (cParms == 1)
     466                            rc = paParms[0].getPointer((void**)&data.pszFormat, &data.cbFormat);
     467                        break;
     468                    }
     469                }
     470
     471                DO_HOST_CALLBACK();
    421472                break;
    422473            }
    … …  
    424475            {
    425476                LogFlowFunc(("GUEST_DND_HG_EVT_PROGRESS\n"));
    426                 if (cParms == 3)
    427                 {
    428                     VBOXDNDCBHGEVTPROGRESSDATA data;
    429                     data.hdr.u32Magic = CB_MAGIC_DND_HG_EVT_PROGRESS;
    430                     rc = paParms[0].getUInt32(&data.uStatus);
    431                     if (RT_SUCCESS(rc))
    432                         rc = paParms[1].getUInt32(&data.uPercentage);
    433                     if (RT_SUCCESS(rc))
    434                         rc = paParms[2].getUInt32(&data.rc);
    435                     DO_HOST_CALLBACK();
    436                 }
     477
     478                VBOXDNDCBHGEVTPROGRESSDATA data;
     479                RT_ZERO(data);
     480                data.hdr.uMagic = CB_MAGIC_DND_HG_EVT_PROGRESS;
     481
     482                switch (pClient->protocol())
     483                {
     484                    case 3:
     485                    {
     486                        if (cParms == 4)
     487                        {
     488                            rc = paParms[0].getUInt32(&data.uStatus);
     489                            if (RT_SUCCESS(rc))
     490                                rc = paParms[1].getUInt32(&data.uStatus);
     491                            if (RT_SUCCESS(rc))
     492                                rc = paParms[2].getUInt32(&data.uPercentage);
     493                            if (RT_SUCCESS(rc))
     494                                rc = paParms[3].getUInt32(&data.rc);
     495                        }
     496                        break;
     497                    }
     498
     499                    case 2:
     500                    default:
     501                    {
     502                        if (cParms == 3)
     503                        {
     504                            rc = paParms[0].getUInt32(&data.uStatus);
     505                            if (RT_SUCCESS(rc))
     506                                rc = paParms[1].getUInt32(&data.uPercentage);
     507                            if (RT_SUCCESS(rc))
     508                                rc = paParms[2].getUInt32(&data.rc);
     509                        }
     510                        break;
     511                    }
     512                }
     513
     514                DO_HOST_CALLBACK();
    437515                break;
    438516            }
    … …  
    441519            {
    442520                LogFlowFunc(("GUEST_DND_GH_ACK_PENDING\n"));
    443                 if (cParms == 3)
    444                 {
    445                     VBOXDNDCBGHACKPENDINGDATA data;
    446                     data.hdr.u32Magic = CB_MAGIC_DND_GH_ACK_PENDING;
    447                     rc = paParms[0].getUInt32(&data.uDefAction);
    448                     if (RT_SUCCESS(rc))
    449                         rc = paParms[1].getUInt32(&data.uAllActions);
    450                     if (RT_SUCCESS(rc))
    451                         rc = paParms[2].getPointer((void**)&data.pszFormat, &data.cbFormat);
    452                     DO_HOST_CALLBACK();
    453                 }
     521
     522                VBOXDNDCBGHACKPENDINGDATA data;
     523                RT_ZERO(data);
     524                data.hdr.uMagic = CB_MAGIC_DND_GH_ACK_PENDING;
     525
     526                switch (pClient->protocol())
     527                {
     528                    case 3:
     529                    {
     530                        if (cParms == 5)
     531                        {
     532                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
     533                            if (RT_SUCCESS(rc))
     534                                rc = paParms[1].getUInt32(&data.uDefAction);
     535                            if (RT_SUCCESS(rc))
     536                                rc = paParms[2].getUInt32(&data.uAllActions);
     537                            if (RT_SUCCESS(rc))
     538                                rc = paParms[3].getPointer((void**)&data.pszFormat, &data.cbFormat);
     539                            if (RT_SUCCESS(rc))
     540                                rc = paParms[4].getUInt32(&data.cbFormat);
     541                        }
     542                        break;
     543                    }
     544
     545                    case 2:
     546                    default:
     547                    {
     548                        if (cParms == 3)
     549                        {
     550                            rc = paParms[0].getUInt32(&data.uDefAction);
     551                            if (RT_SUCCESS(rc))
     552                                rc = paParms[1].getUInt32(&data.uAllActions);
     553                            if (RT_SUCCESS(rc))
     554                                rc = paParms[2].getPointer((void**)&data.pszFormat, &data.cbFormat);
     555                        }
     556                        break;
     557                    }
     558                }
     559
     560                DO_HOST_CALLBACK();
    454561                break;
    455562            }
    … …  
    461568                {
    462569                    VBOXDNDCBSNDDATAHDRDATA data;
    463                     data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DATA_HDR;
    464                     rc = paParms[0].getUInt32(&data.hdr.u32ContextID);
     570                    RT_ZERO(data);
     571                    data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DATA_HDR;
     572                    rc = paParms[0].getUInt32(&data.hdr.uContextID);
    465573                    if (RT_SUCCESS(rc))
    466574                        rc = paParms[1].getUInt32(&data.data.uFlags);
    … …  
    502610                        {
    503611                            VBOXDNDCBSNDDATADATA data;
    504                             data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DATA;
    505                             rc = paParms[0].getUInt32(&data.hdr.u32ContextID);
     612                            RT_ZERO(data);
     613                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DATA;
     614                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
    506615                            if (RT_SUCCESS(rc))
    507616                                rc = paParms[1].getPointer((void**)&data.data.u.v3.pvData, &data.data.u.v3.cbData);
    … …  
    523632                        {
    524633                            VBOXDNDCBSNDDATADATA data;
    525                             data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DATA;
     634                            RT_ZERO(data);
     635                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DATA;
    526636                            rc = paParms[0].getPointer((void**)&data.data.u.v1.pvData, &data.data.u.v1.cbData);
    527637                            if (RT_SUCCESS(rc))
    … …  
    537647            {
    538648                LogFlowFunc(("GUEST_DND_GH_SND_DIR\n"));
    539                 if (cParms == 3)
    540                 {
    541                     VBOXDNDCBSNDDIRDATA data;
    542                     data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_DIR;
    543                     uint32_t cTmp;
    544                     rc = paParms[0].getPointer((void**)&data.pszPath, &cTmp);
    545                     if (RT_SUCCESS(rc))
    546                         rc = paParms[1].getUInt32(&data.cbPath);
    547                     if (RT_SUCCESS(rc))
    548                         rc = paParms[2].getUInt32(&data.fMode);
    549 
    550                     LogFlowFunc(("pszPath=%s, cbPath=%RU32, fMode=0x%x\n", data.pszPath, data.cbPath, data.fMode));
    551                     DO_HOST_CALLBACK();
    552                 }
     649
     650                VBOXDNDCBSNDDIRDATA data;
     651                RT_ZERO(data);
     652                data.hdr.uMagic = CB_MAGIC_DND_GH_SND_DIR;
     653
     654                switch (pClient->protocol())
     655                {
     656                    case 3:
     657                    {
     658                        if (cParms == 4)
     659                        {
     660                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
     661                            if (RT_SUCCESS(rc))
     662                                rc = paParms[0].getPointer((void**)&data.pszPath, &data.cbPath);
     663                            if (RT_SUCCESS(rc))
     664                                rc = paParms[1].getUInt32(&data.cbPath);
     665                            if (RT_SUCCESS(rc))
     666                                rc = paParms[2].getUInt32(&data.fMode);
     667                        }
     668                        break;
     669                    }
     670
     671                    case 2:
     672                    default:
     673                    {
     674                        if (cParms == 3)
     675                        {
     676                            rc = paParms[0].getPointer((void**)&data.pszPath, &data.cbPath);
     677                            if (RT_SUCCESS(rc))
     678                                rc = paParms[1].getUInt32(&data.cbPath);
     679                            if (RT_SUCCESS(rc))
     680                                rc = paParms[2].getUInt32(&data.fMode);
     681                        }
     682                        break;
     683                    }
     684                }
     685
     686                DO_HOST_CALLBACK();
    553687                break;
    554688            }
    … …  
    560694                {
    561695                    VBOXDNDCBSNDFILEHDRDATA data;
    562                     data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_HDR;
    563                     uint32_t cTmp;
    564                     /* paParms[0] is context ID; unused yet. */
    565                     rc = paParms[1].getPointer((void**)&data.pszFilePath, &cTmp);
     696                    RT_ZERO(data);
     697                    data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_HDR;
     698
     699                    rc = paParms[0].getUInt32(&data.hdr.uContextID);
     700                    if (RT_SUCCESS(rc))
     701                        rc = paParms[1].getPointer((void**)&data.pszFilePath, &data.cbFilePath);
    566702                    if (RT_SUCCESS(rc))
    567703                        rc = paParms[2].getUInt32(&data.cbFilePath);
    … …  
    591727                        {
    592728                            VBOXDNDCBSNDFILEDATADATA data;
    593                             data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_DATA;
    594                             rc = paParms[0].getUInt32(&data.hdr.u32ContextID);
     729                            RT_ZERO(data);
     730                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_DATA;
     731
     732                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
    595733                            if (RT_SUCCESS(rc))
    596734                                rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData);
    … …  
    613751                        {
    614752                            VBOXDNDCBSNDFILEDATADATA data;
    615                             data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_DATA;
    616                             rc = paParms[0].getUInt32(&data.hdr.u32ContextID);
     753                            RT_ZERO(data);
     754                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_DATA;
     755                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
    617756                            if (RT_SUCCESS(rc))
    618757                                rc = paParms[1].getPointer((void**)&data.pvData, &data.cbData);
    … …  
    631770                        {
    632771                            VBOXDNDCBSNDFILEDATADATA data;
    633                             data.hdr.u32Magic = CB_MAGIC_DND_GH_SND_FILE_DATA;
     772                            RT_ZERO(data);
     773                            data.hdr.uMagic = CB_MAGIC_DND_GH_SND_FILE_DATA;
    634774                            uint32_t cTmp;
    635775                            rc = paParms[0].getPointer((void**)&data.u.v1.pszFilePath, &cTmp);
    … …  
    655795            {
    656796                LogFlowFunc(("GUEST_DND_GH_EVT_ERROR\n"));
    657                 if (cParms == 1)
    658                 {
    659                     VBOXDNDCBEVTERRORDATA data;
    660                     data.hdr.u32Magic = CB_MAGIC_DND_GH_EVT_ERROR;
    661 
    662                     uint32_t rcOp;
    663                     rc = paParms[0].getUInt32(&rcOp);
    664                     if (RT_SUCCESS(rc))
    665                         data.rc = rcOp;
    666 
    667                     DO_HOST_CALLBACK();
    668                 }
     797
     798                VBOXDNDCBEVTERRORDATA data;
     799                RT_ZERO(data);
     800                data.hdr.uMagic = CB_MAGIC_DND_GH_EVT_ERROR;
     801
     802                switch (pClient->protocol())
     803                {
     804                    case 3:
     805                    {
     806                        if (cParms == 2)
     807                        {
     808                            rc = paParms[0].getUInt32(&data.hdr.uContextID);
     809                            if (RT_SUCCESS(rc))
     810                            {
     811                                uint32_t rcOp;
     812                                rc = paParms[1].getUInt32(&rcOp);
     813                                if (RT_SUCCESS(rc))
     814                                    data.rc = rcOp;
     815                            }
     816                        }
     817                        break;
     818                    }
     819
     820                    case 2:
     821                    default:
     822                    {
     823                        if (cParms == 1)
     824                        {
     825                            uint32_t rcOp;
     826                            rc = paParms[0].getUInt32(&rcOp);
     827                            if (RT_SUCCESS(rc))
     828                                data.rc = (int32_t)rcOp;
     829                        }
     830                        break;
     831                    }
     832                }
     833
     834                DO_HOST_CALLBACK();
    669835                break;
    670836            }
    … …  
    679845                    {
    680846                        VBOXDNDCBHGGETNEXTHOSTMSGDATA data;
    681                         data.hdr.u32Magic = VBOX_DND_CB_MAGIC_MAKE(0 /* uFn */, 0 /* uVer */);
     847                        RT_ZERO(data);
     848                        data.hdr.uMagic = VBOX_DND_CB_MAGIC_MAKE(0 /* uFn */, 0 /* uVer */);
    682849                        data.uMsg    = u32Function;
    683850                        data.cParms  = cParms;
    … …  
    831998
    832999        VBOXDNDCBHGEVTPROGRESSDATA data;
    833         data.hdr.u32Magic = CB_MAGIC_DND_HG_EVT_PROGRESS;
     1000        data.hdr.uMagic = CB_MAGIC_DND_HG_EVT_PROGRESS;
    8341001        data.uPercentage  = RT_MIN(uPercentage, 100);
    8351002        data.uStatus      = uStatus;
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette