#include "service.h"

#include "tlog.h"

#include "tconvert.h"

#include "tfilepath.h"

#ifdef _WIN32

#pragma warning(disable : 4996)

#include <windows.h></windows.h>

#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <process.h></process.h>

#include <tchar.h></tchar.h>

#else

#include <string.h></string.h>

#include <errno.h></errno.h>

#endif

#define SZDEPENDENCIES ""

#ifdef _WIN32

//------------------------------------------------------------------------------

LPTSTR GetLastErrorText(LPTSTR lpszBuf, DWORD dwSize) {

  DWORD dwRet;

  LPTSTR lpszTemp = NULL;

  dwRet = FormatMessage(

      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |

          FORMAT_MESSAGE_ARGUMENT_ARRAY,

      NULL, GetLastError(), LANG_NEUTRAL, (LPTSTR)&lpszTemp, 0, NULL);

  // supplied buffer is not long enough

  if (!dwRet || ((long)dwSize < (long)dwRet + 14))

    lpszBuf[0] = TEXT('\0');

  else {

    lpszTemp[lstrlen(lpszTemp) - 2] =

        TEXT('\0');  // remove cr and newline character

    _stprintf(lpszBuf, TEXT("%s (0x%x)"), lpszTemp, GetLastError());

  }

  if (lpszTemp) LocalFree((HLOCAL)lpszTemp);

  return lpszBuf;

}

#endif  // _WIN32

//------------------------------------------------------------------------------

std::string getLastErrorText() {

  std::string errText;

#ifdef _WIN32

  char errBuff[256];

  errText = GetLastErrorText(errBuff, sizeof(errBuff));

#else

  errText = strerror(errno);

#endif

  return errText;

}

//==============================================================================

//==============================================================================

//==============================================================================

//==============================================================================

class TService::Imp {

public:

  Imp() {}

#ifdef _WIN32

  static void WINAPI serviceMain(DWORD dwArgc, LPTSTR *lpszArgv);

  static void WINAPI serviceCtrl(DWORD dwCtrlCode);

  static BOOL WINAPI controlHandler(DWORD dwCtrlType);

  static bool reportStatusToSCMgr(long currentState, long win32ExitCode,

                                  long waitHint);

#endif

  std::string m_name;

  std::string m_displayName;

  static bool m_console;

#ifdef _WIN32

  static SERVICE_STATUS_HANDLE m_hService;

  static SERVICE_STATUS m_ssStatus;  // current status of the service

  static DWORD m_dwErr;

#endif

};

#ifdef _WIN32

SERVICE_STATUS_HANDLE TService::Imp::m_hService = 0;

SERVICE_STATUS TService::Imp::m_ssStatus;

DWORD TService::Imp::m_dwErr = 0;

#endif

bool TService::Imp::m_console = false;

//------------------------------------------------------------------------------

TService::TService(const std::string &name, const std::string &displayName)

    : m_imp(new Imp) {

  m_imp->m_name        = name;

  m_imp->m_displayName = displayName;

  m_instance           = this;

}

//------------------------------------------------------------------------------

TService::~TService() {}

//------------------------------------------------------------------------------

TService *TService::instance() { return m_instance; }

//------------------------------------------------------------------------------

TService *TService::m_instance = 0;

//------------------------------------------------------------------------------

void TService::setStatus(Status status, long exitCode, long waitHint) {

#ifdef _WIN32

  if (!isRunningAsConsoleApp())

    TService::Imp::reportStatusToSCMgr(status, exitCode, waitHint);

  else {

    if (status == Stopped) exit(1);

  }

#else

  if (status == Stopped) exit(1);

#endif

}

//------------------------------------------------------------------------------

std::string TService::getName() const { return m_imp->m_name; }

//------------------------------------------------------------------------------

std::string TService::getDisplayName() const { return m_imp->m_displayName; }

//------------------------------------------------------------------------------

#ifdef _WIN32

