← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Main/src-server/VRDEServerImpl.cpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-03-07 16:38:36 UTC
  • mfrom: (1.1.13) (3.1.20 experimental)
  • Revision ID: package-import@ubuntu.com-20130307163836-p93jpbgx39tp3gb4
Tags: 4.2.8-dfsg-0ubuntu1
http://bugs.debian.org/691148
http://bugs.debian.org/700823
https://launchpad.net/bugs/1101867
http://bugs.debian.org/700479
http://bugs.debian.org/686994
http://bugs.debian.org/680053
* New upstream release. (Closes: #691148)
  - Fixes compatibility with kernel 3.8. (Closes: #700823; LP: #1101867)
* Switch to my @debian.org email address.
* Move package to contrib as virtualbox 4.2 needs a non-free compiler to
  build the BIOS.
* Build-depend on libdevmapper-dev.
* Refresh patches.
  - Drop 36-fix-ftbfs-xserver-112.patch, cve-2012-3221.patch,
    CVE-2013-0420.patch 37-kcompat-3.6.patch and 38-kcompat-3.7.patch.
* Drop all virtualbox-ose transitional packages.
* Drop the virtualbox-fuse package as vdfuse fails to build with
  virtualbox 4.2.
* Update install files and VBox.sh.
* Bump required kbuild version to 0.1.9998svn2577.
* Fix path to VBoxCreateUSBNode.sh in virtualbox.postinst. (Closes: #700479)
* Add an init script to virtuabox-guest-x11 which loads the vboxvideo
  kernel module. The X Server 1.13 doesn't load it anymore. (Closes: #686994)
* Update man pages. (Closes: #680053)
* Add 36-python-multiarch.patch from Rico Tzschichholz to fix detection of
  python in multiarch paths using pkg-config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Main/src-server/VRDEServerImpl.cpp
4
4
 */
5
5
 
6
6
/*
7
 
 * Copyright (C) 2006-2010 Oracle Corporation
 
7
 * Copyright (C) 2006-2013 Oracle Corporation
8
8
 *
9
9
 * This file is part of VirtualBox Open Source Edition (OSE), as
10
10
 * available from http://www.virtualbox.org. This file is free software;
72
72
 *
73
73
 *  @param aParent  Handle of the parent object.
74
74
 */
75
 
HRESULT VRDEServer::init (Machine *aParent)
 
75
HRESULT VRDEServer::init(Machine *aParent)
76
76
{
77
77
    LogFlowThisFunc(("aParent=%p\n", aParent));
78
78
 
111
111
 *
112
112
 *  @note Locks @a aThat object for reading.
113
113
 */
114
 
HRESULT VRDEServer::init (Machine *aParent, VRDEServer *aThat)
 
114
HRESULT VRDEServer::init(Machine *aParent, VRDEServer *aThat)
115
115
{
116
116
    LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
117
117
 
124
124
    unconst(mParent) = aParent;
125
125
    unconst(mPeer) = aThat;
126
126
 
127
 
    AutoCaller thatCaller (aThat);
 
127
    AutoCaller thatCaller(aThat);
128
128
    AssertComRCReturnRC(thatCaller.rc());
129
129
 
130
130
    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
131
 
    mData.share (aThat->mData);
 
131
    mData.share(aThat->mData);
132
132
 
133
133
    /* Confirm a successful initialization */
134
134
    autoInitSpan.setSucceeded();
143
143
 *
144
144
 *  @note Locks @a aThat object for reading.
145
145
 */
146
 
HRESULT VRDEServer::initCopy (Machine *aParent, VRDEServer *aThat)
 
146
HRESULT VRDEServer::initCopy(Machine *aParent, VRDEServer *aThat)
147
147
{
148
148
    LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
149
149
 
156
156
    unconst(mParent) = aParent;
157
157
    /* mPeer is left null */
158
158
 
159
 
    AutoCaller thatCaller (aThat);
 
159
    AutoCaller thatCaller(aThat);
160
160
    AssertComRCReturnRC(thatCaller.rc());
161
161
 
162
162
    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
163
 
    mData.attachCopy (aThat->mData);
 
163
    mData.attachCopy(aThat->mData);
164
164
 
165
165
    /* Confirm a successful initialization */
166
166
    autoInitSpan.setSucceeded();
245
245
// IVRDEServer properties
246
246
/////////////////////////////////////////////////////////////////////////////
247
247
 
248
 
STDMETHODIMP VRDEServer::COMGETTER(Enabled) (BOOL *aEnabled)
 
248
STDMETHODIMP VRDEServer::COMGETTER(Enabled)(BOOL *aEnabled)
249
249
{
250
250
    CheckComArgOutPointerValid(aEnabled);
251
251
 
257
257
    return S_OK;
258
258
}
259
259
 
260
 
STDMETHODIMP VRDEServer::COMSETTER(Enabled) (BOOL aEnabled)
 
260
STDMETHODIMP VRDEServer::COMSETTER(Enabled)(BOOL aEnabled)
261
261
{
262
262
    AutoCaller autoCaller(this);
263
263
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
264
264
 
265
265
    /* the machine can also be in saved state for this property to change */
266
 
    AutoMutableOrSavedStateDependency adep (mParent);
 
266
    AutoMutableOrSavedStateDependency adep(mParent);
267
267
    if (FAILED(adep.rc())) return adep.rc();
268
268
 
269
269
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
373
373
    return VINF_SUCCESS;
374
374
}
375
375
 
376
 
STDMETHODIMP VRDEServer::SetVRDEProperty (IN_BSTR aKey, IN_BSTR aValue)
 
376
STDMETHODIMP VRDEServer::SetVRDEProperty(IN_BSTR aKey, IN_BSTR aValue)
377
377
{
378
378
    LogFlowThisFunc(("\n"));
379
379
 
380
380
    AutoCaller autoCaller(this);
381
381
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
382
382
 
383
 
    /* The machine needs to be mutable. */
384
 
    AutoMutableStateDependency adep(mParent);
 
383
    /* the machine can also be in saved state for this property to change */
 
384
    AutoMutableOrSavedStateDependency adep(mParent);
385
385
    if (FAILED(adep.rc())) return adep.rc();
386
386
 
387
387
    Bstr key = aKey;
460
460
    return S_OK;
461
461
}
462
462
 
463
 
STDMETHODIMP VRDEServer::GetVRDEProperty (IN_BSTR aKey, BSTR *aValue)
 
463
STDMETHODIMP VRDEServer::GetVRDEProperty(IN_BSTR aKey, BSTR *aValue)
464
464
{
465
465
    CheckComArgOutPointerValid(aValue);
466
466
 
627
627
    return S_OK;
628
628
}
629
629
 
630
 
STDMETHODIMP VRDEServer::COMGETTER(AuthType) (AuthType_T *aType)
 
630
STDMETHODIMP VRDEServer::COMGETTER(AuthType)(AuthType_T *aType)
631
631
{
632
632
    CheckComArgOutPointerValid(aType);
633
633
 
641
641
    return S_OK;
642
642
}
643
643
 
644
 
STDMETHODIMP VRDEServer::COMSETTER(AuthType) (AuthType_T aType)
 
644
STDMETHODIMP VRDEServer::COMSETTER(AuthType)(AuthType_T aType)
645
645
{
646
646
    AutoCaller autoCaller(this);
647
647
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
648
648
 
649
 
    /* the machine needs to be mutable */
650
 
    AutoMutableStateDependency adep(mParent);
 
649
    /* the machine can also be in saved state for this property to change */
 
650
    AutoMutableOrSavedStateDependency adep(mParent);
651
651
    if (FAILED(adep.rc())) return adep.rc();
652
652
 
653
653
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
670
670
    return S_OK;
671
671
}
672
672
 
673
 
STDMETHODIMP VRDEServer::COMGETTER(AuthTimeout) (ULONG *aTimeout)
 
673
STDMETHODIMP VRDEServer::COMGETTER(AuthTimeout)(ULONG *aTimeout)
674
674
{
675
675
    CheckComArgOutPointerValid(aTimeout);
676
676
 
684
684
    return S_OK;
685
685
}
686
686
 
687
 
STDMETHODIMP VRDEServer::COMSETTER(AuthTimeout) (ULONG aTimeout)
 
687
STDMETHODIMP VRDEServer::COMSETTER(AuthTimeout)(ULONG aTimeout)
688
688
{
689
689
    AutoCaller autoCaller(this);
690
690
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
691
691
 
692
 
    /* the machine needs to be mutable */
693
 
    AutoMutableStateDependency adep(mParent);
 
692
    /* the machine can also be in saved state for this property to change */
 
693
    AutoMutableOrSavedStateDependency adep(mParent);
694
694
    if (FAILED(adep.rc())) return adep.rc();
695
695
 
696
696
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
717
717
    return S_OK;
718
718
}
719
719
 
720
 
STDMETHODIMP VRDEServer::COMGETTER(AuthLibrary) (BSTR *aLibrary)
 
720
STDMETHODIMP VRDEServer::COMGETTER(AuthLibrary)(BSTR *aLibrary)
721
721
{
722
722
    CheckComArgOutPointerValid(aLibrary);
723
723
 
748
748
    return S_OK;
749
749
}
750
750
 
751
 
STDMETHODIMP VRDEServer::COMSETTER(AuthLibrary) (IN_BSTR aLibrary)
 
751
STDMETHODIMP VRDEServer::COMSETTER(AuthLibrary)(IN_BSTR aLibrary)
752
752
{
753
753
    AutoCaller autoCaller(this);
754
754
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
755
755
 
756
 
    /* the machine needs to be mutable */
757
 
    AutoMutableStateDependency adep(mParent);
 
756
    /* the machine can also be in saved state for this property to change */
 
757
    AutoMutableOrSavedStateDependency adep(mParent);
758
758
    if (FAILED(adep.rc())) return adep.rc();
759
759
 
760
760
    Bstr bstrLibrary(aLibrary);
779
779
    return S_OK;
780
780
}
781
781
 
782
 
STDMETHODIMP VRDEServer::COMGETTER(AllowMultiConnection) (
783
 
    BOOL *aAllowMultiConnection)
 
782
STDMETHODIMP VRDEServer::COMGETTER(AllowMultiConnection)(BOOL *aAllowMultiConnection)
784
783
{
785
784
    CheckComArgOutPointerValid(aAllowMultiConnection);
786
785
 
794
793
    return S_OK;
795
794
}
796
795
 
797
 
STDMETHODIMP VRDEServer::COMSETTER(AllowMultiConnection) (
798
 
    BOOL aAllowMultiConnection)
 
796
STDMETHODIMP VRDEServer::COMSETTER(AllowMultiConnection)(BOOL aAllowMultiConnection)
799
797
{
800
798
    AutoCaller autoCaller(this);
801
799
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
802
800
 
803
 
    /* the machine needs to be mutable */
804
 
    AutoMutableStateDependency adep(mParent);
 
801
    /* the machine can also be in saved state for this property to change */
 
802
    AutoMutableOrSavedStateDependency adep(mParent);
805
803
    if (FAILED(adep.rc())) return adep.rc();
806
804
 
807
805
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
824
822
    return S_OK;
825
823
}
826
824
 
827
 
STDMETHODIMP VRDEServer::COMGETTER(ReuseSingleConnection) (
828
 
    BOOL *aReuseSingleConnection)
 
825
STDMETHODIMP VRDEServer::COMGETTER(ReuseSingleConnection)(BOOL *aReuseSingleConnection)
829
826
{
830
827
    CheckComArgOutPointerValid(aReuseSingleConnection);
831
828
 
839
836
    return S_OK;
840
837
}
841
838
 
842
 
STDMETHODIMP VRDEServer::COMSETTER(ReuseSingleConnection) (
843
 
    BOOL aReuseSingleConnection)
 
839
STDMETHODIMP VRDEServer::COMSETTER(ReuseSingleConnection)(BOOL aReuseSingleConnection)
844
840
{
845
841
    AutoCaller autoCaller(this);
846
842
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
847
843
 
848
 
    /* the machine needs to be mutable */
849
 
    AutoMutableStateDependency adep(mParent);
 
844
    /* the machine can also be in saved state for this property to change */
 
845
    AutoMutableOrSavedStateDependency adep(mParent);
850
846
    if (FAILED(adep.rc())) return adep.rc();
851
847
 
852
848
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
869
865
    return S_OK;
870
866
}
871
867
 
872
 
STDMETHODIMP VRDEServer::COMGETTER(VRDEExtPack) (BSTR *aExtPack)
 
868
STDMETHODIMP VRDEServer::COMGETTER(VRDEExtPack)(BSTR *aExtPack)
873
869
{
874
870
    CheckComArgOutPointerValid(aExtPack);
875
871
 
919
915
    HRESULT hrc = autoCaller.rc();
920
916
    if (SUCCEEDED(hrc))
921
917
    {
922
 
        /* the machine needs to be mutable */
923
 
        AutoMutableStateDependency adep(mParent);
 
918
        /* the machine can also be in saved state for this property to change */
 
919
        AutoMutableOrSavedStateDependency adep(mParent);
924
920
        hrc = adep.rc();
925
921
        if (SUCCEEDED(hrc))
926
922
        {
994
990
{
995
991
    /* sanity */
996
992
    AutoCaller autoCaller(this);
997
 
    AssertComRCReturnVoid (autoCaller.rc());
 
993
    AssertComRCReturnVoid(autoCaller.rc());
998
994
 
999
995
    /* sanity too */
1000
 
    AutoCaller peerCaller (mPeer);
1001
 
    AssertComRCReturnVoid (peerCaller.rc());
 
996
    AutoCaller peerCaller(mPeer);
 
997
    AssertComRCReturnVoid(peerCaller.rc());
1002
998
 
1003
999
    /* lock both for writing since we modify both (mPeer is "master" so locked
1004
1000
     * first) */
1010
1006
        if (mPeer)
1011
1007
        {
1012
1008
            /* attach new data to the peer and reshare it */
1013
 
            mPeer->mData.attach (mData);
 
1009
            mPeer->mData.attach(mData);
1014
1010
        }
1015
1011
    }
1016
1012
}
1019
1015
 *  @note Locks this object for writing, together with the peer object
1020
1016
 *  represented by @a aThat (locked for reading).
1021
1017
 */
1022
 
void VRDEServer::copyFrom (VRDEServer *aThat)
 
1018
void VRDEServer::copyFrom(VRDEServer *aThat)
1023
1019
{
1024
 
    AssertReturnVoid (aThat != NULL);
 
1020
    AssertReturnVoid(aThat != NULL);
1025
1021
 
1026
1022
    /* sanity */
1027
1023
    AutoCaller autoCaller(this);
1028
 
    AssertComRCReturnVoid (autoCaller.rc());
 
1024
    AssertComRCReturnVoid(autoCaller.rc());
1029
1025
 
1030
1026
    /* sanity too */
1031
 
    AutoCaller thatCaller (aThat);
1032
 
    AssertComRCReturnVoid (thatCaller.rc());
 
1027
    AutoCaller thatCaller(aThat);
 
1028
    AssertComRCReturnVoid(thatCaller.rc());
1033
1029
 
1034
1030
    /* peer is not modified, lock it for reading (aThat is "master" so locked
1035
1031
     * first) */
1037
1033
    AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
1038
1034
 
1039
1035
    /* this will back up current data */
1040
 
    mData.assignCopy (aThat->mData);
 
1036
    mData.assignCopy(aThat->mData);
1041
1037
}
1042
1038
/* vi: set tabstop=4 shiftwidth=4 expandtab: */