ibrcommon/ibrcommon/net/iostreamBIO.cpp

Go to the documentation of this file.

/*
 * iostreamBIO.cpp
 *
 *  Created on: Mar 25, 2011
 *      Author: roettger
 */

#include "iostreamBIO.h"

#include "ibrcommon/Logger.h"

#include <openssl/err.h>

namespace ibrcommon
{

static const int ERR_BUF_SIZE = 256;

const char * const iostreamBIO::name = "iostreamBIO";

/* callback functions for openssl */
static int bwrite(BIO *bio, const char *buf, int len);
static int bread(BIO *bio, char *buf, int len);
//static int bputs(BIO *bio, const char *);
//static int bgets(BIO *bio, char *, int);
static long ctrl(BIO *bio, int cmd, long num, void *ptr);
static int create(BIO *bio);
//static int destroy(BIO *bio);
//static long (*callback_ctrl)(BIO *, int, bio_info_cb *);


static BIO_METHOD iostream_method =
{
                iostreamBIO::type,
                iostreamBIO::name,
                bwrite,
                bread,
                NULL,//bputs
                NULL,//bgets
                ctrl,
                create,
                NULL,//destroy,
                NULL//callback_ctrl
};

iostreamBIO::iostreamBIO(iostream *stream)
        :       _stream(stream)
{
        /* create BIO */
        _bio = BIO_new(&iostream_method);
        if(!_bio){
                /* creation failed, throw exception */
                char err_buf[ERR_BUF_SIZE];
        ERR_error_string_n(ERR_get_error(), err_buf, ERR_BUF_SIZE);
        err_buf[ERR_BUF_SIZE - 1] = '\0';
        IBRCOMMON_LOGGER(critical) << "iostreamBIO: BIO creation failed: " << err_buf << IBRCOMMON_LOGGER_ENDL;
                throw BIOException(err_buf);
        }

        /* save the iostream in the bio object */
        _bio->ptr = stream;
}

BIO *
iostreamBIO::getBIO(){
        return _bio;
}

static int create(BIO *bio)
{
        bio->ptr = NULL;
        /* (from openssl memory bio) */
        bio->shutdown=1;
        bio->init=1;
        /* from bss_mem.c (openssl):
         * bio->num is used to hold the value to return on 'empty', if it is
         * 0, should_retry is not set
         *
         * => -1 means the caller can retry, 0: retry is useless
         * it is set to 0 since the underlying stream is blocking
         */
        bio->num= 0;

        return 1;
}



static long ctrl(BIO *bio, int cmd, long  num, void *ptr)
{
        long ret;
        iostream *stream = reinterpret_cast<iostream*>(bio->ptr);

        IBRCOMMON_LOGGER_DEBUG(90) << "iostreamBIO: ctrl called, cmd: " << cmd << ", num: " << num << "." << IBRCOMMON_LOGGER_ENDL;

        switch(cmd){
        case BIO_CTRL_PUSH:
        case BIO_CTRL_POP:
                ret = 0;
                break;
//      case BIO_CTRL_GET_CLOSE:
//              ret = bio->shutdown;
//              break;
//      case BIO_CTRL_SET_CLOSE:
//              bio->shutdown = (int)num;
//              ret = 1;
//              break;
        case BIO_CTRL_FLUSH:
                /* try to flush the underlying stream */
                ret = 1;
                try{
                        stream->flush();
                } catch(ios_base::failure &ex){
                        /* ignore, the badbit is checked instead */
                }
//              catch(ConnectionClosedException &ex){
//                      throw;
//              }
                if(stream->bad()){
                        IBRCOMMON_LOGGER_DEBUG(20) << "iostreamBIO: underlying Stream went bad while flushing." << IBRCOMMON_LOGGER_ENDL;
                        ret = 0;
                }
                break;
        default:
                IBRCOMMON_LOGGER(warning) << "iostreamBIO: ctrl called with unhandled cmd: " << cmd << "." << IBRCOMMON_LOGGER_ENDL;
                ret = 0;
                break;
        }

        return ret;
}



static int bread(BIO *bio, char *buf, int len)
{
        iostream *stream = reinterpret_cast<iostream*>(bio->ptr);
        streamsize num_bytes = bio->num;

        try{
                /* make sure to read at least 1 byte and then read as much as we can */
                num_bytes = stream->read(buf, 1).readsome(buf+1, len-1) + 1;
        } catch(ios_base::failure &ex){
                /* ignore, bio->num will be returned and indicate the error */
        }
//      catch(ConnectionClosedException &ex){
//              throw; //this exception will be catched at higher layers
//      }

        return num_bytes;
}



static int bwrite(BIO *bio, const char *buf, int len)
{
        if(len == 0){
                return 0;
        }
        iostream *stream = reinterpret_cast<iostream*>(bio->ptr);

        /* write the data */
        try{
                stream->write(buf, len);
        } catch(ios_base::failure &ex){
                /* ignore, the badbit is checked instead */
        }
//      catch(ConnectionClosedException &ex){
//              throw;
//      }
        if(stream->bad()){
                IBRCOMMON_LOGGER_DEBUG(20) << "iostreamBIO: underlying Stream went bad while writing." << IBRCOMMON_LOGGER_ENDL;
                return 0;
        }

        /* flush the underlying stream */
        try{
                stream->flush();
        } catch(ios_base::failure &ex){
                /* ignore, the badbit is checked instead */
        }
//      catch(ConnectionClosedException &ex){
//              throw;
//      }
        if(stream->bad()){
                IBRCOMMON_LOGGER_DEBUG(20) << "iostreamBIO: underlying Stream went bad while flushing (bwrite)." << IBRCOMMON_LOGGER_ENDL;
                return 0;
        }

        return len;
}

}