libassa 3.5.1
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions
ASSA Namespace Reference

Namespaces

namespace  Log
 
namespace  Utils
 

Classes

class  Acceptor
 
class  Address
 
class  AutoPtr
 AutoPtr is based on SGI implementation of a auto_ptr template that makes memory handling a little bit easier. More...
 
class  AutoPtrArray
 AutoPtrArray handles memory management of an array of objects. More...
 
class  AutoPtrArrayRef
 A wrapper class to provide AutoPtr with reference semantics. More...
 
class  AutoPtrRef
 A wrapper class to provide AutoPtr with reference semantics. More...
 
struct  Bfunc
 Bfunc is used by PriorityQueue_impl. More...
 
class  CFUNC_Handler
 CFUNC_Handler class. More...
 
class  CharInBuffer
 CharInBuffer is a bucket for the character-based streams/messages. More...
 
class  ChildStatusHandler
 A helper class of Fork. More...
 
class  CmdLineOpts
 Class CmdLineOpts. More...
 
class  Connector
 Connector is a template class for initialization of communication services. More...
 
class  ConUDPSocket
 
class  Destroyer
 
class  DiagnosticContext
 Class DiagnosticContext tracks who deep a function is in the calling stack. More...
 
class  EventHandler
 EventHandler class. More...
 
class  FdSet
 Class FdSet. More...
 
class  FileLogger
 
class  fnode_t
 forknode_t class. More...
 
class  Fork
 Fork class is a simple wrapper around C library function fork(). More...
 
class  ForkList
 ForkList is a singleton class that keeps a list of all forked children. More...
 
class  GenServer
 
class  IdSet
 
class  INETAddress
 
class  IniFile
 
class  io_ptrs
 io_ptrs structure. More...
 
class  IPv4Socket
 
struct  Less
 Less is borrowed from STL implementation. More...
 
class  Logger
 
class  Logger_Impl
 
class  MaskSet
 
class  MemDump
 
class  Option
 Option class. More...
 
class  PidFileLock
 
class  Pipe
 
class  PriorityQueue
 
class  PriorityQueue_Heap
 
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  SIGALRMHandler
 Class SIGALRMHandler handles SIGALRM signal. More...
 
class  SIGCHLDHandler
 Class SIGCHLDHandler handles SIGCHLD signal. More...
 
class  SigHandler
 
class  SigHandlers
 
class  SigHandlersList
 SigHandlersList class. More...
 
class  SIGINTHandler
 SIGINTHandler handles SIGINT signal. More...
 
class  SIGPOLLHandler
 Class SIGPOLLHandler handles SIGPOLL signal. More...
 
class  SigSet
 
class  SIGUSR1Handler
 Class SIGUSR1Handler. More...
 
class  SIGUSR2Handler
 Class SIGUSR2Handler handles SIGUSR2 signal. More...
 
class  Singleton
 
class  Socket
 
class  Socketbuf
 
class  StdOutLogger
 
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
}
 
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

◆ EH_IO_Callback

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.

◆ SA

Definition at line 33 of file Address.h.

◆ SA_IN

Definition at line 34 of file Address.h.

◆ SA_UN

Definition at line 44 of file Address.h.

◆ TimerId

Timer Id is used in handle_timeout() calls.

Definition at line 27 of file EventHandler.h.

Enumeration Type Documentation

◆ ConnectMode

Enumerator
sync 

Synchronous connection mode.

async 

Asynchronous connection mode.

Definition at line 43 of file Connector.h.

43 {
44 sync,
45 async
46};
@ sync
Synchronous connection mode.
Definition Connector.h:44
@ async
Asynchronous connection mode.
Definition Connector.h:45

◆ EventType

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.

35{
36 READ_EVENT = 0x01,
39 WRITE_EVENT = 0x02,
42 EXCEPT_EVENT = 0x04,
44 TIMEOUT_EVENT = 0x10,
45 SIGNAL_EVENT = 0x20,
46 RWE_EVENTS = 0x07,
47 ALL_EVENTS = 0x37
48};
@ WRITE_EVENT
Notify when there will be room for at least 1 byte to be written to IO channel without blocking.
@ ALL_EVENTS
Mask that includes all events.
@ SIGNAL_EVENT
Notify when UNIX signal is delivered by OS.
@ READ_EVENT
Notify when there will be at least 1 byte available for reading from IO channel without blocking .
@ RWE_EVENTS
READ_EVENT | WRITE_EVENT | EXCEPT_EVENT
@ EXCEPT_EVENT
Notify when there is an exception condition detected in TCP layer.
@ TIMEOUT_EVENT
Notify about expired timer.

