reactos/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     LPWSTR ServiceName;
  16     LPWSTR DisplayName;
  17     LPWSTR BinPath;
  18     LPWSTR Description;
  19     LPWSTR 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 = OpenSCManagerW(NULL,
  34                                 NULL,
  35                                 SC_MANAGER_ALL_ACCESS);
  36     if (hSCManager)
  37     {
  38         hSc = CreateServiceW(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             LPWSTR 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 LPWSTR
  82 GetStringFromDialog(PCREATE_DATA Data,
  83                     UINT id)
  84 {
  85     HWND hwnd;
  86     LPWSTR lpString = NULL;
  87     INT iLen = 0;
  88
  89     hwnd = GetDlgItem(Data->hSelf,
  90                       id);
  91     if (hwnd)
  92     {
  93         iLen = GetWindowTextLengthW(hwnd);
  94         if (iLen)
  95         {
  96             lpString = (LPWSTR)HeapAlloc(ProcessHeap,
  97                                          0,
  98                                          (iLen + 1) * sizeof(WCHAR));
  99             if (lpString)
 100             {
 101                 GetWindowTextW(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     WCHAR Buf[1000];
 171
 172     switch (message)
 173     {
 174         case WM_INITDIALOG:
 175         {
 176             hIcon = (HICON) LoadImageW(hInstance,
 177                                        MAKEINTRESOURCE(IDI_SM_ICON),
 178                                        IMAGE_ICON,
 179                                        16,
 180                                        16,
 181                                        0);
 182
 183             SendMessageW(hDlg,
 184                          WM_SETICON,
 185                          ICON_SMALL,
 186                          (LPARAM)hIcon);
 187
 188             hHelp = GetDlgItem(hDlg,
 189                                IDC_CREATE_HELP);
 190
 191             LoadStringW(hInstance,
 192                         IDS_HELP_OPTIONS,
 193                         Buf,
 194                         sizeof(Buf) / sizeof(WCHAR));
 195
 196             SetWindowTextW(hHelp, Buf);
 197
 198             return TRUE;
 199         }
 200
 201         case WM_COMMAND:
 202         {
 203             if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
 204             {
 205                 bHelpOpen = FALSE;
 206                 DestroyIcon(hIcon);
 207                 DestroyWindow(hDlg);
 208                 return TRUE;
 209             }
 210             break;
 211         }
 212     }
 213
 214     return FALSE;
 215 }
 216
 217 INT_PTR CALLBACK
 218 CreateDialogProc(HWND hDlg,
 219                  UINT message,
 220                  WPARAM wParam,
 221                  LPARAM lParam)
 222 {
 223     HICON hIcon = NULL;
 224
 225     switch (message)
 226     {
 227         case WM_INITDIALOG:
 228         {
 229             hIcon = (HICON)LoadImage(hInstance,
 230                                      MAKEINTRESOURCE(IDI_SM_ICON),
 231                                      IMAGE_ICON,
 232                                      16,
 233                                      16,
 234                                      0);
 235             if (hIcon)
 236             {
 237                 SendMessage(hDlg,
 238                             WM_SETICON,
 239                             ICON_SMALL,
 240                             (LPARAM)hIcon);
 241                 DestroyIcon(hIcon);
 242             }
 243
 244             return TRUE;
 245         }
 246
 247         case WM_COMMAND:
 248         {
 249             switch (LOWORD(wParam))
 250             {
 251                 case IDOK:
 252                 {
 253                     PCREATE_DATA Data;
 254
 255                     Data = (PCREATE_DATA)HeapAlloc(ProcessHeap,
 256                                                    HEAP_ZERO_MEMORY,
 257                                                    sizeof(CREATE_DATA));
 258                     if (Data)
 259                     {
 260                         Data->hSelf = hDlg;
 261
 262                         if (GetDataFromDialog(Data))
 263                         {
 264                             DoCreate(Data);
 265                         }
 266                         else
 267                         {
 268                             /* Something went wrong, leave the dialog
 269                              * open so they can try again */
 270                             FreeMemory(Data);
 271                             break;
 272                         }
 273
 274                         FreeMemory(Data);
 275                     }
 276
 277                     EndDialog(hDlg,
 278                               LOWORD(wParam));
 279                     return TRUE;
 280                 }
 281
 282                 case IDCANCEL:
 283                 {
 284                     EndDialog(hDlg,
 285                               LOWORD(wParam));
 286                     return TRUE;
 287                 }
 288
 289                 case ID_CREATE_HELP:
 290                 {
 291                     HWND hHelp;
 292
 293                     if (! bHelpOpen)
 294                     {
 295                         hHelp = CreateDialog(hInstance,
 296                                              MAKEINTRESOURCE(IDD_DLG_HELP_OPTIONS),
 297                                              hDlg,
 298                                              CreateHelpDialogProc);
 299                         if(hHelp != NULL)
 300                         {
 301                             bHelpOpen = TRUE;
 302                         }
 303                     }
 304                 }
 305                 break;
 306             }
 307         }
 308     }
 309
 310     return FALSE;
 311 }