ASSA::Socketbuf Class Reference

#include <Socketbuf.h>

Inheritance diagram for ASSA::Socketbuf:

ASSA::Streambuf ASSA::io_ptrs List of all members.

Public Member Functions

 Socketbuf (Socket *s_)
virtual ~Socketbuf ()

Protected Member Functions

virtual int sync ()
 This function synchronizes the streambuf with its actual stream of characters.
virtual int underflow ()
 This function is called to supply characters for input (from some source) when the get area is empty, although it may be called at other times.
virtual int overflow (int c_=EOF)
 This function is called to consume characters (flush them to output), typically when the put area is full and an attempt is made to store another character.
virtual int showmanyc ()
 The morphemes of showmanyc are "es-how-many-see", not "show-man-ic".
virtual int doallocate ()
 This function is called by allocate when unbuffered() is zero and base() is zero.

Private Member Functions

int flush_output ()
int sys_read (char *b_, int len_)
int sys_write (char *b_, int len_)
void xput_char (char c_)

Private Attributes

Socketm_s
 Reference to the Socket stream.

Detailed Description

Definition at line 29 of file Socketbuf.h.


Constructor & Destructor Documentation

Socketbuf::Socketbuf Socket s_  ) 
 

Definition at line 22 of file Socketbuf.cpp.

References ASSA::STRMBUFTRACE, trace_with_mask, and ASSA::Streambuf::unbuffered().

00023     : m_s (s_) 
00024 {
00025     trace_with_mask("Socketbuf::Socketbuf",STRMBUFTRACE);
00026     // By default, I am doing buffering IO
00027     unbuffered (0);
00028 }

Socketbuf::~Socketbuf  )  [virtual]
 

Definition at line 56 of file Socketbuf.cpp.

References overflow(), ASSA::STRMBUFTRACE, and trace_with_mask.

00057 {
00058     trace_with_mask("Socketbuf::~Socketbuf",STRMBUFTRACE);
00059     overflow (EOF);     // flush put area
00060 }


Member Function Documentation

int Socketbuf::doallocate  )  [protected, virtual]
 

This function is called by allocate when unbuffered() is zero and base() is zero.

It attempts to make a buffer of suitable size available. On success it must call setb to establish the reserve area, then return a value greater than zero. On failure it returns EOF. The default behavior is to allocate a buffer using new.

Reimplemented from ASSA::Streambuf.

Definition at line 216 of file Socketbuf.cpp.

References DL, ASSA::io_ptrs::dump(), ASSA::io_ptrs::m_buf_base, ASSA::io_ptrs::m_flags, ASSA::io_ptrs::m_shortbuf, ASSA::Streambuf::MAXTCPFRAMESZ, ASSA::Streambuf::setb(), ASSA::Streambuf::setg(), ASSA::Streambuf::setp(), ASSA::STRMBUF, ASSA::STRMBUFTRACE, trace_with_mask, and ASSA::io_ptrs::UNBUFFERED.

Referenced by overflow(), and underflow().

