diff --git a/jni/libucommon/sources/inc/ucommon/stream.h b/jni/libucommon/sources/inc/ucommon/stream.h
new file mode 100644
index 0000000..9645356
--- /dev/null
+++ b/jni/libucommon/sources/inc/ucommon/stream.h
@@ -0,0 +1,482 @@
+// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
+//
+// This file is part of GNU uCommon C++.
+//
+// GNU uCommon C++ is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// GNU uCommon C++ is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
+
+/**
+ * Any ucommon streaming classes that are built from std::streamio facilities
+ * and that support ANSI C++ stream operators.
+ * @file ucommon/stream.h
+ */
+
+#if defined(OLD_STDCPP) || defined(NEW_STDCPP)
+#ifndef _UCOMMON_STREAM_H_
+#define _UCOMMON_STREAM_H_
+
+#ifndef _UCOMMON_CONFIG_H
+#include <ucommon/platform.h>
+#endif
+
+#ifndef _UCOMMON_PROTOCOLS_H_
+#include <ucommon/protocols.h>
+#endif
+
+#ifndef _UCOMMON_THREAD_H_
+#include <ucommon/thread.h>
+#endif
+
+#ifndef _UCOMMON_SOCKET_H_
+#include <ucommon/socket.h>
+#endif
+
+#ifndef _UCOMMON_FSYS_H_
+#include <ucommon/fsys.h>
+#endif
+
+#ifndef _UCOMMON_SHELL_H_
+#include <ucommon/shell.h>
+#endif
+
+#include <iostream>
+
+NAMESPACE_UCOMMON
+
+/**
+ * Common stream buffer for std C++ i/o classes.    This both binds the
+ * character protocol to iostream and offers a common base class for all
+ * other c++ stdlib based streaming classes.
+ * @author David Sugar <dyfet@gnutelephony.org>
+ */
+class __EXPORT StreamBuffer : protected std::streambuf, public std::iostream
+{
+protected:
+    size_t bufsize;
+    char *gbuf, *pbuf;
+
+    StreamBuffer();
+
+    /**
+     * This streambuf method is used for doing unbuffered reads
+     * through the establish tcp socket connection when in interactive mode.
+     * Also this method will handle proper use of buffers if not in
+     * interactive mode.
+     *
+     * @return char from tcp socket connection, EOF if not connected.
+     */
+    int uflow();
+
+    void release(void);
+
+    void allocate(size_t size);
+
+public:
+    /**
+     * Flush the stream input and output buffers, writes pending output.
+     * @return 0 on success, or error code.
+     */
+    int sync(void);
+
+    inline bool is_open(void)
+        {return bufsize > 0;}
+
+    inline operator bool()
+        {return bufsize > 0;}
+
+    inline bool operator!()
+        {return bufsize == 0;}
+};
+
+/**
+ * Streamable tcp connection between client and server.  The tcp stream
+ * class can represent a client connection to a server or an instance of
+ * a service generated by a tcp listener.  As a stream class, data can
+ * be manipulated using the << and >> operators.
+ *
+ * @author David Sugar <dyfet@gnutelephony.org>
+ */
+class __EXPORT tcpstream : public StreamBuffer
+{
+private:
+    __LOCAL void allocate(unsigned size);
+    __LOCAL void reset(void);
+
+protected:
+    socket_t so;
+    timeout_t timeout;
+
+    virtual ssize_t _read(char *buffer, size_t size);
+
+    virtual ssize_t _write(const char *buffer, size_t size);
+
+    virtual bool _wait(void);
+
+    /**
+     * Release the tcp stream and destroy the underlying socket.
+     */
+    void release(void);
+
+    /**
+     * This streambuf method is used to load the input buffer
+     * through the established tcp socket connection.
+     *
+     * @return char from get buffer, EOF if not connected.
+     */
+    int underflow(void);
+
+    /**
+     * This streambuf method is used to write the output
+     * buffer through the established tcp connection.
+     * @param ch char to push through.
+     * @return char pushed through.
+     */
+    int overflow(int ch);
+
+    inline socket_t getsocket(void) const
+        {return so;}
+
+public:
+    /**
+     * Copy constructor...
+     * @param copy for object.
+     */
+    tcpstream(const tcpstream& copy);
+
+    /**
+     * Create a stream from an existing tcp listener.
+     * @param server to accept connection from.
+     * @param segsize for tcp segments and buffering.
+     * @param timeout for socket i/o operations.
+     */
+    tcpstream(const TCPServer *server, unsigned segsize = 536, timeout_t timeout = 0);
+
+    /**
+     * Create an unconnected tcp stream object that is idle until opened.
+     * @param family of protocol to create.
+     * @param timeout for socket i/o operations.
+     */
+    tcpstream(int family = PF_INET, timeout_t timeout = 0);
+
+    /**
+     * A convenience constructor that creates a connected tcp stream directly
+     * from an address.  The socket is constructed to match the type of the
+     * the address family in the socket address that is passed.
+     * @param address of service to connect to.
+     * @param segsize for tcp segments and buffering.
+     * @param timeout for socket i/o operations.
+     */
+    tcpstream(Socket::address& address, unsigned segsize = 536, timeout_t timeout = 0);
+
+    /**
+     * Destroy a tcp stream.
+     */
+    virtual ~tcpstream();
+
+    /**
+     * See if stream connection is active.
+     * @return true if stream is active.
+     */
+    inline operator bool() const
+        {return so != INVALID_SOCKET && bufsize > 0;};
+
+    /**
+     * See if stream is disconnected.
+     * @return true if stream disconnected.
+     */
+    inline bool operator!() const
+        {return so == INVALID_SOCKET || bufsize == 0;};
+
+    /**
+     * Open a stream connection to a tcp service.
+     * @param address of service to access.
+     * @param segment buffering size to use.
+     */
+    void open(Socket::address& address, unsigned segment = 536);
+
+    /**
+     * Open a stream connectoion to a host and service.
+     * @param host to connect to.
+     * @param service to connect to by name or number as string.
+     * @param segment buffering size to use.
+     */
+    void open(const char *host, const char *service, unsigned segment = 536);
+
+    /**
+     * Close an active stream connection.  This does not release the
+     * socket but is a disconnect.
+     */
+    void close(void);
+};
+
+/**
+ * Streamable tcp connection between client and server.  The tcp stream
+ * class can represent a client connection to a server or an instance of
+ * a service generated by a tcp listener.  As a stream class, data can
+ * be manipulated using the << and >> operators.
+ *
+ * @author David Sugar <dyfet@gnutelephony.org>
+ */
+class __EXPORT pipestream : public StreamBuffer
+{
+public:
+    typedef enum {
+        RDONLY,
+        WRONLY,
+        RDWR
+    } access_t;
+
+private:
+    __LOCAL void allocate(size_t size, access_t mode);
+
+protected:
+    fsys_t rd, wr;
+    shell::pid_t pid;
+
+    /**
+     * Release the stream, detach/do not wait for the process.
+     */
+    void release(void);
+
+    /**
+     * This streambuf method is used to load the input buffer
+     * through the established pipe connection.
+     *
+     * @return char from get buffer, EOF if not connected.
+     */
+    int underflow(void);
+
+    /**
+     * This streambuf method is used to write the output
+     * buffer through the established pipe connection.
+     *
+     * @param ch char to push through.
+     * @return char pushed through.
+     */
+    int overflow(int ch);
+
+public:
+    /**
+     * Create an unopened pipe stream.
+     */
+    pipestream();
+
+    /**
+     * Create child process and start pipe.
+     * @param path to execute.
+     * @param access mode of pipe stream.
+     * @param args to pass to command.
+     * @param env to create in child.
+     * @param size of buffer.
+     */
+    pipestream(const char *command, access_t access, char **args, char **env = NULL, size_t size = 512);
+
+    /**
+     * Destroy a pipe stream.
+     */
+    virtual ~pipestream();
+
+    /**
+     * See if stream connection is active.
+     * @return true if stream is active.
+     */
+    inline operator bool() const
+        {return (bufsize > 0);};
+
+    /**
+     * See if stream is disconnected.
+     * @return true if stream disconnected.
+     */
+    inline bool operator!() const
+        {return bufsize == 0;};
+
+    /**
+     * Open a stream connection to a pipe service.
+     * @param path to execute.
+     * @param access mode of stream.
+     * @param args to pass to command.
+     * @param env to create in child process.
+     * @param buffering size to use.
+     */
+    void open(const char *path, access_t access, char **args, char **env = NULL, size_t buffering = 512);
+
+    /**
+     * Close an active stream connection.  This waits for the child to
+     * terminate.
+     */
+    int close(void);
+
+    /**
+     * Force terminate child and close.
+     */
+    void terminate(void);
+
+    inline void cancel(void)
+        {terminate();}
+};
+
+/**
+ * Streamable tcp connection between client and server.  The tcp stream
+ * class can represent a client connection to a server or an instance of
+ * a service generated by a tcp listener.  As a stream class, data can
+ * be manipulated using the << and >> operators.
+ *
+ * @author David Sugar <dyfet@gnutelephony.org>
+ */
+class __EXPORT filestream : public StreamBuffer
+{
+public:
+    typedef enum {
+        RDONLY,
+        WRONLY,
+        RDWR
+    } access_t;
+
+private:
+    __LOCAL void allocate(size_t size, fsys::access_t mode);
+
+protected:
+    fsys_t fd;
+    fsys::access_t ac;
+
+    /**
+     * This streambuf method is used to load the input buffer
+     * through the established pipe connection.
+     *
+     * @return char from get buffer, EOF if not connected.
+     */
+    int underflow(void);
+
+    /**
+     * This streambuf method is used to write the output
+     * buffer through the established pipe connection.
+     *
+     * @param ch char to push through.
+     * @return char pushed through.
+     */
+    int overflow(int ch);
+
+public:
+    /**
+     * Create an unopened pipe stream.
+     */
+    filestream();
+
+    /**
+     * Create duplicate stream.
+     */
+    filestream(const filestream& copy);
+
+    /**
+     * Create and open a file stream.
+     */
+    filestream(const char *path, unsigned mode, fsys::access_t access, size_t bufsize = 512);
+
+    /**
+     * Open file stream.
+     */
+    filestream(const char *path, fsys::access_t access, size_t bufsize = 512);
+
+    /**
+     * Destroy a file stream.
+     */
+    virtual ~filestream();
+
+    /**
+     * See if stream connection is active.
+     * @return true if stream is active.
+     */
+    inline operator bool() const
+        {return (bufsize > 0);};
+
+    /**
+     * See if stream is disconnected.
+     * @return true if stream disconnected.
+     */
+    inline bool operator!() const
+        {return bufsize == 0;};
+
+    /**
+     * Open a stream connection to a tcp service.
+     */
+    void open(const char *filename, fsys::access_t access, size_t buffering = 512);
+
+    /**
+     * Create a stream connection to a tcp service.
+     */
+    void open(const char *filename, unsigned mode, fsys::access_t access, size_t buffering = 512);
+
+    /**
+     * Close an active stream connection.
+     */
+    void close(void);
+
+    /**
+     * Seek position.
+     */
+    void seek(fsys::offset_t offset);
+
+    /**
+     * Get error flag from last i/o operation.
+     * @return last error.
+     */
+    inline int err(void) const
+        {return fd.err();};
+};
+
+/**
+ * At least with gcc, linking of stream operators was broken.  This provides
+ * an auxillory class to solve the issue.
+ */
+class __EXPORT _stream_operators
+{
+private:
+    inline _stream_operators() {};
+
+public:
+    static std::ostream& print(std::ostream& out, const PrintProtocol& format);
+
+    static std::istream& input(std::istream& inp, InputProtocol& format);
+
+    static std::ostream& print(std::ostream& out, const string_t& str);
+
+    static std::istream& input(std::istream& inp, string_t& str);
+
+    static std::ostream& print(std::ostream& out, const stringlist_t& list);
+
+    static std::istream& input(std::istream& in, stringlist_t& list);
+
+};
+
+inline std::ostream& operator<< (std::ostream& out, const PrintProtocol& format)
+        {return _stream_operators::print(out, format);}
+
+inline std::istream& operator>> (std::istream& inp, InputProtocol& format)
+        {return _stream_operators::input(inp, format);}
+
+inline std::ostream& operator<< (std::ostream& out, const string_t& str)
+        {return _stream_operators::print(out, str);}
+
+inline std::istream& operator>> (std::istream& inp, string_t& str)
+        {return _stream_operators::input(inp, str);}
+
+inline std::ostream& operator<< (std::ostream& out, const stringlist_t& list)
+        {return _stream_operators::print(out, list);}
+
+inline std::istream& operator>> (std::istream& in, stringlist_t& list)
+        {return _stream_operators::input(in, list);}
+
+END_NAMESPACE
+
+#endif
+#endif