libassa 3.5.0
Namespaces | Classes | Typedefs | Enumerations | Functions
ASSA Namespace Reference

Namespaces

namespace  Log
namespace  Utils

Classes

class  Acceptor
class  Address
class  AutoPtrRef
 A wrapper class to provide AutoPtr with reference semantics. More...
class  AutoPtr
 AutoPtr is based on SGI implementation of a auto_ptr template that makes memory handling a little bit easier. More...
class  AutoPtrArrayRef
 A wrapper class to provide AutoPtr with reference semantics. More...
class  AutoPtrArray
 AutoPtrArray handles memory management of an array of objects. More...
class  CharInBuffer
 CharInBuffer is a bucket for the character-based streams/messages. More...
class  Option
 Option class. More...
class  CmdLineOpts
 Class CmdLineOpts. More...
class  Connector
 Connector is a template class for initialization of communication services. More...
class  ConUDPSocket
class  Destroyer
class  EventHandler
 EventHandler class. More...
class  FdSet
 Class FdSet. More...
class  FileLogger
class  ChildStatusHandler
 A helper class of Fork. More...
class  Fork
 Fork class is a simple wrapper around C library function fork(). More...
class  fnode_t
 forknode_t class. More...
class  ForkList
 ForkList is a singleton class that keeps a list of all forked children. More...
class  GenServer
class  SIGINTHandler
 SIGINTHandler handles SIGINT signal. More...
class  SIGUSR1Handler
 Class SIGUSR1Handler. More...
class  SIGUSR2Handler
 Class SIGUSR2Handler handles SIGUSR2 signal. More...
class  SIGCHLDHandler
 Class SIGCHLDHandler handles SIGCHLD signal. More...
class  SIGALRMHandler
 Class SIGALRMHandler handles SIGALRM signal. More...
class  SIGPOLLHandler
 Class SIGPOLLHandler handles SIGPOLL signal. More...
class  IdSet
class  INETAddress
class  IniFile
class  IPv4Socket
class  Logger
class  DiagnosticContext
 Class DiagnosticContext tracks who deep a function is in the calling stack. More...
class  Logger_Impl
class  MaskSet
class  MemDump
class  PidFileLock
class  Pipe
class  PriorityQueue
class  PriorityQueue_Heap
struct  Bfunc
 Bfunc is used by PriorityQueue_impl. More...
struct  Less
 Less is borrowed from STL implementation. More...
class  PriorityQueue_Impl
 Class PriorityQueue_Impl. More...
class  PriorityQueue_STLPQ
class  Reactor
class  Regexp
 Regexp class. More...
class  RemoteLogger
class  Repository
class  Semaphore
class  ServiceHandler
class  SigAction
class  SigHandler
class  SigHandlers
class  CFUNC_Handler
 CFUNC_Handler class. More...
class  SigHandlersList
 SigHandlersList class. More...
class  SigSet
class  Singleton
class  Socket
class  Socketbuf
class  StdOutLogger
class  io_ptrs
 io_ptrs structure. More...
class  Streambuf
 Streambuf class. More...
class  Timer
struct  TimerCompare
 TimerCompare class compares two Timers base on their expiration timestamp. More...
class  TimerCountdown
class  TimerQueue
class  TimeVal
class  UDPSocket
class  UnConUDPSocket
class  UNIXAddress
class  xdrIOBuffer

Typedefs

typedef struct sockaddr SA
typedef struct sockaddr_in SA_IN
typedef struct sockaddr_un SA_UN
typedef unsigned long TimerId
 Timer Id is used in handle_timeout() calls.
typedef int(EventHandler::* EH_IO_Callback )(int)
 A type for the pointer to I/O-related callback member function of class EventHandler.

Enumerations

enum  ConnectMode { sync, async }
enum  EventType {
  READ_EVENT = 0x01, WRITE_EVENT = 0x02, EXCEPT_EVENT = 0x04, TIMEOUT_EVENT = 0x10,
  SIGNAL_EVENT = 0x20, RWE_EVENTS = 0x07, ALL_EVENTS = 0x37
}
 EventType defines events types that Reactor understands. More...
