Applied msf secure connection

Change-Id: Ie72c8faaea1b1f6d078196afa53a720327fbf5b9
Signed-off-by: kmook <kmook.choi@samsung.com>

diff --git a/common/Types.h b/common/Types.h
index beeac6e..b9cc30b 100644 (file)
--- a/common/Types.h
+++ b/common/Types.h
@@ -168,6 +168,7 @@ enum AccessControlState {
 #define CONV_JSON_CLIENT_IS_HOST               "client_is_host"
 #define CONV_JSON_CLIENT_CONNECT_TIME  "client_connect_time"
 #define CONV_JSON_CLIENT_CLIENT_ID             "client_id"
+#define CONV_JSON_SECURE_MODE                  "secure_mode"
 
 #define CONV_JSON_ON_START                             "onStart"
 #define CONV_JSON_ON_CONNECT                   "onConnect"

diff --git a/daemon/CMakeLists.txt b/daemon/CMakeLists.txt
index 87f2af3..1c62c67 100755 (executable)
--- a/daemon/CMakeLists.txt
+++ b/daemon/CMakeLists.txt
@@ -41,5 +41,6 @@ TARGET_LINK_LIBRARIES(${DAEMON} ${daemon_pkgs_LIBRARIES} -lpthread -pie)
 INSTALL(TARGETS ${DAEMON} DESTINATION ${BIN_INSTALL_DIR})
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/d2d-conv-manager-iotcon-server.dat DESTINATION
        /usr/share/d2d-conv-manager)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/../msf_tizen_client/src/ca_crt.pem DESTINATION /usr/share/d2d-conv-manager)
 #INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/d2d-conv-manager-iotcon-server.dat DESTINATION
 #       ${SHARE_INSTALL_PREFIX}/d2d-conv-manager)

diff --git a/daemon/discovery_provider/SmartviewDiscoveryProvider.cpp b/daemon/discovery_provider/SmartviewDiscoveryProvider.cpp
index 95bce7b..429fc34 100755 (executable)
--- a/daemon/discovery_provider/SmartviewDiscoveryProvider.cpp
+++ b/daemon/discovery_provider/SmartviewDiscoveryProvider.cpp
@@ -135,7 +135,7 @@ conv::SmartViewDevice* conv::SmartviewDiscoveryProvider::convertIntoConvDevice(S
 
        _D("SmartView Discovered Service : Name[%s] Version[%s] Type[%s] Id[%s] Uri[%s] ",
                                                                serv_name.c_str(), serv_version.c_str(), serv_type.c_str(),
-                                                               serv_id.c_str(), serv_uri.c_str() );
+                                                               serv_id.c_str(), serv_uri.c_str());
 
        conv::SmartViewDevice*  device_info = new(std::nothrow) conv::SmartViewDevice;
        device_info->setId(serv_id);