00217 {
00218     trace_with_mask("Socketbuf::doallocate",STRMBUFTRACE);
00219 
00220     // Get area comes first and matches entier buffer area.
00221     // Put area comes right after it. They are two equally-sized
00222     // separate buffers.
00223     //
00224     // ------------ -
00225     // |          | ^
00226     // | get area | | buffer area
00227     // |          | v
00228     // ------------ -
00229     // | put area |
00230     // |          |
00231     // ------------
00232     //
00233     // Return 1 on allocation and 0 if there is no need
00234 
00235     if (m_buf_base)
00236         return 0;
00237 
00238     if ( ! (m_flags & UNBUFFERED) ) {
00239         DL((STRMBUF,"Buffered IO - allocating %d bytes\n",
00240             2 * MAXTCPFRAMESZ));
00241         char* buf = new char [2 * MAXTCPFRAMESZ];
00242 
00243         setg (buf, buf + MAXTCPFRAMESZ, buf + MAXTCPFRAMESZ);
00244         setb (buf, buf + MAXTCPFRAMESZ, 1);
00245    
00246         buf += MAXTCPFRAMESZ;
00247         setp (buf, buf+MAXTCPFRAMESZ);
00248     }
00249     else {
00250         DL((STRMBUF,"Unbuffered IO - same 1 byte array\n"));
00251         setb (m_shortbuf, m_shortbuf+1, 0);
00252 
00253         // read_base is pointing to the begining,  and
00254         // read_end to one past end of the buffer.
00255         // Because buffer is empty, read_ptr should point
00256         // to the end (same as read_end). This way, calling
00257         // routines will detect that get area needs data from sync.
00258         //
00259         // +- read_base   +- read_ptr 
00260         // |              |- read_end 
00261         // |              |+----- one past end-of-block
00262         // v              vv
00263         // +--------------+-+
00264         // | get area     | |
00265         // +--------------+-+
00266         setg (m_shortbuf, m_shortbuf+1, m_shortbuf+1);
00267 
00268         // write_base  & write_ptr are pointing to the begining, 
00269         // and write_end to one past end of the buffer.
00270         // Because buffer is empty, read_ptr should point
00271         // to the beginning (same as write_base). This way, calling
00272         // routines will detect that put area needs data from sync.
00273         //
00274         // +- write_base   +- write_end points one past 
00275         // |- write_ptr    |    end-of-block
00276         // v               v
00277         // +--------------+-+
00278         // | put area     | |
00279         // +--------------+-+
00280 
00281         setp (m_shortbuf, m_shortbuf+1);
00282     }
00283     dump ();
00284     return 1;
00285 }

int Socketbuf::flush_output  )  [private]
 

Definition at line 182 of file Socketbuf.cpp.

References ASSA::Streambuf::epptr(), ASSA::Streambuf::MAXTCPFRAMESZ, ASSA::Streambuf::pbase(), ASSA::Streambuf::pbump(), ASSA::Streambuf::pptr(), ASSA::Streambuf::setp(), ASSA::STRMBUFTRACE, sys_write(), trace_with_mask, and ASSA::Streambuf::unbuffered().

Referenced by overflow(), and sync().

00183 {
00184     trace_with_mask("Socketbuf::flush_output",STRMBUFTRACE);
00185 
00186     if (pptr () <= pbase ()) {  // Nothing to flush
00187         return 0;
00188     }
00189 
00190     int requested;
00191     int xmitted;
00192 
00193     requested = pptr () - pbase ();
00194 
00195     if ((xmitted = sys_write (pbase (), requested)) < 0) {
00196         return EOF;
00197     }
00198 
00199     if (unbuffered ()) {
00200         setp (pbase (), epptr ());
00201         return 0;
00202     }
00203 
00204     requested -= xmitted;
00205     setp (pbase (), pbase () + MAXTCPFRAMESZ);
00206     pbump (requested);
00207 
00208     if (requested > 0) {
00209         ::memmove (pbase (), pbase () + xmitted, requested);
00210     }
00211 
00212     return 0;
00213 }

int Socketbuf::overflow int  c_ = EOF  )  [protected, virtual]
 

This function is called to consume characters (flush them to output), typically when the put area is full and an attempt is made to store another character.

If c is not EOF, overflow must either store or consume the character, following those already in the put area. It returns EOF on error, any other value on success. The default behavior of the base class version is undefined, so each derived class must define its own overflow. The normal action for a derived class version is to consume the characters in the put area (those between pbase() and pptr()), call setp() to set up a new put area, then store c (using sputc()) if it is not EOF.

Reimplemented from ASSA::Streambuf.

Definition at line 152 of file Socketbuf.cpp.

