1 files changed, 275 insertions, 0 deletions
diff --git a/botan/src/filters/pipe.h b/botan/src/filters/pipe.h
new file mode 100644
index 0000000..120f2fb
--- /dev/null
+++ b/botan/src/filters/pipe.h
@@ -0,0 +1,275 @@
+/*
+* Pipe
+* (C) 1999-2007 Jack Lloyd
+*
+* Distributed under the terms of the Botan license
+*/
+
+#ifndef BOTAN_PIPE_H__
+#define BOTAN_PIPE_H__
+
+#include <botan/data_src.h>
+#include <botan/filter.h>
+#include <botan/exceptn.h>
+#include <iosfwd>
+
+namespace Botan {
+
+/**
+* This class represents pipe objects.
+* A set of filters can be placed into a pipe, and information flows
+* through the pipe until it reaches the end, where the output is
+* collected for retrieval.  If you're familiar with the Unix shell
+* environment, this design will sound quite familiar.
+*/
+
+class BOTAN_DLL Pipe : public DataSource
+   {
+   public:
+      typedef u32bit message_id;
+
+      class Invalid_Message_Number : public Invalid_Argument
+         {
+         public:
+            Invalid_Message_Number(const std::string&, message_id);
+         };
+
+      static const message_id LAST_MESSAGE;
+      static const message_id DEFAULT_MESSAGE;
+
+      /**
+      * Write input to the pipe, i.e. to its first filter.
+      * @param in the byte array to write
+      * @param length the length of the byte array in
+      */
+      void write(const byte in[], u32bit length);
+
+      /**
+      * Write input to the pipe, i.e. to its first filter.
+      * @param in the MemoryRegion containing the data to write
+      */
+      void write(const MemoryRegion<byte>& in);
+
+      /**
+      * Write input to the pipe, i.e. to its first filter.
+      * @param in the string containing the data to write
+      */
+      void write(const std::string& in);
+
+      /**
+      * Write input to the pipe, i.e. to its first filter.
+      * @param in the DataSource to read the data from
+      */
+      void write(DataSource& in);
+
+      /**
+      * Write input to the pipe, i.e. to its first filter.
+      * @param in a single byte to be written
+      */
+      void write(byte in);
+
+      /**
+      * Perform start_msg(), write() and end_msg() sequentially.
+      * @param in the byte array containing the data to write
+      * @param length the length of the byte array to write
+      */
+      void process_msg(const byte in[], u32bit length);
+
+      /**
+      * Perform start_msg(), write() and end_msg() sequentially.
+      * @param in the MemoryRegion containing the data to write
+      */
+      void process_msg(const MemoryRegion<byte>& in);
+
+      /**
+      * Perform start_msg(), write() and end_msg() sequentially.
+      * @param in the string containing the data to write
+      */
+      void process_msg(const std::string& in);
+
+      /**
+      * Perform start_msg(), write() and end_msg() sequentially.
+      * @param in the DataSource providing the data to write
+      */
+      void process_msg(DataSource& in);
+
+      /**
+      * Find out how many bytes are ready to read.
+      * @param msg the number identifying the message
+      * for which the information is desired
+      * @return the number of bytes that can still be read
+      */
+      u32bit remaining(message_id msg = DEFAULT_MESSAGE) const;
+
+      /**
+      * Read the default message from the pipe. Moves the internal
+      * offset so that every call to read will return a new portion of
+      * the message.
+      * @param output the byte array to write the read bytes to
+      * @param length the length of the byte array output
+      * @return the number of bytes actually read into output
+      */
+      u32bit read(byte output[], u32bit length);
+
+      /**
+      * Read a specified message from the pipe. Moves the internal
+      * offset so that every call to read will return a new portion of
+      * the message.
+      * @param output the byte array to write the read bytes to
+      * @param length the length of the byte array output
+      * @param msg the number identifying the message to read from
+      * @return the number of bytes actually read into output
+      */
+      u32bit read(byte output[], u32bit length, message_id msg);
+
+      /**
+      * Read a single byte from the pipe. Moves the internal offset so that
+      * every call to read will return a new portion of the message.
+      * @param output the byte to write the result to
+      * @return the number of bytes actually read into output
+      */
+      u32bit read(byte& output, message_id msg = DEFAULT_MESSAGE);
+
+      /**
+      * Read the full contents of the pipe.
+      * @param msg the number identifying the message to read from
+      * @return a SecureVector holding the contents of the pipe
+      */
+      SecureVector<byte> read_all(message_id msg = DEFAULT_MESSAGE);
+
+      /**
+      * Read the full contents of the pipe.
+      * @param msg the number identifying the message to read from
+      * @return a string holding the contents of the pipe
+      */
+      std::string read_all_as_string(message_id = DEFAULT_MESSAGE);
+
+      /** Read from the default message but do not modify the internal
+      * offset. Consecutive calls to peek() will return portions of
+      * the message starting at the same position.
+      * @param output the byte array to write the peeked message part to
+      * @param length the length of the byte array output
+      * @param offset the offset from the current position in message
+      * @return the number of bytes actually peeked and written into output
+      */
+      u32bit peek(byte output[], u32bit length, u32bit offset) const;
+
+      /** Read from the specified message but do not modify the
+      * internal offset. Consecutive calls to peek() will return
+      * portions of the message starting at the same position.
+      * @param output the byte array to write the peeked message part to
+      * @param length the length of the byte array output
+      * @param offset the offset from the current position in message
+      * @param msg the number identifying the message to peek from
+      * @return the number of bytes actually peeked and written into output
+      */
+      u32bit peek(byte output[], u32bit length,
+                  u32bit offset, message_id msg) const;
+
+      /** Read a single byte from the specified message but do not
+      * modify the internal offset. Consecutive calls to peek() will
+      * return portions of the message starting at the same position.
+      * @param output the byte to write the peeked message byte to
+      * @param offset the offset from the current position in message
+      * @param msg the number identifying the message to peek from
+      * @return the number of bytes actually peeked and written into output
+      */
+      u32bit peek(byte& output, u32bit offset,
+                  message_id msg = DEFAULT_MESSAGE) const;
+
+      u32bit default_msg() const { return default_read; }
+
+      /**
+      * Set the default message
+      * @param msg the number identifying the message which is going to
+      * be the new default message
+      */
+      void set_default_msg(message_id msg);
+
+      /**
+      * Get the number of messages the are in this pipe.
+      * @return the number of messages the are in this pipe
+      */
+      message_id message_count() const;
+
+      /**
+      * Test whether this pipe has any data that can be read from.
+      * @return true if there is more data to read, false otherwise
+      */
+      bool end_of_data() const;
+
+      /**
+      * Start a new message in the pipe. A potential other message in this pipe
+      * must be closed with end_msg() before this function may be called.
+      */
+      void start_msg();
+
+      /**
+      * End the current message.
+      */
+      void end_msg();
+
+      /**
+      * Insert a new filter at the front of the pipe
+      * @param filt the new filter to insert
+      */
+      void prepend(Filter* filt);
+
+      /**
+      * Insert a new filter at the back of the pipe
+      * @param filt the new filter to insert
+      */
+      void append(Filter* filt);
+
+      /**
+      * Remove the first filter at the front of the pipe.
+      */
+      void pop();
+
+      /**
+      * Reset this pipe to an empty pipe.
+      */
+      void reset();
+
+      /**
+      * Construct a Pipe of up to four filters. The filters are set up
+      * in the same order as the arguments.
+      */
+      Pipe(Filter* = 0, Filter* = 0, Filter* = 0, Filter* = 0);
+
+      /**
+      * Construct a Pipe from range of filters passed as an array
+      * @param filters the set of filters to use
+      * @param count the number of elements in filters
+      */
+      Pipe(Filter* filters[], u32bit count);
+      ~Pipe();
+   private:
+      Pipe(const Pipe&) : DataSource() {}
+      Pipe& operator=(const Pipe&) { return (*this); }
+      void init();
+      void destruct(Filter*);
+      void find_endpoints(Filter*);
+      void clear_endpoints(Filter*);
+
+      message_id get_message_no(const std::string&, message_id) const;
+
+      Filter* pipe;
+      class Output_Buffers* outputs;
+      message_id default_read;
+      bool inside_msg;
+   };
+
+/*
+* I/O Operators for Pipe
+*/
+BOTAN_DLL std::ostream& operator<<(std::ostream&, Pipe&);
+BOTAN_DLL std::istream& operator>>(std::istream&, Pipe&);
+
+}
+
+#endif
+
+#if defined(BOTAN_HAS_PIPE_UNIXFD_IO)
+  #include <botan/fd_unix.h>
+#endif