@@ -146,17 +146,21 @@ conv::SmartViewDevice* conv::SmartviewDiscoveryProvider::convertIntoConvDevice(S
 
 conv::SmartViewService* conv::SmartviewDiscoveryProvider::convertIntoConvService(Service* smartview_service)
 {
-       string serv_name, serv_version, serv_type, serv_id, serv_uri;
+       string serv_name, serv_version, serv_type, serv_id, serv_uri, serv_secure;
 
        serv_name = smartview_service->getName();
        serv_version = smartview_service->getVersion();
        serv_type = smartview_service->getType();
        serv_id = smartview_service->getId();
        serv_uri = smartview_service->getUri();
+       if ( smartview_service->IsSecureConnectionSupport() )
+                       serv_secure = "1";
+               else
+                       serv_secure = "0";
 
-       _D("SmartView Discovered Service : Name[%s] Version[%s] Type[%s] Id[%s] Uri[%s] ",
+       _D("SmartView Discovered Service : Name[%s] Version[%s] Type[%s] Id[%s] Uri[%s] Secure[%s]",
                                                                serv_name.c_str(), serv_version.c_str(), serv_type.c_str(),
-                                                               serv_id.c_str(), serv_uri.c_str() );
+                                                               serv_id.c_str(), serv_uri.c_str(), serv_secure.c_str() );
 
        Json json_serv_info;
        json_serv_info.set(CONV_JSON_SERVICE_DATA_PATH, CONV_JSON_SERVICE_DATA_URI, serv_uri);
@@ -164,6 +168,7 @@ conv::SmartViewService* conv::SmartviewDiscoveryProvider::convertIntoConvService
        json_serv_info.set(CONV_JSON_SERVICE_DATA_PATH, CONV_JSON_SERVICE_DATA_NAME, serv_name);
        json_serv_info.set(CONV_JSON_SERVICE_DATA_PATH, CONV_JSON_SERVICE_DATA_VERSION, serv_version);
        json_serv_info.set(CONV_JSON_SERVICE_DATA_PATH, CONV_JSON_SERVICE_DATA_TYPE, serv_type);
+       json_serv_info.set(CONV_JSON_SERVICE_DATA_PATH, CONV_JSON_SECURE_MODE, serv_secure);
 
        conv::SmartViewService *conv_service = new(std::nothrow) conv::SmartViewService;
 
@@ -176,6 +181,7 @@ conv::SmartViewService* conv::SmartviewDiscoveryProvider::convertIntoConvService
        conv_service->setType(serv_type);
        conv_service->setId(serv_id);
        conv_service->setUri(serv_uri);
+       conv_service->setServiceSecureSupport(serv_secure);
 
        conv_service->setServiceInfo(json_serv_info.str());
        conv_service->setServiceType(CONV_TYPE_APP_TO_APP_COMMUNICATION);

diff --git a/daemon/discovery_provider/smartview/SmartViewService.cpp b/daemon/discovery_provider/smartview/SmartViewService.cpp
index 5f16196..b073de6 100755 (executable)
--- a/daemon/discovery_provider/smartview/SmartViewService.cpp
+++ b/daemon/discovery_provider/smartview/SmartViewService.cpp
@@ -103,3 +103,13 @@ void conv::SmartViewService::printInfo()
                        service_name.c_str(), service_version.c_str(), service_type,
                        service_id.c_str(), service_uri.c_str());
 }
+
+string conv::SmartViewService::getServiceSecureSupport()
+{
+       return service_secure;
+}
+
+void conv::SmartViewService::setServiceSecureSupport(string secure)
+{
+       this->service_secure = secure;
+}

diff --git a/daemon/discovery_provider/smartview/SmartViewService.h b/daemon/discovery_provider/smartview/SmartViewService.h
index 667bccf..7e5f4b6 100755 (executable)
--- a/daemon/discovery_provider/smartview/SmartViewService.h
+++ b/daemon/discovery_provider/smartview/SmartViewService.h
@@ -38,6 +38,7 @@ namespace conv
                        string getUri();
                        int getServiceType();
                        string getServiceInfo();
+                       string getServiceSecureSupport();
 
                        void setName(string name);
                        void setVersion(string version);
@@ -46,6 +47,7 @@ namespace conv
                        void setUri(string uri);
                        void setServiceInfo(string serviceInfo);
                        void setServiceType(int service_type);
+                       void setServiceSecureSupport(string secure);
 
                        void printInfo();
 
@@ -59,6 +61,7 @@ namespace conv
                        string service_id;
                        string service_uri;
                        string type;
+                       string service_secure;
        };
 }
 

