* Author:  Original author unknown

 *          Quincy Tse <quincy.tse@nicta.com.au>

/**

 * \ingroup debugging

 * \brief Abnormal program termination

 *

 * \param msg message to output when this macro is hit.

 *

 * This macro is essentially equivalent to NS_FATAL_ERROR,

 * excepts it prepends the error message with the string

 * "aborted. ". When this macro is hit a runtime, the

 * program will be halted using std::terminate, which

 * triggers clean up code regestered by std::set_terminate.

 *

 * This macro is enable unconditionally in all builds,

 * including debug and optimized builds.

 *

 * \see NS_FATAL_ERROR

 */

 *         Quincy Tse <quincy.tse@nicta.com.au>

#include "fatal-error.h"

 *

 * These macro are intended to check certain conditions

 * to be true. Do not put code that also have side effects

 * that your program relies on (eg. code that advances

 * an iterator and return false at end of file) because

 * the code will not be executed on release builds!!

 *

 * If assertion-style checks are required for release

 * builds, use NS_ABORT_UNLESS and NS_ABORT_MSG_UNLESS.

 *         Quincy Tse <quincy.tse@nicta.com.au>

#include <exception>

#include <cstdlib>

#include "fatal-impl.h"

/**

 * \ingroup debugging

 * \brief fatal error handling

 *

 * When this macro is hit at runtime, details of filename

 * and line number is printed to stderr, and the program

 * is halted by calling std::terminate(). This will

 * trigger any clean up code registered by

 * std::set_terminate (NS3 default is a stream-flushing

 * code), but may be overridden.

 *

 * This macro is enabled unconditionally in all builds,

 * including debug and optimized builds.

 */

#define NS_FATAL_ERROR_NO_MSG()                           \

  do                                                      \

    {                                                     \

      std::cerr << "file=" << __FILE__ << ", line=" <<    \

        __LINE__ << std::endl;                            \

      std::terminate ();                                  \

    }                                                     \

  while (false)

/**

 * \ingroup debugging

 *

 * \brief Sets the terminate handler to the normal C++ handler.

 *

 * This macro sets the default handler for std::terminate() back

 * to the standard C++ handler.

 *

 * The standard C++ handler (post-gcc3.4) will identify any

 * uncaught exceptions and print the output of what(), before

 * raising SIGIOT and terminate without clean up.

 */

#define NS_FATAL_SET_CXX_VERBOSE()                                  \

  do                                                                \

    {                                                               \

      std::set_terminate (__gnu_cxx::__verbose_terminate_handler);  \

    }                                                               \

  while (false)

/**

 * \ingroup debugging

 *

 * \brief Sets the terminate handler to silent abort.

 *

 * This macro replaces the default handler for std::terminate()

 * with the std::abort().

 *

 * std::abort will raise SIGIOT and terminates without clean up

 * or any output.

 */

#define NS_FATAL_SET_CXX_SILENT()                   \

  do                                                \

    {                                               \

      std::set_terminate (std::abort);              \

    }                                               \

  while (false)

/**

 * \ingroup debugging

 *

 * \brief Sets the terminate handler to the NS3 default.

 *

 * This macro replaces the default handler for std::terminate()

 * with the ns3::FatalError::HandleTerminate().

 *

 * ns3::FatalError::HandleTerminate will flush all registered

 * ostreams and all FILE* before aborting.

 */

#define NS_FATAL_SET_DEFAULT()                                \

  do                                                          \

    {                                                         \

      std::set_terminate (ns3::FatalError::HandleTerminate);  \

    }                                                         \

  while (false)

/**

 * \ingroup debugging

 * \param handler The handler to ben triggered on std::terminate()

 *

 * \brief Replaces the default terminate handler.

 *

 * This macro replaces the default handler for std::terminate()

 * with the specified handler.

 *

 * The handler should be a function that takes no arguments and

 * returns void. The function should not return. If the function

 * returns, std::terminate will raise SIGIOT and abort execution.

 */

#define NS_FATAL_SET_HANDLER(handler)                         \

  do                                                          \

    {                                                         \

      std::set_terminate (static_cast<void (*)()>(handler));  \

    }                                                         \

  while (false)

/**

 * \ingroup debugging

 * \param stream pointer to stream to be flushed.

 *

 * \brief Register a stream to be flushed on abnormal exit.

 *

 * This is an alias to ns3::FatalError::RegisterStream()

 */

#define NS_FATAL_REGISTER_STREAM(stream)            \

  do                                                \

    {                                               \

      ns3::FatalError::RegisterStream (stream);     \

    }                                               \

  while (false)

/**

 * \ingroup debugging

 * \param stream A pointer to the stream to be unregistered.

 *

 * \brief Unregister a stream for flushing on abnormal exit.

 *

 * This is an alias to ns3::FatalError::UnregisterStream()

 */

#define NS_FATAL_UNREGISTER_STREAM(stream)          \

  do                                                \

    {                                               \

      ns3::FatalError::UnregisterStream (stream);   \

    }                                               \

  while (false)

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 NICTA

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Quincy Tse <quincy.tse@nicta.com.au>

 */

#include "fatal-impl.h"

#include <iostream>

#include <list>

#include <cstdlib>

#include <cstdio>

#include <csignal>

using std::list;

using std::ostream;

namespace ns3 {

namespace FatalError {

/* File-scope */

namespace {

  std::list<std::ostream*>& GetStreamList (void)

