VirtualBox

Changeset 34893 in vbox for trunk


Ignore:
Timestamp:
Dec 9, 2010 2:44:38 PM (14 years ago)
Author:
vboxsync
Message:

ExtPack: First part of the extension pack license code.

Location:
trunk/src/VBox/Main
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/ExtPackManagerImpl.cpp

    r34808 r34893  
    2929#include <iprt/file.h>
    3030#include <iprt/ldr.h>
     31#include <iprt/manifest.h>
    3132#include <iprt/param.h>
    3233#include <iprt/path.h>
    … …  
    8889    /** The file handle of the extension pack file. */
    8990    RTFILE              hExtPackFile;
     91    /** Our manifest for the tarball. */
     92    RTMANIFEST          hOurManifest;
    9093    /** Pointer to the extension pack manager. */
    9194    ComObjPtr<ExtPackManager> ptrExtPackMgr;
    … …  
    188191    m->strExtPackFile               = a_pszFile;
    189192    m->hExtPackFile                 = NIL_RTFILE;
     193    m->hOurManifest                 = NIL_RTMANIFEST;
    190194    m->ptrExtPackMgr                = a_pExtPackMgr;
    191195
    … …  
    225229    RTVFSFILE   hXmlFile;
    226230    vrc = VBoxExtPackValidateTarball(m->hExtPackFile, NULL /*pszExtPackName*/, a_pszFile,
    227                                      szError, sizeof(szError), NULL /*phValidManifest*/, &hXmlFile);
     231                                     szError, sizeof(szError), &m->hOurManifest, &hXmlFile);
    228232    if (RT_FAILURE(vrc))
    229233        return initFailed(tr("%s"), szError);
    … …  
    293297        RTFileClose(m->hExtPackFile);
    294298        m->hExtPackFile = NIL_RTFILE;
     299        RTManifestRelease(m->hOurManifest);
     300        m->hOurManifest = NIL_RTMANIFEST;
    295301
    296302        delete m;
    … …  
    376382}
    377383
     384STDMETHODIMP ExtPackFile::COMGETTER(Usable)(BOOL *a_pfUsable)
     385{
     386    CheckComArgOutPointerValid(a_pfUsable);
     387
     388    AutoCaller autoCaller(this);
     389    HRESULT hrc = autoCaller.rc();
     390    if (SUCCEEDED(hrc))
     391        *a_pfUsable = m->fUsable;
     392    return hrc;
     393}
     394
     395STDMETHODIMP ExtPackFile::COMGETTER(WhyUnusable)(BSTR *a_pbstrWhy)
     396{
     397    CheckComArgOutPointerValid(a_pbstrWhy);
     398
     399    AutoCaller autoCaller(this);
     400    HRESULT hrc = autoCaller.rc();
     401    if (SUCCEEDED(hrc))
     402        m->strWhyUnusable.cloneTo(a_pbstrWhy);
     403    return hrc;
     404}
     405
     406STDMETHODIMP ExtPackFile::COMGETTER(ShowLicense)(BOOL *a_pfShowIt)
     407{
     408    CheckComArgOutPointerValid(a_pfShowIt);
     409
     410    AutoCaller autoCaller(this);
     411    HRESULT hrc = autoCaller.rc();
     412    if (SUCCEEDED(hrc))
     413        *a_pfShowIt = m->Desc.fShowLicense;
     414    return hrc;
     415}
     416
    378417STDMETHODIMP ExtPackFile::COMGETTER(License)(BSTR *a_pbstrHtmlLicense)
    379418{
    380     CheckComArgOutPointerValid(a_pbstrHtmlLicense);
    381 
    382     AutoCaller autoCaller(this);
    383     HRESULT hrc = autoCaller.rc();
    384     if (SUCCEEDED(hrc))
    385     {
    386         Utf8Str Dummy;
    387         Dummy.cloneTo(a_pbstrHtmlLicense);
    388     }
    389     return hrc;
    390 }
    391 
    392 STDMETHODIMP ExtPackFile::COMGETTER(ShowLicense)(BOOL *a_pfShowIt)
    393 {
    394     CheckComArgOutPointerValid(a_pfShowIt);
    395 
    396     AutoCaller autoCaller(this);
    397     HRESULT hrc = autoCaller.rc();
    398     if (SUCCEEDED(hrc))
    399         *a_pfShowIt = FALSE;
    400     return hrc;
    401 }
    402 
    403 STDMETHODIMP ExtPackFile::COMGETTER(Usable)(BOOL *a_pfUsable)
    404 {
    405     CheckComArgOutPointerValid(a_pfUsable);
    406 
    407     AutoCaller autoCaller(this);
    408     HRESULT hrc = autoCaller.rc();
    409     if (SUCCEEDED(hrc))
    410         *a_pfUsable = m->fUsable;
    411     return hrc;
    412 }
    413 
    414 STDMETHODIMP ExtPackFile::COMGETTER(WhyUnusable)(BSTR *a_pbstrWhy)
    415 {
    416     CheckComArgOutPointerValid(a_pbstrWhy);
    417 
    418     AutoCaller autoCaller(this);
    419     HRESULT hrc = autoCaller.rc();
    420     if (SUCCEEDED(hrc))
    421         m->strWhyUnusable.cloneTo(a_pbstrWhy);
     419    Bstr bstrHtml("html");
     420    return QueryLicense(Bstr::Empty.raw(), Bstr::Empty.raw(), bstrHtml.raw(), a_pbstrHtmlLicense);
     421}
     422
     423/* Same as ExtPack::QueryLicense, should really explore the subject of base classes here... */
     424STDMETHODIMP ExtPackFile::QueryLicense(IN_BSTR a_bstrPreferredLocale, IN_BSTR a_bstrPreferredLanguage, IN_BSTR a_bstrFormat,
     425                                       BSTR *a_pbstrLicense)
     426{
     427    /*
     428     * Validate input.
     429     */
     430    CheckComArgOutPointerValid(a_pbstrLicense);
     431    CheckComArgNotNull(a_bstrPreferredLocale);
     432    CheckComArgNotNull(a_bstrPreferredLanguage);
     433    CheckComArgNotNull(a_bstrFormat);
     434
     435    Utf8Str strPreferredLocale(a_bstrPreferredLocale);
     436    if (strPreferredLocale.length() != 2 && strPreferredLocale.length() != 0)
     437        return setError(E_FAIL, tr("The preferred locale is a two character string or empty."));
     438
     439    Utf8Str strPreferredLanguage(a_bstrPreferredLanguage);
     440    if (strPreferredLanguage.length() != 2 && strPreferredLanguage.length() != 0)
     441        return setError(E_FAIL, tr("The preferred lanuage is a two character string or empty."));
     442
     443    Utf8Str strFormat(a_bstrFormat);
     444    if (   !strFormat.equals("html")
     445        && !strFormat.equals("rtf")
     446        && !strFormat.equals("txt"))
     447        return setError(E_FAIL, tr("The license format can only have the values 'html', 'rtf' and 'txt'."));
     448
     449    /*
     450     * Combine the options to form a file name before locking down anything.
     451     */
     452    char szName[sizeof("ExtPack-license-de_DE.html") + 2];
     453    if (strPreferredLocale.isNotEmpty() && strPreferredLanguage.isNotEmpty())
     454        RTStrPrintf(szName, sizeof(szName), "ExtPack-license-%s_%s.%s",
     455                    strPreferredLocale.c_str(), strPreferredLanguage.c_str(), strFormat.c_str());
     456    else if (strPreferredLocale.isNotEmpty())
     457        RTStrPrintf(szName, sizeof(szName), "ExtPack-license-%s.%s",  strPreferredLocale.c_str(), strFormat.c_str());
     458    else if (strPreferredLanguage.isNotEmpty())
     459        RTStrPrintf(szName, sizeof(szName), "ExtPack-license-_%s.%s", strPreferredLocale.c_str(), strFormat.c_str());
     460    else
     461        RTStrPrintf(szName, sizeof(szName), "ExtPack-license.%s",     strFormat.c_str());
     462
     463    /*
     464     * Effectuate the query.
     465     */
     466    AutoCaller autoCaller(this);
     467    HRESULT hrc = autoCaller.rc();
     468    if (SUCCEEDED(hrc))
     469    {
     470        AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
     471
     472        /*
     473         * Look it up in the manifest before scanning the tarball for it
     474         */
     475        if (RTManifestEntryExists(m->hOurManifest, szName))
     476        {
     477            RTVFSFSSTREAM   hTarFss;
     478            char            szError[8192];
     479            int vrc = VBoxExtPackOpenTarFss(m->hExtPackFile, szError, sizeof(szError), &hTarFss);
     480            if (RT_SUCCESS(vrc))
     481            {
     482                for (;;)
     483                {
     484                    /* Get the first/next. */
     485                    char           *pszName;
     486                    RTVFSOBJ        hVfsObj;
     487                    RTVFSOBJTYPE    enmType;
     488                    vrc = RTVfsFsStrmNext(hTarFss, &pszName, &enmType, &hVfsObj);
     489                    if (RT_FAILURE(vrc))
     490                    {
     491                        if (vrc != VERR_EOF)
     492                            hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsFsStrmNext failed: %Rrc"), vrc);
     493                        else
     494                            hrc = setError(E_UNEXPECTED, tr("'%s' was found in the manifest but not in the tarball"), szName);
     495                        break;
     496                    }
     497
     498                    /* Is this it? */
     499                    const char *pszAdjName = pszName[0] == '.' && pszName[1] == '/' ? &pszName[2] : pszName;
     500                    if (   !strcmp(pszAdjName, szName)
     501                        && (   enmType == RTVFSOBJTYPE_IO_STREAM
     502                            || enmType == RTVFSOBJTYPE_FILE))
     503                    {
     504                        RTVFSIOSTREAM hVfsIos = RTVfsObjToIoStream(hVfsObj);
     505                        RTVfsObjRelease(hVfsObj);
     506                        RTStrFree(pszName);
     507
     508                        /* Load the file into memory. */
     509                        RTFSOBJINFO ObjInfo;
     510                        vrc = RTVfsIoStrmQueryInfo(hVfsIos, &ObjInfo, RTFSOBJATTRADD_NOTHING);
     511                        if (RT_SUCCESS(vrc))
     512                        {
     513                            size_t cbFile = (size_t)ObjInfo.cbObject;
     514                            void  *pvFile = RTMemAllocZ(cbFile + 1);
     515                            if (pvFile)
     516                            {
     517                                vrc = RTVfsIoStrmRead(hVfsIos, pvFile, cbFile, true /*fBlocking*/, NULL);
     518                                if (RT_SUCCESS(vrc))
     519                                {
     520                                    /* try translate it into a string we can return. */
     521                                    Bstr bstrLicense((const char *)pvFile, cbFile);
     522                                    if (bstrLicense.isNotEmpty())
     523                                    {
     524                                        bstrLicense.detachTo(a_pbstrLicense);
     525                                        hrc = S_OK;
     526                                    }
     527                                    else
     528                                        hrc = setError(VBOX_E_IPRT_ERROR,
     529                                                       tr("The license file '%s' is empty or contains invalid UTF-8 encoding"),
     530                                                       szName);
     531                                }
     532                                else
     533                                    hrc = setError(VBOX_E_IPRT_ERROR, tr("Failed to read '%s': %Rrc"), szName, vrc);
     534                                RTMemFree(pvFile);
     535                            }
     536                            else
     537                                hrc = setError(E_OUTOFMEMORY, tr("Failed to allocate %zu bytes for '%s'"), cbFile, szName);
     538                        }
     539                        else
     540                            hrc = setError(VBOX_E_IPRT_ERROR, tr("RTVfsIoStrmQueryInfo on '%s': %Rrc"), szName, vrc);
     541                        RTVfsIoStrmRelease(hVfsIos);
     542                        break;
     543                    }
     544
     545                    /* Release current. */
     546                    RTVfsObjRelease(hVfsObj);
     547                    RTStrFree(pszName);
     548                }
     549                RTVfsFsStrmRelease(hTarFss);
     550            }
     551            else
     552                hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("%s"), szError);
     553        }
     554        else
     555            hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The license file '%s' was not found in '%s'"),
     556                           szName, m->strExtPackFile.c_str());
     557    }
    422558    return hrc;
    423559}
    … …  
    14041540}
    14051541
     1542STDMETHODIMP ExtPack::COMGETTER(Usable)(BOOL *a_pfUsable)
     1543{
     1544    CheckComArgOutPointerValid(a_pfUsable);
     1545
     1546    AutoCaller autoCaller(this);
     1547    HRESULT hrc = autoCaller.rc();
     1548    if (SUCCEEDED(hrc))
     1549        *a_pfUsable = m->fUsable;
     1550    return hrc;
     1551}
     1552
     1553STDMETHODIMP ExtPack::COMGETTER(WhyUnusable)(BSTR *a_pbstrWhy)
     1554{
     1555    CheckComArgOutPointerValid(a_pbstrWhy);
     1556
     1557    AutoCaller autoCaller(this);
     1558    HRESULT hrc = autoCaller.rc();
     1559    if (SUCCEEDED(hrc))
     1560        m->strWhyUnusable.cloneTo(a_pbstrWhy);
     1561    return hrc;
     1562}
     1563
     1564STDMETHODIMP ExtPack::COMGETTER(ShowLicense)(BOOL *a_pfShowIt)
     1565{
     1566    CheckComArgOutPointerValid(a_pfShowIt);
     1567
     1568    AutoCaller autoCaller(this);
     1569    HRESULT hrc = autoCaller.rc();
     1570    if (SUCCEEDED(hrc))
     1571        *a_pfShowIt = m->Desc.fShowLicense;
     1572    return hrc;
     1573}
     1574
    14061575STDMETHODIMP ExtPack::COMGETTER(License)(BSTR *a_pbstrHtmlLicense)
    14071576{
    1408     CheckComArgOutPointerValid(a_pbstrHtmlLicense);
    1409 
    1410     AutoCaller autoCaller(this);
    1411     HRESULT hrc = autoCaller.rc();
    1412     if (SUCCEEDED(hrc))
    1413     {
    1414         Utf8Str Dummy;
    1415         Dummy.cloneTo(a_pbstrHtmlLicense);
    1416     }
    1417     return hrc;
    1418 }
    1419 
    1420 STDMETHODIMP ExtPack::COMGETTER(ShowLicense)(BOOL *a_pfShowIt)
    1421 {
    1422     CheckComArgOutPointerValid(a_pfShowIt);
    1423 
    1424     AutoCaller autoCaller(this);
    1425     HRESULT hrc = autoCaller.rc();
    1426     if (SUCCEEDED(hrc))
    1427         *a_pfShowIt = FALSE;
    1428     return hrc;
    1429 }
    1430 
    1431 STDMETHODIMP ExtPack::COMGETTER(Usable)(BOOL *a_pfUsable)
    1432 {
    1433     CheckComArgOutPointerValid(a_pfUsable);
    1434 
    1435     AutoCaller autoCaller(this);
    1436     HRESULT hrc = autoCaller.rc();
    1437     if (SUCCEEDED(hrc))
    1438         *a_pfUsable = m->fUsable;
    1439     return hrc;
    1440 }
    1441 
    1442 STDMETHODIMP ExtPack::COMGETTER(WhyUnusable)(BSTR *a_pbstrWhy)
    1443 {
    1444     CheckComArgOutPointerValid(a_pbstrWhy);
    1445 
    1446     AutoCaller autoCaller(this);
    1447     HRESULT hrc = autoCaller.rc();
    1448     if (SUCCEEDED(hrc))
    1449         m->strWhyUnusable.cloneTo(a_pbstrWhy);
    1450     return hrc;
    1451 }
     1577    Bstr bstrHtml("html");
     1578    return QueryLicense(Bstr::Empty.raw(), Bstr::Empty.raw(), bstrHtml.raw(), a_pbstrHtmlLicense);
     1579}
     1580
     1581STDMETHODIMP ExtPack::QueryLicense(IN_BSTR a_bstrPreferredLocale, IN_BSTR a_bstrPreferredLanguage, IN_BSTR a_bstrFormat,
     1582                                   BSTR *a_pbstrLicense)
     1583{
     1584    /*
     1585     * Validate input.
     1586     */
     1587    CheckComArgOutPointerValid(a_pbstrLicense);
     1588    CheckComArgNotNull(a_bstrPreferredLocale);
     1589    CheckComArgNotNull(a_bstrPreferredLanguage);
     1590    CheckComArgNotNull(a_bstrFormat);
     1591
     1592    Utf8Str strPreferredLocale(a_bstrPreferredLocale);
     1593    if (strPreferredLocale.length() != 2 && strPreferredLocale.length() != 0)
     1594        return setError(E_FAIL, tr("The preferred locale is a two character string or empty."));
     1595
     1596    Utf8Str strPreferredLanguage(a_bstrPreferredLanguage);
     1597    if (strPreferredLanguage.length() != 2 && strPreferredLanguage.length() != 0)
     1598        return setError(E_FAIL, tr("The preferred lanuage is a two character string or empty."));
     1599
     1600    Utf8Str strFormat(a_bstrFormat);
     1601    if (   !strFormat.equals("html")
     1602        && !strFormat.equals("rtf")
     1603        && !strFormat.equals("txt"))
     1604        return setError(E_FAIL, tr("The license format can only have the values 'html', 'rtf' and 'txt'."));
     1605
     1606    /*
     1607     * Combine the options to form a file name before locking down anything.
     1608     */
     1609    char szName[sizeof("ExtPack-license-de_DE.html") + 2];
     1610    if (strPreferredLocale.isNotEmpty() && strPreferredLanguage.isNotEmpty())
     1611        RTStrPrintf(szName, sizeof(szName), "ExtPack-license-%s_%s.%s",
     1612                    strPreferredLocale.c_str(), strPreferredLanguage.c_str(), strFormat.c_str());
     1613    else if (strPreferredLocale.isNotEmpty())
     1614        RTStrPrintf(szName, sizeof(szName), "ExtPack-license-%s.%s",  strPreferredLocale.c_str(), strFormat.c_str());
     1615    else if (strPreferredLanguage.isNotEmpty())
     1616        RTStrPrintf(szName, sizeof(szName), "ExtPack-license-_%s.%s", strPreferredLocale.c_str(), strFormat.c_str());
     1617    else
     1618        RTStrPrintf(szName, sizeof(szName), "ExtPack-license.%s",     strFormat.c_str());
     1619
     1620    /*
     1621     * Effectuate the query.
     1622     */
     1623    AutoCaller autoCaller(this);
     1624    HRESULT hrc = autoCaller.rc();
     1625    if (SUCCEEDED(hrc))
     1626    {
     1627        AutoReadLock autoLock(this COMMA_LOCKVAL_SRC_POS); /* paranoia */
     1628
     1629        char szPath[RTPATH_MAX];
     1630        int vrc = RTPathJoin(szPath, sizeof(szPath), m->strExtPackPath.c_str(), szName);
     1631        if (RT_SUCCESS(vrc))
     1632        {
     1633            void   *pvFile;
     1634            size_t  cbFile;
     1635            vrc = RTFileReadAllEx(szPath, 0, RTFOFF_MAX, RTFILE_RDALL_O_DENY_READ, &pvFile, &cbFile);
     1636            if (RT_SUCCESS(vrc))
     1637            {
     1638                Bstr bstrLicense((const char *)pvFile, cbFile);
     1639                if (bstrLicense.isNotEmpty())
     1640                {
     1641                    bstrLicense.detachTo(a_pbstrLicense);
     1642                    hrc = S_OK;
     1643                }
     1644                else
     1645                    hrc = setError(VBOX_E_IPRT_ERROR, tr("The license file '%s' is empty or contains invalid UTF-8 encoding"),
     1646                                   szPath);
     1647                RTFileReadAllFree(pvFile, cbFile);
     1648            }
     1649            else if (vrc == VERR_FILE_NOT_FOUND || vrc == VERR_PATH_NOT_FOUND)
     1650                hrc = setError(VBOX_E_OBJECT_NOT_FOUND, tr("The license file '%s' was not found in extension pack '%s'"),
     1651                               szName, m->Desc.strName.c_str());
     1652            else
     1653                hrc = setError(VBOX_E_FILE_ERROR, tr("Failed to open the license file '%s': %Rrc"), szPath, vrc);
     1654        }
     1655        else
     1656            hrc = setError(VBOX_E_IPRT_ERROR, tr("RTPathJoin failed: %Rrc"), vrc);
     1657    }
     1658    return hrc;
     1659}
     1660
    14521661
    14531662STDMETHODIMP ExtPack::QueryObject(IN_BSTR a_bstrObjectId, IUnknown **a_ppUnknown)

  • trunk/src/VBox/Main/ExtPackUtil.cpp

    r34787 r34893  
    7575    a_pExtPackDesc->cPlugIns = 0;
    7676    a_pExtPackDesc->paPlugIns = NULL;
     77    a_pExtPackDesc->fShowLicense = false;
    7778}
    7879
    … …  
    158159
    159160    /*
    160      * Parse plug-in descriptions.
     161     * Whether to show the license, optional. (presense is enough here)
     162     */
     163    const xml::ElementNode *pShowLicenseElm = pVBoxExtPackElm->findChildElement("ShowLicense");
     164    bool fShowLicense = pShowLicenseElm != NULL;
     165
     166    /*
     167     * Parse plug-in descriptions (last because of the manual memory management).
    161168     */
    162169    uint32_t                cPlugIns  = 0;
    … …  
    180187    a_pExtPackDesc->cPlugIns        = cPlugIns;
    181188    a_pExtPackDesc->paPlugIns       = paPlugIns;
     189    a_pExtPackDesc->fShowLicense    = fShowLicense;
    182190
    183191    return NULL;
    … …  
    336344    RTMemFree(a_pExtPackDesc->paPlugIns);
    337345    a_pExtPackDesc->paPlugIns = NULL;
     346    a_pExtPackDesc->fShowLicense = false;
    338347}
    339348

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r34864 r34893  
    1436714367    </attribute>
    1436814368    <attribute name="license" type="wstring" readonly="yes">
    14369       <desc>The HTML license text for the extension pack.</desc>
     14369      <desc>
     14370        The default HTML license text for the extension pack.  Same as
     14371        calling queryLicense("", "", "html").
     14372      </desc>
    1437014373    </attribute>
    1437114374    <attribute name="showLicense" type="boolean" readonly="yes">
    … …  
    1438714390      </desc>
    1438814391    </attribute>
     14392
     14393    <method name="queryLicense">
     14394      <desc>
     14395        Full feature version of the license attribute.
     14396      </desc>
     14397      <param name="preferredLocale" type="wstring" dir="in">
     14398        <desc>
     14399          The preferred license locale. Pass an empty string to get the default
     14400          license.
     14401        </desc>
     14402      </param>
     14403      <param name="preferredLanguage" type="wstring" dir="in">
     14404        <desc>
     14405          The preferred license language. Pass an empty string to get the
     14406          default language for the locale.
     14407        </desc>
     14408      </param>
     14409      <param name="format" type="wstring" dir="in">
     14410        <desc>
     14411          The license format: html, rtf or txt. If a license is present there
     14412          will always be an HTML of it, the rich text format (RTF) and plain
     14413          text (txt) versions are optional. If
     14414        </desc>
     14415      </param>
     14416      <param name="licenseText" type="wstring" dir="return">
     14417        <desc>The license text.</desc>
     14418      </param>
     14419    </method>
     14420
    1438914421  </interface>
    1439014422
    … …  
    1440714439        <desc>The object ID.  What exactly this is </desc>
    1440814440      </param>
    14409       <param name="returnInterface" type="$unknown" dir="out">
     14441      <param name="returnInterface" type="$unknown" dir="return">
    1441014442        <desc>The queried interface.</desc>
    1441114443      </param>

  • trunk/src/VBox/Main/include/ExtPackManagerImpl.h

    r34808 r34893  
    5959    STDMETHOD(COMGETTER(VRDEModule))(BSTR *a_pbstrVrdeModule);
    6060    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, a_paPlugIns));
    61     STDMETHOD(COMGETTER(License))(BSTR *a_pbstrHtmlLicense);
    62     STDMETHOD(COMGETTER(ShowLicense))(BOOL *a_pfShowIt);
    6361    STDMETHOD(COMGETTER(Usable))(BOOL *a_pfUsable);
    6462    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *a_pbstrWhy);
     63    STDMETHOD(COMGETTER(ShowLicense))(BOOL *a_pfShowIt);
     64    STDMETHOD(COMGETTER(License))(BSTR *a_pbstrHtmlLicense);
     65    STDMETHOD(QueryLicense)(IN_BSTR a_bstrPreferredLocale, IN_BSTR a_bstrPreferredLanguage,
     66                            IN_BSTR a_bstrFormat, BSTR *a_pbstrLicense);
    6567    /** @}  */
    6668
    … …  
    122124    STDMETHOD(COMGETTER(VRDEModule))(BSTR *a_pbstrVrdeModule);
    123125    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, a_paPlugIns));
    124     STDMETHOD(COMGETTER(License))(BSTR *a_pbstrHtmlLicense);
    125     STDMETHOD(COMGETTER(ShowLicense))(BOOL *a_pfShowIt);
    126126    STDMETHOD(COMGETTER(Usable))(BOOL *a_pfUsable);
    127127    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *a_pbstrWhy);
     128    STDMETHOD(COMGETTER(ShowLicense))(BOOL *a_pfShowIt);
     129    STDMETHOD(COMGETTER(License))(BSTR *a_pbstrHtmlLicense);
     130    STDMETHOD(QueryLicense)(IN_BSTR a_bstrPreferredLocale, IN_BSTR a_bstrPreferredLanguage,
     131                            IN_BSTR a_bstrFormat, BSTR *a_pbstrLicense);
    128132    /** @}  */
    129133

  • trunk/src/VBox/Main/include/ExtPackUtil.h

    r34787 r34893  
    3333 * The name of the signature file in an extension pack.  */
    3434#define VBOX_EXTPACK_SIGNATURE_NAME     "ExtPack.signature"
     35/** @name VBOX_EXTPACK_LICENSE_NAME_PREFIX
     36 * The name prefix of a license file in an extension pack. There can be
     37 * several license files in a pack, the variations being on locale, language
     38 * and format (HTML, RTF, plain text). All extension packages shall include
     39 * a  */
     40#define VBOX_EXTPACK_LICENSE_NAME_PREFIX "ExtPack.license"
    3541/** @name VBOX_EXTPACK_SUFFIX
    3642 * The suffix of a extension pack tarball. */
    … …  
    94100    /** Pointer to an array of plug-in descriptors. */
    95101    PVBOXEXTPACKPLUGINDESC  paPlugIns;
     102    /** Whether to show the license prior to installation. */
     103    bool                    fShowLicense;
    96104} VBOXEXTPACKDESC;
    97105
Note: See TracChangeset for help on using the changeset viewer.

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