service_root.cpp

Go to the documentation of this file.

#ifndef SERVICE_ROOT_IMPLEMENTATION_FILE
#define SERVICE_ROOT_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : service_root                                                      *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "service_root.h"

#include <basis/convert_utf.h>
#include <basis/function.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/mutex.h>
#include <basis/portable.h>
#include <basis/string_array.h>
#include <opsystem/command_line.h>
#include <loggers/file_logger.h>
#include <opsystem/filename.h>
#include <opsystem/ini_config.h>
#include <opsystem/path_configuration.h>
#include <opsystem/rendezvous.h>

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

using namespace portable;

//#define DEBUG_SERVICE_ROOT
  // uncomment for noisier version.

#ifdef __WIN32__
  // pull in the special win32 service junk.
  #include <io.h>
  #include <process.h>
  #include <tchar.h>
  class internal_service_status : public SERVICE_STATUS {};
#else
  // placeholders for other platforms.
  class internal_service_status {};

  enum more_service_markers {
    // control codes used in control_service.
    SERVICE_CONTROL_STOP = 999,
    SERVICE_CONTROL_INTERROGATE
  };
#endif


#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)


service_root *service_root::_last_root = NIL;

service_root::service_root(const istring &service_name,
    const istring &display_name, const string_array &dependencies)
: _leave_now(false),
  _service_name(new istring(service_name)),
  _display_name(new istring(display_name)),
  _dependencies(new string_array(dependencies)),
  _error_code(0),
  _normal_app(false),
  _checkpoint(1),
  _service_status(new internal_service_status),
  _control_handle(0),
  _app_lock(NIL),
  _got_lock(false)
{
  _last_root = this;
  SET_DEFAULT_COMBO_LOGGER;
}

service_root::~service_root()
{
  _last_root = NIL;
  if (_got_lock) _app_lock->unlock();
  WHACK(_service_name);
  WHACK(_display_name);
  WHACK(_dependencies);
  WHACK(_service_status);
  WHACK(_app_lock);
}

const istring &service_root::service_name() const { return *_service_name; }

const istring &service_root::display_name() const { return *_display_name; }

u_int service_root::current_status()
{
#ifdef __WIN32__
  return _service_status->dwCurrentState; 
#else
  return 0;
#endif
}

service_root &service_root::get_root()
{
  if (!_last_root) throw "_last_root not set for service_root class!";
  return *_last_root;
}

void service_root::stop_service() { _leave_now = true; }

const string_array &service_root::dependencies() const
{ return *_dependencies; }

int service_root::instruct(int argc, char **argv)
{
  command_line cmd(argc, argv);
  istring app = cmd.program_name().rootname();
  program_wide_logger().log(app + istring(" --install"));
  program_wide_logger().log("  -> installs the service.");
  program_wide_logger().log("  additional install flags include:");
  program_wide_logger().log("    --automatic -> marks the service as automatically launched.");
  program_wide_logger().log("    --security inifile -> sets service login using inifile.");
  program_wide_logger().log("      (ini file must have a [security] section and two entries");
  program_wide_logger().log("       named user and password)");
  program_wide_logger().log(app + istring(" --remove"));
  program_wide_logger().log("  -> removes the service.");
  program_wide_logger().log(app + istring(" --standalone"));
  program_wide_logger().log("  -> runs as a normal application (not as a service).");
  return 1;
}

bool service_root::report_status(u_int dwCurrentState, u_int dwWin32ExitCode,
    u_int dwWaitHint)
{
#ifndef __WIN32__
  if (dwCurrentState || dwWin32ExitCode || dwWaitHint) {}
  return true;
#else
  // we don't bother with reporting if this service is in standalone mode.
  if (!_normal_app) {
    // this is a real service so make the report.
    if (dwCurrentState == SERVICE_START_PENDING)
      _service_status->dwControlsAccepted = 0;
    else
      _service_status->dwControlsAccepted = SERVICE_ACCEPT_STOP;

    _service_status->dwCurrentState = dwCurrentState;
    _service_status->dwWin32ExitCode = dwWin32ExitCode;
    _service_status->dwWaitHint = dwWaitHint;

    if ( (dwCurrentState == SERVICE_RUNNING)
        || (dwCurrentState == SERVICE_STOPPED) )
      _service_status->dwCheckPoint = 0;
    else
      _service_status->dwCheckPoint = _checkpoint++;

    // Report the status of the service to the service control manager.
    if (!SetServiceStatus((SERVICE_STATUS_HANDLE)_control_handle,
        _service_status)) {
      log_event("failed in call to SetServiceStatus");
      return false;
    }
  }
  return true;
#endif
}

