VirtualBox

source: vbox/trunk/src/VBox/Main/SystemPropertiesImpl.cpp@ 17871

Last change on this file since 17871 was 16569, checked in by vboxsync, 16 years ago

Main: API support for the CPU count contrains.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.4 KB
Line 
1/* $Id: SystemPropertiesImpl.cpp 16569 2009-02-09 08:59:58Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2006-2008 Sun Microsystems, Inc.
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20 * Clara, CA 95054 USA or visit http://www.sun.com if you need
21 * additional information or have any questions.
22 */
23
24#include "SystemPropertiesImpl.h"
25#include "VirtualBoxImpl.h"
26#include "MachineImpl.h"
27#include "Logging.h"
28
29// generated header
30#include "SchemaDefs.h"
31
32#include <iprt/path.h>
33#include <iprt/dir.h>
34
35#include <VBox/err.h>
36#include <VBox/param.h>
37#include <VBox/settings.h>
38
39// defines
40/////////////////////////////////////////////////////////////////////////////
41
42// constructor / destructor
43/////////////////////////////////////////////////////////////////////////////
44
45DEFINE_EMPTY_CTOR_DTOR (SystemProperties)
46
47HRESULT SystemProperties::FinalConstruct()
48{
49 return S_OK;
50}
51
52void SystemProperties::FinalRelease()
53{
54 uninit ();
55}
56
57// public methods only for internal purposes
58/////////////////////////////////////////////////////////////////////////////
59
60/**
61 * Initializes the system information object.
62 *
63 * @returns COM result indicator
64 */
65HRESULT SystemProperties::init (VirtualBox *aParent)
66{
67 LogFlowThisFunc (("aParent=%p\n", aParent));
68
69 ComAssertRet (aParent, E_FAIL);
70
71 /* Enclose the state transition NotReady->InInit->Ready */
72 AutoInitSpan autoInitSpan (this);
73 AssertReturn (autoInitSpan.isOk(), E_FAIL);
74
75 unconst (mParent) = aParent;
76
77 setDefaultMachineFolder (NULL);
78 setDefaultHardDiskFolder (NULL);
79 setDefaultHardDiskFormat (NULL);
80
81 setRemoteDisplayAuthLibrary (NULL);
82
83 mHWVirtExEnabled = false;
84 mLogHistoryCount = 3;
85
86 HRESULT rc = S_OK;
87
88 /* Fetch info of all available hd backends. */
89
90 /// @todo NEWMEDIA VDBackendInfo needs to be improved to let us enumerate
91 /// any number of backends
92
93 /// @todo We currently leak memory because it's not actually clear what to
94 /// free in structures returned by VDBackendInfo. Must be fixed ASAP!
95
96 VDBACKENDINFO aVDInfo [100];
97 unsigned cEntries;
98 int vrc = VDBackendInfo (RT_ELEMENTS (aVDInfo), aVDInfo, &cEntries);
99 AssertRC (vrc);
100 if (RT_SUCCESS (vrc))
101 {
102 for (unsigned i = 0; i < cEntries; ++ i)
103 {
104 ComObjPtr <HardDiskFormat> hdf;
105 rc = hdf.createObject();
106 CheckComRCBreakRC (rc);
107
108 rc = hdf->init (&aVDInfo [i]);
109 CheckComRCBreakRC (rc);
110
111 mHardDiskFormats.push_back (hdf);
112 }
113 }
114
115 /* Confirm a successful initialization */
116 if (SUCCEEDED (rc))
117 autoInitSpan.setSucceeded();
118
119 return rc;
120}
121
122/**
123 * Uninitializes the instance and sets the ready flag to FALSE.
124 * Called either from FinalRelease() or by the parent when it gets destroyed.
125 */
126void SystemProperties::uninit()
127{
128 LogFlowThisFunc (("\n"));
129
130 /* Enclose the state transition Ready->InUninit->NotReady */
131 AutoUninitSpan autoUninitSpan (this);
132 if (autoUninitSpan.uninitDone())
133 return;
134
135 unconst (mParent).setNull();
136}
137
138// ISystemProperties properties
139/////////////////////////////////////////////////////////////////////////////
140
141
142STDMETHODIMP SystemProperties::COMGETTER(MinGuestRAM)(ULONG *minRAM)
143{
144 if (!minRAM)
145 return E_POINTER;
146
147 AutoCaller autoCaller (this);
148 CheckComRCReturnRC (autoCaller.rc());
149
150 /* no need to lock, this is const */
151 *minRAM = SchemaDefs::MinGuestRAM;
152
153 return S_OK;
154}
155
156STDMETHODIMP SystemProperties::COMGETTER(MaxGuestRAM)(ULONG *maxRAM)
157{
158 if (!maxRAM)
159 return E_POINTER;
160
161 AutoCaller autoCaller (this);
162 CheckComRCReturnRC (autoCaller.rc());
163
164 /* no need to lock, this is const */
165 *maxRAM = SchemaDefs::MaxGuestRAM;
166
167 return S_OK;
168}
169
170STDMETHODIMP SystemProperties::COMGETTER(MinGuestVRAM)(ULONG *minVRAM)
171{
172 if (!minVRAM)
173 return E_POINTER;
174
175 AutoCaller autoCaller (this);
176 CheckComRCReturnRC (autoCaller.rc());
177
178 /* no need to lock, this is const */
179 *minVRAM = SchemaDefs::MinGuestVRAM;
180
181 return S_OK;
182}
183
184STDMETHODIMP SystemProperties::COMGETTER(MaxGuestVRAM)(ULONG *maxVRAM)
185{
186 if (!maxVRAM)
187 return E_POINTER;
188
189 AutoCaller autoCaller (this);
190 CheckComRCReturnRC (autoCaller.rc());
191
192 /* no need to lock, this is const */
193 *maxVRAM = SchemaDefs::MaxGuestVRAM;
194
195 return S_OK;
196}
197
198STDMETHODIMP SystemProperties::COMGETTER(MinGuestCPUCount)(ULONG *minCPUCount)
199{
200 if (!minCPUCount)
201 return E_POINTER;
202
203 AutoCaller autoCaller (this);
204 CheckComRCReturnRC (autoCaller.rc());
205
206 /* no need to lock, this is const */
207 *minCPUCount = SchemaDefs::MinCPUCount;
208
209 return S_OK;
210}
211
212STDMETHODIMP SystemProperties::COMGETTER(MaxGuestCPUCount)(ULONG *maxCPUCount)
213{
214 if (!maxCPUCount)
215 return E_POINTER;
216
217 AutoCaller autoCaller (this);
218 CheckComRCReturnRC (autoCaller.rc());
219
220 /* no need to lock, this is const */
221 *maxCPUCount = 1; // SchemaDefs::MaxCPUCount;
222
223 return S_OK;
224}
225
226STDMETHODIMP SystemProperties::COMGETTER(MaxGuestMonitors)(ULONG *maxMonitors)
227{
228 if (!maxMonitors)
229 return E_POINTER;
230
231 AutoCaller autoCaller (this);
232 CheckComRCReturnRC (autoCaller.rc());
233
234 /* no need to lock, this is const */
235 *maxMonitors = SchemaDefs::MaxGuestMonitors;
236
237 return S_OK;
238}
239
240STDMETHODIMP SystemProperties::COMGETTER(MaxVDISize)(ULONG64 *maxVDISize)
241{
242 if (!maxVDISize)
243 return E_POINTER;
244
245 AutoCaller autoCaller (this);
246 CheckComRCReturnRC (autoCaller.rc());
247
248 /** The BIOS supports currently 32 bit LBA numbers (implementing the full
249 * 48 bit range is in theory trivial, but the crappy compiler makes things
250 * more difficult). This translates to almost 2 TBytes (to be on the safe
251 * side, the reported limit is 1 MiByte less than that, as the total number
252 * of sectors should fit in 32 bits, too), which should bei enough for
253 * the moment. The virtual ATA disks support complete LBA48 (although for
254 * example iSCSI is also currently limited to 32 bit LBA), so the
255 * theoretical maximum disk size is 128 PiByte. The user interface cannot
256 * cope with this in a reasonable way yet. */
257 /* no need to lock, this is const */
258 *maxVDISize = 2048 * 1024 - 1;
259
260 return S_OK;
261}
262
263STDMETHODIMP SystemProperties::COMGETTER(NetworkAdapterCount)(ULONG *count)
264{
265 if (!count)
266 return E_POINTER;
267
268 AutoCaller autoCaller (this);
269 CheckComRCReturnRC (autoCaller.rc());
270
271 /* no need to lock, this is const */
272 *count = SchemaDefs::NetworkAdapterCount;
273
274 return S_OK;
275}
276
277STDMETHODIMP SystemProperties::COMGETTER(SerialPortCount)(ULONG *count)
278{
279 if (!count)
280 return E_POINTER;
281
282 AutoCaller autoCaller (this);
283 CheckComRCReturnRC (autoCaller.rc());
284
285 /* no need to lock, this is const */
286 *count = SchemaDefs::SerialPortCount;
287
288 return S_OK;
289}
290
291STDMETHODIMP SystemProperties::COMGETTER(ParallelPortCount)(ULONG *count)
292{
293 if (!count)
294 return E_POINTER;
295
296 AutoCaller autoCaller (this);
297 CheckComRCReturnRC (autoCaller.rc());
298
299 /* no need to lock, this is const */
300 *count = SchemaDefs::ParallelPortCount;
301
302 return S_OK;
303}
304
305STDMETHODIMP SystemProperties::COMGETTER(MaxBootPosition)(ULONG *aMaxBootPosition)
306{
307 CheckComArgOutPointerValid(aMaxBootPosition);
308
309 AutoCaller autoCaller (this);
310 CheckComRCReturnRC (autoCaller.rc());
311
312 /* no need to lock, this is const */
313 *aMaxBootPosition = SchemaDefs::MaxBootPosition;
314
315 return S_OK;
316}
317
318STDMETHODIMP SystemProperties::COMGETTER(DefaultMachineFolder) (BSTR *aDefaultMachineFolder)
319{
320 CheckComArgOutPointerValid(aDefaultMachineFolder);
321
322 AutoCaller autoCaller (this);
323 CheckComRCReturnRC (autoCaller.rc());
324
325 AutoReadLock alock (this);
326
327 mDefaultMachineFolderFull.cloneTo (aDefaultMachineFolder);
328
329 return S_OK;
330}
331
332STDMETHODIMP SystemProperties::COMSETTER(DefaultMachineFolder) (IN_BSTR aDefaultMachineFolder)
333{
334 AutoCaller autoCaller (this);
335 CheckComRCReturnRC (autoCaller.rc());
336
337 /* VirtualBox::saveSettings() needs a write lock */
338 AutoMultiWriteLock2 alock (mParent, this);
339
340 HRESULT rc = setDefaultMachineFolder (aDefaultMachineFolder);
341 if (SUCCEEDED (rc))
342 rc = mParent->saveSettings();
343
344 return rc;
345}
346
347STDMETHODIMP SystemProperties::COMGETTER(DefaultHardDiskFolder) (BSTR *aDefaultHardDiskFolder)
348{
349 CheckComArgOutPointerValid(aDefaultHardDiskFolder);
350
351 AutoCaller autoCaller (this);
352 CheckComRCReturnRC (autoCaller.rc());
353
354 AutoReadLock alock (this);
355
356 mDefaultHardDiskFolderFull.cloneTo (aDefaultHardDiskFolder);
357
358 return S_OK;
359}
360
361STDMETHODIMP SystemProperties::COMSETTER(DefaultHardDiskFolder) (IN_BSTR aDefaultHardDiskFolder)
362{
363 AutoCaller autoCaller (this);
364 CheckComRCReturnRC (autoCaller.rc());
365
366 /* VirtualBox::saveSettings() needs a write lock */
367 AutoMultiWriteLock2 alock (mParent, this);
368
369 HRESULT rc = setDefaultHardDiskFolder (aDefaultHardDiskFolder);
370 if (SUCCEEDED (rc))
371 rc = mParent->saveSettings();
372
373 return rc;
374}
375
376STDMETHODIMP SystemProperties::
377COMGETTER(HardDiskFormats) (ComSafeArrayOut (IHardDiskFormat *, aHardDiskFormats))
378{
379 if (ComSafeArrayOutIsNull (aHardDiskFormats))
380 return E_POINTER;
381
382 AutoCaller autoCaller (this);
383 CheckComRCReturnRC (autoCaller.rc());
384
385 AutoReadLock alock (this);
386
387 SafeIfaceArray <IHardDiskFormat> hardDiskFormats (mHardDiskFormats);
388 hardDiskFormats.detachTo (ComSafeArrayOutArg (aHardDiskFormats));
389
390 return S_OK;
391}
392
393STDMETHODIMP SystemProperties::COMGETTER(DefaultHardDiskFormat) (BSTR *aDefaultHardDiskFormat)
394{
395 CheckComArgOutPointerValid(aDefaultHardDiskFormat);
396
397 AutoCaller autoCaller (this);
398 CheckComRCReturnRC (autoCaller.rc());
399
400 AutoReadLock alock (this);
401
402 mDefaultHardDiskFormat.cloneTo (aDefaultHardDiskFormat);
403
404 return S_OK;
405}
406
407STDMETHODIMP SystemProperties::COMSETTER(DefaultHardDiskFormat) (IN_BSTR aDefaultHardDiskFormat)
408{
409 AutoCaller autoCaller (this);
410 CheckComRCReturnRC (autoCaller.rc());
411
412 /* VirtualBox::saveSettings() needs a write lock */
413 AutoMultiWriteLock2 alock (mParent, this);
414
415 HRESULT rc = setDefaultHardDiskFormat (aDefaultHardDiskFormat);
416 if (SUCCEEDED (rc))
417 rc = mParent->saveSettings();
418
419 return rc;
420}
421
422STDMETHODIMP SystemProperties::COMGETTER(RemoteDisplayAuthLibrary) (BSTR *aRemoteDisplayAuthLibrary)
423{
424 CheckComArgOutPointerValid(aRemoteDisplayAuthLibrary);
425
426 AutoCaller autoCaller (this);
427 CheckComRCReturnRC (autoCaller.rc());
428
429 AutoReadLock alock (this);
430
431 mRemoteDisplayAuthLibrary.cloneTo (aRemoteDisplayAuthLibrary);
432
433 return S_OK;
434}
435
436STDMETHODIMP SystemProperties::COMSETTER(RemoteDisplayAuthLibrary) (IN_BSTR aRemoteDisplayAuthLibrary)
437{
438 AutoCaller autoCaller (this);
439 CheckComRCReturnRC (autoCaller.rc());
440
441 /* VirtualBox::saveSettings() needs a write lock */
442 AutoMultiWriteLock2 alock (mParent, this);
443
444 HRESULT rc = setRemoteDisplayAuthLibrary (aRemoteDisplayAuthLibrary);
445 if (SUCCEEDED (rc))
446 rc = mParent->saveSettings();
447
448 return rc;
449}
450
451STDMETHODIMP SystemProperties::COMGETTER(WebServiceAuthLibrary) (BSTR *aWebServiceAuthLibrary)
452{
453 CheckComArgOutPointerValid(aWebServiceAuthLibrary);
454
455 AutoCaller autoCaller (this);
456 CheckComRCReturnRC (autoCaller.rc());
457
458 AutoReadLock alock (this);
459
460 mWebServiceAuthLibrary.cloneTo (aWebServiceAuthLibrary);
461
462 return S_OK;
463}
464
465STDMETHODIMP SystemProperties::COMSETTER(WebServiceAuthLibrary) (IN_BSTR aWebServiceAuthLibrary)
466{
467 AutoCaller autoCaller (this);
468 CheckComRCReturnRC (autoCaller.rc());
469
470 /* VirtualBox::saveSettings() needs a write lock */
471 AutoMultiWriteLock2 alock (mParent, this);
472
473 HRESULT rc = setWebServiceAuthLibrary (aWebServiceAuthLibrary);
474 if (SUCCEEDED (rc))
475 rc = mParent->saveSettings();
476
477 return rc;
478}
479
480STDMETHODIMP SystemProperties::COMGETTER(HWVirtExEnabled) (BOOL *enabled)
481{
482 if (!enabled)
483 return E_POINTER;
484
485 AutoCaller autoCaller (this);
486 CheckComRCReturnRC (autoCaller.rc());
487
488 AutoReadLock alock (this);
489
490 *enabled = mHWVirtExEnabled;
491
492 return S_OK;
493}
494
495STDMETHODIMP SystemProperties::COMSETTER(HWVirtExEnabled) (BOOL enabled)
496{
497 AutoCaller autoCaller (this);
498 CheckComRCReturnRC (autoCaller.rc());
499
500 /* VirtualBox::saveSettings() needs a write lock */
501 AutoMultiWriteLock2 alock (mParent, this);
502
503 mHWVirtExEnabled = enabled;
504
505 HRESULT rc = mParent->saveSettings();
506
507 return rc;
508}
509
510STDMETHODIMP SystemProperties::COMGETTER(LogHistoryCount) (ULONG *count)
511{
512 if (!count)
513 return E_POINTER;
514
515 AutoCaller autoCaller (this);
516 CheckComRCReturnRC (autoCaller.rc());
517
518 AutoReadLock alock (this);
519
520 *count = mLogHistoryCount;
521
522 return S_OK;
523}
524
525STDMETHODIMP SystemProperties::COMSETTER(LogHistoryCount) (ULONG count)
526{
527 AutoCaller autoCaller (this);
528 CheckComRCReturnRC (autoCaller.rc());
529
530 /* VirtualBox::saveSettings() needs a write lock */
531 AutoMultiWriteLock2 alock (mParent, this);
532
533 mLogHistoryCount = count;
534
535 HRESULT rc = mParent->saveSettings();
536
537 return rc;
538}
539
540// public methods only for internal purposes
541/////////////////////////////////////////////////////////////////////////////
542
543HRESULT SystemProperties::loadSettings (const settings::Key &aGlobal)
544{
545 using namespace settings;
546
547 AutoCaller autoCaller (this);
548 CheckComRCReturnRC (autoCaller.rc());
549
550 AutoWriteLock alock (this);
551
552 AssertReturn (!aGlobal.isNull(), E_FAIL);
553
554 HRESULT rc = S_OK;
555
556 Key properties = aGlobal.key ("SystemProperties");
557
558 Bstr bstr;
559
560 bstr = properties.stringValue ("defaultMachineFolder");
561 rc = setDefaultMachineFolder (bstr);
562 CheckComRCReturnRC (rc);
563
564 bstr = properties.stringValue ("defaultHardDiskFolder");
565 rc = setDefaultHardDiskFolder (bstr);
566 CheckComRCReturnRC (rc);
567
568 bstr = properties.stringValue ("defaultHardDiskFormat");
569 rc = setDefaultHardDiskFormat (bstr);
570 CheckComRCReturnRC (rc);
571
572 bstr = properties.stringValue ("remoteDisplayAuthLibrary");
573 rc = setRemoteDisplayAuthLibrary (bstr);
574 CheckComRCReturnRC (rc);
575
576 bstr = properties.stringValue ("webServiceAuthLibrary");
577 rc = setWebServiceAuthLibrary (bstr);
578 CheckComRCReturnRC (rc);
579
580 /* Note: not <BOOL> because Win32 defines BOOL as int */
581 mHWVirtExEnabled = properties.valueOr <bool> ("HWVirtExEnabled", false);
582
583 mLogHistoryCount = properties.valueOr <ULONG> ("LogHistoryCount", 3);
584
585 return S_OK;
586}
587
588HRESULT SystemProperties::saveSettings (settings::Key &aGlobal)
589{
590 using namespace settings;
591
592 AutoCaller autoCaller (this);
593 CheckComRCReturnRC (autoCaller.rc());
594
595 AutoReadLock alock (this);
596
597 ComAssertRet (!aGlobal.isNull(), E_FAIL);
598
599 /* first, delete the entry */
600 Key properties = aGlobal.findKey ("SystemProperties");
601 if (!properties.isNull())
602 properties.zap();
603 /* then, recreate it */
604 properties = aGlobal.createKey ("SystemProperties");
605
606 if (mDefaultMachineFolder)
607 properties.setValue <Bstr> ("defaultMachineFolder", mDefaultMachineFolder);
608
609 if (mDefaultHardDiskFolder)
610 properties.setValue <Bstr> ("defaultHardDiskFolder", mDefaultHardDiskFolder);
611
612 if (mDefaultHardDiskFormat)
613 properties.setValue <Bstr> ("defaultHardDiskFormat", mDefaultHardDiskFormat);
614
615 if (mRemoteDisplayAuthLibrary)
616 properties.setValue <Bstr> ("remoteDisplayAuthLibrary", mRemoteDisplayAuthLibrary);
617
618 if (mWebServiceAuthLibrary)
619 properties.setValue <Bstr> ("webServiceAuthLibrary", mWebServiceAuthLibrary);
620
621 properties.setValue <bool> ("HWVirtExEnabled", !!mHWVirtExEnabled);
622
623 properties.setValue <ULONG> ("LogHistoryCount", mLogHistoryCount);
624
625 return S_OK;
626}
627
628/**
629 * Rerurns a hard disk format object corresponding to the given format
630 * identifier or null if no such format.
631 *
632 * @param aFormat Format identifier.
633 *
634 * @return ComObjPtr<HardDiskFormat>
635 */
636ComObjPtr <HardDiskFormat> SystemProperties::hardDiskFormat (CBSTR aFormat)
637{
638 ComObjPtr <HardDiskFormat> format;
639
640 AutoCaller autoCaller (this);
641 AssertComRCReturn (autoCaller.rc(), format);
642
643 AutoReadLock alock (this);
644
645 for (HardDiskFormatList::const_iterator it = mHardDiskFormats.begin();
646 it != mHardDiskFormats.end(); ++ it)
647 {
648 /* HardDiskFormat is all const, no need to lock */
649
650 if ((*it)->id().compareIgnoreCase (aFormat) == 0)
651 {
652 format = *it;
653 break;
654 }
655 }
656
657 return format;
658}
659
660// private methods
661/////////////////////////////////////////////////////////////////////////////
662
663HRESULT SystemProperties::setDefaultMachineFolder (CBSTR aPath)
664{
665 Utf8Str path;
666 if (aPath && *aPath)
667 path = aPath;
668 else
669 path = "Machines";
670
671 /* get the full file name */
672 Utf8Str folder;
673 int vrc = mParent->calculateFullPath (path, folder);
674 if (RT_FAILURE (vrc))
675 return setError (E_FAIL,
676 tr ("Invalid default machine folder '%ls' (%Rrc)"),
677 path.raw(), vrc);
678
679 mDefaultMachineFolder = path;
680 mDefaultMachineFolderFull = folder;
681
682 return S_OK;
683}
684
685HRESULT SystemProperties::setDefaultHardDiskFolder (CBSTR aPath)
686{
687 Utf8Str path;
688 if (aPath && *aPath)
689 path = aPath;
690 else
691 path = "HardDisks";
692
693 /* get the full file name */
694 Utf8Str folder;
695 int vrc = mParent->calculateFullPath (path, folder);
696 if (RT_FAILURE (vrc))
697 return setError (E_FAIL,
698 tr ("Invalid default hard disk folder '%ls' (%Rrc)"),
699 path.raw(), vrc);
700
701 mDefaultHardDiskFolder = path;
702 mDefaultHardDiskFolderFull = folder;
703
704 return S_OK;
705}
706
707HRESULT SystemProperties::setDefaultHardDiskFormat (CBSTR aFormat)
708{
709 if (aFormat && *aFormat)
710 mDefaultHardDiskFormat = aFormat;
711 else
712 mDefaultHardDiskFormat = "VDI";
713
714 return S_OK;
715}
716
717HRESULT SystemProperties::setRemoteDisplayAuthLibrary (CBSTR aPath)
718{
719 if (aPath && *aPath)
720 mRemoteDisplayAuthLibrary = aPath;
721 else
722 mRemoteDisplayAuthLibrary = "VRDPAuth";
723
724 return S_OK;
725}
726
727HRESULT SystemProperties::setWebServiceAuthLibrary (CBSTR aPath)
728{
729 if (aPath && *aPath)
730 mWebServiceAuthLibrary = aPath;
731 else
732 mWebServiceAuthLibrary = "VRDPAuth";
733
734 return S_OK;
735}
736/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

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