References doallocate(), ASSA::io_ptrs::dump(), ASSA::Streambuf::epptr(), flush_output(), ASSA::Streambuf::pbase(), ASSA::Streambuf::pptr(), ASSA::STRMBUFTRACE, trace_with_mask, ASSA::Streambuf::unbuffered(), and xput_char().

Referenced by ~Socketbuf().

00153 {
00154     trace_with_mask("Socketbuf::overflow",STRMBUFTRACE);
00155 
00156     // If c == EOF, return flush_output()
00157     // Otherwise, insert c into the buffer
00158 
00159     if (c_ == EOF)
00160         return flush_output ();
00161 
00162     if (pbase () == 0 && doallocate () == EOF)
00163         return EOF;
00164 
00165     if (pptr () >= epptr() && flush_output () == EOF)
00166         return EOF;
00167 
00168     xput_char (c_);
00169 
00170     dump ();
00171 
00172     if ((unbuffered () || pptr () >= epptr ()) && flush_output () == EOF) 
00173         return EOF;
00174 
00175     dump ();
00176 
00177     return c_;
00178 }

int Socketbuf::showmanyc  )  [protected, virtual]
 

The morphemes of showmanyc are "es-how-many-see", not "show-man-ic".

Return an estimate of the number of characters available in the sequence, or -1. If it returns a positive value, then successive calls to underflow() will not return EOF until at least that number of characters have been supplied. If showmanyc() returns -1, then calls to underflow() or uflow() will fail. The intention is not only that these calls will not return EOF, but that they will return ``immediately.''

Reimplemented from ASSA::Streambuf.

Definition at line 40 of file Socketbuf.cpp.

References ASSA::Socket::getBytesAvail(), m_s, ASSA::STRMBUFTRACE, and trace_with_mask.

00041 { 
00042     trace_with_mask("Socketbuf::showmanyc",STRMBUFTRACE);
00043     return m_s->getBytesAvail (); 
00044 }

int Socketbuf::sync  )  [protected, virtual]
 

This function synchronizes the streambuf with its actual stream of characters.

The derived class version should flush any characters in the put area to their final destination, and if possible give back any characters in the input buffer to their source. It should return EOF on any error, zero on success. The default behavior of the base class version is to return zero if there are no pending input or output characters (in_avail() and out_waiting() are both zero), and return EOF otherwise.

Reimplemented from ASSA::Streambuf.

Definition at line 32 of file Socketbuf.cpp.

References flush_output(), ASSA::STRMBUFTRACE, and trace_with_mask.

00033 { 
00034     trace_with_mask("Socketbuf::sync",STRMBUFTRACE);
00035     return flush_output (); 
00036 }

int Socketbuf::sys_read char *  b_,
int  len_
[private]
 

Definition at line 64 of file Socketbuf.cpp.

References DL, ASSA::Socket::getHandler(), m_s, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by underflow().

00065 { 
00066     trace_with_mask("Socketbuf::sys_read",STRMBUFTRACE);
00067     
00068     int ret = ::read (m_s->getHandler (), b_, len_);
00069 
00070     DL((STRMBUFTRACE,"Tried to read %d bytes from OS::socket\n", len_));
00071     DL((STRMBUFTRACE,"::read () returned %d\n", ret));
00072 
00073     if (ret == -1) {
00074         DL((STRMBUFTRACE,"::read () error: %d\n",errno));
00075     }
00076     return (ret);
00077 }

int Socketbuf::sys_write char *  b_,
int  len_
[private]
 

Definition at line 81 of file Socketbuf.cpp.

References DL, ASSA::Socket::getHandler(), m_s, ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by flush_output().

00082 { 
00083     trace_with_mask("Socketbuf::sys_write",STRMBUFTRACE);
00084 
00085     int ret = ::write (m_s->getHandler (), b_, len_);
00086 
00087     DL((STRMBUFTRACE,"Tried to write %d bytes to OS::socket\n", len_));
00088     DL((STRMBUFTRACE,"::write () returned %d\n", ret));
00089 
00090     if (ret == -1) {
00091         DL((STRMBUFTRACE,"::write () error: %d\n",errno));
00092     }
00093 
00094     return (ret);
00095 }