diff --git a/daemon/service_provider/AppCommServiceApplication.cpp b/daemon/service_provider/AppCommServiceApplication.cpp
index cb4ff26..11a0089 100755 (executable)
--- a/daemon/service_provider/AppCommServiceApplication.cpp
+++ b/daemon/service_provider/AppCommServiceApplication.cpp
@@ -175,6 +175,7 @@ void conv::AppCommServiceApplication::onMessage(Message message)
 void conv::AppCommServiceApplication::onError(Error error)
 {
        _D("onError Called");
+       state = APP_COMM_STATE_NONE;
 
        if ((*requestObj) != NULL) {
                _D(RED("publishing_response"));

diff --git a/daemon/service_provider/AppCommServiceProvider.cpp b/daemon/service_provider/AppCommServiceProvider.cpp
index dc32dcf..c59319b 100755 (executable)
--- a/daemon/service_provider/AppCommServiceProvider.cpp
+++ b/daemon/service_provider/AppCommServiceProvider.cpp
@@ -162,6 +162,9 @@ int conv::AppCommServiceProvider::startRequest(Request* requestObj)
        Json channel;
        requestObj->getChannelFromDescription(&channel);
 
+       Json payload;
+       requestObj->getPayloadFromDescription(&payload);
+
        string uri, channelId;
 
        channel.get(NULL, CONV_JSON_URI, &uri);
@@ -170,6 +173,10 @@ int conv::AppCommServiceProvider::startRequest(Request* requestObj)
        IF_FAIL_RETURN_TAG(!uri.empty() || svcInfo->isLocal, CONV_ERROR_INVALID_PARAMETER, _E, "uri is empty");
        IF_FAIL_RETURN_TAG(!channelId.empty(), CONV_ERROR_INVALID_PARAMETER, _E, "channelId is empty");
 
+       string secureMode;
+
+       payload.get(NULL, CONV_JSON_SECURE_MODE, &secureMode);
+
        AppCommServiceApplication *appInfo = NULL;
 
        for (ApplicationInstanceList::iterator iter = svcInfo->applicationInstanceList.begin(); iter != svcInfo->applicationInstanceList.end(); ++iter) {
@@ -202,6 +209,8 @@ int conv::AppCommServiceProvider::startRequest(Request* requestObj)
 
                appInfo->localService = Service::getLocal();
 
+               IF_FAIL_RETURN_TAG(secureMode.compare("1") || appInfo->localService.IsSecureConnectionSupport(), CONV_ERROR_INVALID_PARAMETER, _E, "service does not support secure mode");
+
                Channel* application = appInfo->localService.createChannel(channelId);
 
                // add listeners
@@ -214,6 +223,10 @@ int conv::AppCommServiceProvider::startRequest(Request* requestObj)
                application->addOnAllMessageListener(appInfo);
                application->setonPublishListener(appInfo);
 
+               if ( !secureMode.compare("1") ) {
+                       application->setSecurityMode(true);
+               }
+
                appInfo->isLocal = true;
                appInfo->application = application;
                application->connect();
@@ -221,6 +234,9 @@ int conv::AppCommServiceProvider::startRequest(Request* requestObj)
                svcInfo->applicationInstanceList.push_back(appInfo);
        } else {
                _D("COMMUNCATION_START : uri : %s, channel_id : %s", uri.c_str(), channelId.c_str());
+
+               IF_FAIL_RETURN_TAG(secureMode.compare("1") || svcInfo->serviceObj.IsSecureConnectionSupport(), CONV_ERROR_INVALID_PARAMETER, _E, "service does not support secure mode");
+
                Application* application = new(std::nothrow) Application(&(svcInfo->serviceObj), uri, channelId);
                ASSERT_ALLOC(application);
 
@@ -236,6 +252,10 @@ int conv::AppCommServiceProvider::startRequest(Request* requestObj)
                application->addOnAllMessageListener(appInfo);
                application->setonPublishListener(appInfo);
 
+               if ( !secureMode.compare("1") ) {
+                       application->setSecurityMode(true);
+               }
+
                appInfo->isLocal = false;
                appInfo->application = application;
                application->connect();
@@ -499,6 +519,13 @@ int conv::AppCommServiceProvider::getServiceInfoForDiscovery(Json* jsonObj)
 
                snprintf(uri, sizeof(uri), "http://%s:8001/api/v2/", address);
 
+               string isSecure;
+
+               if ( localService.IsSecureConnectionSupport() )
+                       isSecure = "1";
+               else
+                       isSecure = "0";
+
                Json info;
 
                info.set(NULL, CONV_JSON_SERVICE_DATA_URI, uri);
@@ -506,6 +533,7 @@ int conv::AppCommServiceProvider::getServiceInfoForDiscovery(Json* jsonObj)
                info.set(NULL, CONV_JSON_SERVICE_DATA_TYPE, localService.getType());
                info.set(NULL, CONV_JSON_SERVICE_DATA_ID, localService.getId());
                info.set(NULL, CONV_JSON_SERVICE_DATA_NAME, localService.getName());
+               info.set(NULL, CONV_JSON_SECURE_MODE, isSecure);
 
                jsonObj->set(NULL, CONV_JSON_DISCOVERY_SERVICE_INFO, info);
                g_free(address);

diff --git a/lib/conv_lib_service.cpp b/lib/conv_lib_service.cpp
index 09ea6fa..80f7282 100755 (executable)
--- a/lib/conv_lib_service.cpp
+++ b/lib/conv_lib_service.cpp
@@ -280,7 +280,7 @@ EXTAPI int conv_service_unset_listener_cb(conv_service_h handle)
        return CONV_ERROR_NONE;
 }
 
-EXTAPI int conv_service_start(conv_service_h handle, conv_channel_h channel_handle, conv_payload_h payload)
+EXTAPI int conv_service_start(conv_service_h handle, conv_channel_h channel_handle, conv_payload_h payload_handle)
 {
        IF_FAIL_RETURN_TAG(conv::util::is_feature_supported(), CONV_ERROR_NOT_SUPPORTED, _E, "Not supported");
        ASSERT_NOT_NULL(handle);
@@ -290,10 +290,14 @@ EXTAPI int conv_service_start(conv_service_h handle, conv_channel_h channel_hand
 
        json description;
        json channel;
+       json payload;
 
        if ( channel_handle != NULL )
                channel = channel_handle->jchannel;
 
+       if ( payload_handle != NULL)
+               payload = payload_handle->jpayload;
+
        json service = handle->jservice;
        json device = handle->jdevice;
        std::string type = convert_type_to_string(handle->service_type);
@@ -303,6 +307,7 @@ EXTAPI int conv_service_start(conv_service_h handle, conv_channel_h channel_hand
        description.set(NULL, CONV_JSON_SERVICE, service);
        description.set(NULL, CONV_JSON_CHANNEL, channel);
        description.set(NULL, CONV_JSON_DEVICE, device);
+       description.set(NULL, CONV_JSON_PAYLOAD, payload);
        description.set(NULL, CONV_JSON_TYPE, type);
        description.set(NULL, CONV_JSON_IS_LOCAL, handle->is_local);
 
@@ -350,7 +355,7 @@ EXTAPI int conv_service_read(conv_service_h handle, conv_channel_h channel_handl
        //LCOV_EXCL_STOP
 }
 
-EXTAPI int conv_service_stop(conv_service_h handle, conv_channel_h channel_handle, conv_payload_h payload)
+EXTAPI int conv_service_stop(conv_service_h handle, conv_channel_h channel_handle, conv_payload_h payload_handle)
 {
        IF_FAIL_RETURN_TAG(conv::util::is_feature_supported(), CONV_ERROR_NOT_SUPPORTED, _E, "Not supported");
        ASSERT_NOT_NULL(handle);
@@ -360,10 +365,14 @@ EXTAPI int conv_service_stop(conv_service_h handle, conv_channel_h channel_handl
 
        json description;
        json channel;
+       json payload;
 
        if ( channel_handle != NULL )
                channel = channel_handle->jchannel;
 
+       if (payload_handle != NULL)
+               payload = payload_handle->jpayload;
+
        json service = handle->jservice;
        json device = handle->jdevice;
        std::string type = convert_type_to_string(handle->service_type);
@@ -373,6 +382,7 @@ EXTAPI int conv_service_stop(conv_service_h handle, conv_channel_h channel_handl
        description.set(NULL, CONV_JSON_SERVICE, service);
        description.set(NULL, CONV_JSON_CHANNEL, channel);
        description.set(NULL, CONV_JSON_DEVICE, device);
+       description.set(NULL, CONV_JSON_PAYLOAD, payload);
        description.set(NULL, CONV_JSON_TYPE, type);
        description.set(NULL, CONV_JSON_IS_LOCAL, handle->is_local);
 

diff --git a/msf_tizen_client/include/Channel.h b/msf_tizen_client/include/Channel.h
index f8bde85..f6f7ef2 100755 (executable)
--- a/msf_tizen_client/include/Channel.h
+++ b/msf_tizen_client/include/Channel.h
@@ -32,6 +32,8 @@ class Service;
 class Clients;
 class Channel;
 
+#define CA_PATH                                        "/usr/share/d2d-conv-manager/ca_crt.pem"
+
 class ChannelConnectionHandler {
 public:
        ChannelConnectionHandler();
@@ -99,7 +101,10 @@ public:
 
 class OnErrorListener {
 public:
-       virtual void onError(/*Error error*/) {}
+       virtual void onError(Error error) {}
+       void onError() {
+               onError(Error::create("Error"));
+       }
 };
 
 class OnPublishListener {
@@ -119,6 +124,8 @@ public:
        void setConnectionTimeout(long timeout);
        bool isConnected();
        bool isWebSocketOpen();
+       void setSecureSupport(bool support);
+       bool setSecurityMode(bool mode);
        bool connect();
        void disconnect();
        string getChannelUri(map<string, string> *);
@@ -163,6 +170,8 @@ public:
        void publishMessage(string method, string event, const char *data,
                        const char *to, unsigned char payload[],
                        int payload_size, void *user_data);
+       void handleWsiDestroy();
+       void setCommunicated(bool value);
        // unsigned char *createBinaryMessage(string json, unsigned char payload[],
        // int payload_size);
        static void init_json_key_map();
@@ -289,6 +298,9 @@ private:
        static JsonObject *root_json_object;
        string server_ip_address;
        int server_port;
+       bool IsSecureSupport = false;
+       bool IsSecureMode = false;
+       bool isCommunicated = false;
 };
 
 #endif

diff --git a/msf_tizen_client/include/Service.h b/msf_tizen_client/include/Service.h
index 9cdb24c..41940ac 100755 (executable)
--- a/msf_tizen_client/include/Service.h
+++ b/msf_tizen_client/include/Service.h
@@ -59,6 +59,7 @@ class Service
        typedef std::map<std::string, std::string> map_type;
        static Service local_service;
        void *result_ptr;
+       bool SecureConnectionSupport = false;
 
        static bool success_get_id;
        static string remote_device_id;
@@ -79,6 +80,7 @@ public:
        string getType();
        string getId();
        string getVersion();
+       bool IsSecureConnectionSupport();
        static string getUniqueId(string address);
        static Service getLocal(void);
        static void getByURI(string, Result_Base*);

diff --git a/msf_tizen_client/src/Application.cpp b/msf_tizen_client/src/Application.cpp
index 61dd6f1..db3a545 100755 (executable)
--- a/msf_tizen_client/src/Application.cpp
+++ b/msf_tizen_client/src/Application.cpp
@@ -120,6 +120,7 @@ Application::Application(Service *se, string Uri, string Id)
        waitForOnReady = false;
        install_listener = NULL;
        install_result = false;
+       setSecureSupport(se->IsSecureConnectionSupport());
 }
 
 Application::Application(Service *se, string Uri, string Id, map<string, string> startargs)

diff --git a/msf_tizen_client/src/Channel.cpp b/msf_tizen_client/src/Channel.cpp
index f846b82..dabb94a 100755 (executable)
--- a/msf_tizen_client/src/Channel.cpp
+++ b/msf_tizen_client/src/Channel.cpp
@@ -554,6 +554,23 @@ void Channel::emit(string event, const char *msg, string from,
        }
 }
 
+void Channel::setSecureSupport(bool support)
+{
+       IsSecureSupport = support;
+}
+
+bool Channel::setSecurityMode(bool mode)
+{
+       if (!IsSecureSupport && mode) {
+               MSF_ERR("not support secure mode");
+               return false;
+       }
+
+       IsSecureMode = mode;
+       MSF_DBG("secure mode is setted to '%d'", mode);
+       return true;
+}
+
 bool Channel::connect() { return connect(NULL); }
 
 bool Channel::connect(Result_Base *result1) {
@@ -729,6 +746,8 @@ void Channel::write_socket(Channel* ch_p)
        int n;
        MSF_DBG("write_socket");
 
+       ch_p->setCommunicated(true);
+
        if (lws_partial_buffered(ch_p->wsi_mirror) == 1) {
                MSF_DBG("lws is wrting now. it will retry write.");
                lws_callback_on_writable(ch_p->wsi_mirror);
@@ -885,6 +904,10 @@ int Channel::callback_lws_mirror(struct lws *wsi,
        case LWS_CALLBACK_PROTOCOL_DESTROY:
                break;
 
+       case LWS_CALLBACK_WSI_DESTROY:
+               this_ptr->handleWsiDestroy();
+               break;
+
        case LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED:
        case LWS_CALLBACK_ADD_POLL_FD:
        case LWS_CALLBACK_DEL_POLL_FD:
@@ -1223,6 +1246,10 @@ void Channel::create_websocket(void *att) {
        info.extensions = NULL;
        info.ssl_cert_filepath = NULL;
        info.ssl_private_key_filepath = NULL;
+       if (IsSecureMode) {
+               MSF_DBG("'SecureConnection' is true");
+               info.ssl_ca_filepath = CA_PATH;
+       }
        info.gid = -1;
        info.uid = -1;
        info.options = 0;
@@ -1251,6 +1278,11 @@ void Channel::create_websocket(void *att) {
        string api = getapifromUri(uri);
        api.append("channels/").append(ChannelID);
 
+       if (IsSecureMode) {
+               use_ssl = 1;
+               server_port = 8002;
+       }
+
        struct lws_client_connect_info connect_info;
        memset(&connect_info, 0, sizeof(lws_client_connect_info));
 
@@ -1563,3 +1595,19 @@ void *ChannelConnectionHandler::Pinging(void *arg) {
 void ChannelConnectionHandler::setPingTimeout(long t) {
        pingTimeout = t;
 }
+
+void Channel::handleWsiDestroy()
+{
+       if (!isCommunicated) {
+               was_closed = true;
+               MSF_ERR("wsi destroyed with no communication");
+               if (onErrorListener) {
+                       onErrorListener->onError();
+               }
+       }
+}
+
+void Channel::setCommunicated(bool value)
+{
+       isCommunicated = value;
+}

diff --git a/msf_tizen_client/src/Service.cpp b/msf_tizen_client/src/Service.cpp
index ad06e67..fb17fe3 100755 (executable)
--- a/msf_tizen_client/src/Service.cpp
+++ b/msf_tizen_client/src/Service.cpp
@@ -105,6 +105,11 @@ string Service::getUri()
        return uri;
 }
 
+bool Service::IsSecureConnectionSupport()
+{
+       return SecureConnectionSupport;
+}
+
 void Service::create(char *service_txt)
 {
        position posvalues;
@@ -332,15 +337,22 @@ int Service::json_parse_service(const char *in, void *ptr)
                serviceval.infoURI = json_object_get_string_member(root, "uri");
        }
 
+       Device dev;
        if (json_object_has_member(root, "device")) {
+               dev = Device::create(json_object_get_member(root, "device"));
                if (ptr != NULL) {
-                       Device dev = Device::create(json_object_get_member(root, "device"));
                        (static_cast<Result_Base *>(ptr))->onSuccess(dev);
                }
        }
 
+       Service retService = create(serviceval);
+       if ( !dev.getmodel().empty() && atoi(dev.getmodel().substr(0,2).c_str()) >= 16 ) {
+               MSF_DBG("Secure connection support is true");
+               retService.SecureConnectionSupport = true;
+       }
+
        if ((Resulturi!= NULL)) {
-               Resulturi->onSuccess(create(serviceval));
+               Resulturi->onSuccess(retService);
        }
 
        return 0;
@@ -382,5 +394,6 @@ Application Service::createApplication(string uri, string channelId, map<string,
 Channel *Service::createChannel(string uri)
 {
        Channel *channel = Channel::create(this, uri);
+       channel->setSecureSupport(SecureConnectionSupport);
        return channel;
 }

diff --git a/msf_tizen_client/src/ca_crt.pem b/msf_tizen_client/src/ca_crt.pem
new file mode 100644 (file)
index 0000000..4eb8f67
--- /dev/null
+++ b/msf_tizen_client/src/ca_crt.pem
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDhjCCAm6gAwIBAgIJAPm7naJvG91yMA0GCSqGSIb3DQEBCwUAMFcxCzAJBgNV
+BAYTAktSMRUwEwYDVQQKEwxTbWFydFZpZXdTREsxMTAvBgNVBAMTKFNtYXJ0Vmll
+d1NESyBSb290IENlcml0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMTYwNzI5MDUzNDEw
+WhcNMzYwNzI5MDUzNDEwWjBXMQswCQYDVQQGEwJLUjEVMBMGA1UEChMMU21hcnRW
+aWV3U0RLMTEwLwYDVQQDEyhTbWFydFZpZXdTREsgUm9vdCBDZXJpdGlmaWNhdGUg
+QXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArtBcclIW
+EuObUkeTn+FW3m6Lm/YpwAOeABCtq6RKnBcq6jzEo3I433cSuVC2DrWGiiYi62Qm
+iAzOHEtkvRctj+jEuK7ZKneKkxQ5261os0RsvWG7fONVb4m0ZRBydykgfu/PLwUB
+MWeiF3PB6w7YCzN1MJzb9EISFlhEcqMxDHgwGWHZYo/CTWtIwBVZ07mhdrCQaV2r
+LLJInA+4Wh9nXRO82qRnqYqFZfV7psIOW4MqfjWqNcKAHWWZ1gKrdZc9fPb2YVK4
+OIlaT3Qq9DOCveeU5T8d3MGEoiFnXt4Lp5656nI7MbkAsPEFFRHFkBK3o8CE1HLp
+sELQa6GBRe8WPQIDAQABo1UwUzASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQW
+BBRQyhCp74M+t2GwCiH3g3Aau0AX7DALBgNVHQ8EBAMCAQYwEQYJYIZIAYb4QgEB
+BAQDAgAHMA0GCSqGSIb3DQEBCwUAA4IBAQAVIEeJo4vGsKPZBoY19hCXZnqB6Qcm
+OnWZzAZ0am8OQHQ4/LbSJ+Vnxh7eFiLtPQwuSHJ1a95ODA7RlNgnpC8ymHsL5Wl5
+UKOq5jOs3Jfa0aG99H9TsFKBysXlsBHfaHX+8/AoZUJDOksNeQigj3n4wCdLEPvt
+UpI9qJEjuzXeKxVhwnDkc/AvOuSGUaPiSeCSxy+xpcyWCANc4uVXtOxJluQvy8aC
+m6l0yG3Ucg09yCIkPzKtzG/kAadDRrTOYi/x4ZECtdamHQxncEnb3D881veLc6+s
+ztEvDx0F77vRtadpeBxNZKivG2kJrymuf47pGIS0FlC5+/5ieV54+1/d
+-----END CERTIFICATE-----

diff --git a/packaging/d2d-conv-manager.spec b/packaging/d2d-conv-manager.spec
index f40abe8..3f6e362 100755 (executable)
--- a/packaging/d2d-conv-manager.spec
+++ b/packaging/d2d-conv-manager.spec
@@ -129,6 +129,7 @@ rm -f %{_unitdir_user}/default.target.wants/%{name}.service
 %{_datadir}/license/%{name}
 %attr(755,root,root) %{_sysconfdir}/gumd/useradd.d/99_d2d-conv-manager.post
 /usr/share/d2d-conv-manager/*.dat
+/usr/share/d2d-conv-manager/ca_crt.pem
 
 %files lib
 %manifest lib%{name}.manifest