void WINAPI TService::Imp::serviceCtrl(DWORD dwCtrlCode) {

  // Handle the requested control code.

  //

  switch (dwCtrlCode) {

  // Stop the service.

  //

  // SERVICE_STOP_PENDING should be reported before

  // setting the Stop Event - hServerStopEvent - in

  // ServiceStop().  This avoids a race condition

  // which may result in a 1053 - The Service did not respond...

  // error.

  case SERVICE_CONTROL_STOP:

  case SERVICE_CONTROL_SHUTDOWN: {

    TService::Imp::reportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR,

                                       3000 /*1*/ /*0*/);

    TService::instance()->onStop();

    TService::Imp::reportStatusToSCMgr(SERVICE_STOPPED, NO_ERROR, 3000);

    return;

  }

  // Update the service status.

  //

  case SERVICE_CONTROL_INTERROGATE:

    break;

  // invalid control code

  //

  default:

    break;

  }

  reportStatusToSCMgr(m_ssStatus.dwCurrentState, NO_ERROR, 0);

}

//------------------------------------------------------------------------------

void WINAPI TService::Imp::serviceMain(DWORD dwArgc, LPTSTR *lpszArgv) {

  // register our service control handler:

  //

  m_hService = RegisterServiceCtrlHandler(

      TService::instance()->getName().c_str(), TService::Imp::serviceCtrl);

  if (m_hService == 0) goto cleanup;

  // SERVICE_STATUS members that don't change in example

  //

  m_ssStatus.dwServiceType             = SERVICE_WIN32_OWN_PROCESS;

  m_ssStatus.dwServiceSpecificExitCode = 0;

  // report the status to the service control manager.

  //

  if (!reportStatusToSCMgr(SERVICE_START_PENDING,  // service state

                           NO_ERROR,               // exit code

                           3000))                  // wait hint

    goto cleanup;

  // AGGIUNGERE INIZIALIZZAZIONE QUI

  if (!reportStatusToSCMgr(SERVICE_RUNNING,  // service state

                           NO_ERROR,         // exit code

                           0))               // wait hint

    goto cleanup;

  TService::instance()->onStart(dwArgc, lpszArgv);

cleanup:

  // try to report the stopped status to the service control manager.

  //

  if (m_hService) reportStatusToSCMgr(SERVICE_STOPPED, m_dwErr, 0);

  return;

}

//------------------------------------------------------------------------------

//

//  TService::Imp::controlHandler( DWORD dwCtrlType )

//

//  PURPOSE: Handled console control events

//

//  PARAMETERS:

//    dwCtrlType - type of control event

//

//  RETURN VALUE:

//    True - handled

//    False - unhandled

//

//  COMMENTS:

//

BOOL WINAPI TService::Imp::controlHandler(DWORD dwCtrlType) {

  switch (dwCtrlType) {

  case CTRL_CLOSE_EVENT:

  case CTRL_LOGOFF_EVENT:

  case CTRL_SHUTDOWN_EVENT:

  case CTRL_BREAK_EVENT:  // use Ctrl+C or Ctrl+Break to simulate

  case CTRL_C_EVENT:      // SERVICE_CONTROL_STOP in debug mode

    _tprintf(TEXT("Stopping %s.\n"),

             TService::instance()->getDisplayName().c_str());

    TService::instance()->onStop();

    return TRUE;

    break;

  }

  return FALSE;

}

//------------------------------------------------------------------------------

//

//  FUNCTION: ReportStatusToSCMgr()

//

//  PURPOSE: Sets the current status of the service and

//           reports it to the Service Control Manager

//

//  PARAMETERS:

//    dwCurrentState - the state of the service

//    dwWin32ExitCode - error code to report

//    dwWaitHint - worst case estimate to next checkpoint

//

//  RETURN VALUE:

//    TRUE  - success

//    FALSE - failure

//

//  COMMENTS:

//

//------------------------------------------------------------------------------

