xdasd_w32.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Copyright (c) 2006, Novell, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are 
 * met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright 
 *       notice, this list of conditions and the following disclaimer in the 
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Novell nor the names of its contributors 
 *       may be used to endorse or promote products derived from this 
 *       software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *--------------------------------------------------------------------------*/

#include <xdas_base.h>

#include "xdasd_main.h"
#include "xdasd_log.h"
#include "xdasd_cmdline.h"

#include <stdio.h>
#include <errno.h>

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tchar.h>

#define SERVICENAME        _T("xdasd")
#define SERVICEDISPLAYNAME _T("Distributed Audit Service")
#define SERVICEDESCRIPTION \
   _T("OpenXDAS Distributed Audit Service provides a common point ") \
   _T("of event filtering and propagation for XDAS audit events.")

static SERVICE_STATUS_HANDLE s_hss; 
static SERVICE_STATUS s_status;

static TCHAR * xdasd_gle_text(void) 
{
   static TCHAR buf[256];

   DWORD rv, gle = GetLastError();

   *buf = 0;
   if ((rv = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, gle, 
         LANG_NEUTRAL, buf, xdas_elemcount(buf) - 14, 0)) > 3) 
   {
      buf[_tcslen(buf) - 3] = 0;  /* remove trailing period */
      _sntprintf(buf + _tcslen(buf), 14, _T(" (0x%x)"), gle); 
   } 
   return buf;
} 

/*==========================================================================
                        Service Installation/Initiation
  ==========================================================================*/

static int xdasd_w32svc_install(int automatic) 
{
   DWORD options = automatic? SERVICE_AUTO_START: SERVICE_DEMAND_START;
   SC_HANDLE hscm, hsvc; 
   TCHAR path[512];
   int rv = 1;

   if (GetModuleFileName(0, path, xdas_elemcount(path)) == 0)
      _tprintf(_T("Unable to install %s: %s.\n"), 
            SERVICEDISPLAYNAME, xdasd_gle_text());
   else if ((hscm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS)) != 0)
   {
      if ((hsvc = CreateService(hscm, SERVICENAME, SERVICEDISPLAYNAME, 
            SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, options, 
            SERVICE_ERROR_NORMAL, path, 0, 0, _T(""), 0, 0)) != 0)
      {
         static SERVICE_DESCRIPTION sd = { SERVICEDESCRIPTION };
         ChangeServiceConfig2(hsvc, SERVICE_CONFIG_DESCRIPTION, &sd);
         _putts(SERVICEDISPLAYNAME _T(" installed."));
         CloseServiceHandle(hsvc); 
         rv = 0;
      }
      else
         _tprintf(_T("CreateService failed: %s.\n"), xdasd_gle_text()); 
      CloseServiceHandle(hscm); 
   }
   else
      _tprintf(_T("OpenSCManager failed: %s.\n"), xdasd_gle_text()); 

   return rv;
} 

static int xdasd_w32svc_stop_handle(SC_HANDLE hsvc, int silent)
{
   int rv = 1;

   if (ControlService(hsvc, SERVICE_CONTROL_STOP, &s_status) != FALSE)
   {
      _tprintf(_T("Stopping %s."), SERVICEDISPLAYNAME);
      while (QueryServiceStatus(hsvc, &s_status) != 0 
            && s_status.dwCurrentState == SERVICE_STOP_PENDING)
      {
         printf(".");
         Sleep(1000);
      } 
      if (s_status.dwCurrentState == SERVICE_STOPPED)
      {
         _putts(_T(".Stopped."));
         rv = 0;
      }
      else
         _putts(_T("FAILED.\n")); 
   }
   else if (GetLastError() == ERROR_SERVICE_NOT_ACTIVE)
   {
      if (!silent)
         _putts(SERVICEDISPLAYNAME _T(" not running."));
      rv = 0;
   }
   else
      _tprintf(_T("Unable to stop %s: %s.\n"), 
            SERVICEDISPLAYNAME, xdasd_gle_text());

   return 0;
}
 
static int xdasd_w32svc_remove(void)
{
   int rv = 1;
   SC_HANDLE hscm, hsvc;

   if ((hscm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS)) != 0)
   {
      if ((hsvc = OpenService(hscm, SERVICENAME, SERVICE_ALL_ACCESS)) != 0) 
      {
         xdasd_w32svc_stop_handle(hsvc, 1);
         if (DeleteService(hsvc) != FALSE)
            _putts(SERVICEDISPLAYNAME _T(" has been removed."));
         else
            _tprintf(_T("DeleteService failed: %s.\n"), xdasd_gle_text()); 
         CloseServiceHandle(hsvc);
         rv = 0;
      }
      else
         _tprintf(_T("OpenService failed: %s.\n"), xdasd_gle_text()); 
      
      CloseServiceHandle(hscm);
   }
   else
      _tprintf(_T("OpenSCManager failed: %s.\n"), xdasd_gle_text()); 

   return rv;
} 