◆ Group

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.

25 {
26 TRACE = 0x00000001,
27 APP = 0x00000002,
28 USR1 = 0x00000004,
29 USR2 = 0x00000008,
30 USR3 = 0x00000010,
31 /*-----------------------------------------------------------------------*/
32 ALL_APPS = 0x0000001F,
33 /*-----------------------------------------------------------------------*/
34 ASSAERR = 0x00000020,
35 PIDFLOCK = 0x00000040,
36 CMDLINEOPTS = 0x00000080,
37 SEM = 0x00000100,
38 SIGHAND = 0x00000200,
39 REACT = 0x00000400,
40 REACTTRACE = 0x00000800,
41 SOCK = 0x00001000,
42 SOCKTRACE = 0x00002000,
43 XDRBUF = 0x00004000,
44 XDRBUFTRACE = 0x00008000,
45 STRMBUF = 0x00010000,
46 STRMBUFTRACE = 0x00020000,
47 FORK = 0x00040000,
48 SIGACT = 0x00080000,
49 PIPE = 0x00100000,
50 CHARINBUF = 0x00200000,
51 ADDRESS = 0x00400000,
52 INIFILE = 0x00800000,
53 REGEXP = 0x01000000,
54 RES5 = 0x02000000,
55 RES6 = 0x04000000,
56 RES7 = 0x08000000,
57 RES8 = 0x10000000,
58 RES9 = 0x20000000,
59 RES10 = 0x40000000,
60 /*-----------------------------------------------------------------------*/
61 ALL_LIB = 0x7FFFFFE0,
62 ALL = 0x7FFFFFFF,
63 NONE = 0x00000000
64};
@ PIPE
Class Pipe messages
Definition LogMask.h:49
@ INIFILE
Class IniFile messages
Definition LogMask.h:52
@ RES7
Reserved for future use
Definition LogMask.h:56
@ FORK
Class Fork messages
Definition LogMask.h:47
@ ADDRESS
Class Address & friends messages
Definition LogMask.h:51
@ REACT
Class Reactor/PrioriyQueue messages
Definition LogMask.h:39
@ SOCK
Class Socket & friends messages
Definition LogMask.h:41
@ SOCKTRACE
Extended Socket & friends messages
Definition LogMask.h:42
@ REGEXP
Class RegExp messages
Definition LogMask.h:53
@ USR3
Additional application-level messages
Definition LogMask.h:30
@ SEM
Class Semaphore messages
Definition LogMask.h:37
@ SIGHAND
Class SigHandler(s) messages
Definition LogMask.h:38
@ XDRBUF
Class xdrIOBuffer messages
Definition LogMask.h:43
@ RES6
Reserved for future use
Definition LogMask.h:55
@ NONE
Total silence
Definition LogMask.h:63
@ RES8
Reserved for future use
Definition LogMask.h:57
@ USR2
Additional application-level messages
Definition LogMask.h:29
@ ALL_LIB
All library messages
Definition LogMask.h:61
@ APP
Application-level messages
Definition LogMask.h:27
@ RES5
Reserved for future use
Definition LogMask.h:54
@ CMDLINEOPTS
Class CmdLineOpts messages
Definition LogMask.h:36
@ STRMBUFTRACE
Extended Streambuf & friends messages
Definition LogMask.h:46
@ ASSAERR
ASSA and system errors
Definition LogMask.h:34
@ USR1
Additional application-level messages
Definition LogMask.h:28
@ XDRBUFTRACE
Extended xdrIOBuffer messages
Definition LogMask.h:44
@ ALL_APPS
All application-level messages
Definition LogMask.h:32
@ STRMBUF
Class Streambuf & friends messages
Definition LogMask.h:45
@ TRACE
Function call trace
Definition LogMask.h:26
@ REACTTRACE
Extended Reactor/PrioriyQueue messages
Definition LogMask.h:40
@ CHARINBUF
Class CharInBuffer messages
Definition LogMask.h:50
@ SIGACT
Class SigACtion messages
Definition LogMask.h:48
@ ALL
All messages: library + application
Definition LogMask.h:62
@ PIDFLOCK
Class PidFileLock messages
Definition LogMask.h:35
@ RES10
Reserved for future use
Definition LogMask.h:59
@ RES9
Reserved for future use
Definition LogMask.h:58