void service_root::log_event(const istring &to_log) const
{
#ifndef __WIN32__
  program_wide_logger().log(to_log);
#else
  if (_normal_app) {
    // we don't send events to the system log when standalone.
    program_wide_logger().log(to_log);
  } else {
    // we're a real service probably, so send a system event out.
    u_int dwErr = GetLastError();
    HANDLE event_source = RegisterEventSource(NIL,
        to_unicode_temp(service_name()));
    if (!event_source) return;  // failed to create the event support.
    istring message(istring::SPRINTF, "%s had an error %d.",
        service_name().s(), dwErr);
    LPCTSTR string_list[2];
    to_unicode_persist(temp_msg, message);
    string_list[0] = temp_msg;
    to_unicode_persist(temp_log, to_log);
    string_list[1] = temp_log;
    ReportEvent(event_source, EVENTLOG_ERROR_TYPE, 0, 0, NIL, 2, 0,
        string_list, NIL);                
    DeregisterEventSource(event_source);
  }
#endif
}

bool service_root::already_running(const istring &program_name)
{
  FUNCDEF("already_running");
  if (!program_name) {
    LOG("no program name for service, so we're not making it a singleton.");
    return false;  // "no program" is never running.
  }
  // create the lock name based on our program name.
  _app_lock = new rendezvous(program_name + "_service_");
  _got_lock = _app_lock->lock(rendezvous::IMMEDIATE_RETURN);
#ifdef DEBUG_SERVICE_ROOT
  if (_got_lock)
    LOG("program was not running yet.")
  else
    LOG("program was already running!");
#endif
  return !_got_lock;
}

void service_root::stop_service_handler(int formal(sig_num))
{ get_root().stop_service(); }

int service_root::initialize(int argc, char **argv, const istring &program_name)
{
  FUNCDEF("initialize");
#ifndef __WIN32__
  if (already_running(program_name)) {
    LOG("service is already running, so this instance is leaving.");
    return 0;
  }

  // hook in some signal handlers so we do a clean shutdown.
  signal(SIGHUP, stop_service_handler);
  signal(SIGINT, stop_service_handler);

  standalone(argc, argv);
  return 0;
#else
  to_unicode_persist(temp_serv, service_name());

  SERVICE_TABLE_ENTRY dispatchTable[] = {
    { temp_serv, (LPSERVICE_MAIN_FUNCTION)setup },
    { NIL, NIL }
  };

  command_line args(argc, argv);

  // note: for the installation of the service to really "work", the person
  // being set up as the service's user id must have the right to run as a
  // service.  this is separately available in the run_as_service program.

  if (args.entries() > 0) {
    int index = 0;
    if (args.find("install", index, false)) {
      istring user, password;  // only used if there's security info.
      bool set_auto = false;
      index = 0;  // reset for second search.
      if (args.find("automatic", index, false))
        set_auto = true;  // they want automatic startup.
      index = 0;  // reset for third search.
      if (args.find("security", index, false)) {
        index++;  // jump to next item for the filename.
        if (index > args.entries() - 1) {
          // they've left us no string for this.
          LOG("Failed to find the filename for the \"security\""
              "parameter!\n");
          return instruct(argc, argv);
        }
        command_parameter parm = args.get(index);
        istring ini_file = parm.text();
        ini_configurator conf(ini_file, ini_configurator::RETURN_ONLY,
            ini_configurator::APPLICATION_DIRECTORY);
//hmmm: check if the ini config is happy.
        user = conf.load("security", "user", "");
        password = conf.load("security", "password", "");
        unlink(ini_file.s());
      }

      install(set_auto, user, password);
      return 0;
    } else if (args.find("remove", index, false)) {
      remove();
      return 0;
    } else if (args.find("standalone", index, false)) {
      if (already_running(program_name)) {
        LOG("service is already running, so this instance is leaving.");
        return 0;
      }
      standalone(argc, argv);
      return 0;
    } else return instruct(argc, argv);
      // if they got to here, they don't know what the commands are, so
      // print them out.
  }

  if (already_running(program_name)) {
    LOG("service is already running, so this instance is leaving.");
    return 0;
  }

  // no command line parameters were passed, so this is probably being started
  // by the Service Control Manager.

  LOG("starting service control dispatcher.");

  if (!StartServiceCtrlDispatcher(dispatchTable)) {
    log_event("StartServiceCtrlDispatcher failed.");
    return 1;
  }
  return 0;
#endif
}