static int xdasd_w32svc_start(void)
{
   int rv = 1;
   SC_HANDLE hscm, hsvc; 

   if ((hscm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS)) != 0)
   {
      if ((hsvc = OpenService(hscm, SERVICENAME, SERVICE_ALL_ACCESS)) != 0)
      {
         if ((rv = (int)StartService(hsvc, 0, 0)) != 0)
            _putts(SERVICEDISPLAYNAME _T(" has been started."));
         else
            _tprintf(_T("StartService failed: %s.\n"), xdasd_gle_text()); 
         CloseServiceHandle(hsvc); 
      }
      else
         _tprintf(_T("OpenService failed: %s.\n"), xdasd_gle_text()); 
      CloseServiceHandle(hscm); 
   }
   else
      _tprintf(_T("OpenSCManager failed: %s\n"), xdasd_gle_text()); 

   return rv;
}

static int xdasd_w32svc_stop(void)
{
   int rv = 1;
   SC_HANDLE hscm, hsvc;

   if ((hscm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS)) != 0)
   {
      if ((hsvc = OpenService(hscm, SERVICENAME, SERVICE_ALL_ACCESS)) != 0)
      {
         rv = xdasd_w32svc_stop_handle(hsvc, 0);
         CloseServiceHandle(hsvc); 
      }
      else
         _tprintf(_T("OpenService failed: %s.\n"), xdasd_gle_text()); 

      CloseServiceHandle(hscm); 
   }
   else
      _tprintf(_T("OpenSCManager failed: %s.\n"), xdasd_gle_text()); 

   return rv;
}

/*==========================================================================
                              Service Execution
  ==========================================================================*/

static BOOL xdasd_scmgr_report(DWORD curstate, DWORD ecode, DWORD hint) 
{
   static DWORD chkpoint = 1;

   BOOL rv = TRUE;

   /* when debugging we don't report to the SCM */
   if (curstate == SERVICE_START_PENDING)
      s_status.dwControlsAccepted = 0;
   else
      s_status.dwControlsAccepted = SERVICE_ACCEPT_STOP; 

   s_status.dwCurrentState = curstate; 
   s_status.dwWin32ExitCode = ecode; 
   s_status.dwWaitHint = hint; 
   s_status.dwCheckPoint = 
         (curstate == SERVICE_RUNNING || curstate == SERVICE_STOPPED)? 
               0: chkpoint++; 

   /* report the status of the service to the service control manager.*/
   if ((rv = SetServiceStatus(s_hss, &s_status)) == FALSE)
      xdasd_log(0, "SetServiceStatus failed.\n"); 

   return rv; 
} 

static void xdasd_stop_service(void) 
{
   xdasd_set_signal(XDASD_SIGTERM);
   xdasd_scmgr_report(SERVICE_STOPPED, NO_ERROR, 3000);
} 

static void xdasd_start_service(int argc, char ** argv)
{
   (void)argc;
   (void)argv;

} 

static VOID WINAPI xdasd_svc_control(DWORD ccode) 
{
   if (ccode == SERVICE_CONTROL_STOP)
   {
      xdasd_scmgr_report(SERVICE_STOP_PENDING, NO_ERROR, 0);
      xdasd_stop_service();
      return;
   }
   xdasd_scmgr_report(s_status.dwCurrentState, NO_ERROR, 0);
} 

static void WINAPI xdasd_service_main(DWORD argc, LPTSTR * argv) 
{
   if ((s_hss = RegisterServiceCtrlHandler(SERVICENAME, 
         xdasd_svc_control)) != 0)
   {
      /* initialize SERVICE_STATUS members that don't change */
      s_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
      s_status.dwServiceSpecificExitCode = 0;

      /* report the xdasd status to the service control manager */
      if (xdasd_scmgr_report(SERVICE_START_PENDING, NO_ERROR, 3000))
      {
         int err;
         XDASDCmdLine cmdline;

         /* NOTE: The following cast is a problem that needs to be fixed! */
         if (xdasd_parse_cmdline(argc, (char **)argv, &cmdline) < 0)
         {
            xdasd_scmgr_report(SERVICE_STOP_PENDING, (DWORD)(-1), 0);
            return;
         }

         if (!xdasd_scmgr_report(SERVICE_START_PENDING, 0, 3000))
            return;

         err = xdasd_main_init(&cmdline);
         xdasd_scmgr_report(err? SERVICE_STOP_PENDING: SERVICE_RUNNING, err, 0);
         if (!err)
            xdasd_main_run();
      }
      xdasd_scmgr_report(SERVICE_STOPPED, 0, 0);
   }
}

int main(int argc, char ** argv) 
{
   int err;
   XDASDCmdLine cmdline;

   if (xdasd_parse_cmdline(argc, argv, &cmdline) != 0)
      xdasd_fatal("Invalid command line.\n");

   switch (cmdline.action)
   {
      case XDASD_INSTALL:  return xdasd_w32svc_install(cmdline.autostart);
      case XDASD_REMOVE:   return xdasd_w32svc_remove();
      case XDASD_START:    return xdasd_w32svc_start();
      case XDASD_STOP:     return xdasd_w32svc_stop();

      default: /* default action (no cmdline options) is to run the service */
      {
         static SERVICE_TABLE_ENTRY dispatchTable[] = 
         { 
            {SERVICENAME, (LPSERVICE_MAIN_FUNCTION)xdasd_service_main}, 
            {0, 0} 
         };

         if (StartServiceCtrlDispatcher(dispatchTable) != FALSE)
            return 0;
         if (GetLastError() != ERROR_FAILED_SERVICE_CONTROLLER_CONNECT)
            return 1;
      }
   }
   if ((err = xdasd_main_init(&cmdline)) == 0)
      xdasd_main_run();
   return err;
}