diff --git a/jni/libzrtp/sources/zrtp/libzrtpcpp/ZrtpConfigure.h b/jni/libzrtp/sources/zrtp/libzrtpcpp/ZrtpConfigure.h
new file mode 100644
index 0000000..bb78cef
--- /dev/null
+++ b/jni/libzrtp/sources/zrtp/libzrtpcpp/ZrtpConfigure.h
@@ -0,0 +1,564 @@
+/*
+  Copyright (C) 2009 - 2013 Werner Dittmann
+
+  This program 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.
+
+  This program 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 General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * Authors: Werner Dittmann <Werner.Dittmann@t-online.de>
+ */
+
+#ifndef _ZRTPCONFIGURE_H_
+#define _ZRTPCONFIGURE_H_
+
+/**
+ * @file ZrtpConfigure.h
+ * @brief The ZRTP configure functions
+ * @ingroup GNU_ZRTP
+ * @{
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <list>
+#include <string>
+#include <vector>
+#include <string.h>
+
+#include <libzrtpcpp/ZrtpCallback.h>
+
+/**
+ * This enumerations list all configurable algorithm types.
+ */
+
+enum AlgoTypes {
+    Invalid = 0, HashAlgorithm = 1, CipherAlgorithm, PubKeyAlgorithm, SasType, AuthLength
+};
+
+typedef void(*encrypt_t)(uint8_t*, int32_t, uint8_t*, uint8_t*, int32_t);
+typedef void(*decrypt_t)(uint8_t*, int32_t, uint8_t*, uint8_t*, int32_t);
+
+/**
+ * The algorithm enumration class.
+ *
+ * This simple class is just a container of an algorithm's name and
+ * its associated algorithm type. We use this class together with the
+ * EnumBase class to implement a Java-like enum class functionality
+ * (not fully, but OK for our use case).
+ *
+ * An application shall use the get / check methods to retrieve information.
+ */
+class AlgorithmEnum {
+public:
+    /**
+     * Create an AlgorithmEnum object.
+     *
+     * @param type
+     *    Defines the algorithm type
+     * @param name
+     *    Set the names of the algorithm. The name is copied
+     *    and the call may reuse the space.
+     * @param klen
+     *    The key length for this algorihm in byte, for example 16 or 32
+     * @param ra
+     *    A human readable short string that describes the algorihm.
+     * @param en
+     *    Pointer to the encryption function of this algorithn
+     * @param de
+     *    Pointer to the decryption funtions of this algorithm.
+     * @param alId
+     *    The algorithm id used by SRTP to identify an algorithm type, for
+     *    example Skein, Sha1, Aes, ...
+     *
+     * @see AlgoTypes
+     */
+    AlgorithmEnum(const AlgoTypes type, const char* name, int32_t klen,
+                  const char* ra, encrypt_t en, decrypt_t de, SrtpAlgorithms alId);
+
+    /**
+     * AlgorithmEnum destructor
+     */
+    ~AlgorithmEnum();
+
+    /**
+     * Get the algorihm's name
+     *
+     * @returns
+     *    Algorithm's name as null terminated C-string. The
+     *    application must not free this memory.
+     */
+    const char* getName();
+
+    /**
+     * Get the algorihm's readable name
+     *
+     * @returns
+     *    Algorithm's readable name as null terminated C-string. The
+     *    application must not free this memory.
+     */
+    const char* getReadable();
+
+    /**
+     * Get the algorihm's key length.
+     *
+     * @returns
+     *    An integer definig the key length in bytes.
+     */
+    int getKeylen();
+
+    /**
+     * Get the algorihm's integer id.
+     *
+     * @returns
+     *    An integer that defines the algorithm.
+     */
+    SrtpAlgorithms getAlgoId();
+    /**
+     * Get the algorihm's key length.
+     *
+     * @returns
+     *    An integer definig the key length in bytes.
+     */
+    encrypt_t getEncrypt();
+
+    /**
+     * Get the algorihm's key length.
+     *
+     * @returns
+     *    An integer definig the key length in bytes.
+     */
+    decrypt_t getDecrypt();
+
+    /**
+     * Get the algorithm type of this AlgorithmEnum object.
+     *
+     * @returns
+     *     The algorithm type.
+     *
+     * @see AlgoTypes
+     */
+    AlgoTypes getAlgoType();
+
+    /**
+     * Check if this AlgorithmEnum object is valid
+     *
+     * @returns
+     *    @c true if the object is valid, @c false otherwise
+     */
+    bool isValid();
+
+private:
+    AlgoTypes algoType;
+    std::string algoName;
+    int32_t   keyLen;
+    std::string readable;
+    encrypt_t encrypt;
+    decrypt_t decrypt;
+    SrtpAlgorithms   algoId;
+};
+
+/**
+ * EnumBase provides methods to store and access algorithm enumerations of
+ * a specific algorithm type.
+ *
+ * An application shall use the get / check methods to retrieve information
+ * from the preset Algorithm Enumerations.
+ *
+ * @see AlgoTypes
+ * @see zrtpHashes
+ * @see zrtpSymCiphers
+ * @see zrtpPubKeys
+ * @see zrtpSasTypes
+ * @see zrtpAuthLengths
+ */
+class __EXPORT EnumBase {
+public:
+    /**
+     * Get an AlgorithmEnum by its name
+     *
+     * @param name
+     *    The name of the AlgorithmEnum to search.
+     * @returns
+     *    The AlgorithmEnum if found or an invalid AlgorithmEnum if the name
+     *    was not found
+     */
+    AlgorithmEnum& getByName(const char* name);
+
+    /**
+     * Return all names of all currently stored AlgorithmEnums
+     *
+     * @return
+     *    A C++ std::list of C++ std::strings that contain the names.
+     */
+    std::list<std::string>* getAllNames();
+
+    /**
+     * Get the number of currently stored AlgorithmEnums
+     *
+     * @return
+     *    The number of currently stored AlgorithmEnums
+     */
+    int getSize();
+
+    /**
+     * Get the AlgoTypes to which this EnumBase belongs.
+     *
+     * @return
+     *     The AlgoTypes of this EnumBase.
+     * @see AlgoTypes.
+     */
+    AlgoTypes getAlgoType();
+
+    /**
+     * Return the AlgorithmEnum by its ordinal number
+     *
+     * @param ord
+     *     The ordinal number of the AlgorithmEnum.
+     * @return
+     *     The AlgorithmEnum if found, an invalid Algorithm otherwise.
+     */
+    AlgorithmEnum& getByOrdinal(int ord);
+
+    /**
+     * Get the ordinal number of an AlgorithmEnum
+     *
+     * @param algo
+     *     Return toe ordinal numer of this AlgorithmEnum.
+     *
+     * @return
+     *    Return the ordinal number of this AlgorithmEnum if found,
+     *    -1 otherwise.
+     */
+    int getOrdinal(AlgorithmEnum& algo);
+
+protected:
+    EnumBase(AlgoTypes algo);
+    ~EnumBase();
+    void insert(const char* name);
+    void insert(const char* name, int32_t klen,
+                const char* ra, encrypt_t en, decrypt_t de, SrtpAlgorithms alId);
+
+private:
+    AlgoTypes algoType;
+    std::vector <AlgorithmEnum* > algos;
+};
+
+/**
+ * The enumaration subclasses that contain the supported algorithm enumerations.
+ */
+class __EXPORT HashEnum : public EnumBase {
+public:
+    HashEnum();
+    ~HashEnum();
+};
+
+class __EXPORT SymCipherEnum : public EnumBase {
+public:
+    SymCipherEnum();
+    ~SymCipherEnum();
+};
+
+class __EXPORT PubKeyEnum : public EnumBase {
+public:
+    PubKeyEnum();
+    ~PubKeyEnum();
+};
+
+class __EXPORT SasTypeEnum : public EnumBase {
+public:
+    SasTypeEnum();
+    ~SasTypeEnum();
+};
+
+class __EXPORT AuthLengthEnum : public EnumBase {
+public:
+    AuthLengthEnum();
+    ~AuthLengthEnum();
+};
+
+extern __EXPORT HashEnum zrtpHashes;
+extern __EXPORT SymCipherEnum zrtpSymCiphers;
+extern __EXPORT PubKeyEnum zrtpPubKeys;
+extern __EXPORT SasTypeEnum zrtpSasTypes;
+extern __EXPORT AuthLengthEnum zrtpAuthLengths;
+
+/**
+ * ZRTP configuration data.
+ *
+ * This class contains data and functions to set ZRTP configuration data.
+ * An application may use this class to set configuration information for
+ * ZRTP. ZRTP uses this configuration information to announce various
+ * algorithms via its Hello message. An application may use this class to
+ * restrict or allow use of algorithms.
+ *
+ * The constructor does not set any algorithms, thus it is an empty
+ * configuration. An application may use this empty configuration and
+ * hand it over to ZRTP. In this case ZRTP does not announce any algorithms
+ * in its Hello message and uses mandatory algorithms only.
+ *
+ * An application can configure implemented algorithms only.
+ */
+class __EXPORT ZrtpConfigure {
+public:
+    ZrtpConfigure();         /* Creates Configuration data */
+    ~ZrtpConfigure();
+
+    /**
+     * Define the algorithm selection policies.
+     */
+    typedef enum _policies {
+        Standard = 1,
+        PreferNonNist = 2
+    } Policy;
+
+    /**
+     * Set the maximum number of algorithms per algorithm type that an application can
+     * configure.
+     */
+    static const int maxNoOfAlgos = 7;
+    /**
+     * Convenience function that sets a pre-defined standard configuration.
+     *
+     * The standard configuration consists of the following algorithms:
+     * <ul>
+     * <li> Hash: SHA256 </li>
+     * <li> Symmetric Cipher: AES 128, AES 256 </li>
+     * <li> Public Key Algorithm: DH2048, DH3027, MultiStream </li>
+     * <li> SAS type: libase 32 </li>
+     * <li> SRTP Authentication lengths: 32, 80 </li>
+     *</ul>
+     */
+    void setStandardConfig();
+
+    /**
+     * Convenience function that sets the mandatory algorithms only.
+     *
+     * Mandatory algorithms are:
+     * <ul>
+     * <li> Hash: SHA256 </li>
+     * <li> Symmetric Cipher: AES 128 </li>
+     * <li> Public Key Algorithm: DH3027, MultiStream </li>
+     * <li> SAS type: libase 32 </li>
+     * <li> SRTP Authentication lengths: 32, 80 </li>
+     *</ul>
+     */
+    void setMandatoryOnly();
+
+    /**
+     * Clear all configuration data.
+     *
+     * The functions clears all configuration data.
+     */
+    void clear();
+
+    /**
+     * Add an algorithm to configuration data.
+     *
+     * Adds the specified algorithm to the configuration data.
+     * If no free configuration data slot is available the
+     * function does not add the algorithm and returns -1. The
+     * methods appends the algorithm to the existing algorithms.
+     *
+     * @param algoType
+     *    Specifies which algorithm type to select
+     * @param algo
+     *    The enumeration of the algorithm to add.
+     * @return
+     *    Number of free configuration data slots or -1 on error
+     */
+    int32_t addAlgo(AlgoTypes algoType, AlgorithmEnum& algo);
+
+    /**
+     * Add an algorithm to configuration data at given index.
+     *
+     * Adds the specified algorithm to the configuration data vector
+     * at a given index. If the index is larger than the actual size
+     * of the configuration vector the method just appends the algorithm.
+     *
+     * @param algoType
+     *    Specifies which algorithm type to select
+     * @param algo
+     *    The enumeration of the algorithm to add.
+     * @param index
+     *    The index where to add the algorihm
+     * @return
+     *    Number of free configuration data slots or -1 on error
+     */
+    int32_t addAlgoAt(AlgoTypes algoType, AlgorithmEnum& algo, int32_t index);
+
+    /**
+     * Remove a algorithm from configuration data.
+     *
+     * Removes the specified algorithm from configuration data. If
+     * the algorithm was not configured previously the function does
+     * not modify the configuration data and returns the number of
+     * free configuration data slots.
+     *
+     * If an application removes all algorithms then ZRTP does not
+     * include any algorithm into the hello message and falls back
+     * to a predefined mandatory algorithm.
+     *
+     * @param algoType
+     *    Specifies which algorithm type to select
+     * @param algo
+     *    The enumeration of the algorithm to remove.
+     * @return
+     *    Number of free configuration slots.
+     */
+    int32_t removeAlgo(AlgoTypes algoType, AlgorithmEnum& algo);
+
+    /**
+     * Returns the number of configured algorithms.
+     *
+     * @param algoType
+     *    Specifies which algorithm type to select
+     * @return
+     *    The number of configured algorithms (used configuration
+     *    data slots)
+     */
+    int32_t getNumConfiguredAlgos(AlgoTypes algoType);
+
+    /**
+     * Returns the identifier of the algorithm at index.
+     *
+     * @param algoType
+     *    Specifies which algorithm type to select
+     * @param index
+     *    The index in the list of the algorihm type
+     * @return
+     *    A pointer the the algorithm enumeration. If the index
+     *    does not point to a configured slot then the function
+     *    returns NULL.
+     *
+     */
+    AlgorithmEnum& getAlgoAt(AlgoTypes algoType, int32_t index);
+
+    /**
+     * Checks if the configuration data of the algorihm type already contains
+     * a specific algorithms.
+     *
+     * @param algoType
+     *    Specifies which algorithm type to select
+     * @param algo
+     *    The algorithm to check
+     * @return
+     *    True if the algorithm was found, false otherwise.
+     *
+     */
+    bool containsAlgo(AlgoTypes algoType, AlgorithmEnum& algo);
+
+    /**
+     * Enables or disables trusted MitM processing.
+     *
+     * For further details of trusted MitM processing refer to ZRTP
+     * specification, chapter 7.3
+     *
+     * @param yesNo
+     *    If set to true then trusted MitM processing is enabled.
+     */
+    void setTrustedMitM(bool yesNo);
+
+    /**
+     * Check status of trusted MitM processing.
+     *
+     * @return
+     *    Returns true if trusted MitM processing is enabled.
+     */
+    bool isTrustedMitM();
+
+    /**
+     * Enables or disables SAS signature processing.
+     *
+     * For further details of trusted MitM processing refer to ZRTP
+     * specification, chapter 7.2
+     *
+     * @param yesNo
+     *    If set to true then certificate processing is enabled.
+     */
+    void setSasSignature(bool yesNo);
+
+    /**
+     * Check status of SAS signature processing.
+     *
+     * @return
+     *    Returns true if certificate processing is enabled.
+     */
+    bool isSasSignature();
+
+    /**
+     * Enables or disables paranoid mode.
+     *
+     * For further explanation of paranoid mode refer to the documentation
+     * of ZRtp class.
+     *
+     * @param yesNo
+     *    If set to true then paranoid mode is enabled.
+     */
+    void setParanoidMode(bool yesNo);
+
+    /**
+     * Check status of paranoid mode.
+     *
+     * @return
+     *    Returns true if paranoid mode is enabled.
+     */
+    bool isParanoidMode();
+
+    /// Helper function to print some internal data
+    void printConfiguredAlgos(AlgoTypes algoTyp);
+
+    Policy getSelectionPolicy()         {return selectionPolicy;}
+    void setSelectionPolicy(Policy pol) {selectionPolicy = pol;}
+
+  private:
+    std::vector<AlgorithmEnum* > hashes;
+    std::vector<AlgorithmEnum* > symCiphers;
+    std::vector<AlgorithmEnum* > publicKeyAlgos;
+    std::vector<AlgorithmEnum* > sasTypes;
+    std::vector<AlgorithmEnum* > authLengths;
+
+    bool enableTrustedMitM;
+    bool enableSasSignature;
+    bool enableParanoidMode;
+
+
+    AlgorithmEnum& getAlgoAt(std::vector<AlgorithmEnum* >& a, int32_t index);
+    int32_t addAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo);
+    int32_t addAlgoAt(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo, int32_t index);
+    int32_t removeAlgo(std::vector<AlgorithmEnum* >& a,  AlgorithmEnum& algo);
+    int32_t getNumConfiguredAlgos(std::vector<AlgorithmEnum* >& a);
+    bool containsAlgo(std::vector<AlgorithmEnum* >& a, AlgorithmEnum& algo);
+    std::vector<AlgorithmEnum* >& getEnum(AlgoTypes algoType);
+
+    void printConfiguredAlgos(std::vector<AlgorithmEnum* >& a);
+
+    Policy selectionPolicy;
+
+  protected:
+
+  public:
+};
+
+/**
+ * @}
+ */
+#endif
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-default-style: ellemtel
+ * c-basic-offset: 4
+ * End:
+ */