[1.0.16][rtsp] Add interface to set certificate path

- add interface to set cert path via set/get_connection_param
  which is required to support RTSP TLS

Change-Id: I0ef9872ca3357724ff265195638ce85b8ad00702

diff --git a/include/MediaTransporterParam.h b/include/MediaTransporterParam.h
index 2106257a9866a502f11087fcbbfa373727e1e3ef..58c4dd2a78825cd2303f48c5636c564cd7749315 100644 (file)
--- a/include/MediaTransporterParam.h
+++ b/include/MediaTransporterParam.h
@@ -65,10 +65,20 @@ struct connectionParam {
 };
 
 bool _isValidKeyLength(int keyLen);
-void setConnectionParam(std::string key, std::string value, connectionParam* connectionParam);
-std::string getConnectionParam(const connectionParam& connectionParam, const std::string& key);
+void setConnectionParam(std::string key, std::string value, connectionParam* param);
+std::string getConnectionParam(const connectionParam& param, const std::string& key);
 }; // srt
 
+namespace rtsp {
+       struct connectionParam {
+               std::string certPath;
+               /* auth param could be added after */
+       };
+
+       void setConnectionParam(std::string key, std::string value, connectionParam* param);
+       std::string getConnectionParam(const connectionParam& param, const std::string& key);
+} // rtsp
+
 }; // param
 
 } // tizen_media_transporter

diff --git a/include/MediaTransporterReceiverRtsp.h b/include/MediaTransporterReceiverRtsp.h
index 17e477c3ec650172693b39584652547d8a13f58b..db340a151cb977d558b017ecfe5a1ee842413be0 100644 (file)
--- a/include/MediaTransporterReceiverRtsp.h
+++ b/include/MediaTransporterReceiverRtsp.h
@@ -44,6 +44,9 @@ public:
        void startPipeline() override;
        void stopPipeline() override;
 
+       void setConnection(std::string name, std::string value) override;
+       std::string getConnection(std::string name) override;
+
        void setSenderAddress(std::string address) override;
        std::string getSenderAddress() override { return _senderAddress; }
 
@@ -58,6 +61,7 @@ private:
        static void _decodebinPadAddedCallback(GstElement* decodebin, GstPad* new_pad, gpointer userData);
        static void _decodebinNoMorePadsCallback(GstElement* decodebin, gpointer userData);
 
+       param::rtsp::connectionParam _connectionParam;
        std::string _senderAddress;
 };
 

diff --git a/include/MediaTransporterSenderToServerRtsp.h b/include/MediaTransporterSenderToServerRtsp.h
index aa85594f7fff9e8a898da0007fcb3042e07c9e92..8e6e13d819aa9adcb45447a49a8a4c0cf4e1cad5 100644 (file)
--- a/include/MediaTransporterSenderToServerRtsp.h
+++ b/include/MediaTransporterSenderToServerRtsp.h
@@ -37,13 +37,18 @@ public:
        void startPipeline() override;
        void stopPipeline() override;
 
+       void setConnection(std::string name, std::string value) override;
+       std::string getConnection(std::string name) override;
+
        void setReceiverAddress(std::string address) override;
        std::string getReceiverAddress() override { return _receiverAddress; }
 
        mtprConnectionType type() override { return MTPR_CONNECTION_TYPE_RTSP_SENDER_TO_SERVER; }
 
 private:
+       param::rtsp::connectionParam _connectionParam;
        std::string _receiverAddress; // rtsp server address to upload data
+
        GstElement* _rtspSink { nullptr };
 };
 

