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     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                 HeapFree(ProcessHeap,
  69                          0,
  70                          lpSuccess);
  71             }
  72
  73             CloseServiceHandle(hSc);
  74             bRet = TRUE;
  75         }
  76
  77         CloseServiceHandle(hSCManager);
  78     }
  79
  80     return bRet;
  81 }
  82
  83 static LPTSTR
  84 GetStringFromDialog(PCREATE_DATA Data,
  85                     UINT id)
  86 {
  87     HWND hwnd;
  88     LPTSTR lpString = NULL;
  89     INT iLen = 0;
  90
  91     hwnd = GetDlgItem(Data->hSelf,
  92                       id);
  93     if (hwnd)
  94     {
  95         iLen = GetWindowTextLength(hwnd);
  96         if (iLen)
  97         {
  98             lpString = (LPTSTR)HeapAlloc(ProcessHeap,
  99                                          0,
 100                                          (iLen + 1) * sizeof(TCHAR));
 101             if (lpString)
 102             {
 103                 GetWindowText(hwnd,
 104                               lpString,
 105                               iLen + 1);
 106             }
 107         }
 108     }
 109
 110     return lpString;
 111 }
 112
 113 static BOOL
 114 GetDataFromDialog(PCREATE_DATA Data)
 115 {
 116     BOOL bRet = FALSE;
 117
 118     if ((Data->ServiceName = GetStringFromDialog(Data, IDC_CREATE_SERVNAME)))
 119     {
 120         if ((Data->DisplayName = GetStringFromDialog(Data, IDC_CREATE_DISPNAME)))
 121         {
 122             if ((Data->BinPath = GetStringFromDialog(Data, IDC_CREATE_PATH)))
 123             {
 124                 Data->Description = GetStringFromDialog(Data, IDC_CREATE_DESC);
 125                 Data->Options = GetStringFromDialog(Data, IDC_CREATE_OPTIONS);
 126
 127                 bRet = TRUE;
 128             }
 129         }
 130     }
 131
 132     return bRet;
 133 }
 134
 135 static VOID
 136 FreeMemory(PCREATE_DATA Data)
 137 {
 138     if (Data->ServiceName != NULL)
 139         HeapFree(ProcessHeap,
 140                  0,
 141                  Data->ServiceName);
 142     if (Data->DisplayName != NULL)
 143         HeapFree(ProcessHeap,
 144                  0,
 145                  Data->DisplayName);
 146     if (Data->BinPath != NULL)
 147         HeapFree(ProcessHeap,
 148                  0,
 149                  Data->BinPath);
 150     if (Data->Description != NULL)
 151         HeapFree(ProcessHeap,
 152                  0,
 153                  Data->Description);
 154     if (Data->Options != NULL)
 155         HeapFree(ProcessHeap,
 156                  0,
 157                  Data->Options);
 158
 159     HeapFree(ProcessHeap,
 160              0,
 161              Data);
 162 }
 163
 164 INT_PTR CALLBACK
 165 CreateHelpDialogProc(HWND hDlg,
 166                      UINT message,
 167                      WPARAM wParam,
 168                      LPARAM lParam)
 169 {
 170     HWND hHelp;
 171     HICON hIcon = NULL;
 172     TCHAR Buf[1000];
 173
 174     switch (message)
 175     {
 176         case WM_INITDIALOG:
 177         {
 178             hIcon = (HICON) LoadImage(hInstance,
 179                               MAKEINTRESOURCE(IDI_SM_ICON),
 180                               IMAGE_ICON,
 181                               16,
 182                               16,
 183                               0);
 184
 185             SendMessage(hDlg,
 186                         WM_SETICON,
 187                         ICON_SMALL,
 188                         (LPARAM)hIcon);
 189
 190             hHelp = GetDlgItem(hDlg,
 191                                IDC_CREATE_HELP);
 192
 193             LoadString(hInstance,
 194                        IDS_HELP_OPTIONS,
 195                        Buf,
 196                        sizeof(Buf) / sizeof(TCHAR));
 197
 198             SetWindowText(hHelp,
 199                           Buf);
 200
 201             return TRUE;
 202         }
 203
 204         case WM_COMMAND:
 205         {
 206             if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
 207             {
 208                 bHelpOpen = FALSE;
 209                 DestroyIcon(hIcon);
 210                 DestroyWindow(hDlg);
 211                 return TRUE;
 212             }
 213             break;
 214         }
 215     }
 216
 217     return FALSE;
 218 }
 219
 220 INT_PTR CALLBACK
 221 CreateDialogProc(HWND hDlg,
 222                  UINT message,
 223                  WPARAM wParam,
 224                  LPARAM lParam)
 225 {
 226     HICON hIcon = NULL;
 227
 228     switch (message)
 229     {
 230         case WM_INITDIALOG:
 231         {
 232             hIcon = (HICON)LoadImage(hInstance,
 233                                      MAKEINTRESOURCE(IDI_SM_ICON),
 234                                      IMAGE_ICON,
 235                                      16,
 236                                      16,
 237                                      0);
 238             if (hIcon)
 239             {
 240                 SendMessage(hDlg,
 241                             WM_SETICON,
 242                             ICON_SMALL,
 243                             (LPARAM)hIcon);
 244                 DestroyIcon(hIcon);
 245             }
 246
 247             return TRUE;
 248         }
 249
 250         case WM_COMMAND:
 251         {
 252             switch (LOWORD(wParam))
 253             {
 254                 case IDOK:
 255                 {
 256                     PCREATE_DATA Data;
 257
 258                     Data = (PCREATE_DATA)HeapAlloc(ProcessHeap,
 259                                                    HEAP_ZERO_MEMORY,
 260                                                    sizeof(CREATE_DATA));
 261                     if (Data)
 262                     {
 263                         Data->hSelf = hDlg;
 264
 265                         if (GetDataFromDialog(Data))
 266                         {
 267                             DoCreate(Data);
 268                         }
 269                         else
 270                         {
 271                             /* Something went wrong, leave the dialog
 272                              * open so they can try again */
 273                             FreeMemory(Data);
 274                             break;
 275                         }
 276
 277                         FreeMemory(Data);
 278                     }
 279
 280                     EndDialog(hDlg,
 281                               LOWORD(wParam));
 282                     return TRUE;
 283                 }
 284
 285                 case IDCANCEL:
 286                 {
 287                     EndDialog(hDlg,
 288                               LOWORD(wParam));
 289                     return TRUE;
 290                 }
 291
 292                 case ID_CREATE_HELP:
 293                 {
 294                     HWND hHelp;
 295
 296                     if (! bHelpOpen)
 297                     {
 298                         hHelp = CreateDialog(hInstance,
 299                                              MAKEINTRESOURCE(IDD_DLG_HELP_OPTIONS),
 300                                              hDlg,
 301                                              CreateHelpDialogProc);
 302                         if(hHelp != NULL)
 303                         {
 304                             bHelpOpen = TRUE;
 305                         }
 306                     }
 307                 }
 308                 break;
 309             }
 310         }
 311     }
 312
 313     return FALSE;
 314 }