/home/vlg/develop/libASSA/libassa/assa/Streambuf.cpp

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                              Streambuf.cpp
//------------------------------------------------------------------------------
//  Copyright (c) 1999 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//
//------------------------------------------------------------------------------
//  Created: 12/02/99
//------------------------------------------------------------------------------

#include "assa/Streambuf.h"
#include "assa/MemDump.h"

using namespace ASSA;

void
io_ptrs::
dump () const 
{
#ifdef LOG_PACKET
    trace_with_mask("io_ptrs::dump",STRMBUF);
    int len;

    DL((STRMBUF,"---Ptr------:---Val---\n"));
    DL((STRMBUF,"m_read_base.: 0x%x\n", (u_long)m_read_base));
    DL((STRMBUF,"m_read_ptr..: 0x%x\n", (u_long)m_read_ptr ));
    DL((STRMBUF,"m_read_end..: 0x%x\n", (u_long)m_read_end ));

    if (m_read_ptr && (len = m_read_end - m_read_ptr) > 0) {
        MemDump get_area (m_read_ptr, len);
        DL((STRMBUF,"\n%s\n", get_area.getMemDump ()));
    }

    DL((STRMBUF,"m_write_base: 0x%x\n", (u_long)m_write_base));
    DL((STRMBUF,"m_write_ptr.: 0x%x\n", (u_long)m_write_ptr ));
    DL((STRMBUF,"m_write_end.: 0x%x\n", (u_long)m_write_end ));

    if (m_write_base && (len = m_write_ptr - m_write_base) > 0) {
        MemDump put_area (m_write_base, len);
        DL((STRMBUF,"%s\n", put_area.getMemDump ()));
    }

    DL((STRMBUF,"m_buf_base..: 0x%x\n", (u_long)m_buf_base  ));
    DL((STRMBUF,"m_buf_end...: 0x%x\n", (u_long)m_buf_end   ));
    DL((STRMBUF,"------------:---------\n");

#endif
}

int 
Streambuf::
snextc ()
{   
    trace_with_mask("Streambuf::snextc",STRMBUFTRACE);

    if (m_read_ptr >= m_read_end && underflow () == EOF) {
        return EOF;
    }
    return m_read_ptr++, sgetc (); 
}

void
Streambuf::
setg (char* gbeg_, char* gnext_, char* gend_)
{
    trace_with_mask("Streambuf::setg",STRMBUFTRACE);

    m_read_base = gbeg_;
    m_read_ptr  = gnext_;
    m_read_end  = gend_;
}

void
Streambuf::
setb (char* b_, char* eb_, int del_)
{
    trace_with_mask("Streambuf::setb",STRMBUFTRACE);

    if (m_buf_base && !(m_flags & USER_BUF))
        delete m_buf_base;

    m_buf_base = b_;
    m_buf_end = eb_;
    
    if (del_)
        m_flags &= ~ USER_BUF; // clear bit
    else
        m_flags |= USER_BUF; // set bit

    dump ();
}

Streambuf*
Streambuf::
setbuf (char* p_, int len_)
{
    trace_with_mask("Streambuf::setb",STRMBUFTRACE);

    if (sync () == EOF) // Flush out all pending bytes before
        return NULL;    // resetting buffer. Also, first time around,
    // calling sync() suppose to set put area
    // pointers.

    if (p_ == NULL || len_ == 0) {
        DL((STRMBUF,"Unbuffered IO set.\n"));
        unbuffered (1);
        // We do it from doalloc instead - vlg
        // setb (m_shortbuf, m_shortbuf+1, 0);
    }
    else {
        DL((STRMBUF,"Buffered IO set.\n"));
        unbuffered (0);
        setb (p_, p_ + len_, 0);
    }
    setp (0, 0);
    setg (0, 0, 0);

    return this;
}

int
Streambuf::
xsgetn (char* data_, int len_)
{
    trace_with_mask("Streambuf::xsgetn",STRMBUFTRACE);

    /*
      Get area is empty and nothing is on the socket.
    */
    int count = m_read_end - m_read_ptr; // Bytes in Get area

    if (count == 0 && underflow () == EOF) {
        DL((STRMBUFTRACE,"returning %d. count: %d\n", EOF));
        return EOF;
    }
    count = m_read_end - m_read_ptr; // Adjusted bytes in Get area

    DL((STRMBUFTRACE,"Adjusted bytes in Get Area: %d\n",count));

    if (count > len_) {
        count = len_;
    }

    if (count <= 0) {
        count = 0;  // Peer closed connection
    }
    else if (count > 20) {
        memcpy (data_, m_read_ptr, count);
        m_read_ptr += count;
    }
    else {
        char* s = data_;
        char* p = m_read_ptr;
        int i = count;
        while (i-- > 0) {
            *s++ = *p++;
        }
        m_read_ptr = p;
    }
    DL((STRMBUFTRACE,"Transferred %d bytes to user-space buffer\n", count));

    return (count);
}

int
Streambuf::
uflow ()
{
    trace_with_mask("Streambuf::uflow",STRMBUFTRACE);

    if (underflow () == EOF)
        return EOF;
    dump ();
    return *(unsigned char *) m_read_ptr++;
}

int
Streambuf::
xsputn (const char* data_, int len_)
{
    trace_with_mask("Streambuf::xsputn",STRMBUFTRACE);

    const char* s = data_;
    int more = len_;
    if (more <= 0) {
        return 0;
    }

    for (;;) {
        int count = m_write_end - m_write_ptr; // Space available

        if (count > 0) {

            if (count > more) // Enough buffer space
                count = more;

            if (count > 20) {
                memcpy (m_write_ptr, s, count);
                s += count;
                m_write_ptr += count;
            }
            else if (count <= 0) {
                count = 0;
            }
            else {
                char* p = m_write_ptr;
                int i;

                for (i=count; --i >= 0;) {
                    *p++ = *s++;
                }
                m_write_ptr = p;
            }
            more -= count;
        } // if (count>0)
        
        if (more == 0 || overflow ((unsigned char) *s++) == EOF) {
            break;
        }
        more--;

    } // for (;;)

    return (len_ - more);
}


int
Streambuf::doallocate ()
{
    trace_with_mask("Streambuf::doallocate",STRMBUFTRACE);

    char* buf;
    buf = new char [1024];
    if (buf == NULL) {
        return EOF;
    }
    setb (buf, buf+1024, 1);

    return 1;
}

---