Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
sdmain.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 30k
Category:

Windows Kernel

Development Platform:

Visual C++

sdmain.cpp：Code Content
  1. #include "stdafx.h"
  2. #pragma hdrstop
  4. #ifdef POSTSPLIT
  6. #include "cmnquery.h"
  7. #include "dsquery.h"
  8. #include "startids.h"
  9. #include "dsgetdc.h"
  10. #include "lm.h"
  11. #include "wab.h"
  12. #include "winldap.h"
  13. #include "activeds.h"
  16. // This is the implementation for the Shell Application level IDispatch
  17. // Currently we will try to maintain only one object per process.
  18. // BUGBUG:: The following defines must be equal to the stuff in cabinet.h...
  20. #define IDM_SYSBUTTON   300
  21. #define IDM_FINDBUTTON  301
  22. #define IDM_HELPBUTTON  302
  23. #define IDM_FILERUN                 401
  24. #define IDM_CASCADE                 403
  25. #define IDM_HORIZTILE               404
  26. #define IDM_VERTTILE                405
  27. #define IDM_DESKTOPARRANGEGRID      406
  28. #define IDM_ARRANGEMINIMIZEDWINDOWS 407
  29. #define IDM_SETTIME                 408
  30. #define IDM_SUSPEND                 409
  31. #define IDM_EJECTPC                 410
  32. #define IDM_TASKLIST                412
  33. #define IDM_TRAYPROPERTIES          413
  34. #define IDM_EDITSTARTMENU           414
  35. #define IDM_MINIMIZEALL             415
  36. #define IDM_UNDO                    416
  37. #define IDM_RETURN                  417
  38. #define IDM_PRINTNOTIFY_FOLDER      418
  39. #define IDM_MINIMIZEALLHOTKEY       419
  40. #define IDM_SHOWTASKMAN             420
  41. #define IDM_RECENT              501
  42. #define IDM_FIND                502
  43. #define IDM_PROGRAMS            504
  44. #define IDM_CONTROLS            505
  45. #define IDM_EXITWIN             506
  46. // #define IDM_FONTS            509
  47. #define IDM_PRINTERS            510
  48. #define IDM_STARTMENU           511
  49. #define IDM_MYCOMPUTER          512
  50. #define IDM_PROGRAMSINIT        513
  51. #define IDM_RECENTINIT          514
  52. #define IDM_MENU_FIND           520
  53. #define TRAY_IDM_FINDFIRST      521  // this range
  54. #define TRAY_IDM_FINDLAST       550  // is reserved for find command
  55. #define IDM_RECENTLIST          650
  56. #define IDM_QUICKTIPS   800
  57. #define IDM_HELPCONT    801
  58. #define IDM_WIZARDS     802
  59. #define IDM_USEHELP     803             // REVIEW: probably won't be used
  60. #define IDM_TUTORIAL    804
  61. #define IDM_ABOUT       805
  62. #define IDM_LAST_MENU_ITEM   IDM_ABOUT
  63. #define FCIDM_FIRST             FCIDM_GLOBALFIRST
  64. #define FCIDM_LAST              FCIDM_BROWSERLAST
  65. //#define FCIDM_FINDFILES         (FCIDM_BROWSER_TOOLS+0x0005)
  66. #define FCIDM_FINDCOMPUTER      (FCIDM_BROWSER_TOOLS+0x0006)
  68. //============================================================================
  70. class CShellDispatch : public IShellDispatch2, 
  71.                        public CObjectSafety,
  72.                        protected CImpIDispatch,
  73.                        public CObjectWithSite
  74. {
  75.    friend class CAdviseRouter;
  76.    friend HRESULT GetApplicationObject(DWORD dwSafetyOptions, IUnknown *punkSite, IDispatch **ppid);
  78.     public:
  80.         //Non-delegating object IUnknown
  81.         STDMETHODIMP         QueryInterface(REFIID, void **);
  82.         STDMETHODIMP_(ULONG) AddRef(void);
  83.         STDMETHODIMP_(ULONG) Release(void);
  85.         //IDispatch members
  86.         virtual STDMETHODIMP GetTypeInfoCount(UINT * pctinfo)
  87.             { return CImpIDispatch::GetTypeInfoCount(pctinfo); }
  88.         virtual STDMETHODIMP GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo **pptinfo)
  89.             { return CImpIDispatch::GetTypeInfo(itinfo, lcid, pptinfo); }
  90.         virtual STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid)
  91.             { return CImpIDispatch::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid); }
  92.         virtual STDMETHODIMP Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
  93.             { return CImpIDispatch::Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr); }
  95.         //IShellDispatch functions
  96.         STDMETHODIMP get_Application(IDispatch **ppid);
  97.         STDMETHODIMP get_Parent (IDispatch **ppid);
  98.         STDMETHOD(Open)(THIS_ VARIANT vDir);
  99.         STDMETHOD(Explore)(THIS_ VARIANT vDir);
  100.         STDMETHOD(NameSpace)(THIS_ VARIANT vDir, Folder **ppsdf);
  101.         STDMETHODIMP BrowseForFolder(long Hwnd, BSTR Title, long Options, VARIANT RootFolder, Folder **ppsdf);
  102.         STDMETHODIMP ControlPanelItem(BSTR szDir);
  103.         STDMETHODIMP MinimizeAll(void);
  104.         STDMETHODIMP UndoMinimizeALL(void);
  105.         STDMETHODIMP FileRun(void);
  106.         STDMETHODIMP CascadeWindows(void);
  107.         STDMETHODIMP TileVertically(void);
  108.         STDMETHODIMP TileHorizontally(void);
  109.         STDMETHODIMP ShutdownWindows(void);
  110.         STDMETHODIMP Suspend(void);
  111.         STDMETHODIMP EjectPC(void);
  112.         STDMETHODIMP SetTime(void);
  113.         STDMETHODIMP TrayProperties(void);
  114.         STDMETHODIMP Help(void);
  115.         STDMETHODIMP FindFiles(void);
  116.         STDMETHODIMP FindComputer(void);
  117.         STDMETHODIMP RefreshMenu(void);
  118.         STDMETHODIMP Windows(IDispatch **ppid);
  119.         STDMETHODIMP get_ObjectCount(int *pcObjs);
  120.         STDMETHODIMP IsRestricted(BSTR Group, BSTR Restriction, long * lpValue);
  121.         STDMETHODIMP ShellExecute(BSTR File, VARIANT vArgs, VARIANT vDir, VARIANT vOperation, VARIANT vShow);
  122.         STDMETHODIMP FindPrinter(BSTR name, BSTR location, BSTR model);
  123.         STDMETHODIMP GetSystemInformation(BSTR name, VARIANT * pvOut);
  124.         STDMETHODIMP ServiceStart(BSTR ServiceName, VARIANT Persistent, VARIANT *pSuccess);
  125.         STDMETHODIMP ServiceStop(BSTR ServiceName, VARIANT Persistent, VARIANT *pSuccess);
  126.         STDMETHODIMP IsServiceRunning(BSTR ServiceName, VARIANT *pRunning);
  127.         STDMETHODIMP CanStartStopService(BSTR ServiceName, VARIANT *pCanStartStop);
  128.         STDMETHODIMP ShowBrowserBar( BSTR bstrClsid, VARIANT bShow, VARIANT *pSuccess );
  129.                 
  130.         // Constructor and the like.. 
  131.         CShellDispatch(void);
  132.     protected:
  133.         ULONG           m_cRef;             //Object reference count
  134.     
  135.         ~CShellDispatch(void);
  136.         BOOL            FAllowUserToDoAnything(void);   // Check if we are in paranoid mode...
  137.         HRESULT         _TrayCommand(UINT idCmd);
  138.         HRESULT         ExecuteFolder(VARIANT vDir, LPCTSTR pszVerb);
  139.         VARIANT_BOOL    _ServiceStartStop(BSTR ServiceName, BOOL fStart, BOOL fPersist);
  141.         HMODULE         m_hmodWAB;          // module handle for WAB32 
  142.         LPWABOPEN       _GetWABOpen();
  143.         HRESULT         _GetNC(BSTR *pbstrResult, LPCTSTR pszDnsForestName);
  145. };
  148. STDAPI CShellDispatch_CreateInstance(IUnknown* pUnkOuter, REFIID riid, void **ppvOut)
  149. {
  150.     HRESULT hr = E_OUTOFMEMORY;
  151.     *ppvOut = NULL;
  152.     TraceMsg(DM_TRACE, "CSD_CreateInstance called");
  154.     // aggregation checking is handled in class factory
  155.     CShellDispatch * pshd = new CShellDispatch();
  156.     if (pshd)
  157.     {
  158.         hr = pshd->QueryInterface(riid, ppvOut);
  159.         pshd->Release();   // g_pCShellDispatch doesn't want a ref.
  160.     }
  162.     return hr;
  163. }
  165. HRESULT GetApplicationObject(DWORD dwSafetyOptions, IUnknown *punkSite, IDispatch **ppid)
  166. {
  167.     *ppid = NULL;   // Handle failure cases.
  169.     if (dwSafetyOptions && (!punkSite || IsSafePage(punkSite) != S_OK))
  170.         return E_ACCESSDENIED;
  172.     HRESULT hres = CShellDispatch_CreateInstance(NULL, IID_IDispatch, (void **) ppid);
  173.     if (SUCCEEDED(hres))
  174.     {
  175.         if (punkSite)
  176.             IUnknown_SetSite(*ppid, punkSite);
  178.         if (dwSafetyOptions && SUCCEEDED(hres))
  179.             hres = MakeSafeForScripting((IUnknown**)ppid);
  180.     }
  182.     return hres;
  183. }
  185. CShellDispatch::CShellDispatch(void) :
  186.         m_cRef(1), 
  187.         m_hmodWAB(NULL),
  188.         CImpIDispatch(&LIBID_Shell32, 1, 0, &IID_IShellDispatch2)
  189. {
  190.     DllAddRef();
  191.     TraceMsg(DM_TRACE, "CShellDispatch::CShellDispatch called");
  192. }
  195. CShellDispatch::~CShellDispatch(void)
  196. {
  197.     TraceMsg(DM_TRACE, "CShellDispatch::~CShellDispatch called");
  198.     
  199.     if ( m_hmodWAB )
  200.         FreeLibrary(m_hmodWAB);
  202.     DllRelease();
  203. }
  205. BOOL  CShellDispatch::FAllowUserToDoAnything(void)
  206. {
  207.     if (!_dwSafetyOptions)
  208.         return TRUE;   // We are not running in safe mode so say everything is OK...   
  210.     if (!_punkSite)
  211.         return FALSE;   // We are in safe but don't have anyway to know where we are...
  212.     return (IsSafePage(_punkSite) == S_OK);
  214. }
  216. STDMETHODIMP CShellDispatch::QueryInterface(REFIID riid, void ** ppv)
  217. {
  218.     TraceMsg(DM_TRACE, "CShellDispatch::QueryInterface called");
  219.     static const QITAB qit[] = {
  220.         QITABENT(CShellDispatch, IShellDispatch2),
  221.         QITABENTMULTI(CShellDispatch, IShellDispatch, IShellDispatch2),
  222.         QITABENTMULTI(CShellDispatch, IDispatch, IShellDispatch2),
  223.         QITABENT(CShellDispatch, IObjectSafety),
  224.         QITABENT(CShellDispatch, IObjectWithSite),
  225.         { 0 },
  226.     };
  228.     return QISearch(this, qit, riid, ppv);
  229. }
  232. STDMETHODIMP_(ULONG) CShellDispatch::AddRef(void)
  233. {
  234.     TraceMsg(DM_TRACE, "CShellDispatch::AddRef called");
  235.     return ++m_cRef;
  236. }
  239. STDMETHODIMP_(ULONG) CShellDispatch::Release(void)
  240. {
  241.     TraceMsg(DM_TRACE, "CShellDispatch::Release called");
  242.     if (0L!=--m_cRef)
  243.         return m_cRef;
  245.     delete this;
  246.     return 0L;
  247. }
  249. // Helper function to process commands to the tray.
  250. HRESULT CShellDispatch::_TrayCommand(UINT idCmd)
  251. {
  252.     if (!FAllowUserToDoAnything())
  253.         return E_ACCESSDENIED;
  255.     HWND hwndTray = FindWindowA(WNDCLASS_TRAYNOTIFY, NULL);
  256.     if (hwndTray)
  257.         PostMessage(hwndTray, WM_COMMAND, idCmd, 0);
  258.     return NOERROR;
  259. }
  261. STDMETHODIMP CShellDispatch::get_Application(IDispatch **ppid)
  262. {
  263.     // Simply return ourself
  264.     return QueryInterface(IID_IDispatch, (PVOID*)ppid);
  265. }
  267. STDMETHODIMP CShellDispatch::get_Parent(IDispatch **ppid)
  268. {
  269.     return QueryInterface(IID_IDispatch, (PVOID*)ppid);
  270. }
  272. HRESULT CShellDispatch::ExecuteFolder(VARIANT vDir, LPCTSTR pszVerb)
  273. {
  274.     SHELLEXECUTEINFO sei = {sizeof(SHELLEXECUTEINFO)};  
  276.     // Check to see if we allow the user to do this...
  277.     if (!FAllowUserToDoAnything())
  278.         return E_ACCESSDENIED;
  280.     sei.lpIDList = (void *)VariantToIDList(&vDir);
  281.     if (sei.lpIDList)
  282.     {
  283.         // Everything should have been initialize to 0
  284.         // BUGBUG:: Should be invoke idlist but that is failing when
  285.         // explore
  286.         sei.fMask = SEE_MASK_IDLIST;
  287.         sei.nShow = SW_SHOWNORMAL;
  288.         sei.lpVerb = pszVerb;
  290.         //TraceMsg(DM_TRACE, "CShellDispatch::Open(%s) called", szParam);
  292.         HRESULT hres = ShellExecuteEx(&sei) ? NOERROR : S_FALSE;
  294.         ILFree((LPITEMIDLIST)sei.lpIDList);
  296.         return hres;
  297.     }
  298.     return S_FALSE; // bad dir
  299. }
  302. STDMETHODIMP CShellDispatch::Open(VARIANT vDir)
  303. {
  304.     return ExecuteFolder(vDir, NULL);
  305. }
  307. STDMETHODIMP CShellDispatch::Explore(VARIANT vDir)
  308. {
  309.     return ExecuteFolder(vDir, TEXT("explore"));
  310. }
  312. STDMETHODIMP CShellDispatch::NameSpace(VARIANT vDir, Folder **ppsdf)
  313. {
  314.     *ppsdf = NULL;
  316.     if (!FAllowUserToDoAnything())
  317.         return E_ACCESSDENIED;
  319.     HRESULT hres;
  320.     LPITEMIDLIST pidl = VariantToIDList(&vDir);
  321.     if (pidl)
  322.     {
  323.         hres = CFolder_Create(NULL, pidl, NULL, IID_Folder, (void **)ppsdf);
  324.         ILFree(pidl);
  325.     }
  326.     else
  327.         hres = S_FALSE; // bad dir
  328.     return hres;
  329. }
  331. STDMETHODIMP CShellDispatch::IsRestricted(BSTR Group, BSTR Restriction, long * lpValue)
  332. {
  333.     if (lpValue) 
  334.         *lpValue = SHGetRestriction(NULL, Group, Restriction);
  335.     return S_OK;
  336. }
  338. STDMETHODIMP CShellDispatch::ShellExecute(BSTR File, VARIANT vArgs, VARIANT vDir, VARIANT vOperation, VARIANT vShow)
  339. {
  340.     SHELLEXECUTEINFO sei = {sizeof(SHELLEXECUTEINFO)};  
  341.     TCHAR szFile[MAX_PATH];
  342.     TCHAR szDir[MAX_PATH];
  343.     TCHAR szOper[128];  // don't think any verb longer than this...
  345.     // Check to see if we allow the user to do this...
  346.     if (!FAllowUserToDoAnything())
  347.         return E_ACCESSDENIED;
  349.     // Initialize the shellexecute structure...
  351.     sei.nShow = SW_SHOWNORMAL;
  353.     // Ok setup the FileName.
  354.     SHUnicodeToTCharCP(CP_ACP, File, szFile, ARRAYSIZE(szFile));
  355.     sei.lpFile = szFile;
  357.     // Now the Args
  358.     sei.lpParameters = VariantToStr(&vArgs, NULL, 0);
  359.     sei.lpDirectory = VariantToStr(&vDir, szDir, ARRAYSIZE(szDir));
  360.     sei.lpVerb = VariantToStr(&vOperation, szOper, ARRAYSIZE(szOper));
  362.     // Finally the show -- Could use convert, but that takes 3 calls...
  363.     if (vShow.vt == (VT_BYREF|VT_VARIANT) && vShow.pvarVal)
  364.         vShow = *vShow.pvarVal;
  365.     switch (vShow.vt)
  366.     {
  367.     case VT_I2:
  368.         sei.nShow = (int)vShow.iVal;
  369.         break;
  371.     case VT_I4:
  372.         sei.nShow = (int)vShow.lVal;
  373.     }
  375.     HRESULT hres = ShellExecuteEx(&sei) ? NOERROR : S_FALSE;
  377.     // Cleanup anything we allocated
  378.     if (sei.lpParameters)
  379.         LocalFree((HLOCAL)sei.lpParameters);
  381.     return hres;
  383. }
  384. //
  385. // These next few methods deal with NT services in general, and the
  386. // Content Indexing Service in particular, so they're stubbed out
  387. // to return E_NOTIMPL on Win9x.
  388. //
  390. //
  391. // Helper function for ServiceStart and ServiceStop
  392. //
  393. VARIANT_BOOL CShellDispatch::_ServiceStartStop(BSTR ServiceName, BOOL fStart, BOOL fPersistent)
  394. {
  395. #ifdef WINNT
  396.     SC_HANDLE hSvc = 0;
  397.     SC_HANDLE hSc = 0;
  398.     BOOL fResult = FALSE;
  399.     VARIANT_BOOL fRetVal = VARIANT_FALSE;
  400.     SERVICE_STATUS ServiceStatus;
  402.     hSc = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
  403.     if (!hSc) {
  404.         goto exit_gracefully;
  405.     } // if
  407.     hSvc = OpenServiceW(
  408.         hSc,
  409.         ServiceName,
  410.         (fStart ? SERVICE_START : SERVICE_STOP) 
  411.             | (fPersistent ? SERVICE_CHANGE_CONFIG : 0)
  412.     );
  413.     if (!hSvc) {
  414.         goto exit_gracefully;
  415.     } // if
  416.         
  417.     if (fPersistent) {
  419.         fResult = ChangeServiceConfig(
  420.             hSvc,
  421.             SERVICE_NO_CHANGE,
  422.             (fStart ? SERVICE_AUTO_START : SERVICE_DEMAND_START),
  423.             SERVICE_NO_CHANGE,
  424.             NULL,
  425.             NULL,
  426.             NULL,
  427.             NULL,
  428.             NULL,
  429.             NULL,
  430.             NULL
  431.         );
  432.         
  433.         //
  434.         // Consider failure here a soft error.
  435.         //
  437.     } // if (fPersistent)
  439.     if (fStart) {
  440.         fResult = StartService(hSvc, 0, NULL);
  441.     }
  442.     else {
  443.         fResult = ControlService(hSvc, SERVICE_CONTROL_STOP, &ServiceStatus);
  444.     }
  445.     if (!fResult) {
  446.         goto exit_gracefully;
  447.     } // if
  449.     fRetVal = VARIANT_TRUE;
  451. exit_gracefully:
  452.     if (hSvc) {
  453.         CloseServiceHandle(hSvc);
  454.         hSvc = 0;
  455.     } // if
  456.     if (hSc) {
  457.         CloseServiceHandle(hSc);
  458.         hSc = 0;
  459.     } // if
  461.     return(fRetVal);
  462. #else // WINNT
  463.     return(FALSE);
  464. #endif // WINNT
  465. }
  467. STDMETHODIMP CShellDispatch::ServiceStart(BSTR ServiceName, VARIANT Persistent, VARIANT *pSuccess)
  468. {
  469. #ifdef WINNT
  470.     // Check to see if we allow the user to do this...
  471.     if (!FAllowUserToDoAnything())
  472.         return E_ACCESSDENIED;
  474.     if (VT_BOOL != Persistent.vt) {
  475.         return(E_INVALIDARG);
  476.     } // if
  478.     VariantClear(pSuccess);
  479.     pSuccess->vt = VT_BOOL;
  480.     pSuccess->boolVal = _ServiceStartStop(ServiceName, TRUE, Persistent.boolVal);
  482.     return(S_OK);
  483. #else // WINNT
  484.     return(E_NOTIMPL);
  485. #endif // WINNT
  486. }
  488. STDMETHODIMP CShellDispatch::ServiceStop(BSTR ServiceName, VARIANT Persistent, VARIANT *pSuccess)
  489. {
  490. #ifdef WINNT
  491.     // Check to see if we allow the user to do this...
  492.     if (!FAllowUserToDoAnything())
  493.         return E_ACCESSDENIED;
  495.     if (VT_BOOL != Persistent.vt) {
  496.         return(E_INVALIDARG);
  497.     } // if
  499.     VariantClear(pSuccess);
  500.     pSuccess->vt = VT_BOOL;
  501.     pSuccess->boolVal = _ServiceStartStop(ServiceName, FALSE, Persistent.boolVal);
  503.     return(S_OK);
  504. #else // WINNT
  505.     return(E_NOTIMPL);
  506. #endif // WINNT
  507. }
  509. STDMETHODIMP CShellDispatch::IsServiceRunning(BSTR ServiceName, VARIANT *pIsRunning)
  510. {
  511. #ifdef WINNT
  512.     SC_HANDLE hSvc = 0;
  513.     SC_HANDLE hSc = 0;
  514.     SERVICE_STATUS ServiceStatus;
  515.     BOOL fResult = FALSE;
  517.     VariantClear(pIsRunning);
  518.     pIsRunning->vt = VT_BOOL;
  519.     pIsRunning->boolVal = VARIANT_FALSE;
  521.     // Check to see if we allow the user to do this...
  522.     if (!FAllowUserToDoAnything())
  523.         return E_ACCESSDENIED;
  525.     hSc = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
  526.     if (!hSc) {
  527.         goto exit_gracefully;
  528.     } // if
  530.     hSvc = OpenService(
  531.         hSc,
  532.         ServiceName,
  533.         SERVICE_QUERY_STATUS
  534.     );
  535.     if (!hSvc) {
  536.         goto exit_gracefully;
  537.     } // if
  538.         
  539.     fResult = QueryServiceStatus(hSvc, &ServiceStatus);
  540.     if (!fResult) {
  541.         goto exit_gracefully;
  542.     } // if
  544.     switch (ServiceStatus.dwCurrentState) {
  545.         case SERVICE_START_PENDING:
  546.         case SERVICE_RUNNING:
  547.         case SERVICE_CONTINUE_PENDING:
  548.             pIsRunning->boolVal = VARIANT_TRUE;
  549.             break;
  551.         default:
  552.             break;
  554.     } // switch
  556. exit_gracefully:
  558.     if (hSc) {
  559.         CloseServiceHandle(hSc);
  560.         hSc = 0;
  561.     } // if
  562.     if (hSvc) {
  563.         CloseServiceHandle(hSvc);
  564.         hSvc = 0;
  565.     } // if
  567.     return(S_OK);
  568. #else // WINNT
  569.     return(E_NOTIMPL);
  570. #endif
  572. }
  574. STDMETHODIMP CShellDispatch::CanStartStopService(BSTR ServiceName, VARIANT *pCanStartStop)
  575. {
  576. #ifdef WINNT
  577.     SC_HANDLE hSvc = 0;
  578.     SC_HANDLE hSc = 0;
  579.     BOOL fResult = FALSE;
  581.     VariantClear(pCanStartStop);
  582.     pCanStartStop->vt = VT_BOOL;
  583.     pCanStartStop->boolVal = VARIANT_FALSE;
  585.     // Check to see if we allow the user to do this...
  586.     if (!FAllowUserToDoAnything())
  587.         return E_ACCESSDENIED;
  589.     hSc = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
  590.     if (!hSc) {
  591.         goto exit_gracefully;
  592.     } // if
  594.     hSvc = OpenService(
  595.         hSc,
  596.         ServiceName,
  597.         SERVICE_START | SERVICE_STOP | SERVICE_CHANGE_CONFIG
  598.     );
  599.     if (!hSvc) {
  600.         DWORD dwErr = GetLastError() ;
  601.         goto exit_gracefully;
  602.     } // if
  603.         
  604.     pCanStartStop->boolVal = VARIANT_TRUE;
  606. exit_gracefully:
  608.     if (hSc) {
  609.         CloseServiceHandle(hSc);
  610.         hSc = 0;
  611.     } // if
  612.     if (hSvc) {
  613.         CloseServiceHandle(hSvc);
  614.         hSvc = 0;
  615.     } // if
  617.     return(S_OK);
  618. #else // WINNT
  619.     return(E_NOTIMPL);
  620. #endif // WINNT
  622. }
  624. STDMETHODIMP CShellDispatch::ShowBrowserBar(BSTR bstrClsid, VARIANT varShow, VARIANT *pSuccess)
  625. {
  626.     if( !(bstrClsid && *bstrClsid && pSuccess) )
  627.         return E_INVALIDARG ;
  629.     HRESULT hr        = E_FAIL ;
  630.     pSuccess->vt      = VT_BOOL ;
  631.     pSuccess->boolVal = VARIANT_FALSE ;
  633.     if( NULL == _punkSite )
  634.         return E_FAIL ;
  636.     IShellBrowser* psb ;
  637.     hr = IUnknown_QueryService( _punkSite, SID_STopLevelBrowser, IID_IShellBrowser, (void **)&psb ) ;
  639.     if( SUCCEEDED( hr ) ) 
  640.     {
  641.         IWebBrowser2 *pb2;
  642.         hr = IUnknown_QueryService( psb, SID_SWebBrowserApp, IID_IWebBrowser2, 
  643.                                    (void **)&pb2);
  644.         if (SUCCEEDED(hr))
  645.         {
  646.             VARIANT varGuid, varNil ;
  647.         
  648.             varGuid.vt      = VT_BSTR ;
  649.             varGuid.bstrVal = bstrClsid ;
  650.             VariantInit( &varNil ) ;
  652.             hr = pb2->ShowBrowserBar( &varGuid, &varShow, &varNil ) ;
  653.             
  654.             if( SUCCEEDED( hr ) )
  655.                 pSuccess->boolVal = VARIANT_TRUE ;
  656.         
  657.             pb2->Release() ;
  658.         }
  659.         psb->Release() ;
  660.     }
  662.     return hr ;
  663. }
  665. STDMETHODIMP CShellDispatch::BrowseForFolder(long Hwnd, BSTR Title, long Options, 
  666.         VARIANT RootFolder, Folder **ppsdf)
  667. {
  668.     // BUGBUG:: Not all of the arguments are being processed yet...
  669.     TCHAR szTitle[MAX_PATH];      // hopefully long enough...
  670.     BROWSEINFO browse;
  671.     LPITEMIDLIST pidl;
  672.     HRESULT hres;
  674.     if (!FAllowUserToDoAnything())
  675.         return E_ACCESSDENIED;
  677.     SHUnicodeToTCharCP(CP_ACP, Title, szTitle, ARRAYSIZE(szTitle));
  678.     browse.lpszTitle = szTitle;
  680.     browse.pszDisplayName = NULL;
  681.     browse.hwndOwner = (HWND)LongToHandle( Hwnd );
  682.     browse.ulFlags = (ULONG)Options;
  683.     browse.lpfn = NULL;
  684.     browse.lParam = 0;
  685.     browse.iImage = 0;
  686.     browse.pidlRoot = VariantToIDList(&RootFolder);
  688.     pidl = SHBrowseForFolder(&browse);
  690.     if (browse.pidlRoot)
  691.         ILFree((LPITEMIDLIST)browse.pidlRoot);
  693.     *ppsdf = NULL;
  694.     if (pidl)
  695.     {
  696.         hres = CFolder_Create(NULL, pidl, NULL, IID_Folder, (void **)ppsdf);
  697.         ILFree(pidl);
  698.     }
  699.     else
  700.         hres = S_FALSE;     // Not a strong error...
  701.     return hres;
  702. }
  704. STDMETHODIMP CShellDispatch::ControlPanelItem(BSTR bszDir)
  705. {
  706.     if (!FAllowUserToDoAnything())
  707.         return E_ACCESSDENIED;
  708. #ifdef UNICODE
  709.     SHRunControlPanel(bszDir, NULL);
  711. #else // UNICODE
  712.     TCHAR szParam[MAX_PATH];
  714.     SHUnicodeToAnsi(bszDir, szParam, ARRAYSIZE(szParam));
  715.     SHRunControlPanel(szParam, NULL);
  716.     TraceMsg(DM_TRACE, "CShellDispatch::ControlPanelItem(%s) called", szParam);
  717. #endif // UNICODE
  719.     return NOERROR;
  720. }
  722. STDMETHODIMP CShellDispatch::MinimizeAll(void)
  723. {
  724.     return _TrayCommand(IDM_MINIMIZEALL);
  725. }
  727. STDMETHODIMP CShellDispatch::UndoMinimizeALL(void)
  728. {
  729.     return _TrayCommand(IDM_UNDO);
  730. }
  732. STDMETHODIMP CShellDispatch::FileRun(void)
  733. {
  734.     return _TrayCommand(IDM_FILERUN);
  735. }
  737. STDMETHODIMP CShellDispatch::CascadeWindows(void)
  738. {
  739.     return _TrayCommand(IDM_CASCADE);
  740. }
  742. STDMETHODIMP CShellDispatch::TileVertically(void)
  743. {
  744.     return _TrayCommand(IDM_VERTTILE);
  745. }
  747. STDMETHODIMP CShellDispatch::TileHorizontally(void)
  748. {
  749.     return _TrayCommand(IDM_HORIZTILE);
  750. }
  752. STDMETHODIMP CShellDispatch::ShutdownWindows(void)
  753. {
  754.     return _TrayCommand(IDM_EXITWIN);
  755. }
  757. STDMETHODIMP CShellDispatch::Suspend(void)
  758. {
  759.     return _TrayCommand(IDM_SUSPEND);
  760. }
  762. STDMETHODIMP CShellDispatch::EjectPC(void)
  763. {
  764.     return _TrayCommand(IDM_EJECTPC);
  765. }
  768. STDMETHODIMP CShellDispatch::SetTime(void)
  769. {
  770.     return _TrayCommand(IDM_SETTIME);
  771. }
  773. STDMETHODIMP CShellDispatch::TrayProperties(void)
  774. {
  775.     return _TrayCommand(IDM_TRAYPROPERTIES);
  776. }
  778. STDMETHODIMP CShellDispatch::Help(void)
  779. {
  780.     return _TrayCommand(IDM_HELPSEARCH);
  781. }
  783. STDMETHODIMP CShellDispatch::FindFiles(void)
  784. {
  785.     return _TrayCommand(FCIDM_FINDFILES);
  786. }
  788. STDMETHODIMP CShellDispatch::FindComputer(void)
  789. {
  790.     return _TrayCommand(FCIDM_FINDCOMPUTER);
  791. }
  793. STDMETHODIMP CShellDispatch::RefreshMenu(void)
  794. {
  795.     return _TrayCommand(FCIDM_REFRESH);
  796. }
  798. STDMETHODIMP CShellDispatch::Windows(IDispatch **ppid)
  799. {
  800.     if (!FAllowUserToDoAnything())
  801.         return E_ACCESSDENIED;
  802.     return CoCreateInstance(CLSID_ShellWindows, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)ppid);
  803. }
  806. //
  807. // the "FindPrinter" method on the application object invokes the DS query to find a printer given
  808. // the name, location and model.  Because the query UI is a blocking API we spin this onto a seperate
  809. // thread before calling "OpenQueryWindow".
  810. //
  812. typedef struct 
  813. {
  814.     LPWSTR pszName;
  815.     LPWSTR pszLocation;
  816.     LPWSTR pszModel;
  817. } FINDPRINTERINFO;
  819. void _FreeFindPrinterInfo(FINDPRINTERINFO *pfpi)
  820. {
  821.     if ( pfpi )
  822.     {
  823.         Str_SetPtrW(&pfpi->pszName, NULL);
  824.         Str_SetPtrW(&pfpi->pszLocation, NULL);
  825.         Str_SetPtrW(&pfpi->pszModel, NULL);
  826.         LocalFree(pfpi);               // free the parameters we were given
  827.     }
  828. }
  830. HRESULT _SetStrToPropertyBag(IPropertyBag *ppb, LPCWSTR pszProperty, LPCWSTR pszValue)
  831. {
  832.     VARIANT variant = { 0 };
  834.     V_VT(&variant) = VT_BSTR;
  835.     V_BSTR(&variant) = SysAllocString(pszValue);
  837.     if ( !V_BSTR(&variant) )
  838.         return E_OUTOFMEMORY;
  840.     HRESULT hres = ppb->Write(pszProperty, &variant);
  841.     SysFreeString(V_BSTR(&variant));    
  843.     return hres;
  844. }
  846. HRESULT _GetPrintPropertyBag(FINDPRINTERINFO *pfpi, IPropertyBag **pppb)
  847. {
  848.     HRESULT hres = S_OK;
  849.     IPropertyBag *ppb = NULL;
  851.     // if we have properties that need to be passed then lets package them up
  852.     // into a property bag.
  854.     if ( pfpi->pszName || pfpi->pszLocation || pfpi->pszModel )
  855.     {
  856.         hres = SHCreatePropertyBag(IID_IPropertyBag, (void **)&ppb);
  857.         if ( SUCCEEDED(hres) )
  858.         {
  859.             if ( pfpi->pszName )
  860.                 hres = _SetStrToPropertyBag(ppb, L"printName", pfpi->pszName);
  862.             if ( pfpi->pszLocation && SUCCEEDED(hres) )
  863.                 hres = _SetStrToPropertyBag(ppb, L"printLocation", pfpi->pszLocation);
  865.             if ( pfpi->pszModel && SUCCEEDED(hres) )
  866.                 hres = _SetStrToPropertyBag(ppb, L"printModel", pfpi->pszModel);
  867.         }
  868.     }
  870.     if ( FAILED(hres) && ppb )
  871.         ppb->Release();
  872.     else
  873.         *pppb = ppb;
  875.     return hres;
  876. }
  878. DWORD WINAPI _FindPrinterThreadProc(void *ptp)
  879. {
  880.     FINDPRINTERINFO *pfpi = (FINDPRINTERINFO*)ptp;
  882.     ICommonQuery *pcq;
  883.     if (SUCCEEDED(CoCreateInstance(CLSID_CommonQuery, NULL, CLSCTX_INPROC_SERVER, IID_ICommonQuery, (void **)&pcq)))
  884.     {
  885.         OPENQUERYWINDOW oqw = { 0 };
  887.         oqw.cbStruct = SIZEOF(oqw);
  888.         oqw.dwFlags = OQWF_DEFAULTFORM | OQWF_REMOVEFORMS | OQWF_PARAMISPROPERTYBAG;
  889.         oqw.clsidHandler = CLSID_DsQuery;
  890.         oqw.clsidDefaultForm = CLSID_DsFindPrinter;
  891.     
  892.         if ( SUCCEEDED(_GetPrintPropertyBag(pfpi, &oqw.ppbFormParameters)) )
  893.             pcq->OpenQueryWindow(NULL, &oqw, NULL);
  895.         if ( oqw.pFormParameters )
  896.             oqw.ppbFormParameters->Release();
  898.         pcq->Release();
  899.     }
  901.     _FreeFindPrinterInfo(pfpi);
  903.     return 0;
  904. }
  906. STDMETHODIMP CShellDispatch::FindPrinter(BSTR name, BSTR location, BSTR model)
  907. {
  908.     if (!FAllowUserToDoAnything())
  909.         return E_ACCESSDENIED;
  911.     // bundle the parameters to pass over to the bg thread which will issue the query
  913.     FINDPRINTERINFO *pfpi = (FINDPRINTERINFO*)LocalAlloc(LPTR, SIZEOF(FINDPRINTERINFO));
  914.     if ( !pfpi )
  915.         return E_OUTOFMEMORY;
  917.     if ( Str_SetPtrW(&pfpi->pszName, name) && 
  918.          Str_SetPtrW(&pfpi->pszLocation, location) && 
  919.          Str_SetPtrW(&pfpi->pszModel, model) )
  920.     {
  921.         if (SHCreateThread(_FindPrinterThreadProc, pfpi, CTF_PROCESS_REF | CTF_COINIT, NULL))
  922.         {
  923.             pfpi = NULL;            // thread owns
  924.         }
  925.     }
  927.     // either close the thread handle, or release the parameter block.   we assume
  928.     // that if the thread was created it will handle discarding the block.
  930.     if (pfpi)
  931.         _FreeFindPrinterInfo(pfpi);
  933.     return S_OK;
  934. }
  937. #ifdef WINNT
  939. // NT4 returns a good processor level in wProcessorLevel
  940. #define _GetProcessorLevelFromSystemInfo(pinfo) (pinfo)->wProcessorLevel
  942. #else
  944. // Win95 doesn't support SYSTEM_INFO.wProcessorLevel so we have
  945. // to do it the hard way.  Win98 does support it, but that's scant
  946. // consolation.
  948. UINT _GetProcessorLevelFromSystemInfo(SYSTEM_INFO *pinfo)
  949. {
  950.     UINT uiLevel = 0;
  952.     switch (pinfo->dwProcessorType)
  953.     {
  954.     case PROCESSOR_INTEL_386:
  955.         uiLevel = 3;
  956.         break;
  958.     case PROCESSOR_INTEL_486:
  959.         uiLevel = 4;
  961.     // We'll assume that everything Pentium or better supports CPUID
  962.     // But just in case, we'll wrap this inside a try/except.
  963.     default:
  964.         __try {
  966.             // The CPUID instruction trashes EBX but the compiler doesn't know
  967.             // that so we have to trash it explicitly
  968.             _asm {
  969.                 xor eax, eax
  970.                 inc eax
  971.                 _emit 0x0F          // CPUID
  972.                 _emit 0xA2
  973.                 xor ebx, ebx        // so compiler doesn't assume ebx is preserved
  974.                 and ah, 15          // Processor level returned in low nibble of ah
  975.                 mov byte ptr uiLevel, ah
  976.             }
  977.         } __except (EXCEPTION_EXECUTE_HANDLER) { }
  978.         break;
  979.     }
  980.     return uiLevel;
  981. }
  982. #endif
  984. STDMETHODIMP CShellDispatch::GetSystemInformation(BSTR bstrName, VARIANT * pvOut)
  985. {
  986.     if (!FAllowUserToDoAnything())
  987.         return E_ACCESSDENIED;
  988.     
  989.     TCHAR szName[MAX_PATH];
  990.     SHUnicodeToTCharCP(CP_ACP, bstrName, szName, ARRAYSIZE(szName));
  992.     if (!lstrcmpi(szName, TEXT("DirectoryServiceAvailable")))
  993.     {
  994.         pvOut->vt = VT_BOOL;
  995.         V_BOOL(pvOut) = GetEnvironmentVariable(TEXT("USERDNSDOMAIN"), NULL, 0) > 0;
  996.         return S_OK;
  997.     }
  998.     else if (!lstrcmpi(szName, TEXT("DoubleClickTime")))
  999.     {
  1000.         pvOut->vt = VT_UI4;
  1001.         V_UI4(pvOut) = GetDoubleClickTime();
  1002.         return S_OK;
  1003.     }
  1004.     else if (!lstrcmpi(szName, TEXT("ProcessorLevel")))
  1005.     {
  1006.         SYSTEM_INFO info;
  1007.         GetSystemInfo(&info);
  1008.         pvOut->vt = VT_I4;
  1009.         V_UI4(pvOut) = _GetProcessorLevelFromSystemInfo(&info);
  1010.         return S_OK;
  1011.     }
  1012.     else if (!lstrcmpi(szName, TEXT("ProcessorSpeed")))
  1013.     {
  1014.         HKEY hkey;
  1015.         if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, 
  1016.                                           TEXT("Hardware\Description\System\CentralProcessor\0"), 
  1017.                                           0, KEY_READ, &hkey))
  1018.             return E_FAIL;
  1020.         DWORD dwValue = 0;
  1021.         DWORD cb = sizeof( dwValue );
  1023.         if (ERROR_SUCCESS != SHQueryValueEx(hkey,
  1024.                     TEXT("~Mhz"),
  1025.                     NULL,
  1026.                     NULL,
  1027.                     (LPBYTE) &dwValue,
  1028.                     &cb) == ERROR_SUCCESS) 
  1029.         {       
  1030.             RegCloseKey(hkey);
  1031.             return E_FAIL;
  1032.         }
  1033.         RegCloseKey(hkey);
  1034.         pvOut->vt = VT_I4;
  1035.         V_UI4(pvOut) = dwValue;
  1036.         return S_OK;
  1037.     }
  1038.     else if (!lstrcmpi(szName, TEXT("ProcessorArchitecture")))
  1039.     {
  1040.         SYSTEM_INFO info;
  1041.         GetSystemInfo(&info);
  1042.         pvOut->vt = VT_I4;
  1043.         V_UI4(pvOut) = info.wProcessorArchitecture;
  1044.         return S_OK;
  1045.     }
  1046.     else if (!lstrcmpi(szName, TEXT("PhysicalMemoryInstalled")))
  1047.     {
  1048.         MEMORYSTATUSEX MemoryStatus;
  1049.         MemoryStatus.dwLength = SIZEOF(MEMORYSTATUSEX);
  1050.         NT5_GlobalMemoryStatusEx(&MemoryStatus);
  1051.         pvOut->vt = VT_R8;
  1052.         V_R8(pvOut) = (double)(signed __int64) MemoryStatus.ullTotalPhys;
  1053.         return S_OK;
  1054.     }
  1055.     else
  1056.     {
  1057.         return E_INVALIDARG;
  1058.     }
  1059. }
  1063. #endif // POSTSPLIT