service.h

См. документацию.

/* $Id: service.h 2920 2013-01-14 19:37:00Z roma $ */
#ifndef _FFL_CSSC_SERVICE_H_
#define _FFL_CSSC_SERVICE_H_

#include <winsock2.h>
#include <WS2tcpip.h>
#include <windows.h>
#include <string>

namespace ffl
{

        namespace cssc
        {

                class service
                {
                public:

                        enum type
                        {
                                FILE_SYSTEM_DRIVER              = SERVICE_FILE_SYSTEM_DRIVER,   
                                KERNEL_DRIVER                   = SERVICE_KERNEL_DRIVER,                
                                WIN32_OWN_PROCESS               = SERVICE_WIN32_OWN_PROCESS,    
                                WIN32_SHARE_PROCESS             = SERVICE_WIN32_SHARE_PROCESS,  
                        };

                        static const char* spell(type _type) throw();

                        enum status
                        {
                                CONTINUE_PENDING        = SERVICE_CONTINUE_PENDING,     
                                PAUSE_PENDING           = SERVICE_PAUSE_PENDING,        
                                PAUSED                          = SERVICE_PAUSED,                       
                                RUNNING                         = SERVICE_RUNNING,                      
                                START_PENDING           = SERVICE_START_PENDING,        
                                STOP_PENDING            = SERVICE_STOP_PENDING,         
                                STOPPED                         = SERVICE_STOPPED,                      
                        };

                        static const char* spell(status _status) throw();

                        enum accept
                        {
                                NOTHING                 = 0,

                                NETBINDCHANGE   = SERVICE_ACCEPT_NETBINDCHANGE, 
                                PARAMCHANGE             = SERVICE_ACCEPT_PARAMCHANGE,
                                PAUSE_CONTINUE  = SERVICE_ACCEPT_PAUSE_CONTINUE,
#if WINVER >= 0x0502

                                PRESHUTDOWN             = SERVICE_ACCEPT_PRESHUTDOWN,
#endif

                                SHUTDOWN                = SERVICE_ACCEPT_SHUTDOWN,

                                STOP    =       SERVICE_ACCEPT_STOP,
                                HARDWAREPROFILECHANGE   = SERVICE_ACCEPT_HARDWAREPROFILECHANGE,
                                POWEREVENT      = SERVICE_ACCEPT_POWEREVENT,
#if WINVER >= 0x601
                                SESSIONCHANGE   = SERVICE_ACCEPT_SESSIONCHANGE,
                                TIMECHANGE      = SERVICE_ACCEPT_TIMECHANGE,
#endif
#if WINVER >= 0x0601

                                TRIGGEREVENT    = SERVICE_ACCEPT_TRIGGEREVENT,
#endif

#if WINVER >= 0x0602

                                USERMODEREBOOT  = SERVICE_ACCEPT_USERMODEREBOOT,
#endif

                        };

                        class context
                        {
                        public:

                                context(service::type _type) throw();

                                virtual void initialize(service* _s, const char* _name) throw(...) = 0;

                                virtual void terminate() throw(){}

                                void pending(service::status _s, long _wait) throw();

                                void state(service::status _s, service::accept _a = NOTHING) throw();

                                void error() throw();

                                void error(int _code) throw();

                                void checkpoint() throw();

                        protected:

                                SERVICE_STATUS Status;

                                virtual void send() throw() = 0;

                        };

                        class scm:public context
                        {
                        public:

                                scm(service::type _type) throw():context(_type){}

                                void initialize(service* _s, const char* _name) throw(...);

                        private:

                                SERVICE_STATUS_HANDLE Handle;

                                static DWORD WINAPI handler(DWORD _control, DWORD _event, LPVOID _data, LPVOID _context) throw();

                                void send() throw();

                        };

                        class console:public context
                        {
                        public:

                                console(service::type _type) throw():context(_type){}

                                void initialize(service* _s, const char* _n) throw(...);

                                void terminate() throw();

                        private:

                                static BOOL WINAPI handler(DWORD) throw();

                                void send() throw();

                                std::string Name;

                                static service* Service;

                        };

                        service(context& _c) throw():Context(_c){}

                        virtual void stop() throw(){}

                        template<class S, class C> class main
                        {
                        public:

                                main(service::type _type) throw():Context(_type), Service(Context){}

                                void run(int _argc, const char* _argv[]) throw()
                                {
                                        try
                                        {
                                                Context.initialize(&Service, _argc > 0 ? _argv[0]:"");
                                        }
                                        catch(...)
                                        {
                                                return;
                                        }
                                        Service.run(_argc, _argv);
                                        Context.terminate();
                                }

                        private:

                                S Service;

                                C Context;

                        };

                protected:

                        context& Context;

                };

        }

}

#define FFL_CSSC_SERVICE(T)                                                                                     \
VOID WINAPI service_entry(DWORD _argc, LPSTR* _argv) throw()                    \
{                                                                                                                                               \
        service::main<T, service::scm>(service::WIN32_OWN_PROCESS).run(_argc, (const char**)_argv);\
}                                                                                                                                               \
void console_entry(int _argc, const char** _argv) throw()                               \
{                                                                                                                                               \
        service::main<T, service::console>(service::WIN32_OWN_PROCESS).run(_argc, _argv);                               \
}                                                                                                                                               \
int main(int _argc, const char** _argv) throw()                                                 \
{                                                                                                                                               \
        SERVICE_TABLE_ENTRY s[2];                                                                                       \
        s[0].lpServiceName = "";                                                                                                \
        s[0].lpServiceProc = service_entry;                                                                     \
        s[1].lpServiceName = 0;                                                                                         \
        s[1].lpServiceProc = 0;                                                                                         \
        if(!StartServiceCtrlDispatcher(s))                                                                      \
        {                                                                                                                                       \
                DWORD e = GetLastError();                                                                               \
                if(e == ERROR_FAILED_SERVICE_CONTROLLER_CONNECT)                                \
                        console_entry(_argc, _argv);                                                            \
        }                                                                                                                                       \
        return 0;                                                                                                                       \
}                                       

#endif