enum  Group {
  TRACE = 0x00000001, APP = 0x00000002, USR1 = 0x00000004, USR2 = 0x00000008,
  USR3 = 0x00000010, ALL_APPS = 0x0000001F, ASSAERR = 0x00000020, PIDFLOCK = 0x00000040,
  CMDLINEOPTS = 0x00000080, SEM = 0x00000100, SIGHAND = 0x00000200, REACT = 0x00000400,
  REACTTRACE = 0x00000800, SOCK = 0x00001000, SOCKTRACE = 0x00002000, XDRBUF = 0x00004000,
  XDRBUFTRACE = 0x00008000, STRMBUF = 0x00010000, STRMBUFTRACE = 0x00020000, FORK = 0x00040000,
  SIGACT = 0x00080000, PIPE = 0x00100000, CHARINBUF = 0x00200000, ADDRESS = 0x00400000,
  INIFILE = 0x00800000, REGEXP = 0x01000000, RES5 = 0x02000000, RES6 = 0x04000000,
  RES7 = 0x08000000, RES8 = 0x10000000, RES9 = 0x20000000, RES10 = 0x40000000,
  ALL_LIB = 0x7FFFFFE0, ALL = 0x7FFFFFFF, NONE = 0x00000000
}
 Bit mask used to mask out log messages. More...
enum  marker_t { FUNC_MSG, FUNC_ENTRY, FUNC_EXIT }

Functions

Socketoperator>> (Socket &s_, CharInBuffer &b_)
 Regardless of the delimeter size, which can be >1, add the character received to the buffer and compare the end of the buffer with the delimeter.
bool isReadEvent (EventType e_)
bool isWriteEvent (EventType e_)
bool isExceptEvent (EventType e_)
bool isTimeoutEvent (EventType e_)
bool isSignalEvent (EventType e_)
bool isRWEEvents (EventType e_)
bool isAllEvents (EventType e_)
bool is_valid_handler (handler_t socket_)
 Detect socket() error in a portable way.
void disable_handler (handler_t &socket_)
 Set socket descriptor to invalid value in a portable way.
int get_errno ()
 Fetch error number in a portable way.
void set_errno (int new_errno_)
 Set error number in a portable way.
Socketflush (Socket &os_)
 flush manipulator.
Socketendl (Socket &os_)
 endl manipulator.
Socketends (Socket &os_)
 ends manipulator.
