nt_service_control_manager.hpp

j2me is based on j2mepolish, client & server for mobile application.

//         Copyright E骾n O'Callaghan 2008 - 2008.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#ifndef NT_SERVICE_CONTROL_MANAGER_HPP_INCLUDED
#define NT_SERVICE_CONTROL_MANAGER_HPP_INCLUDED

#include "StdAfx.hpp"

#include <boost/serialization/optional.hpp>
#include <boost/serialization/shared_ptr.hpp>

#include "nt_service_exception.hpp"

class nt_service_control_manager : private boost::noncopyable
{
#if defined(UNICODE_) || defined(UNICODE)
	typedef std::wstring t_string;
#else
	typedef std::string t_string;
#endif

public:
	class manager_settings
	{
		friend class nt_service_control_manager;

	public:
		manager_settings() :
			lpDatabaseName_(SERVICES_ACTIVE_DATABASE)
		{}

		manager_settings(LPCTSTR lpMachineName, LPCTSTR lpDatabaseName=SERVICES_ACTIVE_DATABASE, 
				DWORD dwDesiredAccess=SC_MANAGER_ALL_ACCESS) :
			lpDatabaseName_(lpDatabaseName),
			dwDesiredAccess_(dwDesiredAccess)
		{
			if (lpMachineName) lpMachineName_ = lpMachineName;
		}

		manager_settings(const nt_service_control_manager& scm) :
			lpDatabaseName_(scm.lpDatabaseName_),
			dwDesiredAccess_(scm.dwDesiredAccess_)
		{
			if (scm.lpMachineName_) lpMachineName_ = scm.lpMachineName_;
		}

		friend class boost::serialization::access;
		template<class Archive>
		void serialize(Archive & ar, const unsigned int version)
		{
			using boost::serialization::make_nvp;

			ar & make_nvp("machine_name", lpMachineName_);
			ar & make_nvp("desired_access", dwDesiredAccess_);
		}

	private:	
		boost::optional<t_string> lpMachineName_;
		LPCTSTR lpDatabaseName_;
		DWORD dwDesiredAccess_;
	};

	typedef boost::shared_ptr<manager_settings> manager_settings_ptr;
	friend class manager_settings;

public:
	nt_service_control_manager(LPCTSTR lpMachineName, LPCTSTR lpDatabaseName=SERVICES_ACTIVE_DATABASE, 
			DWORD dwDesiredAccess=SC_MANAGER_ALL_ACCESS) :
		dwDesiredAccess_(dwDesiredAccess)
	{
		if (lpMachineName) lpMachineName_ = lpMachineName;

		handle_ = OpenSCManager((lpMachineName_ ? lpMachineName_->c_str() : NULL), lpDatabaseName, dwDesiredAccess);

		if (!handle_) throw_nt_service_exception(lpMachineName);
	}

	explicit nt_service_control_manager(manager_settings ms, LPCTSTR lpDatabaseName=SERVICES_ACTIVE_DATABASE) :
		dwDesiredAccess_(ms.dwDesiredAccess_),
		lpMachineName_(ms.lpMachineName_)
	{
		handle_ = OpenSCManager((lpMachineName_ ? lpMachineName_->c_str() : NULL), lpDatabaseName, dwDesiredAccess_);

		if (!handle_) throw_nt_service_exception((lpMachineName_ ? lpMachineName_->c_str() : L"(not specified)"));
	}

	~nt_service_control_manager()
	{
		if (handle_) CloseServiceHandle(handle_);
	}

	manager_settings_ptr settings()
	{
		if (!settings_)
			settings_.reset(new manager_settings(*this));

		return settings_;
	}

	SC_HANDLE handle() const { return handle_; }

	operator SC_HANDLE() { return handle(); }

private:
	SC_HANDLE handle_;  

	boost::optional<t_string> lpMachineName_;
	LPCTSTR lpDatabaseName_;
	DWORD dwDesiredAccess_;

	manager_settings_ptr settings_;
};

typedef boost::shared_ptr<nt_service_control_manager> nt_service_control_manager_ptr;

#endif // NT_SERVICE_CONTROL_MANAGER_HPP_INCLUDED