Also filter single quotes and / in html_entities() to prevent XSS attack in normal...

[libi2ncommon] / src / pipestream.hxx

/***************************************************************************
              inpipestream.hxx  -  C++ streambuffer wrapper 
                             -------------------
    begin                : Thu Dec 27 2001
    copyright            : (C) 2001 by Intra2net AG
    email                : intranator@intra2net.com
 ***************************************************************************/

#ifndef _PIPESTREAM
#define _PIPESTREAM

#include <stdio.h>

#include <string>
#include <streambuf>
#include <istream>
#include <ostream>
#include <cstdio>

#include "exception.hxx"

// ATTENTION: A lot of mysterious STL bugs occured
//            with a "real" buffer (buffer larger than 1 byte and up to 100 bytes)
//            -> Keep it slow and working!

class inpipebuf : public std::streambuf
{
protected:
    char buffer;
    FILE *pipe;

    // "callback" variables for destructor to store exit status
    bool *status_set;
    int *exit_status;

public:
    inpipebuf(const std::string& command)
    {
        status_set = NULL;
        exit_status = NULL;

        pipe = popen (command.c_str(), "r");
        if (pipe == NULL)
            throw EXCEPTION (pipestream_error, "can't open program or permission denied");

        // force underflow
        setg (&buffer, &buffer, &buffer);
    }

    ~inpipebuf()
    {
        if (pipe != NULL) {
            int pclose_exit = pclose (pipe);

            if (exit_status && pclose_exit != -1) {
                *status_set = true;
                *exit_status = pclose_exit;
            }

            pipe = NULL;
        }
    }

    void store_exit_status(bool *_status_set, int *_exit_status)
    { status_set = _status_set; exit_status = _exit_status; }

protected:
    virtual int_type underflow()
    {
        if (gptr() < egptr())
            return traits_type::to_int_type(*gptr());

        buffer = fgetc (pipe);
        if (feof (pipe))
        {
            // ERROR or EOF
            return EOF;
        }

        setg (&buffer, &buffer, &buffer+sizeof(char));

        return traits_type::to_int_type(*gptr());
    }
};

class inpipestream : public std::istream
{
protected:
    inpipebuf buf;

public:
    inpipestream(const std::string& command)
            : buf(command), std::istream(&buf)
    {}

    void store_exit_status(bool *_status_set, int *_exit_status)
    { buf.store_exit_status(_status_set, _exit_status); }
};

class outpipebuf : public std::streambuf
{
protected:
    FILE *pipe;

    // "callback" variables for destructor to store exit status
    bool *status_set;
    int *exit_status;

public:
    outpipebuf(const std::string& command)
    {
        status_set = NULL;
        exit_status = NULL;

        pipe = popen (command.c_str(), "w");
        if (pipe == NULL)
            throw EXCEPTION (pipestream_error, "can't open program or permission denied");
    }

    ~outpipebuf()
    {
        if (pipe != NULL) {
            int pclose_exit = pclose (pipe);

            if (exit_status && pclose_exit != -1) {
                *status_set = true;
                *exit_status = pclose_exit;
            }

            pipe = NULL;
        }
    }

    void store_exit_status(bool *_status_set, int *_exit_status)
    { status_set = _status_set; exit_status = _exit_status; }

protected:
    virtual int_type overflow(int_type c)
    {
        if (c != EOF)
        {
            if (fputc(c,pipe)==EOF)
                return EOF;
        }
        return c;
    }

    virtual std::streamsize xsputn(const char* s, std::streamsize num)
    {
        return fwrite(s,num,1,pipe);
    }
};

class outpipestream : public std::ostream
{
protected:
    outpipebuf buf;
public:
    outpipestream(const std::string& command)
            : buf(command), std::ostream(&buf)
    {}

    void store_exit_status(bool *_status_set, int *_exit_status)
    { buf.store_exit_status(_status_set, _exit_status); }
};

#endif