    {

      static std::list<ostream*> streams;

      return streams;

    }

}

void

RegisterStream (ostream* stream)

{

  GetStreamList ().push_back (stream);

}

void

UnregisterStream (ostream* stream)

{

  GetStreamList ().remove (stream);

}

void

HandleTerminate (void)

{

  FlushStreams ();

  std::abort ();

}

namespace {

  /* Overrides normal SIGSEGV handler once the

   * HandleTerminate function is run. */

  void sigHandler(int sig) {HandleTerminate ();}

}

inline void

FlushStreams (void)

{

  struct sigaction hdl;

  /* Override default SIGSEGV handler - will flush subsequent

   * streams even if one of the stream pointers is bad.

   * The SIGSEGV override should only be active for the

   * duration of this function. */

  hdl.sa_handler=sigHandler;

  sigaction (SIGSEGV, &hdl, 0);

  std::list<ostream*>& l = GetStreamList ();

  /* Need to do it this way in case any of the ostream* causes SIGSEGV */

  while (!l.empty ())

    {

      ostream* s (l.front ());

      l.pop_front ();

      s->flush ();

    }

  /* Restore default SIGSEGV handler (Not that it matters anyway) */

  hdl.sa_handler=SIG_DFL;

  sigaction (SIGSEGV, &hdl, 0);

  /* Flush all opened FILE* */

  std::fflush (0);

  /* Flush stdandard streams - shouldn't be required (except for clog) */

  std::cout.flush ();

  std::cerr.flush ();

  std::clog.flush ();

}

namespace {

  struct _StartUp {

    // Run following code on startup

    _StartUp (void) {

      std::set_terminate (HandleTerminate);

    }

  } _start;

}

} //FatalError

} //ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 NICTA

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Quincy Tse <quincy.tse@nicta.com.au>

 */

#ifndef FATAL_IMPL_H

#define FATAL_IMPL_H

#include <ostream>

/**

 * \ingroup debugging

 * \defgroup fatalHandler Fatal Error Handler 

 *

 * \brief Functions to help clean up when fatal error

 * is encountered.

 *

 * The functions in this group are used to perform

 * limited clean up, like flushing active streams, when

 * fatal error are encountered (through assertion fail,

 * calls to NS_ABORT_* and calls to NS_FATAL_ERROR.

 *

 * Currently, other than flushing active ostreams, these

 * functions does not interfere with outside memory. There

 * is still a residual risk that may be invalid ostream

 * pointers may be present, and may corrupt the memory

 * on the attempt to execute the flush() function.

 *

 * The function to handle abnormal termination should not

 * be called directly. It is automatically triggered when

 * a std::terminate() is called. Do not call FlushStreams()

 * or HandleTerminate - they will cause the program to

 * perform abnormal termination.

 *

 * Terminating by dereferencing null pointers and by calls

 * to std::abort will not trigger the clean up code.

 *

 * NS3 developers may use NS_FATAL_SET_HANDLER to change

 * the behaviour on abnormal termination caused by calls

 * to std::terminate(). Developers should call the

 * FlushStreams() function at the end of their handler

 * when they are implementing their own handler, otherwise

 * the ostreams will be not flushed, or their handling

 * code may not be executed (FlushStreams() may call

 * std::abort() if there are bad ostream* registered.

 *

 */

namespace ns3 {

namespace FatalError {

/**

 * \ingroup fatalHandler

 * \param stream The stream to be flushed on abnormal exit.

 *

 * \brief Register a stream to be flushed on abnormal exit.

 *

 * If a std::terminate() call is encountered after the

 * stream had been registered and before it had been

 * unregistered, stream->flush() will be called. Users of

 * this function is to ensure stream remains valid until

 * it had been unregistered.

 */

void RegisterStream (std::ostream* stream);

/**

 * \ingroup fatalHandler

 * \param stream The stream to be unregistered.

 *

 * \brief Unregister a stream for flushing on abnormal exit.

 *

 * After a stream had been unregistered, stream->flush()

 * will no longer be called should abnormal termination is

 * encountered.

 *

 * If stream is not registered, nothing will happen.

 */

void UnregisterStream (std::ostream* stream);

/**

 * \ingroup fatalHandler

 *

 * \brief Flush all currently registered streams.

 *

 * This function iterates through each registered stream and

 * unregister them. The default SIGSEGV handler is overridden

 * when this function is being executed, and will be restored

 * when this function returns.

 *

 * If a SIGSEGV is encountered (most likely due to bad ostream*

 * being registered, or a registered osteam* pointing to an

 * ostream that had already been destroyed), this function will

 * skip the bad ostream* and continue to flush the next stram.

 * The function will then terminate raising SIGIOT (aka SIGABRT)

 *

 * DO NOT call this function until the program is ready to crash.

 */

void FlushStreams (void);

/**

 * \ingroup fatalHandler

 *

 * \brief Handles clean up when std::terminate() is called.

 *

 * Once this handler had been registered using

 * std::set_terminate() (via the macro NS_FATAL_SET_DEFAULT()),

 * The system will trigger this function when std::terminate() is

 * called. std::terminate() expects this function not to return.

 * If this function returns, std::terminate will raise a SIGIOT

 * and terminate the program.

 *

 * This function calls FlushStreams() and then aborts execution

 * using std::abort().

 *

 * This function does not return.

 */

void HandleTerminate (void);

} //FatalError

} //ns3

#endif

        'fatal-impl.cc',

        'fatal-impl.h',