◆ marker_t

Enumerator
FUNC_MSG 
FUNC_ENTRY 
FUNC_EXIT 

Definition at line 67 of file LogMask.h.

67 {
71};
@ FUNC_ENTRY
Definition LogMask.h:69
@ FUNC_MSG
Definition LogMask.h:68
@ FUNC_EXIT
Definition LogMask.h:70

Function Documentation

◆ disable_handler()

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 108 of file Logger_Impl.h.

109 {
111 }
#define BAD_HANDLER
Sort out WIN32/mingw oddities.
Definition Logger_Impl.h:81
A wrapper class to provide AutoPtr with reference semantics.
Definition AutoPtr.h:32

References BAD_HANDLER.

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

◆ endl()

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.

603{
604 char c = '\n';
605 os_.write (&c, 1);
606 os_.flush ();
607 return (os_);
608}

◆ ends()

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.

623{
624 char c = '\0';
625 os_.write (&c, 1);
626 return (os_);
627}

◆ flush()

Socket & ASSA::flush ( Socket os_)
inline

flush manipulator.

Flush a stream buffer.

Definition at line 587 of file Socket.h.

588{
589 os_.flush ();
590 return (os_);
591}

Referenced by ASSA::RemoteLogger::log_close(), ASSA::RemoteLogger::log_func(), ASSA::RemoteLogger::log_msg(), ASSA::RemoteLogger::log_open(), and ASSA::RemoteLogger::log_resync().

◆ get_errno()

int ASSA::get_errno ( )
inline

◆ is_valid_handler()

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 100 of file Logger_Impl.h.

101 {
102 return (socket_ != BAD_HANDLER);
103 }

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().

◆ isAllEvents()

bool ASSA::isAllEvents ( EventType  e_)
inline

Definition at line 87 of file EventHandler.h.

88{
89 return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_) &&
91}
bool isReadEvent(EventType e_)
bool isExceptEvent(EventType e_)
bool isSignalEvent(EventType e_)
bool isTimeoutEvent(EventType e_)
bool isWriteEvent(EventType e_)

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

◆ isExceptEvent()

bool ASSA::isExceptEvent ( EventType  e_)
inline

Definition at line 63 of file EventHandler.h.

64{
65 return (e_ & EXCEPT_EVENT) == EXCEPT_EVENT;
66}

References EXCEPT_EVENT.

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

◆ isReadEvent()

bool ASSA::isReadEvent ( EventType  e_)
inline

Definition at line 51 of file EventHandler.h.

52{
53 return (e_ & READ_EVENT) == READ_EVENT;
54}

References READ_EVENT.

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

◆ isRWEEvents()

bool ASSA::isRWEEvents ( EventType  e_)
inline

Definition at line 81 of file EventHandler.h.

82{
83 return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_);
84}

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

◆ isSignalEvent()

bool ASSA::isSignalEvent ( EventType  e_)
inline

Definition at line 75 of file EventHandler.h.

76{
77 return (e_ & SIGNAL_EVENT) == SIGNAL_EVENT;
78}

References SIGNAL_EVENT.

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

◆ isTimeoutEvent()

bool ASSA::isTimeoutEvent ( EventType  e_)
inline

Definition at line 69 of file EventHandler.h.

70{
71 return (e_ & TIMEOUT_EVENT) == TIMEOUT_EVENT;
72}

References TIMEOUT_EVENT.

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

◆ isWriteEvent()

bool ASSA::isWriteEvent ( EventType  e_)
inline

Definition at line 57 of file EventHandler.h.

58{
59 return (e_ & WRITE_EVENT) == WRITE_EVENT;
60}

References WRITE_EVENT.

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

◆ operator!=()

bool ASSA::operator!= ( const TimeVal lhs_,
const TimeVal rhs_ 
)
inline

Definition at line 312 of file TimeVal.h.

313{
314 return !( lhs_ == rhs_ );
315}

◆ operator+()

TimeVal ASSA::operator+ ( const TimeVal lhs_,
const TimeVal rhs_ 
)
inline

Definition at line 273 of file TimeVal.h.

274{
276 temp += rhs_;
277 temp.normalize ();
278 return temp;
279}

◆ operator-()

TimeVal ASSA::operator- ( const TimeVal lhs_,
const TimeVal rhs_ 
)
inline

Definition at line 282 of file TimeVal.h.