bool TService::Imp::reportStatusToSCMgr(long currentState, long win32ExitCode,

                                        long waitHint) {

  /*

  SERVICE_STATUS srvStatus;		// Declare a SERVICE_STATUS structure,

  and fill it in

  srvStatus.dwServiceType  = SERVICE_WIN32_OWN_PROCESS;	// We're a service

  running in our own process

  // Set the state of the service from the argument, and save it away

  // for future use

  _dwPrevState=_dwCurrState;

  srvStatus.dwCurrentState = _dwCurrState = dwState;

  // Which commands will we accept from the SCM? All the common ones...

  srvStatus.dwControlsAccepted =	SERVICE_ACCEPT_STOP |

                                                                                                  SERVICE_ACCEPT_PAUSE_CONTINUE |

                                                                                                  SERVICE_ACCEPT_SHUTDOWN;

  srvStatus.dwWin32ExitCode = dwExitCode;	// Set the Win32 exit code for

  the service

  srvStatus.dwServiceSpecificExitCode = 0;	// Set the service-specific exit

  code

  srvStatus.dwCheckPoint = dwProgress;	// Set the checkpoint value

  srvStatus.dwWaitHint = __WAIT_TIME_FOR_SERVICE;	// 3 second timeout for

  waits

  return SetServiceStatus( _hService, &srvStatus); // pass the structure to the

  SCM

*/

  static DWORD dwCheckPoint = 1;

  BOOL fResult              = true;

  if (!m_console)  // when running as a console application we don't report to

                   // the SCM

  {

    if (currentState == SERVICE_START_PENDING)

      m_ssStatus.dwControlsAccepted = 0;

    else

      m_ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |

                                      SERVICE_ACCEPT_PAUSE_CONTINUE |

                                      SERVICE_ACCEPT_SHUTDOWN;

    ;

    m_ssStatus.dwCurrentState  = currentState;

    m_ssStatus.dwWin32ExitCode = win32ExitCode;

    m_ssStatus.dwWaitHint      = waitHint;

    if ((currentState == SERVICE_RUNNING) || (currentState == SERVICE_STOPPED))

      m_ssStatus.dwCheckPoint = 0;

    else

      m_ssStatus.dwCheckPoint = dwCheckPoint++;

    // Report the status of the service to the service control manager.

    //

    if (!(fResult = SetServiceStatus(m_hService, &m_ssStatus))) {

      TService::addToMessageLog(QString("Failed to set the service status"));

    }

  }

  return !!fResult;

}

#endif

//------------------------------------------------------------------------------

void TService::run(int argc, char *argv[], bool console) {

  m_imp->m_console = console;

/*

#ifdef _DEBUG

  DebugBreak();

#endif

*/

#ifdef _WIN32

  if (console) {

    _tprintf(TEXT("Starting %s.\n"),

             TService::instance()->getDisplayName().c_str());

    SetConsoleCtrlHandler(TService::Imp::controlHandler, TRUE);

    TService::instance()->onStart(argc, argv);

  } else {

    SERVICE_TABLE_ENTRY dispatchTable[2];

    std::string name = TService::instance()->getName().c_str();

    dispatchTable[0].lpServiceName = (char *)name.c_str();

    dispatchTable[0].lpServiceProc =

        (LPSERVICE_MAIN_FUNCTION)TService::Imp::serviceMain;

    dispatchTable[1].lpServiceName = NULL;

    dispatchTable[1].lpServiceProc = NULL;

    if (!StartServiceCtrlDispatcher(dispatchTable))

      TService::addToMessageLog(QString(TEXT("Service start failed.")));

  }

#else

  TService::instance()->onStart(argc, argv);

#endif

}

//------------------------------------------------------------------------------

void TService::start(const std::string &name) {}

//------------------------------------------------------------------------------

void TService::stop(const std::string &name) {}

//------------------------------------------------------------------------------

bool TService::isRunningAsConsoleApp() const { return m_imp->m_console; }

//------------------------------------------------------------------------------

