#include <Socketbuf.h>
Inheritance diagram for ASSA::Socketbuf:
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 | |
Socket * | m_s |
Reference to the Socket stream. |
Definition at line 29 of file Socketbuf.h.
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
Reference to the Socket stream.
Definition at line 51 of file Socketbuf.h. Referenced by showmanyc(), sys_read(), and sys_write(). |