VirtualBox

source: vbox/trunk/src/VBox/Main/include/VirtualBoxImpl.h@ 86127

Last change on this file since 86127 was 86069, checked in by vboxsync, 5 years ago

OCI: Make ICloudProviderRegisteredEvent a non-waitable notification
sent after the fact. Introduce separate ICloudProviderUninstallEvent
sent before unistallation attempt, waitable. Introduce separate
ICloudProviderListChangedEvent that is sent when we are done with all
the extpack providers and the list of providers can be re-read.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.1 KB
Line 
1/* $Id: VirtualBoxImpl.h 86069 2020-09-09 03:03:23Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef MAIN_INCLUDED_VirtualBoxImpl_h
19#define MAIN_INCLUDED_VirtualBoxImpl_h
20#ifndef RT_WITHOUT_PRAGMA_ONCE
21# pragma once
22#endif
23
24#include "VirtualBoxBase.h"
25#include "objectslist.h"
26#include "VirtualBoxWrap.h"
27
28#ifdef RT_OS_WINDOWS
29# include "win/resource.h"
30#endif
31
32//#ifdef DEBUG_bird
33//# define VBOXSVC_WITH_CLIENT_WATCHER
34//#endif
35
36namespace com
37{
38 class Event;
39 class EventQueue;
40}
41
42class SessionMachine;
43class GuestOSType;
44class Progress;
45class Host;
46class SystemProperties;
47class DHCPServer;
48class PerformanceCollector;
49class CloudProviderManager;
50#ifdef VBOX_WITH_EXTPACK
51class ExtPackManager;
52#endif
53class AutostartDb;
54class NATNetwork;
55#ifdef VBOX_WITH_CLOUD_NET
56class CloudNetwork;
57#endif /* VBOX_WITH_CLOUD_NET */
58
59
60typedef std::list<ComObjPtr<SessionMachine> > SessionMachinesList;
61
62#ifdef RT_OS_WINDOWS
63class SVCHlpClient;
64#endif
65
66namespace settings
67{
68 class MainConfigFile;
69 struct MediaRegistry;
70}
71
72
73#if defined(VBOX_WITH_SDS) && !defined(VBOX_WITH_XPCOM)
74class VirtualBoxClassFactory; /* See ../src-server/win/svcmain.cpp */
75#endif
76
77#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
78struct SharedClipboardAreaData;
79#endif
80
81class ATL_NO_VTABLE VirtualBox :
82 public VirtualBoxWrap
83#ifdef RT_OS_WINDOWS
84 , public ATL::CComCoClass<VirtualBox, &CLSID_VirtualBox>
85#endif
86{
87
88public:
89
90 typedef std::list<ComPtr<IInternalSessionControl> > InternalControlList;
91 typedef ObjectsList<Machine> MachinesOList;
92
93#if 0 /* obsoleted by AsyncEvent */
94 class CallbackEvent;
95 friend class CallbackEvent;
96#endif
97 class AsyncEvent;
98 friend class AsyncEvent;
99
100#ifndef VBOX_WITH_XPCOM
101# ifdef VBOX_WITH_SDS
102 DECLARE_CLASSFACTORY_EX(VirtualBoxClassFactory)
103# else
104 DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
105# endif
106#endif
107
108 // Do not use any ATL registry support.
109 //DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
110
111 // Kind of redundant (VirtualBoxWrap declares itself not aggregatable and
112 // CComCoClass<VirtualBox, &CLSID_VirtualBox> as aggregatable, the former
113 // is the first inheritance), but the C++ multiple inheritance rules and
114 // the class factory in svcmain.cpp needs this to disambiguate.
115 DECLARE_NOT_AGGREGATABLE(VirtualBox)
116
117 // to postpone generation of the default ctor/dtor
118 DECLARE_EMPTY_CTOR_DTOR(VirtualBox)
119
120 HRESULT FinalConstruct();
121 void FinalRelease();
122
123 // public initializer/uninitializer for internal purposes only
124 HRESULT init();
125 HRESULT initMachines();
126 HRESULT initMedia(const Guid &uuidMachineRegistry,
127 const settings::MediaRegistry &mediaRegistry,
128 const Utf8Str &strMachineFolder);
129 void uninit();
130
131 // public methods only for internal purposes
132
133 /**
134 * Override of the default locking class to be used for validating lock
135 * order with the standard member lock handle.
136 */
137 virtual VBoxLockingClass getLockingClass() const
138 {
139 return LOCKCLASS_VIRTUALBOXOBJECT;
140 }
141
142#ifdef DEBUG
143 void i_dumpAllBackRefs();
144#endif
145
146 HRESULT i_postEvent(Event *event);
147
148 HRESULT i_addProgress(IProgress *aProgress);
149 HRESULT i_removeProgress(IN_GUID aId);
150
151#ifdef RT_OS_WINDOWS
152 typedef DECLCALLBACKPTR(HRESULT, SVCHelperClientFunc,(SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc));
153 HRESULT i_startSVCHelperClient(bool aPrivileged,
154 SVCHelperClientFunc aFunc,
155 void *aUser, Progress *aProgress);
156#endif
157
158 void i_addProcessToReap(RTPROCESS pid);
159 void i_updateClientWatcher();
160
161 int i_loadVDPlugin(const char *pszPluginLibrary);
162 int i_unloadVDPlugin(const char *pszPluginLibrary);
163
164 void i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, const BOOL aRegistered);
165 void i_onMediumConfigChanged(IMedium *aMedium);
166 void i_onMediumChanged(IMediumAttachment* aMediumAttachment);
167 void i_onStorageControllerChanged(const Guid &aMachineId, const com::Utf8Str &aControllerName);
168 void i_onStorageDeviceChanged(IMediumAttachment* aStorageDevice, const BOOL fRemoved, const BOOL fSilent);
169 void i_onMachineStateChanged(const Guid &aId, MachineState_T aState);
170 void i_onMachineDataChanged(const Guid &aId, BOOL aTemporary = FALSE);
171 BOOL i_onExtraDataCanChange(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue, Bstr &aError);
172 void i_onExtraDataChanged(const Guid &aId, const Utf8Str &aKey, const Utf8Str &aValue);
173 void i_onMachineRegistered(const Guid &aId, BOOL aRegistered);
174 void i_onSessionStateChanged(const Guid &aId, SessionState_T aState);
175
176 void i_onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId);
177 void i_onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId);
178 void i_onSnapshotRestored(const Guid &aMachineId, const Guid &aSnapshotId);
179 void i_onSnapshotChanged(const Guid &aMachineId, const Guid &aSnapshotId);
180
181#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
182 int i_clipboardAreaCreate(ULONG uAreaID, uint32_t fFlags, SharedClipboardAreaData **ppAreaData);
183 int i_clipboardAreaDestroy(SharedClipboardAreaData *pAreaData);
184
185 HRESULT i_onClipboardAreaRegister(const std::vector<com::Utf8Str> &aParms, ULONG *aID);
186 HRESULT i_onClipboardAreaUnregister(ULONG aID);
187 HRESULT i_onClipboardAreaAttach(ULONG aID);
188 HRESULT i_onClipboardAreaDetach(ULONG aID);
189 ULONG i_onClipboardAreaGetMostRecent(void);
190 ULONG i_onClipboardAreaGetRefCount(ULONG aID);
191#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
192
193 void i_onGuestPropertyChanged(const Guid &aMachineId, const Utf8Str &aName, const Utf8Str &aValue, const Utf8Str &aFlags);
194 void i_onNatRedirectChanged(const Guid &aMachineId, ULONG ulSlot, bool fRemove, const Utf8Str &aName,
195 NATProtocol_T aProto, const Utf8Str &aHostIp, uint16_t aHostPort,
196 const Utf8Str &aGuestIp, uint16_t aGuestPort);
197 void i_onNATNetworkChanged(const Utf8Str &aNetworkName);
198 void i_onNATNetworkStartStop(const Utf8Str &aNetworkName, BOOL aStart);
199 void i_onNATNetworkSetting(const Utf8Str &aNetworkName, BOOL aEnabled, const Utf8Str &aNetwork,
200 const Utf8Str &aGateway, BOOL aAdvertiseDefaultIpv6RouteEnabled,
201 BOOL fNeedDhcpServer);
202 void i_onNATNetworkPortForward(const Utf8Str &aNetworkName, BOOL create, BOOL fIpv6,
203 const Utf8Str &aRuleName, NATProtocol_T proto,
204 const Utf8Str &aHostIp, LONG aHostPort,
205 const Utf8Str &aGuestIp, LONG aGuestPort);
206 void i_onHostNameResolutionConfigurationChange();
207
208 int i_natNetworkRefInc(const Utf8Str &aNetworkName);
209 int i_natNetworkRefDec(const Utf8Str &aNetworkName);
210
211 void i_onCloudProviderListChanged(BOOL aRegistered);
212 void i_onCloudProviderRegistered(const Utf8Str &aProviderId, BOOL aRegistered);
213 void i_onCloudProviderUninstall(const Utf8Str &aProviderId);
214
215#ifdef VBOX_WITH_CLOUD_NET
216 HRESULT i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
217 ComObjPtr<CloudNetwork> *aNetwork = NULL);
218 HRESULT i_getEventSource(ComPtr<IEventSource>& aSource);
219#endif /* VBOX_WITH_CLOUD_NET */
220
221 ComObjPtr<GuestOSType> i_getUnknownOSType();
222
223 void i_getOpenedMachines(SessionMachinesList &aMachines,
224 InternalControlList *aControls = NULL);
225 MachinesOList &i_getMachinesList();
226
227 HRESULT i_findMachine(const Guid &aId,
228 bool fPermitInaccessible,
229 bool aSetError,
230 ComObjPtr<Machine> *aMachine = NULL);
231
232 HRESULT i_findMachineByName(const Utf8Str &aName,
233 bool aSetError,
234 ComObjPtr<Machine> *aMachine = NULL);
235
236 HRESULT i_validateMachineGroup(const com::Utf8Str &aGroup, bool fPrimary);
237 HRESULT i_convertMachineGroups(const std::vector<com::Utf8Str> aMachineGroups, StringsList *pllMachineGroups);
238
239 HRESULT i_findHardDiskById(const Guid &id,
240 bool aSetError,
241 ComObjPtr<Medium> *aHardDisk = NULL);
242 HRESULT i_findHardDiskByLocation(const Utf8Str &strLocation,
243 bool aSetError,
244 ComObjPtr<Medium> *aHardDisk = NULL);
245 HRESULT i_findDVDOrFloppyImage(DeviceType_T mediumType,
246 const Guid *aId,
247 const Utf8Str &aLocation,
248 bool aSetError,
249 ComObjPtr<Medium> *aImage = NULL);
250 HRESULT i_findRemoveableMedium(DeviceType_T mediumType,
251 const Guid &uuid,
252 bool fRefresh,
253 bool aSetError,
254 ComObjPtr<Medium> &pMedium);
255
256 HRESULT i_findGuestOSType(const Utf8Str &strOSType,
257 ComObjPtr<GuestOSType> &guestOSType);
258
259 const Guid &i_getGlobalRegistryId() const;
260
261 const ComObjPtr<Host> &i_host() const;
262 SystemProperties *i_getSystemProperties() const;
263 CloudProviderManager *i_getCloudProviderManager() const;
264#ifdef VBOX_WITH_EXTPACK
265 ExtPackManager *i_getExtPackManager() const;
266#endif
267#ifdef VBOX_WITH_RESOURCE_USAGE_API
268 const ComObjPtr<PerformanceCollector> &i_performanceCollector() const;
269#endif /* VBOX_WITH_RESOURCE_USAGE_API */
270
271 void i_getDefaultMachineFolder(Utf8Str &str) const;
272 void i_getDefaultHardDiskFormat(Utf8Str &str) const;
273
274 /** Returns the VirtualBox home directory */
275 const Utf8Str &i_homeDir() const;
276 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
277 void i_copyPathRelativeToConfig(const Utf8Str &strSource, Utf8Str &strTarget);
278 HRESULT i_registerMedium(const ComObjPtr<Medium> &pMedium, ComObjPtr<Medium> *ppMedium,
279 AutoWriteLock &mediaTreeLock);
280 HRESULT i_unregisterMedium(Medium *pMedium);
281 void i_pushMediumToListWithChildren(MediaList &llMedia, Medium *pMedium);
282 HRESULT i_unregisterMachineMedia(const Guid &id);
283 HRESULT i_unregisterMachine(Machine *pMachine, const Guid &id);
284 void i_rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
285 const Utf8Str &strNewConfigDir);
286 void i_saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
287 const Guid &uuidRegistry,
288 const Utf8Str &strMachineFolder);
289 HRESULT i_saveSettings();
290 void i_markRegistryModified(const Guid &uuid);
291 void i_unmarkRegistryModified(const Guid &uuid);
292 void i_saveModifiedRegistries();
293 static const com::Utf8Str &i_getVersionNormalized();
294 static HRESULT i_ensureFilePathExists(const Utf8Str &strFileName, bool fCreate);
295 const Utf8Str& i_settingsFilePath();
296 AutostartDb* i_getAutostartDb() const;
297 RWLockHandle& i_getMachinesListLockHandle();
298 RWLockHandle& i_getMediaTreeLockHandle();
299 int i_encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext);
300 int i_decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext);
301 void i_storeSettingsKey(const Utf8Str &aKey);
302 bool i_isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType);
303
304
305
306private:
307 class ClientWatcher;
308
309 // wrapped IVirtualBox properties
310 HRESULT getVersion(com::Utf8Str &aVersion);
311 HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized);
312 HRESULT getRevision(ULONG *aRevision);
313 HRESULT getPackageType(com::Utf8Str &aPackageType);
314 HRESULT getAPIVersion(com::Utf8Str &aAPIVersion);
315 HRESULT getAPIRevision(LONG64 *aAPIRevision);
316 HRESULT getHomeFolder(com::Utf8Str &aHomeFolder);
317 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
318 HRESULT getHost(ComPtr<IHost> &aHost);
319 HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties);
320 HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines);
321 HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups);
322 HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks);
323 HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages);
324 HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages);
325 HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations);
326 HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes);
327 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
328 HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector);
329 HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers);
330 HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks);
331 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
332 HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager);
333 HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
334 HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
335 HRESULT getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks);
336 HRESULT getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager);
337
338 // wrapped IVirtualBox methods
339 HRESULT composeMachineFilename(const com::Utf8Str &aName,
340 const com::Utf8Str &aGroup,
341 const com::Utf8Str &aCreateFlags,
342 const com::Utf8Str &aBaseFolder,
343 com::Utf8Str &aFile);
344 HRESULT createMachine(const com::Utf8Str &aSettingsFile,
345 const com::Utf8Str &aName,
346 const std::vector<com::Utf8Str> &aGroups,
347 const com::Utf8Str &aOsTypeId,
348 const com::Utf8Str &aFlags,
349 ComPtr<IMachine> &aMachine);
350 HRESULT openMachine(const com::Utf8Str &aSettingsFile,
351 ComPtr<IMachine> &aMachine);
352 HRESULT registerMachine(const ComPtr<IMachine> &aMachine);
353 HRESULT findMachine(const com::Utf8Str &aNameOrId,
354 ComPtr<IMachine> &aMachine);
355 HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
356 std::vector<ComPtr<IMachine> > &aMachines);
357 HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
358 std::vector<MachineState_T> &aStates);
359 HRESULT createAppliance(ComPtr<IAppliance> &aAppliance);
360 HRESULT createUnattendedInstaller(ComPtr<IUnattended> &aUnattended);
361 HRESULT createMedium(const com::Utf8Str &aFormat,
362 const com::Utf8Str &aLocation,
363 AccessMode_T aAccessMode,
364 DeviceType_T aDeviceType,
365 ComPtr<IMedium> &aMedium);
366 HRESULT openMedium(const com::Utf8Str &aLocation,
367 DeviceType_T aDeviceType,
368 AccessMode_T aAccessMode,
369 BOOL aForceNewUuid,
370 ComPtr<IMedium> &aMedium);
371 HRESULT getGuestOSType(const com::Utf8Str &aId,
372 ComPtr<IGuestOSType> &aType);
373 HRESULT createSharedFolder(const com::Utf8Str &aName,
374 const com::Utf8Str &aHostPath,
375 BOOL aWritable,
376 BOOL aAutomount,
377 const com::Utf8Str &aAutoMountPoint);
378 HRESULT removeSharedFolder(const com::Utf8Str &aName);
379 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
380 HRESULT getExtraData(const com::Utf8Str &aKey,
381 com::Utf8Str &aValue);
382 HRESULT setExtraData(const com::Utf8Str &aKey,
383 const com::Utf8Str &aValue);
384 HRESULT setSettingsSecret(const com::Utf8Str &aPassword);
385 HRESULT createDHCPServer(const com::Utf8Str &aName,
386 ComPtr<IDHCPServer> &aServer);
387 HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
388 ComPtr<IDHCPServer> &aServer);
389 HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer);
390 HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
391 ComPtr<INATNetwork> &aNetwork);
392 HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
393 ComPtr<INATNetwork> &aNetwork);
394 HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
395 HRESULT createCloudNetwork(const com::Utf8Str &aNetworkName,
396 ComPtr<ICloudNetwork> &aNetwork);
397 HRESULT findCloudNetworkByName(const com::Utf8Str &aNetworkName,
398 ComPtr<ICloudNetwork> &aNetwork);
399 HRESULT removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork);
400 HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
401 const com::Utf8Str &aVersion,
402 com::Utf8Str &aUrl,
403 com::Utf8Str &aFile,
404 BOOL *aResult);
405
406 static HRESULT i_setErrorStaticBoth(HRESULT aResultCode, int vrc, const Utf8Str &aText)
407 {
408 return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true, vrc);
409 }
410
411 HRESULT i_registerMachine(Machine *aMachine);
412 HRESULT i_registerDHCPServer(DHCPServer *aDHCPServer,
413 bool aSaveRegistry = true);
414 HRESULT i_unregisterDHCPServer(DHCPServer *aDHCPServer);
415 HRESULT i_registerNATNetwork(NATNetwork *aNATNetwork,
416 bool aSaveRegistry = true);
417 HRESULT i_unregisterNATNetwork(NATNetwork *aNATNetwork,
418 bool aSaveRegistry = true);
419 HRESULT i_checkMediaForConflicts(const Guid &aId,
420 const Utf8Str &aLocation,
421 Utf8Str &aConflictType,
422 ComObjPtr<Medium> *pDupMedium);
423 int i_decryptSettings();
424 int i_decryptMediumSettings(Medium *pMedium);
425 int i_decryptSettingBytes(uint8_t *aPlaintext,
426 const uint8_t *aCiphertext,
427 size_t aCiphertextSize) const;
428 int i_encryptSettingBytes(const uint8_t *aPlaintext,
429 uint8_t *aCiphertext,
430 size_t aPlaintextSize,
431 size_t aCiphertextSize) const;
432 void i_reportDriverVersions(void);
433
434 struct Data; // opaque data structure, defined in VirtualBoxImpl.cpp
435
436 Data *m;
437
438 /* static variables (defined in VirtualBoxImpl.cpp) */
439 static com::Utf8Str sVersion;
440 static com::Utf8Str sVersionNormalized;
441 static ULONG sRevision;
442 static com::Utf8Str sPackageType;
443 static com::Utf8Str sAPIVersion;
444 static std::map<com::Utf8Str, int> sNatNetworkNameToRefCount;
445 static RWLockHandle* spMtxNatNetworkNameToRefCountLock;
446
447 static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
448
449#ifdef RT_OS_WINDOWS
450 friend class StartSVCHelperClientData;
451 static void i_SVCHelperClientThreadTask(StartSVCHelperClientData *pTask);
452#endif
453
454#if defined(RT_OS_WINDOWS) && defined(VBOXSVC_WITH_CLIENT_WATCHER)
455protected:
456 void i_callHook(const char *a_pszFunction) RT_OVERRIDE;
457 bool i_watchClientProcess(RTPROCESS a_pidClient, const char *a_pszFunction);
458public:
459 static void i_logCaller(const char *a_pszFormat, ...);
460private:
461
462#endif
463};
464
465////////////////////////////////////////////////////////////////////////////////
466
467#endif /* !MAIN_INCLUDED_VirtualBoxImpl_h */
468
Note: See TracBrowser for help on using the repository browser.

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