diff --git a/include/mtpr.h b/include/mtpr.h
index f08b1bf9cf1b169b7b636fe5d7082f2a5e1cf356..aa6e741bda738df1c45a0478fd81325cac9b1476 100644 (file)
--- a/include/mtpr.h
+++ b/include/mtpr.h
@@ -215,6 +215,14 @@ typedef enum {
  */
 #define MTPR_CONNECTION_PARAM_RIST_SENDER_BUFFER "sender-buffer"
 
+/**
+ * @brief Definition for certificate path for RTSP TLS
+ * @since_tizen 7.5
+ * @see mtpr_set_connection_param()
+ * @see mtpr_get_connection_param()
+ */
+#define MTPR_CONNECTION_PARAM_RTSP_CERTIFICATE_PATH "cert-path"
+
 /**
  * @brief Called when an error occurs.
  * @details The following error codes can be received:\n

diff --git a/packaging/capi-media-transporter.spec b/packaging/capi-media-transporter.spec
index 067c49aa7d113b817e1e878067dcfa4a4f1df4e6..4a27867a1fa58bac2fd3f5bd047c421477ab7116 100644 (file)
--- a/packaging/capi-media-transporter.spec
+++ b/packaging/capi-media-transporter.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-transporter
 Summary:    A Media Transporter library in Tizen Native API
-Version:    1.0.15
+Version:    1.0.16
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/MediaTransporterParam.cpp b/src/MediaTransporterParam.cpp
index 8f817d705a3c41cc6e846ca28741aee6389b782d..964425a266b5d75c0c0784fc7b8aafba97303692 100644 (file)
--- a/src/MediaTransporterParam.cpp
+++ b/src/MediaTransporterParam.cpp
@@ -42,7 +42,7 @@ bool param::srt::_isValidKeyLength(int keyLen)
        }
 }
 
-void param::srt::setConnectionParam(std::string key, std::string value, param::srt::connectionParam* connectionParam)
+void param::srt::setConnectionParam(std::string key, std::string value, param::srt::connectionParam* param)
 {
        SECURE_LOG_INFO("%s : %s", key.c_str(), value.c_str());
 
@@ -55,15 +55,15 @@ void param::srt::setConnectionParam(std::string key, std::string value, param::s
                                LOG_ERROR("invalid srt mode value %d", val);
                                throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid srt mode value");
                        }
-                       connectionParam->mode = static_cast<connectionMode>(val);
+                       param->mode = static_cast<connectionMode>(val);
 
                } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_STREAMID) == 0) {
-                       connectionParam->streamId = value;
+                       param->streamId = value;
 
                } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PASSPHRASE) == 0) {
                        if (!value.empty() && (value.length() < SRT_MIN_PASSPHRASE || value.length() > SRT_MAX_PASSPHRASE))
                                throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "wrong passphrase");
-                       connectionParam->passPhrase = value;
+                       param->passPhrase = value;
                } else if (key.compare(MTPR_CONNECTION_PARAM_SRT_PBKEYLEN) == 0) {
                        size_t size;
                        int val = stoi(value, &size);
@@ -71,7 +71,7 @@ void param::srt::setConnectionParam(std::string key, std::string value, param::s
                                LOG_ERROR("invalid pbkeylen value %d", val);
                                throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid pbkeylen value");
                        }
-                       connectionParam->pbKeyLen = static_cast<connectionKeyLength>(val);
+                       param->pbKeyLen = static_cast<connectionKeyLength>(val);
 
                } else {
                        LOG_ERROR("invalid param name %s", key.c_str());
@@ -83,19 +83,42 @@ void param::srt::setConnectionParam(std::string key, std::string value, param::s
        }
 }
 
-std::string param::srt::getConnectionParam(const param::srt::connectionParam& connectionParam, const std::string& key)
+std::string param::srt::getConnectionParam(const param::srt::connectionParam& param, const std::string& key)
 {
        if (key == MTPR_CONNECTION_PARAM_SRT_STREAMID)
-               return connectionParam.streamId;
+               return param.streamId;
 
        if (key == MTPR_CONNECTION_PARAM_SRT_PASSPHRASE)
-               return connectionParam.passPhrase;
+               return param.passPhrase;
 
        if (key == MTPR_CONNECTION_PARAM_SRT_PBKEYLEN)
-               return std::to_string(static_cast<int>(connectionParam.pbKeyLen));
+               return std::to_string(static_cast<int>(param.pbKeyLen));
 
        if (key == MTPR_CONNECTION_PARAM_SRT_MODE)
-               return std::to_string(static_cast<int>(connectionParam.mode));
+               return std::to_string(static_cast<int>(param.mode));
+
+       throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid param name");
+}
+
+void param::rtsp::setConnectionParam(std::string key, std::string value, param::rtsp::connectionParam* param)
+{
+       try {
+               if (key.compare(MTPR_CONNECTION_PARAM_RTSP_CERTIFICATE_PATH) == 0) {
+                       param->certPath = value;
+               } else {
+                       LOG_ERROR("invalid param name %s", key.c_str());
+                       throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid param name");
+               }
+       } catch (const std::exception& e) {
+               LOG_ERROR("error : %s, throw invalid param", e.what());
+               throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid parameter");
+       }
+}
+
+std::string param::rtsp::getConnectionParam(const param::rtsp::connectionParam& param, const std::string& key)
+{
+       if (key == MTPR_CONNECTION_PARAM_RTSP_CERTIFICATE_PATH)
+               return param.certPath;
 
        throw MediaTransporterException(MTPR_ERROR_INVALID_PARAMETER, "invalid param name");
 }

diff --git a/src/MediaTransporterReceiverRtsp.cpp b/src/MediaTransporterReceiverRtsp.cpp
index aeb644df0a68d7e48eefb6417eb80f0b5be7b32c..d795d43209aab637189ef4322ba9c0247e9fd2bd 100644 (file)
--- a/src/MediaTransporterReceiverRtsp.cpp
+++ b/src/MediaTransporterReceiverRtsp.cpp
@@ -17,6 +17,7 @@
 #include <cassert>
 #include <string>
 #include <algorithm>
+#include <gst/rtsp/rtsp.h>
 
 #include "MediaTransporterBase.h"
 #include "MediaTransporterException.h"
@@ -26,6 +27,7 @@
 #include "MediaTransporterUtil.h"
 
 using namespace tizen_media_transporter;
+using namespace tizen_media_transporter::param::rtsp;
 
 MediaTransporterReceiverRtsp::MediaTransporterReceiverRtsp()
 {
@@ -185,6 +187,27 @@ void MediaTransporterReceiverRtsp::buildPipeline()
                        "latency", 10,
                        NULL);
 
+               if (!_connectionParam.certPath.empty()) {
+                       GError* error = NULL;
+                       GTlsDatabase* tlsDatabase = NULL;
+
+                       SECURE_LOGD("Cert Path = %s", _connectionParam.certPath.c_str());
+
+                       tlsDatabase = g_tls_file_database_new(_connectionParam.certPath.c_str(), &error);
+                       if (error) {
+                               LOG_ERROR("failed setting tls database: %s", error->message);
+                               g_error_free (error);
+
+                               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed setting tls db");
+                       }
+
+                       g_object_set(G_OBJECT(src),
+                               "protocols", (GST_RTSP_LOWER_TRANS_TCP | GST_RTSP_LOWER_TRANS_TLS),
+                               "tls-database", tlsDatabase, NULL);
+
+                       g_clear_object(&tlsDatabase);
+               }
+
                gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(src), "pad-added",
                                                                                G_CALLBACK(_srcPadAddedCallback), this);
                gst::_connectAndAppendSignal(&_gst.signals, G_OBJECT(src), "no-more-pads",
@@ -212,6 +235,16 @@ void MediaTransporterReceiverRtsp::stopPipeline()
                                                        MediaTransporterIni::get().general().timeout);
 }
 
+void MediaTransporterReceiverRtsp::setConnection(std::string name, std::string val)
+{
+       setConnectionParam(name, val, &_connectionParam);
+}
+
+std::string MediaTransporterReceiverRtsp::getConnection(std::string name)
+{
+       return getConnectionParam(_connectionParam, name);
+}
+
 void MediaTransporterReceiverRtsp::setSenderAddress(std::string address)
 {
        _senderAddress = address;

diff --git a/src/MediaTransporterSenderToServerRtsp.cpp b/src/MediaTransporterSenderToServerRtsp.cpp
index 0db8a9c587eda860657e0e11089f555cad991867..f8b2e6a47ef5837118cfa29305acb9fdfae31c54 100644 (file)
--- a/src/MediaTransporterSenderToServerRtsp.cpp
+++ b/src/MediaTransporterSenderToServerRtsp.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <gst/rtsp/rtsp.h>
+
 #include "MediaTransporterBase.h"
 #include "MediaTransporterException.h"
 #include "MediaTransporterSenderToServerRtsp.h"
@@ -23,6 +25,7 @@
 #include "MediaTransporterParseIni.h"
 
 using namespace tizen_media_transporter;
+using namespace tizen_media_transporter::param::rtsp;
 
 MediaTransporterSenderToServerRtsp::MediaTransporterSenderToServerRtsp()
 {
@@ -54,6 +57,27 @@ void MediaTransporterSenderToServerRtsp::buildPipeline()
                g_object_set(G_OBJECT(sink),
                        "location", util::addProtocolPrefix(_receiverAddress, "rtsp").c_str(), NULL);
 
+               if (!_connectionParam.certPath.empty()) {
+                       GError* error = NULL;
+                       GTlsDatabase* tlsDatabase = NULL;
+
+                       SECURE_LOGD("Cert Path = %s", _connectionParam.certPath.c_str());
+
+                       tlsDatabase = g_tls_file_database_new(_connectionParam.certPath.c_str(), &error);
+                       if (error) {
+                               LOG_ERROR("failed setting tls database: %s", error->message);
+                               g_error_free (error);
+
+                               throw MediaTransporterException(MTPR_ERROR_INVALID_OPERATION, "failed setting tls db");
+                       }
+
+                       g_object_set(G_OBJECT(sink),
+                               "protocols", (GST_RTSP_LOWER_TRANS_TCP | GST_RTSP_LOWER_TRANS_TLS),
+                               "tls-database", tlsDatabase, NULL);
+
+                       g_clear_object(&tlsDatabase);
+               }
+
                gst_bin_add_many(GST_BIN(_gst.pipeline), mux, sink, NULL);
                if (!gst_element_link(mux, sink)) {
                        LOG_ERROR("failed to gst_element_link()");
@@ -88,6 +112,16 @@ void MediaTransporterSenderToServerRtsp::stopPipeline()
                                                        MediaTransporterIni::get().general().timeout);
 }
 
+void MediaTransporterSenderToServerRtsp::setConnection(std::string name, std::string val)
+{
+       setConnectionParam(name, val, &_connectionParam);
+}
+
+std::string MediaTransporterSenderToServerRtsp::getConnection(std::string name)
+{
+       return getConnectionParam(_connectionParam, name);
+}
+
 void MediaTransporterSenderToServerRtsp::setReceiverAddress(std::string address)
 {
        _receiverAddress = address;

diff --git a/unittest/ut_rtsp_sender_to_server.cpp b/unittest/ut_rtsp_sender_to_server.cpp
index a3c55de364118a885ff853f2dd9f56737b0a8765..f16d6516d85901a120e74b2b60bf6eaf348ee9ee 100644 (file)
--- a/unittest/ut_rtsp_sender_to_server.cpp
+++ b/unittest/ut_rtsp_sender_to_server.cpp
@@ -331,15 +331,27 @@ TEST_F(MediaTransporterTestRtspSenderToServer, get_state_n)
        ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
+TEST_F(MediaTransporterTestRtspSenderToServer, set_get_connection_param_p)
+{
+       char* value = NULL;
+       int ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RTSP_CERTIFICATE_PATH, "/tmp/test.pem");
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+
+       ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RTSP_CERTIFICATE_PATH, &value);
+       ASSERT_EQ(ret, MTPR_ERROR_NONE);
+       ASSERT_STREQ(value, "/tmp/test.pem");
+       g_free(value);
+}
+
 TEST_F(MediaTransporterTestRtspSenderToServer, set_connection_param_n)
 {
        int ret = MTPR_ERROR_NONE;
 
        ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, "2");
-       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
        ret = mtpr_set_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, "0.02");
-       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
 TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_param_n)
@@ -348,10 +360,10 @@ TEST_F(MediaTransporterTestRtspSenderToServer, get_connection_param_n)
        gchar* value = NULL;
 
        ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_SRT_MODE, &value);
-       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 
        ret = mtpr_get_connection_param(_mtpr, MTPR_CONNECTION_PARAM_RIST_MAX_RTCP_BANDWIDTH, &value);
-       ASSERT_EQ(ret, MTPR_ERROR_INVALID_OPERATION);
+       ASSERT_EQ(ret, MTPR_ERROR_INVALID_PARAMETER);
 }
 
 // MediaTransporterTestRtspSenderToServerRun