int Socketbuf::underflow  )  [protected, virtual]
 

This function is called to supply characters for input (from some source) when the get area is empty, although it may be called at other times.

If the get area is not empty, it should just return the first character (without advancing the get pointer). If the get area is empty, it should establish a new get area, aquire new input, and return the first character, if any. If no input characters are available, it should leave an empty get area and return EOF. The default behavior of the base class version is undefined, so each derived class must define its own underflow.

Reimplemented from ASSA::Streambuf.

Definition at line 99 of file Socketbuf.cpp.

References ASSA::Streambuf::base(), DL, doallocate(), ASSA::io_ptrs::dump(), ASSA::MemDump::dump_to_log(), ASSA::Streambuf::egptr(), ASSA::io_ptrs::EOF_SEEN, ASSA::Streambuf::gptr(), ASSA::io_ptrs::m_flags, ASSA::Streambuf::MAXTCPFRAMESZ, ASSA::Streambuf::setg(), ASSA::STRMBUF, ASSA::STRMBUFTRACE, sys_read(), trace_with_mask, and ASSA::Streambuf::unbuffered().

00100 {
00101     /*
00102       The important thing to note is that this function
00103       returns:
00104         a) pointer to the first character in buffer available.
00105         b) EOF if sys_read () failed.
00106         
00107       In case of peer closing its connection, a) will be true.
00108       Caller can always find out number of bytes in buffer
00109       and determine if peer indeed closed connection.
00110     */
00111     trace_with_mask("Socketbuf::underflow",STRMBUFTRACE);
00112 
00113     if (gptr () < egptr ())                   // The get area is not empty,
00114         return *(unsigned char*) gptr (); //  return 1st character
00115 
00116     if (base () == 0 &&    // If buffer isn't established,
00117         doallocate () == EOF)  // allocate buffer (both buff & unbuff IO)
00118         return EOF;
00119 
00120     int bufsz = unbuffered () ? 1 : MAXTCPFRAMESZ;
00121 
00122     /*
00123       Read as much as I can up to the allocated buffer size.
00124       EOF = (-1).
00125     */
00126     int rval = sys_read (base (), bufsz); 
00127 
00128     DL((STRMBUF,"Socketbuf::sys_read() returned %d bytes\n", rval));
00129 
00130     if (rval == EOF) {
00131 
00132         if (errno != EWOULDBLOCK) {
00133             m_flags |= EOF_SEEN;
00134         }
00135         return EOF;
00136     }
00137 
00138     DL((STRMBUF,"Having read %d bytes from socket\n",rval));
00139     MemDump::dump_to_log (STRMBUF, "Data received:", base (), rval);
00140 
00141     // Set get area pointers according to the data just read
00142 
00143     setg (base (), base (), base () + rval); 
00144 
00145     dump ();
00146 
00147     return *(unsigned char*) gptr (); // Return front character
00148 }

void Socketbuf::xput_char char  c_  )  [private]
 

Definition at line 48 of file Socketbuf.cpp.

References ASSA::Streambuf::pbump(), ASSA::Streambuf::pptr(), ASSA::STRMBUFTRACE, and trace_with_mask.

Referenced by overflow().

00049 { 
00050     trace_with_mask("Socketbuf::xput_char",STRMBUFTRACE);
00051     *pptr() = c_; 
00052     pbump (1); 
00053 }


Member Data Documentation

Socket* ASSA::Socketbuf::m_s [private]
 

Reference to the Socket stream.

Definition at line 51 of file Socketbuf.h.

Referenced by showmanyc(), sys_read(), and sys_write().


The documentation for this class was generated from the following files:
Generated on Tue Jun 20 10:36:23 2006 for libassa by  doxygen 1.4.6