void service_root::setup(int argc, char **argv)
{
  service_root &root = get_root();
#ifdef __WIN32__
  // register the control request handler for the service.
  root._control_handle = (void *)RegisterServiceCtrlHandler
      (to_unicode_temp(root.service_name()), control_service);

  if (!root._control_handle) return;
    // failed to get a handle.  this is not good.

  // set some boilerplate values.
  root._service_status->dwServiceType = SERVICE_WIN32_OWN_PROCESS;

  // add in desktop interaction, which will really only work for the SYSTEM
  // account (LocalSystem).  but apparently if we don't add it here, the
  // registration for the service in the services browser doesn't show it as
  // an option.
  root._service_status->dwServiceType |= SERVICE_INTERACTIVE_PROCESS;

  root._service_status->dwServiceSpecificExitCode = 0;
#else
  root._control_handle = 0;
#endif

  // record that we have started the service.
  root.report_status(SERVICE_START_PENDING, 0, 0);
  // now actually begin.
  root.perform_service(argc, argv);

  // tell the SCM that we're shutting down now.
  if (root._control_handle)
    root.report_status(SERVICE_STOPPED, root.error_code(), 0);
}

void service_root::control_service(u_long control_code)
{
  service_root &root = get_root();
  switch(control_code) {
    case SERVICE_CONTROL_STOP:
      root.report_status(SERVICE_STOP_PENDING, 0, 0);
        // SERVICE_STOP_PENDING is reported before the stop to avoid a race
        // condition between the shutdown process and the service status
        // reporting (might claim an error 1053 occurred otherwise).
      root.stop_service();
      return;
    case SERVICE_CONTROL_INTERROGATE:
//do something useful here?
      break;
    default:  // unknown control codes...
      break;
  }
  root.report_status(root.current_status(), 0, 0);
}

flexichar *service_root::compute_dependency_string()
{
  // this might be useful in general, although it's only used here so far.
  // this takes a string array and warps it into a single string.  strings
  // are separated by null characters, while the end of the list has two
  // null characters.  note that the returned string must be deleted after
  // it is done being used!
  int deplen = 2;  // two character minimum for double nulls.
  // the incoming dependencies are utf-8 strings, so we should always have
  // enough space by counting their length, even when going to unicode.
  for (int i = 0; i < _dependencies->length(); i++)
    deplen += (*_dependencies)[i].length() + 1;
  flexichar *dep_copy = new flexichar[deplen];
  int dep_posn = 0;
  for (int j = 0; j < _dependencies->length(); j++) {
    to_unicode_persist(current_dep, (*_dependencies)[j]);
    const int len = current_dep.length();
    for (int k = 0; k < len + 1; k++) {
      *(dep_copy + dep_posn + k) = ((flexichar *)current_dep)[k];
    }
    dep_posn += len + 1;
  }
  // dependency format wants two nulls at end.
  *(dep_copy + dep_posn++) = '\0';
  *(dep_copy + dep_posn++) = '\0';
  return dep_copy;
}