TimeVal operator+ (const TimeVal &lhs_, const TimeVal &rhs_)
TimeVal operator- (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator> (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator!= (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator<= (const TimeVal &lhs_, const TimeVal &rhs_)
bool operator>= (const TimeVal &lhs_, const TimeVal &rhs_)
Socketoperator>> (Socket &s_, xdrIOBuffer &b_)

Typedef Documentation

int(EventHandler::* ASSA::EH_IO_Callback)(int)

A type for the pointer to I/O-related callback member function of class EventHandler.

These are:

  • handle_read ()
  • handle_write ()
  • handle_except ()
See also:
EventHandler

Definition at line 236 of file EventHandler.h.

typedef struct sockaddr ASSA::SA

Definition at line 33 of file Address.h.

typedef struct sockaddr_in ASSA::SA_IN

Definition at line 34 of file Address.h.

typedef struct sockaddr_un ASSA::SA_UN

Definition at line 44 of file Address.h.

typedef unsigned long ASSA::TimerId

Timer Id is used in handle_timeout() calls.

Definition at line 27 of file EventHandler.h.


Enumeration Type Documentation

Enumerator:
sync 

Synchronous connection mode.

async 

Asynchronous connection mode.

Definition at line 43 of file Connector.h.

                 { 
    sync,                   
    async                   
};

EventType defines events types that Reactor understands.

Enumerator:
READ_EVENT 

Notify when there will be at least 1 byte available for reading from IO channel without blocking .

WRITE_EVENT 

Notify when there will be room for at least 1 byte to be written to IO channel without blocking.

EXCEPT_EVENT 

Notify when there is an exception condition detected in TCP layer.

TIMEOUT_EVENT 

Notify about expired timer.

SIGNAL_EVENT 

Notify when UNIX signal is delivered by OS.

RWE_EVENTS 

READ_EVENT | WRITE_EVENT | EXCEPT_EVENT.

ALL_EVENTS 

Mask that includes all events.

Definition at line 34 of file EventHandler.h.

{   
    READ_EVENT    = 0x01,   
    WRITE_EVENT   = 0x02,   
    EXCEPT_EVENT  = 0x04,   
    TIMEOUT_EVENT = 0x10,   
    SIGNAL_EVENT  = 0x20,   
    RWE_EVENTS    = 0x07,   
    ALL_EVENTS    = 0x37    
};

Bit mask used to mask out log messages.

Enumerator:
TRACE 

Function call trace.

APP 

Application-level messages.

USR1 

Additional application-level messages.

USR2 

Additional application-level messages.

USR3 

Additional application-level messages.

ALL_APPS 

All application-level messages.

ASSAERR 

ASSA and system errors.

PIDFLOCK 

Class PidFileLock messages.

CMDLINEOPTS 

Class CmdLineOpts messages.

SEM 

Class Semaphore messages.

SIGHAND 

Class SigHandler(s) messages.

REACT 

Class Reactor/PrioriyQueue messages.

REACTTRACE 

Extended Reactor/PrioriyQueue messages.

SOCK 

Class Socket & friends messages.

SOCKTRACE 

Extended Socket & friends messages.

XDRBUF 

Class xdrIOBuffer messages.

XDRBUFTRACE 

Extended xdrIOBuffer messages.

STRMBUF 

Class Streambuf & friends messages.

STRMBUFTRACE 

Extended Streambuf & friends messages.

FORK 

Class Fork messages.

SIGACT 

Class SigACtion messages.

PIPE 

Class Pipe messages.

CHARINBUF 

Class CharInBuffer messages.

ADDRESS 

Class Address & friends messages.

INIFILE 

Class IniFile messages.

REGEXP 

Class RegExp messages.

RES5 

Reserved for future use.

RES6 

Reserved for future use.

RES7 

Reserved for future use.

RES8 

Reserved for future use.

RES9 

Reserved for future use.

RES10 

Reserved for future use.

ALL_LIB 

All library messages.

ALL 

All messages: library + application.

NONE 

Total silence.

Definition at line 25 of file LogMask.h.

           {
    TRACE        = 0x00000001, 
    APP          = 0x00000002, 
    USR1         = 0x00000004, 
    USR2         = 0x00000008, 
    USR3         = 0x00000010, 
    /*-----------------------------------------------------------------------*/
    ALL_APPS     = 0x0000001F, 
    /*-----------------------------------------------------------------------*/
    ASSAERR      = 0x00000020, 
    PIDFLOCK     = 0x00000040, 
    CMDLINEOPTS  = 0x00000080, 
    SEM          = 0x00000100, 
    SIGHAND      = 0x00000200, 
    REACT        = 0x00000400, 
    REACTTRACE   = 0x00000800, 
    SOCK         = 0x00001000, 
    SOCKTRACE    = 0x00002000, 
    XDRBUF       = 0x00004000, 
    XDRBUFTRACE  = 0x00008000, 
    STRMBUF      = 0x00010000, 
    STRMBUFTRACE = 0x00020000, 
    FORK         = 0x00040000, 
    SIGACT       = 0x00080000, 
    PIPE         = 0x00100000, 
    CHARINBUF    = 0x00200000, 
    ADDRESS      = 0x00400000, 
    INIFILE      = 0x00800000, 
    REGEXP       = 0x01000000, 
    RES5         = 0x02000000, 
    RES6         = 0x04000000, 
    RES7         = 0x08000000, 
    RES8         = 0x10000000, 
    RES9         = 0x20000000, 
    RES10        = 0x40000000, 
    /*-----------------------------------------------------------------------*/
    ALL_LIB      = 0x7FFFFFE0, 
    ALL          = 0x7FFFFFFF, 
    NONE         = 0x00000000  
};
Enumerator:
FUNC_MSG 
FUNC_ENTRY 
FUNC_EXIT 

Definition at line 67 of file LogMask.h.


Function Documentation

void ASSA::disable_handler ( handler_t socket_) [inline]

Set socket descriptor to invalid value in a portable way.

socket_ is set to the value out of valid range.

Definition at line 106 of file Logger_Impl.h.

References BAD_HANDLER.

Referenced by ASSA::IPv4Socket::accept(), ASSA::Socket::close_handler(), and ASSA::IPv4Socket::open().

    {
        socket_ = BAD_HANDLER;
    }
Socket& ASSA::endl ( Socket &  os_) [inline]

endl manipulator.

If you want to insert a newline character ('
') to terminate a text line, you should favor the manipulator endl. This manipulator inserts a newline character and also flushes the stream buffer.

Author:
Vladislav Grinchenko

Definition at line 602 of file Socket.h.

References ASSA::Socket::flush(), and ASSA::Socket::write().

Referenced by ASSA::GenServer::display_help(), ASSA::FileLogger::dump(), ASSA::FileLogger::handle_rollover(), ASSA::GenServer::init(), and ASSA::Logger::log_open().

{
    char c = '\n';
    os_.write (&c, 1);
    os_.flush ();
    return (os_);
}
Socket& ASSA::ends ( Socket &  os_) [inline]

ends manipulator.

You can insert a null character (without flushing the output stream) with the manipulator ends. A common use for a Socket object is to mediate output to a stream buffer that constructs an in-memory character sequence. Such a sequence wants a terminating null character. The manipulator ends provides highly visible evidence that the null character is indeed being supplied.

Author:
Vladislav Grinchenko

Definition at line 622 of file Socket.h.

References ASSA::Socket::write().

Referenced by ASSA::Semaphore::dump(), ASSA::Option::dump(), ASSA::FdSet::dump_c_str(), ASSA::Socket::dumpState(), ASSA::GenServer::get_version(), ASSA::GenServer::handle_signal(), ASSA::Reactor::registerIOHandler(), and ASSA::PidFileLock::write_pid().

{
    char c = '\0';
    os_.write (&c, 1);
    return (os_);
}
Socket& ASSA::flush ( Socket &  os_) [inline]
int ASSA::get_errno ( ) [inline]

Fetch error number in a portable way.

Definition at line 113 of file Logger_Impl.h.

Referenced by ASSA::IPv4Socket::connect(), ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::connect(), ASSA::Connector< SERVICE_HANDLER, PEER_CONNECTOR >::handle_write(), ASSA::IPv4Socket::read(), ASSA::Socketbuf::sys_read(), and ASSA::Socketbuf::underflow().

    {
        int myerrno;
#if defined (WIN32)
        myerrno = WSAGetLastError ();
#else
        myerrno = errno;
#endif
        return myerrno;
    }       
bool ASSA::is_valid_handler ( handler_t  socket_) [inline]

Detect socket() error in a portable way.

Returns:
true if socket is in valid range; false otherwise.

Definition at line 98 of file Logger_Impl.h.

References BAD_HANDLER.

Referenced by ASSA::IPv4Socket::accept(), ASSA::Socket::clear(), ASSA::IPv4Socket::clone(), ASSA::IPv4Socket::close(), ASSA::IPv4Socket::connect(), ASSA::IPv4Socket::open(), ASSA::IPv4Socket::read(), ASSA::Reactor::removeIOHandler(), and ASSA::IPv4Socket::write().

    {
        return (socket_ != BAD_HANDLER);
    }
bool ASSA::isAllEvents ( EventType  e_) [inline]

Definition at line 87 of file EventHandler.h.

References isExceptEvent(), isReadEvent(), isSignalEvent(), isTimeoutEvent(), and isWriteEvent().

{
    return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_) &&
        isSignalEvent (e_) && isTimeoutEvent (e_) ;
}
bool ASSA::isExceptEvent ( EventType  e_) [inline]
bool ASSA::isReadEvent ( EventType  e_) [inline]

Definition at line 51 of file EventHandler.h.

References READ_EVENT.

Referenced by isAllEvents(), isRWEEvents(), ASSA::Reactor::registerIOHandler(), and ASSA::Reactor::removeHandler().

{     
    return (e_ & READ_EVENT) == READ_EVENT;
}
bool ASSA::isRWEEvents ( EventType  e_) [inline]

Definition at line 81 of file EventHandler.h.

References isExceptEvent(), isReadEvent(), and isWriteEvent().

{
    return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_);
}
bool ASSA::isSignalEvent ( EventType  e_) [inline]

Definition at line 75 of file EventHandler.h.

References SIGNAL_EVENT.

Referenced by isAllEvents(), and ASSA::Reactor::registerIOHandler().

{
    return (e_ & SIGNAL_EVENT) == SIGNAL_EVENT;
}
bool ASSA::isTimeoutEvent ( EventType  e_) [inline]

Definition at line 69 of file EventHandler.h.

References TIMEOUT_EVENT.

Referenced by isAllEvents(), ASSA::Reactor::registerIOHandler(), and ASSA::Reactor::removeHandler().

{
    return (e_ & TIMEOUT_EVENT) == TIMEOUT_EVENT;
}
bool ASSA::isWriteEvent ( EventType  e_) [inline]

Definition at line 57 of file EventHandler.h.

References WRITE_EVENT.

Referenced by isAllEvents(), isRWEEvents(), ASSA::Reactor::registerIOHandler(), and ASSA::Reactor::removeHandler().

{
    return (e_ & WRITE_EVENT) == WRITE_EVENT;
}
bool ASSA::operator!= ( const TimeVal &  lhs_,
const TimeVal &  rhs_ 
) [inline]

Definition at line 312 of file TimeVal.h.

{
    return !( lhs_ == rhs_ );
}
TimeVal ASSA::operator+ ( const TimeVal &  lhs_,
const TimeVal &  rhs_ 
) [inline]

Definition at line 273 of file TimeVal.h.

References ASSA::TimeVal::normalize().

{
    TimeVal temp(lhs_);
    temp += rhs_;
    temp.normalize ();
    return temp;
}
TimeVal ASSA::operator- ( const TimeVal &  lhs_,
const TimeVal &  rhs_ 
) [inline]

Definition at line 282 of file TimeVal.h.

References ASSA::TimeVal::normalize().

{
    TimeVal temp(lhs_);
    temp -= rhs_;
    temp.normalize ();
    return temp;
}
bool ASSA::operator<= ( const TimeVal &  lhs_,
const TimeVal &  rhs_ 
) [inline]

Definition at line 318 of file TimeVal.h.

{
    return !(rhs_ < lhs_);
}
bool ASSA::operator> ( const TimeVal &  lhs_,
const TimeVal &  rhs_ 
) [inline]

Definition at line 306 of file TimeVal.h.

{
    return rhs_ < lhs_;
}
bool ASSA::operator>= ( const TimeVal &  lhs_,
const TimeVal &  rhs_ 
) [inline]

Definition at line 324 of file TimeVal.h.

{
    return !(lhs_ < rhs_);
}
Socket& ASSA::operator>> ( ASSA::Socket s_,
ASSA::CharInBuffer b_ 
)

Regardless of the delimeter size, which can be >1, add the character received to the buffer and compare the end of the buffer with the delimeter.

Read bytes from Socket stream until either record delimiter is detected, or EOF occured, or Socket stream is exhausted.

If match, bite off delimiter and set the state to complete. If not, continue reading till either there is no more characters to read, or Socket error (Fail or EOF), or buffer overflow. If overflow occurs, set the state to 'error' and terminate.

Definition at line 80 of file CharInBuffer.cpp.

References CHARINBUF, ASSA::CharInBuffer::chop(), ASSA::CharInBuffer::complete, DL, ASSA::CharInBuffer::error, ASSA::CharInBuffer::m_buffer, ASSA::CharInBuffer::m_delimiter, ASSA::CharInBuffer::m_max_size, ASSA::CharInBuffer::m_state, ASSA::Socket::read(), ASSA::CharInBuffer::state(), ASSA::CharInBuffer::state_name(), trace_with_mask, and ASSA::CharInBuffer::waiting.

{
    trace_with_mask ("Socket >> CharInBuffer", CHARINBUF);
    register char c;

    if (b_.state () != CharInBuffer::waiting) {
        DL((CHARINBUF,"Wrong state %s\n", b_.state_name (b_.state ())));
        return s_;
    }

    while (s_.read (&c, 1) == 1) 
    {
        b_.m_buffer += c;

        if (b_.m_buffer.size() < b_.m_delimiter.size()) { // Bug # 1252926
            continue;
        }

        if (b_.m_buffer.substr (
                b_.m_buffer.size ()-b_.m_delimiter.size ()) == b_.m_delimiter) 
        {
            b_.chop ();
            b_.m_state = CharInBuffer::complete;
            return s_;
        }

        if (b_.m_buffer.length () >= b_.m_max_size) {
            b_.m_state = CharInBuffer::error;
            break;
        }
    }

    if (!s_) {                  // EOF or error
        b_.state (CharInBuffer::error);
    }
    
    return s_;
}
Socket& ASSA::operator>> ( Socket s_,
xdrIOBuffer b_ 
)

Definition at line 25 of file xdrIOBuffer.cpp.

References ASSAERR, DL, ASSA::xdrIOBuffer::dump(), EL, ASSA::xdrIOBuffer::error, ASSA::xdrIOBuffer::get_state(), ASSA::Socket::getBytesAvail(), ASSA::xdrIOBuffer::m_buf, ASSA::xdrIOBuffer::m_ptr, ASSA::xdrIOBuffer::m_state, ASSA::xdrIOBuffer::m_sz, ASSA::Socket::read(), ASSA::xdrIOBuffer::size(), trace_with_mask, ASSA::xdrIOBuffer::waiting, XDRBUFTRACE, and ASSA::xdrIOBuffer::xmitted.

{
    trace_with_mask("Socket >> xdrIOBuffer", XDRBUFTRACE);

    DL((XDRBUFTRACE,"Buffer Initially:\n"));
    b_.dump ();

    if (b_.m_state != xdrIOBuffer::waiting) {
        EL((ASSAERR,"Wrong state: %s\n", b_.get_state ().c_str ()));
        return s_;
    }
    int expected = b_.m_sz - b_.size ();

    DL((XDRBUFTRACE,"Bytes expected: %d\n",expected));
    DL((XDRBUFTRACE,"Bytes in Socket buffer(s): %d\n", s_.getBytesAvail ()));
    int ret;

    if ((ret = s_.read (b_.m_ptr, expected)) <= 0) 
    {
#if defined(WIN32)
        if (WSAGetLastError () != WSAEWOULDBLOCK) {
            WSASetLastError (0);
            EL((ASSAERR,"Socket::read() error!\n"));
            b_.m_state = xdrIOBuffer::error;
        }
#else
        if (errno != EWOULDBLOCK) { 
            EL((ASSAERR,"Socket::read() error!\n"));
            b_.m_state = xdrIOBuffer::error;
        }
#endif
        else {
            EL((ASSAERR,"Socket::read() error! \n"));
        }
        return s_;
    }
    b_.m_ptr += ret;

    DL((XDRBUFTRACE,"Received %d bytes\n", ret));
    b_.dump ();

    if (b_.m_sz == b_.size ()) { // at the end
        DL((XDRBUFTRACE,"Complete message is in the buffer!\n"));
        b_.m_state = xdrIOBuffer::xmitted;
        b_.m_ptr = b_.m_buf;    // rewind m_ptr for parsing stage
        b_.dump ();
    }
    return s_;
}
void ASSA::set_errno ( int  new_errno_) [inline]
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines