smsdaemon/serialport/PosixSignalDispatcher.cpp

//
// C++ Implementation: %{MODULE}
//
// Description:
//
//
// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "PosixSignalDispatcher.h"
#include "PosixSignalHandler.h"
#include <map>
#include <errno.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>

namespace
{
    /**
     * Implementation class for the PosixSignalDispatcher.
     */
    class PosixSignalDispatcherImpl
    {
    public:
        /*
         * As in the case of PosixSignalDispatcher, this is also
         * a singleton class. The only instance of this class can
         * be obtained using this method.
         */
        static
        PosixSignalDispatcherImpl&
        Instance() ;

        /*
         * Implementation of PosixSignalDispatcher::AttachHandler()
         */
        void
        AttachHandler( const int           posixSignalNumber,
                       PosixSignalHandler& signalHandler )
        throw( PosixSignalDispatcher::CannotAttachHandler ) ;

        /*
         * Implementation of PosixSignalDispatcher::DetachHandler()
         */
        void
        DetachHandler( const int                 posixSignalNumber,
                       const PosixSignalHandler& signalHandler )
        throw( PosixSignalDispatcher::CannotDetachHandler,
               std::logic_error ) ;
    private:
        /*
         * List of signal handlers that are currently associated
         * with the dispatcher.
         */
        typedef std::multimap<int, PosixSignalHandler*> SignalHandlerList ;
        static SignalHandlerList mSignalHandlerList ;

        /*
         * List of signal handlers that were originally attached
         * to the corresponding signals.
         */
        typedef std::map<int, struct sigaction> OriginalSigactionList ;
        static OriginalSigactionList mOriginalSigactionList ;

        /*
         * Default constructor.
         */
        PosixSignalDispatcherImpl() ;

        /*
         * Destuctor.
         */
        ~PosixSignalDispatcherImpl() ;

        /*
         * Static function that is used to attach the signal
         * dispatcher to a signal using sigaction().
         */
        static
        void
        SigactionHandler( int signalNumber ) ;
    } ;

    //
    // Initialization of static members of class PosixSignalDispatcherImpl.
    //
    PosixSignalDispatcherImpl::SignalHandlerList
    PosixSignalDispatcherImpl::mSignalHandlerList ;

    PosixSignalDispatcherImpl::OriginalSigactionList
    PosixSignalDispatcherImpl::mOriginalSigactionList ;

} ;

PosixSignalDispatcher::PosixSignalDispatcher()
{
    /* empty */
}

PosixSignalDispatcher::~PosixSignalDispatcher()
{
    /* empty */
}

PosixSignalDispatcher&
PosixSignalDispatcher::Instance()
{
    static PosixSignalDispatcher single_instance ;
    return single_instance ;
}

void
PosixSignalDispatcher::AttachHandler( const int           posixSignalNumber,
                                      PosixSignalHandler& signalHandler )
    throw( CannotAttachHandler )
{
    PosixSignalDispatcherImpl::Instance().AttachHandler( posixSignalNumber,
            signalHandler ) ;
    return ;
}

void
PosixSignalDispatcher::DetachHandler( const int                 posixSignalNumber,
                                      const PosixSignalHandler& signalHandler )
    throw( CannotDetachHandler,
           std::logic_error )
{
    PosixSignalDispatcherImpl::Instance().DetachHandler( posixSignalNumber,
            signalHandler ) ;
}

namespace
{
    inline
    PosixSignalDispatcherImpl::PosixSignalDispatcherImpl()
    {
        /* empty */
    }

    inline
    PosixSignalDispatcherImpl::~PosixSignalDispatcherImpl()
    {
        /* empty */
    }

    inline
    PosixSignalDispatcherImpl&
    PosixSignalDispatcherImpl::Instance()
    {
        static PosixSignalDispatcherImpl single_instance ;
        return single_instance ;
    }

    inline
    void
    PosixSignalDispatcherImpl::AttachHandler(
        const int           posixSignalNumber,
        PosixSignalHandler& signalHandler )
    throw( PosixSignalDispatcher::CannotAttachHandler )
    {
        /*
         * Attach this instance of PosixSignalDispatcher to the specified
         * signal.
         */
        struct sigaction sigaction_info ;
        sigaction_info.sa_handler = PosixSignalDispatcherImpl::SigactionHandler ;
        sigemptyset( &sigaction_info.sa_mask ) ;
        sigaction_info.sa_flags = 0 ;
        /*
         * Install the handler and get a copy of the previous handler.
         */
        struct sigaction old_action ;
        if ( sigaction( posixSignalNumber,
                        &sigaction_info,
                        &old_action ) < 0 )
        {
            throw PosixSignalDispatcher::CannotAttachHandler( strerror(errno) ) ;
        }
        /*
         * Save a copy of the old handler if it is not PosixSignalDispatcher::SignalHandler.
         */
        if ( PosixSignalDispatcherImpl::SigactionHandler != old_action.sa_handler )
        {
            mOriginalSigactionList.insert(
                OriginalSigactionList::value_type( posixSignalNumber,
                                                   old_action ) ) ;
        }
        /*
         * Add the specified handler to the list of handlers associated with the signal.
         */
        mSignalHandlerList.insert(
            SignalHandlerList::value_type( posixSignalNumber,
                                           &signalHandler ) ) ;
        return ;
    }

    inline
    void
    PosixSignalDispatcherImpl::DetachHandler(
        const int                 posixSignalNumber,
        const PosixSignalHandler& signalHandler )
    throw( PosixSignalDispatcher::CannotDetachHandler,
           std::logic_error )
    {
        /*
         * Get the range of values in the SignalHandlerList corresponding
         * to the specified signal number.
         */
        std::pair<SignalHandlerList::iterator, SignalHandlerList::iterator>
        iterator_range = mSignalHandlerList.equal_range( posixSignalNumber ) ;
        /*
         * Check if signalHandler is attached to the posixSignalNumber signal.
         */
        SignalHandlerList::iterator sig_handler_location = mSignalHandlerList.end() ;
        for( SignalHandlerList::iterator i=iterator_range.first ;
                i != iterator_range.second ;
                ++i )
        {
            if ( i->second == &signalHandler )
            {
                sig_handler_location = i ;
                break ;
            }
        }
        /*
         * If the signal handler is found, we need to remove it from the list.
         */
        if ( mSignalHandlerList.end() != sig_handler_location )
        {
            mSignalHandlerList.erase( sig_handler_location ) ;
            /*
             * If this was the only signal handler associated with the specified
             * signal number, then we remove the signal dispatcher from handling
             * the signal and install the original signal.
             */
            if ( 0 == mSignalHandlerList.count( posixSignalNumber ) )
            {
                /*
                 * Retrieve the original sigaction corresponding to the signal.
                 */
                OriginalSigactionList::iterator original_sigaction =
                    mOriginalSigactionList.find( posixSignalNumber ) ;
                /*
                 * If the signal dispatcher implementation is correct,
                 * then we should always find the original sigaction.
                 * If we do not find one, we throw an exception.
                 */
                if ( mOriginalSigactionList.end() == original_sigaction )
                {
                    throw std::logic_error( "Signal dispatcher in invalid state." ) ;
                }
                /*
                 * Install the original handler. Throw an exception if we
                 * encounter any error.
                 */
                if ( sigaction( posixSignalNumber,
                                &original_sigaction->second,
                                NULL ) < 0 )
                {
                    throw PosixSignalDispatcher::CannotDetachHandler( strerror(errno) ) ;
                }
            }
        }
        return ;
    }