283{
285 temp -= rhs_;
286 temp.normalize ();
287 return temp;
288}

◆ operator<=()

bool ASSA::operator<= ( const TimeVal lhs_,
const TimeVal rhs_ 
)
inline

Definition at line 317 of file TimeVal.h.

319{
320 return !(rhs_ < lhs_);
321}

◆ operator>()

bool ASSA::operator> ( const TimeVal lhs_,
const TimeVal rhs_ 
)
inline

Definition at line 306 of file TimeVal.h.

307{
308 return rhs_ < lhs_;
309}

◆ operator>=()

bool ASSA::operator>= ( const TimeVal lhs_,
const TimeVal rhs_ 
)
inline

Definition at line 324 of file TimeVal.h.

325{
326 return !(lhs_ < rhs_);
327}

◆ operator>>() [1/2]

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.

81{
82 trace_with_mask ("Socket >> CharInBuffer", CHARINBUF);
83 register char c;
84
85 if (b_.state () != CharInBuffer::waiting) {
86 DL((CHARINBUF,"Wrong state %s\n", b_.state_name (b_.state ())));
87 return s_;
88 }
89
90 while (s_.read (&c, 1) == 1)
91 {
92 b_.m_buffer += c;
93
94 if (b_.m_buffer.size() < b_.m_delimiter.size()) { // Bug # 1252926
95 continue;
96 }
97
98 if (b_.m_buffer.substr (
99 b_.m_buffer.size ()-b_.m_delimiter.size ()) == b_.m_delimiter)
100 {
101 b_.chop ();
102 b_.m_state = CharInBuffer::complete;
103 return s_;
104 }
105
106 if (b_.m_buffer.length () >= b_.m_max_size) {
107 b_.m_state = CharInBuffer::error;
108 break;
109 }
110 }
111
112 if (!s_) { // EOF or error
113 b_.state (CharInBuffer::error);
114 }
115
116 return s_;
117}
#define DL(X)
A macro for writing debug message to the Logger.
Definition Logger.h:273
#define trace_with_mask(s, m)
trace_with_mask() is used to trace function call chain in C++ program.
Definition Logger.h:437
@ complete
matched end-of-record - full record
@ error
overflow or Socket I/O error
@ waiting
incomplete record is in the buffer

◆ operator>>() [2/2]

Socket & ASSA::operator>> ( Socket s_,
xdrIOBuffer b_ 
)

Definition at line 25 of file xdrIOBuffer.cpp.

26{
27 trace_with_mask("Socket >> xdrIOBuffer", XDRBUFTRACE);
28
29 DL((XDRBUFTRACE,"Buffer Initially:\n"));
30 b_.dump ();
31
32 if (b_.m_state != xdrIOBuffer::waiting) {
33 EL((ASSAERR,"Wrong state: %s\n", b_.get_state ().c_str ()));
34 return s_;
35 }
36 int expected = b_.m_sz - b_.size ();
37
38 DL((XDRBUFTRACE,"Bytes expected: %d\n",expected));
39 DL((XDRBUFTRACE,"Bytes in Socket buffer(s): %d\n", s_.getBytesAvail ()));
40 int ret;
41
42 if ((ret = s_.read (b_.m_ptr, expected)) <= 0)
43 {
44#if defined(WIN32)
47 EL((ASSAERR,"Socket::read() error!\n"));
48 b_.m_state = xdrIOBuffer::error;
49 }
50#else
51 if (errno != EWOULDBLOCK) {
52 EL((ASSAERR,"Socket::read() error!\n"));
53 b_.m_state = xdrIOBuffer::error;
54 }
55#endif
56 else {
57 EL((ASSAERR,"Socket::read() error! \n"));
58 }
59 return s_;
60 }
61 b_.m_ptr += ret;
62
63 DL((XDRBUFTRACE,"Received %d bytes\n", ret));
64 b_.dump ();
65
66 if (b_.m_sz == b_.size ()) { // at the end
67 DL((XDRBUFTRACE,"Complete message is in the buffer!\n"));
68 b_.m_state = xdrIOBuffer::xmitted;
69 b_.m_ptr = b_.m_buf; // rewind m_ptr for parsing stage
70 b_.dump ();
71 }
72 return s_;
73}
#define EL(X)
A macro for writing error message to the Logger.
Definition Logger.h:285

◆ set_errno()

void ASSA::set_errno ( int  new_errno_)
inline