//hmmm: shouldn't that return a bool or something?
void service_root::install(bool set_auto, const istring &user_in,
    const istring &password)
{
  FUNCDEF("install");
#ifndef __WIN32__
  if (set_auto || !user_in || !password) {}
  return;
#else
  istring path = ::module_name();
  if (!path) {
    LOG(istring("Unable to install ") + display_name().s()
        + istring(" - ") + system_error_text(GetLastError()));
    return;
  }

  // permit the service to use the desktop if it's LocalSystem.
  bool can_use_desktop = false;
  if ( !user_in
      || user_in.iequals("LocalSystem")
      || user_in.iequals(".\\LocalSystem") ) {
    LOG("setting the service to be able to interact with the desktop.");
    can_use_desktop = true;
  }

  istring user = user_in;
  if (user.t() && negative(user.find('\\')) ) {
    // fix the user's domain name to be local.  we are tolerating using an
    // nt-domain username but don't expect it to work properly.
    user = istring(".\\") + user_in;
  }

  SC_HANDLE manager = OpenSCManager(NIL, NIL, SC_MANAGER_ALL_ACCESS);
    // open the manager on this machine with the local database.
  if (manager) {
    flexichar *dep_copy = service_root::compute_dependency_string();
      // this is a newly allocated string which we must delete below.

//hmmm: shouldn't we have a flag for when we want this to be an automatically
//      started service at startup!!!???
//      we need to encapsulate how services can start at the interface.

    // this handles when automatic startup is desired.
    int start_flag = SERVICE_DEMAND_START;
    if (set_auto) start_flag = SERVICE_AUTO_START;

    // prepare appropriate parms for security info, if passed.
    const char *user_p = user.t()? user.s() : NIL;
    const char *pass_p = password.t()? password.s() : NIL;

    int service_mode = SERVICE_WIN32_OWN_PROCESS;
    if (can_use_desktop) service_mode |= SERVICE_INTERACTIVE_PROCESS;
//hmmm: only include the interactive if they pass --desktop?

    SC_HANDLE service = CreateService(manager, to_unicode_temp(service_name()),
        to_unicode_temp(display_name()), SERVICE_ALL_ACCESS, service_mode,
        start_flag, SERVICE_ERROR_NORMAL, to_unicode_temp(path), NIL, NIL,
        dep_copy, to_unicode_temp(user_p), to_unicode_temp(pass_p));
    WHACK(dep_copy);  // clean up the copy we made.

    if ( service ) {
      istring sec_info;
      if (user.t())
        sec_info = istring(" under user id ") + user;
      program_wide_logger().log(display_name() + istring(" is now installed") + sec_info + ".");
      CloseServiceHandle(service);
    } else
      program_wide_logger().log(istring("CreateService failed: ")
          + system_error_text(GetLastError()));

    CloseServiceHandle(manager);
  } else
    program_wide_logger().log(istring("OpenSCManager failed: ")
        + system_error_text(GetLastError()));
#endif
}

void service_root::remove()
{
  FUNCDEF("remove");
#ifndef __WIN32__
  return;
#else
  SC_HANDLE manager = OpenSCManager(NIL, NIL, SC_MANAGER_ALL_ACCESS);
  if (!manager) {
    program_wide_logger().log(istring("OpenSCManager failed: ")
        + system_error_text(GetLastError()));
    return;
  }
  SC_HANDLE service = OpenService(manager, to_unicode_temp(service_name()),
      SERVICE_ALL_ACCESS);
  if (!service) {
    program_wide_logger().log(istring("OpenService failed: ")
        + system_error_text(GetLastError()));
    CloseServiceHandle(manager);
    return;
  }
  // now try to stop the service.
  if (ControlService(service, SERVICE_CONTROL_STOP, _service_status)) {
#ifndef OMIT_PROGRAM_WIDE_LOGGER
    log_base::line_ending eol = program_wide_logger().eol();
    program_wide_logger().eol(log_base::NO_ENDING);
#else
    log_base::line_ending eol = log_base::CRLF_AT_END;
#endif
    program_wide_logger().log(istring("Stopping ") + display_name() + ".");
    portable::sleep_ms(200);
    while (QueryServiceStatus( service, _service_status ) ) {
      if (current_status() == SERVICE_STOP_PENDING) {
        program_wide_logger().log(".");
        portable::sleep_ms(100);
      } else break;
    }
    program_wide_logger().eol(eol);
    program_wide_logger().log("");  // force one ending out.

    if (current_status() == SERVICE_STOPPED)
      program_wide_logger().log(display_name() + istring(" stopped."));
    else
      program_wide_logger().log(display_name() + istring(" failed to stop."));
  }

  // now remove the service
  if (DeleteService(service))
    program_wide_logger().log(display_name() + istring(" removed."));
  else
    program_wide_logger().log(display_name() + istring(" could not be "
        "removed: ") + system_error_text(GetLastError()));
  // clean up everything.
  CloseServiceHandle(service);
  CloseServiceHandle(manager);
#endif
}

void service_root::standalone(int argc, char **argv)
{
  _normal_app = true;
  program_wide_logger().log(istring("running ") + display_name() + " as a normal application.");
#ifdef __WIN32__
  SetConsoleCtrlHandler(standalone_controller, true);
#endif
  perform_service(argc, argv);
}

int service_root::standalone_controller(u_long control_type)
{
#ifndef __WIN32__
  if (control_type) {}
  return false;
#else
  service_root &root = get_root();
  switch (control_type) {
    // the break event is used as a stop of the simulated service.
    case CTRL_C_EVENT:  // fall-through.
    case CTRL_BREAK_EVENT:
      program_wide_logger().log(isprintf("stopping stand-alone run "
          "of %s.", root.display_name().s()));
      root.stop_service();
      return true;
      break;
  }
  return false;  // didn't handle anything.
#endif
}


#endif //SERVICE_ROOT_IMPLEMENTATION_FILE

---