base/applications/mscutils/servman/create.c

   1 /*
   2  * PROJECT:     ReactOS Services
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        base/applications/mscutils/servman/create.c
   5  * PURPOSE:     Create a new service
   6  * COPYRIGHT:   Copyright 2006-2007 Ged Murphy <gedmurphy@reactos.org>
   7  *
   8  */
   9
  10 #include "precomp.h"
  11
  12 typedef struct _CREATE_DATA
  13 {
  14     HWND hSelf;
  15     LPTSTR ServiceName;
  16     LPTSTR DisplayName;
  17     LPTSTR BinPath;
  18     LPTSTR Description;
  19     LPTSTR Options;
  20
  21 } CREATE_DATA, *PCREATE_DATA;
  22
  23 static BOOL bHelpOpen = FALSE;
  24
  25 static BOOL
  26 DoCreate(PCREATE_DATA Data)
  27 {
  28     SC_HANDLE hSCManager;
  29     SC_HANDLE hSc;
  30     BOOL bRet = FALSE;
  31
  32     /* open handle to the SCM */
  33     hSCManager = OpenSCManager(NULL,
  34                                NULL,
  35                                SC_MANAGER_ALL_ACCESS);
  36     if (hSCManager)
  37     {
  38         hSc = CreateService(hSCManager,
  39                             Data->ServiceName,
  40                             Data->DisplayName,
  41                             SERVICE_ALL_ACCESS,
  42                             SERVICE_WIN32_OWN_PROCESS,
  43                             SERVICE_DEMAND_START,
  44                             SERVICE_ERROR_NORMAL,
  45                             Data->BinPath,
  46                             NULL,
  47                             NULL,
  48                             NULL,
  49                             NULL,
  50                             NULL);
  51
  52         if (hSc)
  53         {
  54             LPTSTR lpSuccess;
  55
  56             /* Set the service description as CreateService
  57                does not do this for us */
  58             SetServiceDescription(Data->ServiceName,
  59                                   Data->Description);
  60
  61             /* report success to user */
  62             if (AllocAndLoadString(&lpSuccess,
  63                                    hInstance,
  64                                    IDS_CREATE_SUCCESS))
  65             {
  66                 DisplayString(lpSuccess);
  67
  68                 LocalFree(lpSuccess);
  69             }
  70
  71             CloseServiceHandle(hSc);
  72             bRet = TRUE;
  73         }
  74
  75         CloseServiceHandle(hSCManager);
  76     }
  77
  78     return bRet;
  79 }
  80
  81 static LPTSTR
  82 GetStringFromDialog(PCREATE_DATA Data,
  83                     UINT id)
  84 {
  85     HWND hwnd;
  86     LPTSTR lpString = NULL;
  87     INT iLen = 0;
  88
  89     hwnd = GetDlgItem(Data->hSelf,
  90                       id);
  91     if (hwnd)
  92     {
  93         iLen = GetWindowTextLength(hwnd);
  94         if (iLen)
  95         {
  96             lpString = (LPTSTR)HeapAlloc(ProcessHeap,
  97                                          0,
  98                                          (iLen + 1) * sizeof(TCHAR));
  99             if (lpString)
 100             {
 101                 GetWindowText(hwnd,
 102                               lpString,
 103                               iLen + 1);
 104             }
 105         }
 106     }
 107
 108     return lpString;
 109 }
 110
 111 static BOOL
 112 GetDataFromDialog(PCREATE_DATA Data)
 113 {
 114     BOOL bRet = FALSE;
 115
 116     if ((Data->ServiceName = GetStringFromDialog(Data, IDC_CREATE_SERVNAME)))
 117     {
 118         if ((Data->DisplayName = GetStringFromDialog(Data, IDC_CREATE_DISPNAME)))
 119         {
 120             if ((Data->BinPath = GetStringFromDialog(Data, IDC_CREATE_PATH)))
 121             {
 122                 Data->Description = GetStringFromDialog(Data, IDC_CREATE_DESC);
 123                 Data->Options = GetStringFromDialog(Data, IDC_CREATE_OPTIONS);
 124
 125                 bRet = TRUE;
 126             }
 127         }
 128     }
 129
 130     return bRet;
 131 }
 132
 133 static VOID
 134 FreeMemory(PCREATE_DATA Data)
 135 {
 136     if (Data->ServiceName != NULL)
 137         HeapFree(ProcessHeap,
 138                  0,
 139                  Data->ServiceName);
 140     if (Data->DisplayName != NULL)
 141         HeapFree(ProcessHeap,
 142                  0,
 143                  Data->DisplayName);
 144     if (Data->BinPath != NULL)
 145         HeapFree(ProcessHeap,
 146                  0,
 147                  Data->BinPath);
 148     if (Data->Description != NULL)
 149         HeapFree(ProcessHeap,
 150                  0,
 151                  Data->Description);
 152     if (Data->Options != NULL)
 153         HeapFree(ProcessHeap,
 154                  0,
 155                  Data->Options);
 156
 157     HeapFree(ProcessHeap,
 158              0,
 159              Data);
 160 }
 161
 162 INT_PTR CALLBACK
 163 CreateHelpDialogProc(HWND hDlg,
 164                      UINT message,
 165                      WPARAM wParam,
 166                      LPARAM lParam)
 167 {
 168     HWND hHelp;
 169     HICON hIcon = NULL;
 170     TCHAR Buf[1000];
 171
 172     switch (message)
 173     {
 174         case WM_INITDIALOG:
 175         {
 176             hIcon = (HICON) LoadImage(hInstance,
 177                               MAKEINTRESOURCE(IDI_SM_ICON),
 178                               IMAGE_ICON,
 179                               16,
 180                               16,
 181                               0);
 182
 183             SendMessage(hDlg,
 184                         WM_SETICON,
 185                         ICON_SMALL,
 186                         (LPARAM)hIcon);
 187
 188             hHelp = GetDlgItem(hDlg,
 189                                IDC_CREATE_HELP);
 190
 191             LoadString(hInstance,
 192                        IDS_HELP_OPTIONS,
 193                        Buf,
 194                        sizeof(Buf) / sizeof(TCHAR));
 195
 196             SetWindowText(hHelp,
 197                           Buf);
 198
 199             return TRUE;
 200         }
 201
 202         case WM_COMMAND:
 203         {
 204             if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
 205             {
 206                 bHelpOpen = FALSE;
 207                 DestroyIcon(hIcon);
 208                 DestroyWindow(hDlg);
 209                 return TRUE;
 210             }
 211             break;
 212         }
 213     }
 214
 215     return FALSE;
 216 }
 217
 218 INT_PTR CALLBACK
 219 CreateDialogProc(HWND hDlg,
 220                  UINT message,
 221                  WPARAM wParam,
 222                  LPARAM lParam)
 223 {
 224     HICON hIcon = NULL;
 225
 226     switch (message)
 227     {
 228         case WM_INITDIALOG:
 229         {
 230             hIcon = (HICON)LoadImage(hInstance,
 231                                      MAKEINTRESOURCE(IDI_SM_ICON),
 232                                      IMAGE_ICON,
 233                                      16,
 234                                      16,
 235                                      0);
 236             if (hIcon)
 237             {
 238                 SendMessage(hDlg,
 239                             WM_SETICON,
 240                             ICON_SMALL,
 241                             (LPARAM)hIcon);
 242                 DestroyIcon(hIcon);
 243             }
 244
 245             return TRUE;
 246         }
 247
 248         case WM_COMMAND:
 249         {
 250             switch (LOWORD(wParam))
 251             {
 252                 case IDOK:
 253                 {
 254                     PCREATE_DATA Data;
 255
 256                     Data = (PCREATE_DATA)HeapAlloc(ProcessHeap,
 257                                                    HEAP_ZERO_MEMORY,
 258                                                    sizeof(CREATE_DATA));
 259                     if (Data)
 260                     {
 261                         Data->hSelf = hDlg;
 262
 263                         if (GetDataFromDialog(Data))
 264                         {
 265                             DoCreate(Data);
 266                         }
 267                         else
 268                         {
 269                             /* Something went wrong, leave the dialog
 270                              * open so they can try again */
 271                             FreeMemory(Data);
 272                             break;
 273                         }
 274
 275                         FreeMemory(Data);
 276                     }
 277
 278                     EndDialog(hDlg,
 279                               LOWORD(wParam));
 280                     return TRUE;
 281                 }
 282
 283                 case IDCANCEL:
 284                 {
 285                     EndDialog(hDlg,
 286                               LOWORD(wParam));
 287                     return TRUE;
 288                 }
 289
 290                 case ID_CREATE_HELP:
 291                 {
 292                     HWND hHelp;
 293
 294                     if (! bHelpOpen)
 295                     {
 296                         hHelp = CreateDialog(hInstance,
 297                                              MAKEINTRESOURCE(IDD_DLG_HELP_OPTIONS),
 298                                              hDlg,
 299                                              CreateHelpDialogProc);
 300                         if(hHelp != NULL)
 301                         {
 302                             bHelpOpen = TRUE;
 303                         }
 304                     }
 305                 }
 306                 break;
 307             }
 308         }
 309     }
 310
 311     return FALSE;
 312 }