    void
    PosixSignalDispatcherImpl::SigactionHandler( int signalNumber )
    {
        /*
         * Get a list of handlers associated with signalNumber.
         */
        std::pair<SignalHandlerList::iterator, SignalHandlerList::iterator>
        iterator_range = mSignalHandlerList.equal_range( signalNumber ) ;
        /*
         * Call each handler.
         */
        for( SignalHandlerList::iterator i=iterator_range.first ;
                i != iterator_range.second ;
                ++i )
        {
            i->second->HandlePosixSignal( signalNumber ) ;
        }
        //
        // :TODO: Why is the following code commented out using "#if 0" ?
        // Check and remove this code if it is not necessary. Otherwise, if 
        // it has been commented out due to a bug then debug and correct it. 
        //
#if 0
        /*
         * Get the original handler that was associated with the
         * signal and call it if possible.
         */
        OriginalSigactionList::iterator original_sigaction =
            mOriginalSigactionList.find( posixSignalNumber ) ;
        if ( ( mOriginalSigactionList.end() != original_sigaction ) &&
                ( SIG_DFL != original_sigaction->second.sa_handler ) &&
                ( SIG_IGN != original_sigaction->second.sa_handler ) &&
                ( 0 != original_sigaction->second.sa_handler ) )
        {
            original_sigaction->second.sa_handler( signalNumber ) ;
        }
#endif
        //
        return ;
    }
} ;
1	torben	26	//
2			// C++ Implementation: %{MODULE}
3			//
4			// Description:
5			//
6			//
7			// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
8			//
9			// Copyright: See COPYING file that comes with this distribution
10			//
11			//
12			#include "PosixSignalDispatcher.h"
13			#include "PosixSignalHandler.h"
14			#include <map>
15			#include <errno.h>
16			#include <signal.h>
17	torben	114	#include <stdlib.h>
18			#include <string.h>
19	torben	26
20			namespace
21			{
22			/**
23			* Implementation class for the PosixSignalDispatcher.
24			*/
25			class PosixSignalDispatcherImpl
26			{
27			public:
28			/*
29			* As in the case of PosixSignalDispatcher, this is also
30			* a singleton class. The only instance of this class can
31			* be obtained using this method.
32			*/
33			static
34			PosixSignalDispatcherImpl&
35			Instance() ;
36
37			/*
38			* Implementation of PosixSignalDispatcher::AttachHandler()
39			*/
40			void
41			AttachHandler( const int posixSignalNumber,
42			PosixSignalHandler& signalHandler )
43			throw( PosixSignalDispatcher::CannotAttachHandler ) ;
44
45			/*
46			* Implementation of PosixSignalDispatcher::DetachHandler()
47			*/
48			void
49			DetachHandler( const int posixSignalNumber,
50			const PosixSignalHandler& signalHandler )
51			throw( PosixSignalDispatcher::CannotDetachHandler,
52			std::logic_error ) ;
53			private:
54			/*
55			* List of signal handlers that are currently associated
56			* with the dispatcher.
57			*/
58			typedef std::multimap<int, PosixSignalHandler*> SignalHandlerList ;
59			static SignalHandlerList mSignalHandlerList ;
60
61			/*
62			* List of signal handlers that were originally attached
63			* to the corresponding signals.
64			*/
65			typedef std::map<int, struct sigaction> OriginalSigactionList ;
66			static OriginalSigactionList mOriginalSigactionList ;
67
68			/*
69			* Default constructor.
70			*/
71			PosixSignalDispatcherImpl() ;
72
73			/*
74			* Destuctor.
75			*/
76			~PosixSignalDispatcherImpl() ;
77
78			/*
79			* Static function that is used to attach the signal
80			* dispatcher to a signal using sigaction().
81			*/
82			static
83			void
84			SigactionHandler( int signalNumber ) ;
85			} ;
86
87			//
88			// Initialization of static members of class PosixSignalDispatcherImpl.
89			//
90			PosixSignalDispatcherImpl::SignalHandlerList
91			PosixSignalDispatcherImpl::mSignalHandlerList ;
92
93			PosixSignalDispatcherImpl::OriginalSigactionList
94			PosixSignalDispatcherImpl::mOriginalSigactionList ;
95
96			} ;
97
98			PosixSignalDispatcher::PosixSignalDispatcher()
99			{
100			/* empty */
101			}
102
103			PosixSignalDispatcher::~PosixSignalDispatcher()
104			{
105			/* empty */
106			}
107
108			PosixSignalDispatcher&
109			PosixSignalDispatcher::Instance()
110			{
111			static PosixSignalDispatcher single_instance ;
112			return single_instance ;
113			}
114
115			void
116			PosixSignalDispatcher::AttachHandler( const int posixSignalNumber,
117			PosixSignalHandler& signalHandler )
118			throw( CannotAttachHandler )
119			{
120			PosixSignalDispatcherImpl::Instance().AttachHandler( posixSignalNumber,
121			signalHandler ) ;
122			return ;
123			}
124
125			void
126			PosixSignalDispatcher::DetachHandler( const int posixSignalNumber,
127			const PosixSignalHandler& signalHandler )
128			throw( CannotDetachHandler,
129			std::logic_error )
130			{
131			PosixSignalDispatcherImpl::Instance().DetachHandler( posixSignalNumber,
132			signalHandler ) ;
133			}
134
135			namespace
136			{
137			inline
138			PosixSignalDispatcherImpl::PosixSignalDispatcherImpl()
139			{
140			/* empty */
141			}
142
143			inline
144			PosixSignalDispatcherImpl::~PosixSignalDispatcherImpl()
145			{
146			/* empty */
147			}
148
149			inline
150			PosixSignalDispatcherImpl&
151			PosixSignalDispatcherImpl::Instance()
152			{
153			static PosixSignalDispatcherImpl single_instance ;
154			return single_instance ;
155			}
156
157			inline
158			void
159			PosixSignalDispatcherImpl::AttachHandler(
160			const int posixSignalNumber,
161			PosixSignalHandler& signalHandler )
162			throw( PosixSignalDispatcher::CannotAttachHandler )
163			{
164			/*
165			* Attach this instance of PosixSignalDispatcher to the specified
166			* signal.
167			*/
168			struct sigaction sigaction_info ;
169			sigaction_info.sa_handler = PosixSignalDispatcherImpl::SigactionHandler ;
170			sigemptyset( &sigaction_info.sa_mask ) ;
171			sigaction_info.sa_flags = 0 ;
172			/*
173			* Install the handler and get a copy of the previous handler.
174			*/
175			struct sigaction old_action ;
176			if ( sigaction( posixSignalNumber,
177			&sigaction_info,
178			&old_action ) < 0 )
179			{
180			throw PosixSignalDispatcher::CannotAttachHandler( strerror(errno) ) ;
181			}
182			/*
183			* Save a copy of the old handler if it is not PosixSignalDispatcher::SignalHandler.
184			*/
185			if ( PosixSignalDispatcherImpl::SigactionHandler != old_action.sa_handler )
186			{
187			mOriginalSigactionList.insert(
188			OriginalSigactionList::value_type( posixSignalNumber,
189			old_action ) ) ;
190			}
191			/*
192			* Add the specified handler to the list of handlers associated with the signal.
193			*/
194			mSignalHandlerList.insert(
195			SignalHandlerList::value_type( posixSignalNumber,
196			&signalHandler ) ) ;
197			return ;
198			}
199
200			inline
201			void
202			PosixSignalDispatcherImpl::DetachHandler(
203			const int posixSignalNumber,
204			const PosixSignalHandler& signalHandler )
205			throw( PosixSignalDispatcher::CannotDetachHandler,
206			std::logic_error )
207			{
208			/*
209			* Get the range of values in the SignalHandlerList corresponding
210			* to the specified signal number.
211			*/
212			std::pair<SignalHandlerList::iterator, SignalHandlerList::iterator>
213			iterator_range = mSignalHandlerList.equal_range( posixSignalNumber ) ;
214			/*
215			* Check if signalHandler is attached to the posixSignalNumber signal.
216			*/
217			SignalHandlerList::iterator sig_handler_location = mSignalHandlerList.end() ;
218			for( SignalHandlerList::iterator i=iterator_range.first ;
219			i != iterator_range.second ;
220			++i )
221			{
222			if ( i->second == &signalHandler )
223			{
224			sig_handler_location = i ;
225			break ;
226			}
227			}
228			/*
229			* If the signal handler is found, we need to remove it from the list.
230			*/
231			if ( mSignalHandlerList.end() != sig_handler_location )
232			{
233			mSignalHandlerList.erase( sig_handler_location ) ;
234			/*
235			* If this was the only signal handler associated with the specified
236			* signal number, then we remove the signal dispatcher from handling
237			* the signal and install the original signal.
238			*/
239			if ( 0 == mSignalHandlerList.count( posixSignalNumber ) )
240			{
241			/*
242			* Retrieve the original sigaction corresponding to the signal.
243			*/
244			OriginalSigactionList::iterator original_sigaction =
245			mOriginalSigactionList.find( posixSignalNumber ) ;
246			/*
247			* If the signal dispatcher implementation is correct,
248			* then we should always find the original sigaction.
249			* If we do not find one, we throw an exception.
250			*/
251			if ( mOriginalSigactionList.end() == original_sigaction )
252			{
253			throw std::logic_error( "Signal dispatcher in invalid state." ) ;
254			}
255			/*
256			* Install the original handler. Throw an exception if we
257			* encounter any error.
258			*/
259			if ( sigaction( posixSignalNumber,
260			&original_sigaction->second,
261			NULL ) < 0 )
262			{
263			throw PosixSignalDispatcher::CannotDetachHandler( strerror(errno) ) ;
264			}
265			}
266			}
267			return ;
268			}
269
270
271			void
272			PosixSignalDispatcherImpl::SigactionHandler( int signalNumber )
273			{
274			/*
275			* Get a list of handlers associated with signalNumber.
276			*/
277			std::pair<SignalHandlerList::iterator, SignalHandlerList::iterator>
278			iterator_range = mSignalHandlerList.equal_range( signalNumber ) ;
279			/*
280			* Call each handler.
281			*/
282			for( SignalHandlerList::iterator i=iterator_range.first ;
283			i != iterator_range.second ;
284			++i )
285			{
286			i->second->HandlePosixSignal( signalNumber ) ;
287			}
288			//
289			// :TODO: Why is the following code commented out using "#if 0" ?
290			// Check and remove this code if it is not necessary. Otherwise, if
291			// it has been commented out due to a bug then debug and correct it.
292			//
293			#if 0
294			/*
295			* Get the original handler that was associated with the
296			* signal and call it if possible.
297			*/
298			OriginalSigactionList::iterator original_sigaction =
299			mOriginalSigactionList.find( posixSignalNumber ) ;
300			if ( ( mOriginalSigactionList.end() != original_sigaction ) &&
301			( SIG_DFL != original_sigaction->second.sa_handler ) &&
302			( SIG_IGN != original_sigaction->second.sa_handler ) &&
303			( 0 != original_sigaction->second.sa_handler ) )
304			{
305			original_sigaction->second.sa_handler( signalNumber ) ;
306			}
307			#endif
308			//
309			return ;
310			}
311			} ;