void TService::install(const std::string &name, const std::string &displayName,

                       const TFilePath &appPath) {

#ifdef _WIN32

  SC_HANDLE schService;

  SC_HANDLE schSCManager;

  schSCManager = OpenSCManager(NULL,  // machine (NULL == local)

                               NULL,  // database (NULL == default)

                               SC_MANAGER_ALL_ACCESS);  // access required

  if (schSCManager) {

    schService = CreateService(

        schSCManager,                                  // SCManager database

        name.c_str(),                                  // name of service

        displayName.c_str(),                           // name to display

        SERVICE_ALL_ACCESS,                            // desired access

        SERVICE_WIN32_OWN_PROCESS,                     // service type

        SERVICE_DEMAND_START,                          // start type

        SERVICE_ERROR_NORMAL,                          // error control type

        ::to_string(appPath.getWideString()).c_str(),  // service's binary

        NULL,                                          // no load ordering group

        NULL,                                          // no tag identifier

        TEXT(SZDEPENDENCIES),                          // dependencies

        NULL,                                          // LocalSystem account

        NULL);                                         // no password

    if (schService) {

      _tprintf(TEXT("%s installed.\n"), displayName.c_str());

      CloseServiceHandle(schService);

    } else {

      _tprintf(TEXT("CreateService failed - %s\n"), getLastErrorText().c_str());

    }

    CloseServiceHandle(schSCManager);

  } else

    _tprintf(TEXT("OpenSCManager failed - %s\n"), getLastErrorText().c_str());

#endif

}

//------------------------------------------------------------------------------

void TService::remove(const std::string &name) {

#ifdef _WIN32

  std::string displayName = name;

  SC_HANDLE schService;

  SC_HANDLE schSCManager;

  schSCManager = OpenSCManager(NULL,  // machine (NULL == local)

                               NULL,  // database (NULL == default)

                               SC_MANAGER_ALL_ACCESS);  // access required

  if (schSCManager) {

    schService = OpenService(schSCManager, name.c_str(), SERVICE_ALL_ACCESS);

    if (schService) {

      SERVICE_STATUS ssStatus;  // current status of the service

      // try to stop the service

      if (ControlService(schService, SERVICE_CONTROL_STOP, &ssStatus)) {

        _tprintf(TEXT("Stopping %s."), displayName.c_str());

        Sleep(1000);

        while (QueryServiceStatus(schService, &ssStatus)) {

          if (ssStatus.dwCurrentState == SERVICE_STOP_PENDING) {

            _tprintf(TEXT("."));

            Sleep(1000);

          } else

            break;

        }

        if (ssStatus.dwCurrentState == SERVICE_STOPPED)

          _tprintf(TEXT("\n%s stopped.\n"), displayName.c_str());

        else

          _tprintf(TEXT("\n%s failed to stop.\n"), displayName.c_str());

      }

      // now remove the service

      if (DeleteService(schService))

        _tprintf(TEXT("%s removed.\n"), displayName.c_str());

      else

        _tprintf(TEXT("DeleteService failed - %s\n"),

                 getLastErrorText().c_str());

      CloseServiceHandle(schService);

    } else

      _tprintf(TEXT("OpenService failed - %s\n"), getLastErrorText().c_str());

    CloseServiceHandle(schSCManager);

  } else

    _tprintf(TEXT("OpenSCManager failed - %s\n"), getLastErrorText().c_str());

#endif

}

//------------------------------------------------------------------------------

void TService::addToMessageLog(const QString &msg) {

  addToMessageLog(msg.toStdString());

}

void TService::addToMessageLog(const std::string &msg) {

#ifdef _WIN32

  TCHAR szMsg[256];

  HANDLE hEventSource;

  LPCTSTR lpszStrings[2];

  if (!TService::Imp::m_console) {

    TService::Imp::m_dwErr = GetLastError();

    // Use event logging to log the error.

    //

    hEventSource =

        RegisterEventSource(NULL, TService::instance()->getName().c_str());

    _stprintf(szMsg, TEXT("%s error: %d"),

              TService::instance()->getName().c_str(), TService::Imp::m_dwErr);

    lpszStrings[0] = szMsg;

    lpszStrings[1] = msg.c_str();

    if (hEventSource != NULL) {

      ReportEvent(hEventSource,         // handle of event source

                  EVENTLOG_ERROR_TYPE,  // event type

                  0,                    // event category

                  0,                    // event ID

                  NULL,                 // current user's SID

                  2,                    // strings in lpszStrings

                  0,                    // no bytes of raw data

                  lpszStrings,          // array of error strings

                  NULL);                // no raw data

      (VOID) DeregisterEventSource(hEventSource);

    }

  } else {

    std::cout << msg.c_str();

  }

#else

  if (!TService::Imp::m_console) {

    QString str(msg.c_str());

    TSysLog::error(str);

  } else {

    std::cout << msg.c_str();

  }

#endif

}