reactos/base/applications/mscutils/servman/propsheet_depends.c

   1 /*
   2  * PROJECT:     ReactOS Services
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        base/applications/mscutils/servman/propsheet_depends.c
   5  * PURPOSE:     Property dialog box message handler
   6  * COPYRIGHT:   Copyright 2006-2009 Ged Murphy <gedmurphy@reactos.org>
   7  *
   8  */
   9
  10 #include "precomp.h"
  11
  12
  13 static HTREEITEM
  14 AddItemToTreeView(HWND hTreeView,
  15                   HTREEITEM hRoot,
  16                   LPTSTR lpLabel,
  17                   ULONG serviceType)
  18 {
  19     TV_ITEM tvi;
  20     TV_INSERTSTRUCT tvins;
  21
  22     ZeroMemory(&tvi, sizeof(tvi));
  23     ZeroMemory(&tvins, sizeof(tvins));
  24
  25     tvi.mask = TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_IMAGE;
  26     tvi.pszText = lpLabel;
  27     tvi.cchTextMax = lstrlen(lpLabel);
  28
  29     if (serviceType == SERVICE_WIN32_OWN_PROCESS ||
  30         serviceType == SERVICE_WIN32_SHARE_PROCESS)
  31     {
  32         tvi.iImage = 1;
  33         tvi.iSelectedImage = 1;
  34     }
  35     else if (serviceType == SERVICE_KERNEL_DRIVER ||
  36              serviceType == SERVICE_FILE_SYSTEM_DRIVER)
  37     {
  38         tvi.iImage = 2;
  39         tvi.iSelectedImage = 2;
  40     }
  41     else
  42     {
  43         tvi.iImage = 0;
  44         tvi.iSelectedImage = 0;
  45     }
  46
  47     tvins.item = tvi;
  48     tvins.hParent = hRoot;
  49
  50     return TreeView_InsertItem(hTreeView, &tvins);
  51 }
  52
  53 #if 0
  54 static VOID
  55 AddServiceDependency(PSERVICEPROPSHEET dlgInfo,
  56                      HWND hTreeView,
  57                      SC_HANDLE hSCManager,
  58                      LPTSTR lpServiceName,
  59                      HTREEITEM hParent,
  60                      HWND hwndDlg)
  61 {
  62     LPQUERY_SERVICE_CONFIG lpServiceConfig;
  63     SC_HANDLE hService;
  64     HTREEITEM hChild;
  65     LPTSTR lpStr;
  66     LPTSTR lpNoDepends;
  67
  68     hService = OpenService(hSCManager,
  69                            lpServiceName,
  70                            SERVICE_QUERY_CONFIG);
  71     if (hService)
  72     {
  73
  74         lpStr = GetDependentServices(hService);
  75         if (lpStr)
  76         {
  77             while (*lpStr)
  78             {
  79                 hChild = AddItemToTreeView(hTreeView,
  80                                            hParent,
  81                                            lpServiceConfig->lpDisplayName,
  82                                            lpServiceConfig->dwServiceType);
  83
  84
  85                 AddServiceDependency(dlgInfo,
  86                                      hTreeView,
  87                                      hSCManager,
  88                                      lpStr,
  89                                      hChild,
  90                                      hwndDlg);
  91
  92                 while (*lpStr++)
  93                     ;
  94             }
  95         }
  96         else
  97         {
  98             if (TreeView_GetCount(hTreeView) == 0)
  99             {
 100                 if (AllocAndLoadString(&lpNoDepends, hInstance, IDS_NO_DEPENDS))
 101                 {
 102                     lpStr = lpNoDepends;
 103                 }
 104
 105                 AddItemToTreeView(hTreeView,
 106                                   hParent,
 107                                   lpStr,
 108                                   0);
 109
 110                 HeapFree(ProcessHeap,
 111                          0,
 112                          lpNoDepends);
 113
 114                 EnableWindow(hTreeView, FALSE);
 115             }
 116         }
 117
 118
 119         HeapFree(ProcessHeap,
 120                  0,
 121                  lpStr);
 122
 123         CloseServiceHandle(hService);
 124     }
 125
 126 }
 127 #endif
 128
 129 static VOID
 130 AddServiceDependent(HWND hTreeView,
 131                     HTREEITEM hParent,
 132                     SC_HANDLE hSCManager,
 133                     LPTSTR lpServiceName,
 134                     LPTSTR lpDisplayName,
 135                     DWORD dwServiceType)
 136 {
 137     LPENUM_SERVICE_STATUS lpServiceStatus;
 138     SC_HANDLE hChildService;
 139     HTREEITEM hChildNode;
 140     DWORD count;
 141     INT i;
 142
 143
 144     hChildNode = AddItemToTreeView(hTreeView,
 145                                    hParent,
 146                                    lpDisplayName,
 147                                    dwServiceType);
 148
 149     hChildService = OpenService(hSCManager,
 150                                 lpServiceName,
 151                                 SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS);
 152     if (hChildService)
 153     {
 154         lpServiceStatus = GetServiceDependents(hChildService, &count);
 155         if (lpServiceStatus)
 156         {
 157             for (i = 0; i < count; i++)
 158             {
 159                 AddServiceDependent(hTreeView,
 160                                     hChildNode,
 161                                     hSCManager,
 162                                     lpServiceStatus[i].lpServiceName,
 163                                     lpServiceStatus[i].lpDisplayName,
 164                                     lpServiceStatus[i].ServiceStatus.dwServiceType);
 165             }
 166
 167             HeapFree(ProcessHeap,
 168                      0,
 169                      lpServiceStatus);
 170         }
 171
 172         CloseServiceHandle(hChildService);
 173     }
 174 }
 175
 176 static VOID
 177 SetServiceDependents(HWND hTreeView,
 178                      SC_HANDLE hSCManager,
 179                      SC_HANDLE hService)
 180 {
 181     LPENUM_SERVICE_STATUS lpServiceStatus;
 182     LPTSTR lpNoDepends;
 183     DWORD count, i;
 184
 185     lpServiceStatus = GetServiceDependents(hService, &count);
 186     if (lpServiceStatus)
 187     {
 188         for (i = 0; i < count; i++)
 189         {
 190             AddServiceDependent(hTreeView,
 191                                 NULL,
 192                                 hSCManager,
 193                                 lpServiceStatus[i].lpServiceName,
 194                                 lpServiceStatus[i].lpDisplayName,
 195                                 lpServiceStatus[i].ServiceStatus.dwServiceType);
 196         }
 197     }
 198     else
 199     {
 200             AllocAndLoadString(&lpNoDepends, hInstance, IDS_NO_DEPENDS);
 201
 202             AddItemToTreeView(hTreeView,
 203                               NULL,
 204                               lpNoDepends,
 205                               0);
 206
 207             HeapFree(ProcessHeap,
 208                      0,
 209                      lpNoDepends);
 210
 211             EnableWindow(hTreeView, FALSE);
 212     }
 213 }
 214
 215 static VOID
 216 SetDependentServices(SC_HANDLE hService)
 217 {
 218 }
 219
 220 static VOID
 221 InitDependPage(PSERVICEPROPSHEET dlgInfo,
 222                HWND hwndDlg)
 223 {
 224     HWND hTreeView1, hTreeView2;
 225     SC_HANDLE hSCManager;
 226     SC_HANDLE hService;
 227
 228     dlgInfo->hDependsImageList = InitImageList(IDI_NODEPENDS,
 229                                                IDI_DRIVER,
 230                                                GetSystemMetrics(SM_CXSMICON),
 231                                                GetSystemMetrics(SM_CXSMICON),
 232                                                IMAGE_ICON);
 233
 234
 235     hTreeView1 = GetDlgItem(hwndDlg, IDC_DEPEND_TREE1);
 236     if (!hTreeView1)
 237         return;
 238
 239     (void)TreeView_SetImageList(hTreeView1,
 240                                 dlgInfo->hDependsImageList,
 241                                 TVSIL_NORMAL);
 242
 243     hTreeView2 = GetDlgItem(hwndDlg, IDC_DEPEND_TREE2);
 244     if (!hTreeView2)
 245         return;
 246
 247     (void)TreeView_SetImageList(hTreeView2,
 248                                 dlgInfo->hDependsImageList,
 249                                 TVSIL_NORMAL);
 250
 251     hSCManager = OpenSCManager(NULL,
 252                                NULL,
 253                                SC_MANAGER_ALL_ACCESS);
 254     if (hSCManager)
 255     {
 256         hService = OpenService(hSCManager,
 257                                dlgInfo->pService->lpServiceName,
 258                                SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_QUERY_CONFIG);
 259         if (hService)
 260         {
 261             /* Set the first tree view */
 262             SetServiceDependents(hTreeView1,
 263                                  hSCManager,
 264                                  hService);
 265
 266             /* Set the second tree view */
 267             SetDependentServices(hService);
 268
 269             CloseServiceHandle(hService);
 270         }
 271
 272         CloseServiceHandle(hSCManager);
 273     }
 274
 275 }
 276
 277
 278
 279 /*
 280  * Dependancies Property dialog callback.
 281  * Controls messages to the Dependancies dialog
 282  */
 283 INT_PTR CALLBACK
 284 DependenciesPageProc(HWND hwndDlg,
 285                      UINT uMsg,
 286                      WPARAM wParam,
 287                      LPARAM lParam)
 288 {
 289     PSERVICEPROPSHEET dlgInfo;
 290
 291     /* Get the window context */
 292     dlgInfo = (PSERVICEPROPSHEET)GetWindowLongPtr(hwndDlg,
 293                                                   GWLP_USERDATA);
 294     if (dlgInfo == NULL && uMsg != WM_INITDIALOG)
 295     {
 296         return FALSE;
 297     }
 298
 299     switch (uMsg)
 300     {
 301         case WM_INITDIALOG:
 302         {
 303             dlgInfo = (PSERVICEPROPSHEET)(((LPPROPSHEETPAGE)lParam)->lParam);
 304             if (dlgInfo != NULL)
 305             {
 306                 SetWindowLongPtr(hwndDlg,
 307                                  GWLP_USERDATA,
 308                                  (LONG_PTR)dlgInfo);
 309
 310                 InitDependPage(dlgInfo, hwndDlg);
 311             }
 312         }
 313         break;
 314
 315         case WM_COMMAND:
 316             switch(LOWORD(wParam))
 317             {
 318
 319             }
 320             break;
 321     }
 322
 323     return FALSE;
 324 }