VirtualBox

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

Last change on this file since 14981 was 14949, checked in by vboxsync, 16 years ago

Appended vim modeline to set tabstop and expand tabs (in the way
suggested by our coding guidelines).
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.7 KB
Line 
1/* $Id: VirtualBoxImpl.h 14949 2008-12-03 15:17:16Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2006-2007 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#ifndef ____H_VIRTUALBOXIMPL
25#define ____H_VIRTUALBOXIMPL
26
27#include "VirtualBoxBase.h"
28
29#include "VBox/com/EventQueue.h"
30
31#include <list>
32#include <vector>
33#include <map>
34
35#ifdef RT_OS_WINDOWS
36# include "win/resource.h"
37#endif
38
39#ifdef VBOX_WITH_RESOURCE_USAGE_API
40#include "PerformanceImpl.h"
41#endif /* VBOX_WITH_RESOURCE_USAGE_API */
42
43
44class Machine;
45class SessionMachine;
46class HardDisk2;
47class DVDImage2;
48class FloppyImage2;
49class MachineCollection;
50class GuestOSType;
51class GuestOSTypeCollection;
52class SharedFolder;
53class Progress;
54class ProgressCollection;
55class Host;
56class SystemProperties;
57
58#ifdef RT_OS_WINDOWS
59class SVCHlpClient;
60#endif
61
62struct VMClientWatcherData;
63
64class ATL_NO_VTABLE VirtualBox :
65 public VirtualBoxBaseWithChildrenNEXT,
66 public VirtualBoxSupportErrorInfoImpl <VirtualBox, IVirtualBox>,
67 public VirtualBoxSupportTranslation <VirtualBox>,
68#ifdef RT_OS_WINDOWS
69 public IDispatchImpl<IVirtualBox, &IID_IVirtualBox, &LIBID_VirtualBox,
70 kTypeLibraryMajorVersion, kTypeLibraryMinorVersion>,
71 public CComCoClass<VirtualBox, &CLSID_VirtualBox>
72#else
73 public IVirtualBox
74#endif
75{
76
77public:
78
79 typedef std::list <ComPtr <IVirtualBoxCallback> > CallbackList;
80 typedef std::vector <ComPtr <IVirtualBoxCallback> > CallbackVector;
81
82 typedef std::vector <ComObjPtr <SessionMachine> > SessionMachineVector;
83 typedef std::vector <ComObjPtr <Machine> > MachineVector;
84
85 typedef std::vector <ComPtr <IInternalSessionControl> > InternalControlVector;
86
87 class CallbackEvent;
88 friend class CallbackEvent;
89
90 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (VirtualBox)
91
92 DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
93
94 DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
95 DECLARE_NOT_AGGREGATABLE(VirtualBox)
96
97 DECLARE_PROTECT_FINAL_CONSTRUCT()
98
99 BEGIN_COM_MAP(VirtualBox)
100 COM_INTERFACE_ENTRY(IDispatch)
101 COM_INTERFACE_ENTRY(ISupportErrorInfo)
102 COM_INTERFACE_ENTRY(IVirtualBox)
103 END_COM_MAP()
104
105 NS_DECL_ISUPPORTS
106
107 /* to postpone generation of the default ctor/dtor */
108 VirtualBox();
109 ~VirtualBox();
110
111 HRESULT FinalConstruct();
112 void FinalRelease();
113
114 /* public initializer/uninitializer for internal purposes only */
115 HRESULT init();
116 void uninit();
117
118 /* IVirtualBox properties */
119 STDMETHOD(COMGETTER(Version)) (BSTR *aVersion);
120 STDMETHOD(COMGETTER(Revision)) (ULONG *aRevision);
121 STDMETHOD(COMGETTER(PackageType)) (BSTR *aPackageType);
122 STDMETHOD(COMGETTER(HomeFolder)) (BSTR *aHomeFolder);
123 STDMETHOD(COMGETTER(SettingsFilePath)) (BSTR *aSettingsFilePath);
124 STDMETHOD(COMGETTER(SettingsFileVersion)) (BSTR *aSettingsFileVersion);
125 STDMETHOD(COMGETTER(SettingsFormatVersion)) (BSTR *aSettingsFormatVersion);
126 STDMETHOD(COMGETTER(Host)) (IHost **aHost);
127 STDMETHOD(COMGETTER(SystemProperties)) (ISystemProperties **aSystemProperties);
128 STDMETHOD(COMGETTER(Machines2)) (ComSafeArrayOut (IMachine *, aMachines));
129 STDMETHOD(COMGETTER(HardDisks2)) (ComSafeArrayOut (IHardDisk2 *, aHardDisks));
130 STDMETHOD(COMGETTER(DVDImages)) (ComSafeArrayOut (IDVDImage2 *, aDVDImages));
131 STDMETHOD(COMGETTER(FloppyImages)) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages));
132 STDMETHOD(COMGETTER(ProgressOperations)) (IProgressCollection **aOperations);
133 STDMETHOD(COMGETTER(GuestOSTypes)) (IGuestOSTypeCollection **aGuestOSTypes);
134 STDMETHOD(COMGETTER(SharedFolders)) (ISharedFolderCollection **aSharedFolders);
135 STDMETHOD(COMGETTER(PerformanceCollector)) (IPerformanceCollector **aPerformanceCollector);
136
137 /* IVirtualBox methods */
138
139 STDMETHOD(CreateMachine) (INPTR BSTR aName, INPTR BSTR aOsTypeId, INPTR BSTR aBaseFolder,
140 INPTR GUIDPARAM aId, IMachine **aMachine);
141 STDMETHOD(CreateLegacyMachine) (INPTR BSTR aName, INPTR BSTR aOsTypeId, INPTR BSTR aSettingsFile,
142 INPTR GUIDPARAM aId, IMachine **aMachine);
143 STDMETHOD(OpenMachine) (INPTR BSTR aSettingsFile, IMachine **aMachine);
144 STDMETHOD(RegisterMachine) (IMachine *aMachine);
145 STDMETHOD(GetMachine) (INPTR GUIDPARAM aId, IMachine **aMachine);
146 STDMETHOD(FindMachine) (INPTR BSTR aName, IMachine **aMachine);
147 STDMETHOD(UnregisterMachine) (INPTR GUIDPARAM aId, IMachine **aMachine);
148
149 STDMETHOD(CreateHardDisk2) (INPTR BSTR aFormat, INPTR BSTR aLocation,
150 IHardDisk2 **aHardDisk);
151 STDMETHOD(OpenHardDisk2) (INPTR BSTR aLocation, IHardDisk2 **aHardDisk);
152 STDMETHOD(GetHardDisk2) (INPTR GUIDPARAM aId, IHardDisk2 **aHardDisk);
153 STDMETHOD(FindHardDisk2) (INPTR BSTR aLocation, IHardDisk2 **aHardDisk);
154
155 STDMETHOD(OpenDVDImage) (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
156 IDVDImage2 **aDVDImage);
157 STDMETHOD(GetDVDImage) (INPTR GUIDPARAM aId, IDVDImage2 **aDVDImage);
158 STDMETHOD(FindDVDImage) (INPTR BSTR aLocation, IDVDImage2 **aDVDImage);
159
160 STDMETHOD(OpenFloppyImage) (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
161 IFloppyImage2 **aFloppyImage);
162 STDMETHOD(GetFloppyImage) (INPTR GUIDPARAM aId, IFloppyImage2 **aFloppyImage);
163 STDMETHOD(FindFloppyImage) (INPTR BSTR aLocation, IFloppyImage2 **aFloppyImage);
164
165 STDMETHOD(GetGuestOSType) (INPTR BSTR aId, IGuestOSType **aType);
166 STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable);
167 STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
168 STDMETHOD(GetNextExtraDataKey) (INPTR BSTR aKey, BSTR *aNextKey, BSTR *aNextValue);
169 STDMETHOD(GetExtraData) (INPTR BSTR aKey, BSTR *aValue);
170 STDMETHOD(SetExtraData) (INPTR BSTR aKey, INPTR BSTR aValue);
171 STDMETHOD(OpenSession) (ISession *aSession, INPTR GUIDPARAM aMachineId);
172 STDMETHOD(OpenRemoteSession) (ISession *aSession, INPTR GUIDPARAM aMachineId,
173 INPTR BSTR aType, INPTR BSTR aEnvironment,
174 IProgress **aProgress);
175 STDMETHOD(OpenExistingSession) (ISession *aSession, INPTR GUIDPARAM aMachineId);
176
177 STDMETHOD(RegisterCallback) (IVirtualBoxCallback *aCallback);
178 STDMETHOD(UnregisterCallback) (IVirtualBoxCallback *aCallback);
179
180 STDMETHOD(WaitForPropertyChange) (INPTR BSTR aWhat, ULONG aTimeout,
181 BSTR *aChanged, BSTR *aValues);
182
183 STDMETHOD(SaveSettings)();
184 STDMETHOD(SaveSettingsWithBackup) (BSTR *aBakFileName);
185
186 /* public methods only for internal purposes */
187
188 HRESULT postEvent (Event *event);
189
190 HRESULT addProgress (IProgress *aProgress);
191 HRESULT removeProgress (INPTR GUIDPARAM aId);
192
193#ifdef RT_OS_WINDOWS
194 typedef DECLCALLBACKPTR (HRESULT, SVCHelperClientFunc)
195 (SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc);
196 HRESULT startSVCHelperClient (bool aPrivileged,
197 SVCHelperClientFunc aFunc,
198 void *aUser, Progress *aProgress);
199#endif
200
201 void addProcessToReap (RTPROCESS pid);
202 void updateClientWatcher();
203
204 void onMachineStateChange (const Guid &aId, MachineState_T aState);
205 void onMachineDataChange (const Guid &aId);
206 BOOL onExtraDataCanChange(const Guid &aId, INPTR BSTR aKey, INPTR BSTR aValue,
207 Bstr &aError);
208 void onExtraDataChange(const Guid &aId, INPTR BSTR aKey, INPTR BSTR aValue);
209 void onMachineRegistered (const Guid &aId, BOOL aRegistered);
210 void onSessionStateChange (const Guid &aId, SessionState_T aState);
211
212 void onSnapshotTaken (const Guid &aMachineId, const Guid &aSnapshotId);
213 void onSnapshotDiscarded (const Guid &aMachineId, const Guid &aSnapshotId);
214 void onSnapshotChange (const Guid &aMachineId, const Guid &aSnapshotId);
215 void onGuestPropertyChange (const Guid &aMachineId, INPTR BSTR aName, INPTR BSTR aValue,
216 INPTR BSTR aFlags);
217
218 ComObjPtr <GuestOSType> getUnknownOSType();
219
220 void getOpenedMachines (SessionMachineVector &aMachines,
221 InternalControlVector *aControls = NULL);
222
223 /** Shortcut to #getOpenedMachines (aMachines, &aControls). */
224 void getOpenedMachinesAndControls (SessionMachineVector &aMachines,
225 InternalControlVector &aControls)
226 { getOpenedMachines (aMachines, &aControls); }
227
228 bool isMachineIdValid (const Guid &aId)
229 {
230 return SUCCEEDED (findMachine (aId, false /* aSetError */, NULL));
231 }
232
233 HRESULT findMachine (const Guid &aId, bool aSetError,
234 ComObjPtr <Machine> *machine = NULL);
235
236 HRESULT findHardDisk2 (const Guid *aId, const BSTR aLocation,
237 bool aSetError, ComObjPtr <HardDisk2> *aHardDisk = NULL);
238 HRESULT findDVDImage2 (const Guid *aId, const BSTR aLocation,
239 bool aSetError, ComObjPtr <DVDImage2> *aImage = NULL);
240 HRESULT findFloppyImage2 (const Guid *aId, const BSTR aLocation,
241 bool aSetError, ComObjPtr <FloppyImage2> *aImage = NULL);
242
243 const ComObjPtr <Host> &host() { return mData.mHost; }
244 const ComObjPtr <SystemProperties> &systemProperties()
245 { return mData.mSystemProperties; }
246#ifdef VBOX_WITH_RESOURCE_USAGE_API
247 const ComObjPtr <PerformanceCollector> &performanceCollector()
248 { return mData.mPerformanceCollector; }
249#endif /* VBOX_WITH_RESOURCE_USAGE_API */
250
251
252 /** Returns the VirtualBox home directory */
253 const Utf8Str &homeDir() { return mData.mHomeDir; }
254
255 int calculateFullPath (const char *aPath, Utf8Str &aResult);
256 void calculateRelativePath (const char *aPath, Utf8Str &aResult);
257
258 HRESULT registerHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
259 HRESULT unregisterHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
260
261 HRESULT registerDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
262 HRESULT unregisterDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
263
264 HRESULT registerFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
265 HRESULT unregisterFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
266
267 HRESULT cast (IHardDisk2 *aFrom, ComObjPtr <HardDisk2> &aTo);
268
269 HRESULT saveSettings();
270 HRESULT updateSettings (const char *aOldPath, const char *aNewPath);
271
272 const Bstr &settingsFileName() { return mData.mCfgFile.mName; }
273
274 static HRESULT ensureFilePathExists (const char *aFileName);
275
276 class SettingsTreeHelper : public settings::XmlTreeBackend::InputResolver
277 , public settings::XmlTreeBackend::AutoConverter
278 {
279 public:
280
281 // InputResolver interface
282 xml::Input *resolveEntity (const char *aURI, const char *aID);
283
284 // AutoConverter interface
285 bool needsConversion (const settings::Key &aRoot, char **aOldVersion) const;
286 const char *templateUri() const;
287 };
288
289 static HRESULT loadSettingsTree (settings::XmlTreeBackend &aTree,
290 xml::File &aFile,
291 bool aValidate,
292 bool aCatchLoadErrors,
293 bool aAddDefaults,
294 Utf8Str *aFormatVersion = NULL);
295
296 /**
297 * Shortcut to loadSettingsTree (aTree, aFile, true, true, true).
298 *
299 * Used when the settings file is to be loaded for the first time for the
300 * given object in order to recreate it from the stored settings.
301 *
302 * @param aFormatVersion Where to store the current format version of the
303 * loaded settings tree.
304 */
305 static HRESULT loadSettingsTree_FirstTime (settings::XmlTreeBackend &aTree,
306 xml::File &aFile,
307 Utf8Str &aFormatVersion)
308 {
309 return loadSettingsTree (aTree, aFile, true, true, true,
310 &aFormatVersion);
311 }
312
313 /**
314 * Shortcut to loadSettingsTree (aTree, aFile, true, false, true).
315 *
316 * Used when the settings file is loaded again (after it has been fully
317 * checked and validated by #loadSettingsTree_FirstTime()) in order to
318 * look at settings that don't have any representation within object's
319 * data fields.
320 */
321 static HRESULT loadSettingsTree_Again (settings::XmlTreeBackend &aTree,
322 xml::File &aFile)
323 {
324 return loadSettingsTree (aTree, aFile, true, false, true);
325 }
326
327 /**
328 * Shortcut to loadSettingsTree (aTree, aFile, true, false, false).
329 *
330 * Used when the settings file is loaded again (after it has been fully
331 * checked and validated by #loadSettingsTree_FirstTime()) in order to
332 * update some settings and then save them back.
333 */
334 static HRESULT loadSettingsTree_ForUpdate (settings::XmlTreeBackend &aTree,
335 xml::File &aFile)
336 {
337 return loadSettingsTree (aTree, aFile, true, false, false);
338 }
339
340 static HRESULT saveSettingsTree (settings::TreeBackend &aTree,
341 xml::File &aFile,
342 Utf8Str &aFormatVersion);
343
344 static HRESULT backupSettingsFile (const Bstr &aFileName,
345 const Utf8Str &aOldFormat,
346 Bstr &aBakFileName);
347
348 static HRESULT handleUnexpectedExceptions (RT_SRC_POS_DECL);
349
350 /**
351 * Returns a lock handle used to protect changes to the hard disk hierarchy
352 * (e.g. serialize access to the HardDisk2::mParent fields and methods
353 * adding/removing children). When using this lock, the following rules must
354 * be obeyed:
355 *
356 * 1. The write lock on this handle must be either held alone on the thread
357 * or requested *after* the VirtualBox object lock. Mixing with other
358 * locks is prohibited.
359 *
360 * 2. The read lock on this handle may be intermixed with any other lock
361 * with the exception that it must be requested *after* the VirtualBox
362 * object lock.
363 */
364 RWLockHandle *hardDiskTreeHandle() { return &mHardDiskTreeHandle; }
365
366 /* for VirtualBoxSupportErrorInfoImpl */
367 static const wchar_t *getComponentName() { return L"VirtualBox"; }
368
369private:
370
371 typedef std::list <ComObjPtr <Machine> > MachineList;
372 typedef std::list <ComObjPtr <GuestOSType> > GuestOSTypeList;
373
374 typedef std::map <Guid, ComPtr <IProgress> > ProgressMap;
375
376 typedef std::list <ComObjPtr <HardDisk2> > HardDisk2List;
377 typedef std::list <ComObjPtr <DVDImage2> > DVDImage2List;
378 typedef std::list <ComObjPtr <FloppyImage2> > FloppyImage2List;
379 typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
380
381 typedef std::map <Guid, ComObjPtr <HardDisk2> > HardDisk2Map;
382
383 HRESULT checkMediaForConflicts2 (const Guid &aId, const Bstr &aLocation,
384 Utf8Str &aConflictType);
385
386 HRESULT loadMachines (const settings::Key &aGlobal);
387 HRESULT loadMedia (const settings::Key &aGlobal);
388
389 HRESULT registerMachine (Machine *aMachine);
390
391 HRESULT lockConfig();
392 HRESULT unlockConfig();
393
394 /** @note This method is not thread safe */
395 bool isConfigLocked() { return mData.mCfgFile.mHandle != NIL_RTFILE; }
396
397 /**
398 * Main VirtualBox data structure.
399 * @note |const| members are persistent during lifetime so can be accessed
400 * without locking.
401 */
402 struct Data
403 {
404 Data();
405
406 struct CfgFile
407 {
408 CfgFile() : mHandle (NIL_RTFILE) {}
409
410 const Bstr mName;
411 RTFILE mHandle;
412 };
413
414 // const data members not requiring locking
415 const Utf8Str mHomeDir;
416
417 // const objects not requiring locking
418 const ComObjPtr <Host> mHost;
419 const ComObjPtr <SystemProperties> mSystemProperties;
420#ifdef VBOX_WITH_RESOURCE_USAGE_API
421 const ComObjPtr <PerformanceCollector> mPerformanceCollector;
422#endif /* VBOX_WITH_RESOURCE_USAGE_API */
423
424 CfgFile mCfgFile;
425
426 Utf8Str mSettingsFileVersion;
427
428 MachineList mMachines;
429 GuestOSTypeList mGuestOSTypes;
430
431 ProgressMap mProgressOperations;
432
433 HardDisk2List mHardDisks2;
434 DVDImage2List mDVDImages2;
435 FloppyImage2List mFloppyImages2;
436 SharedFolderList mSharedFolders;
437
438 /// @todo NEWMEDIA do we really need this map? Used only in
439 /// find() it seems
440 HardDisk2Map mHardDisk2Map;
441
442 CallbackList mCallbacks;
443 };
444
445 Data mData;
446
447 /** Client watcher thread data structure */
448 struct ClientWatcherData
449 {
450 ClientWatcherData()
451#if defined(RT_OS_WINDOWS)
452 : mUpdateReq (NULL)
453#elif defined(RT_OS_OS2)
454 : mUpdateReq (NIL_RTSEMEVENT)
455#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
456 : mUpdateReq (NIL_RTSEMEVENT)
457#else
458# error "Port me!"
459#endif
460 , mThread (NIL_RTTHREAD) {}
461
462 // const objects not requiring locking
463#if defined(RT_OS_WINDOWS)
464 const HANDLE mUpdateReq;
465#elif defined(RT_OS_OS2)
466 const RTSEMEVENT mUpdateReq;
467#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
468 const RTSEMEVENT mUpdateReq;
469#else
470# error "Port me!"
471#endif
472 const RTTHREAD mThread;
473
474 typedef std::list <RTPROCESS> ProcessList;
475 ProcessList mProcesses;
476 };
477
478 ClientWatcherData mWatcherData;
479
480 const RTTHREAD mAsyncEventThread;
481 EventQueue * const mAsyncEventQ;
482
483 /**
484 * "Safe" lock. May only be used if guaranteed that no other locks are
485 * requested while holding it and no functions that may do so are called.
486 * Currently, protects the following:
487 *
488 * - mProgressOperations
489 */
490 RWLockHandle mSafeLock;
491
492 RWLockHandle mHardDiskTreeHandle;
493
494 static Bstr sVersion;
495 static ULONG sRevision;
496 static Bstr sPackageType;
497 static Bstr sSettingsFormatVersion;
498
499 static DECLCALLBACK(int) ClientWatcher (RTTHREAD thread, void *pvUser);
500 static DECLCALLBACK(int) AsyncEventHandler (RTTHREAD thread, void *pvUser);
501
502#ifdef RT_OS_WINDOWS
503 static DECLCALLBACK(int) SVCHelperClientThread (RTTHREAD aThread, void *aUser);
504#endif
505};
506
507////////////////////////////////////////////////////////////////////////////////
508
509/**
510 * Abstract callback event class to asynchronously call VirtualBox callbacks
511 * on a dedicated event thread. Subclasses reimplement #handleCallback()
512 * to call appropriate IVirtualBoxCallback methods depending on the event
513 * to be dispatched.
514 *
515 * @note The VirtualBox instance passed to the constructor is strongly
516 * referenced, so that the VirtualBox singleton won't be released until the
517 * event gets handled by the event thread.
518 */
519class VirtualBox::CallbackEvent : public Event
520{
521public:
522
523 CallbackEvent (VirtualBox *aVirtualBox) : mVirtualBox (aVirtualBox)
524 {
525 Assert (aVirtualBox);
526 }
527
528 void *handler();
529
530 virtual void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback) = 0;
531
532private:
533
534 /*
535 * Note that this is a weak ref -- the CallbackEvent handler thread
536 * is bound to the lifetime of the VirtualBox instance, so it's safe.
537 */
538 ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
539};
540
541#endif // ____H_VIRTUALBOXIMPL
542/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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