Line data Source code
1 : /*
2 : * If not stated otherwise in this file or this component's LICENSE file the
3 : * following copyright and licenses apply:
4 : *
5 : * Copyright 2022 Sky UK
6 : *
7 : * Licensed under the Apache License, Version 2.0 (the "License");
8 : * you may not use this file except in compliance with the License.
9 : * You may obtain a copy of the License at
10 : *
11 : * http://www.apache.org/licenses/LICENSE-2.0
12 : *
13 : * Unless required by applicable law or agreed to in writing, software
14 : * distributed under the License is distributed on an "AS IS" BASIS,
15 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 : * See the License for the specific language governing permissions and
17 : * limitations under the License.
18 : */
19 :
20 : #include "MediaKeysIpc.h"
21 : #include "RialtoClientLogging.h"
22 :
23 : namespace
24 : {
25 : firebolt::rialto::MediaKeyErrorStatus
26 64 : convertMediaKeyErrorStatus(const firebolt::rialto::ProtoMediaKeyErrorStatus &errorStatus)
27 : {
28 64 : switch (errorStatus)
29 : {
30 48 : case firebolt::rialto::ProtoMediaKeyErrorStatus::OK:
31 : {
32 48 : return firebolt::rialto::MediaKeyErrorStatus::OK;
33 : }
34 16 : case firebolt::rialto::ProtoMediaKeyErrorStatus::BAD_SESSION_ID:
35 : {
36 16 : return firebolt::rialto::MediaKeyErrorStatus::BAD_SESSION_ID;
37 : }
38 0 : case firebolt::rialto::ProtoMediaKeyErrorStatus::NOT_SUPPORTED:
39 : {
40 0 : return firebolt::rialto::MediaKeyErrorStatus::NOT_SUPPORTED;
41 : }
42 0 : case firebolt::rialto::ProtoMediaKeyErrorStatus::INVALID_STATE:
43 : {
44 0 : return firebolt::rialto::MediaKeyErrorStatus::INVALID_STATE;
45 : }
46 0 : case firebolt::rialto::ProtoMediaKeyErrorStatus::FAIL:
47 : {
48 0 : return firebolt::rialto::MediaKeyErrorStatus::FAIL;
49 : }
50 : }
51 0 : return firebolt::rialto::MediaKeyErrorStatus::FAIL;
52 : }
53 :
54 3 : firebolt::rialto::KeyStatus convertKeyStatus(const firebolt::rialto::KeyStatusesChangedEvent_KeyStatus &protoKeyStatus)
55 : {
56 3 : switch (protoKeyStatus)
57 : {
58 1 : case firebolt::rialto::KeyStatusesChangedEvent_KeyStatus_USABLE:
59 : {
60 1 : return firebolt::rialto::KeyStatus::USABLE;
61 : }
62 1 : case firebolt::rialto::KeyStatusesChangedEvent_KeyStatus_EXPIRED:
63 : {
64 1 : return firebolt::rialto::KeyStatus::EXPIRED;
65 : }
66 1 : case firebolt::rialto::KeyStatusesChangedEvent_KeyStatus_OUTPUT_RESTRICTED:
67 : {
68 1 : return firebolt::rialto::KeyStatus::OUTPUT_RESTRICTED;
69 : }
70 0 : case firebolt::rialto::KeyStatusesChangedEvent_KeyStatus_PENDING:
71 : {
72 0 : return firebolt::rialto::KeyStatus::PENDING;
73 : }
74 0 : case firebolt::rialto::KeyStatusesChangedEvent_KeyStatus_INTERNAL_ERROR:
75 : {
76 0 : return firebolt::rialto::KeyStatus::INTERNAL_ERROR;
77 : }
78 0 : case firebolt::rialto::KeyStatusesChangedEvent_KeyStatus_RELEASED:
79 : {
80 0 : return firebolt::rialto::KeyStatus::RELEASED;
81 : }
82 : }
83 0 : return firebolt::rialto::KeyStatus::INTERNAL_ERROR;
84 : }
85 :
86 16 : const char *toString(const firebolt::rialto::MediaKeyErrorStatus &errorStatus)
87 : {
88 16 : switch (errorStatus)
89 : {
90 0 : case firebolt::rialto::MediaKeyErrorStatus::OK:
91 : {
92 0 : return "OK";
93 : }
94 16 : case firebolt::rialto::MediaKeyErrorStatus::BAD_SESSION_ID:
95 : {
96 16 : return "BAD_SESSION_ID";
97 : }
98 0 : case firebolt::rialto::MediaKeyErrorStatus::NOT_SUPPORTED:
99 : {
100 0 : return "NOT_SUPPORTED";
101 : }
102 0 : case firebolt::rialto::MediaKeyErrorStatus::INVALID_STATE:
103 : {
104 0 : return "INVALID_STATE";
105 : }
106 0 : case firebolt::rialto::MediaKeyErrorStatus::FAIL:
107 : {
108 0 : return "FAIL";
109 : }
110 : }
111 0 : return "UNKNOWN";
112 : }
113 : } // namespace
114 :
115 : namespace firebolt::rialto::client
116 : {
117 0 : std::shared_ptr<IMediaKeysIpcFactory> IMediaKeysIpcFactory::createFactory()
118 : {
119 0 : std::shared_ptr<IMediaKeysIpcFactory> factory;
120 :
121 : try
122 : {
123 0 : factory = std::make_shared<MediaKeysIpcFactory>();
124 : }
125 0 : catch (const std::exception &e)
126 : {
127 0 : RIALTO_CLIENT_LOG_ERROR("Failed to create the media keys ipc factory, reason: %s", e.what());
128 : }
129 :
130 0 : return factory;
131 : }
132 :
133 0 : std::unique_ptr<IMediaKeys> MediaKeysIpcFactory::createMediaKeysIpc(const std::string &keySystem) const
134 : {
135 0 : std::unique_ptr<IMediaKeys> mediaKeysIpc;
136 : try
137 : {
138 : mediaKeysIpc =
139 0 : std::make_unique<client::MediaKeysIpc>(keySystem, IIpcClientAccessor::instance().getIpcClient(),
140 0 : firebolt::rialto::common::IEventThreadFactory::createFactory());
141 : }
142 0 : catch (const std::exception &e)
143 : {
144 0 : RIALTO_CLIENT_LOG_ERROR("Failed to create the media keys ipc, reason: %s", e.what());
145 : }
146 :
147 0 : return mediaKeysIpc;
148 : }
149 :
150 101 : MediaKeysIpc::MediaKeysIpc(const std::string &keySystem, IIpcClient &ipcClient,
151 101 : const std::shared_ptr<common::IEventThreadFactory> &eventThreadFactory)
152 303 : : IpcModule(ipcClient), m_eventThread(eventThreadFactory->createEventThread("rialto-media-keys-events"))
153 : {
154 101 : RIALTO_CLIENT_LOG_DEBUG("entry:");
155 :
156 101 : if (!attachChannel())
157 : {
158 3 : throw std::runtime_error("Failed attach to the ipc channel");
159 : }
160 :
161 98 : if (!createMediaKeys(keySystem))
162 : {
163 1 : detachChannel();
164 1 : throw std::runtime_error("Could not create the media keys instance");
165 : }
166 117 : }
167 :
168 194 : MediaKeysIpc::~MediaKeysIpc()
169 : {
170 97 : RIALTO_CLIENT_LOG_DEBUG("entry:");
171 :
172 97 : destroyMediaKeys();
173 :
174 97 : detachChannel();
175 :
176 97 : m_eventThread.reset();
177 194 : }
178 :
179 133 : bool MediaKeysIpc::createRpcStubs(const std::shared_ptr<ipc::IChannel> &ipcChannel)
180 : {
181 133 : m_mediaKeysStub = std::make_unique<::firebolt::rialto::MediaKeysModule_Stub>(ipcChannel.get());
182 133 : if (!m_mediaKeysStub)
183 : {
184 0 : return false;
185 : }
186 133 : return true;
187 : }
188 :
189 133 : bool MediaKeysIpc::subscribeToEvents(const std::shared_ptr<ipc::IChannel> &ipcChannel)
190 : {
191 133 : if (!ipcChannel)
192 : {
193 0 : return false;
194 : }
195 :
196 266 : int eventTag = ipcChannel->subscribe<firebolt::rialto::LicenseRequestEvent>(
197 133 : [this](const std::shared_ptr<firebolt::rialto::LicenseRequestEvent> &event)
198 136 : { m_eventThread->add(&MediaKeysIpc::onLicenseRequest, this, event); });
199 133 : if (eventTag < 0)
200 0 : return false;
201 133 : m_eventTags.push_back(eventTag);
202 :
203 266 : eventTag = ipcChannel->subscribe<firebolt::rialto::LicenseRenewalEvent>(
204 133 : [this](const std::shared_ptr<firebolt::rialto::LicenseRenewalEvent> &event)
205 6 : { m_eventThread->add(&MediaKeysIpc::onLicenseRenewal, this, event); });
206 133 : if (eventTag < 0)
207 1 : return false;
208 132 : m_eventTags.push_back(eventTag);
209 :
210 264 : eventTag = ipcChannel->subscribe<firebolt::rialto::KeyStatusesChangedEvent>(
211 132 : [this](const std::shared_ptr<firebolt::rialto::KeyStatusesChangedEvent> &event)
212 3 : { m_eventThread->add(&MediaKeysIpc::onKeyStatusesChanged, this, event); });
213 132 : if (eventTag < 0)
214 0 : return false;
215 132 : m_eventTags.push_back(eventTag);
216 :
217 132 : return true;
218 : }
219 :
220 98 : bool MediaKeysIpc::createMediaKeys(const std::string &keySystem)
221 : {
222 98 : if (!reattachChannelIfRequired())
223 : {
224 0 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
225 0 : return false;
226 : }
227 :
228 98 : firebolt::rialto::CreateMediaKeysRequest request;
229 :
230 : request.set_key_system(keySystem);
231 :
232 98 : firebolt::rialto::CreateMediaKeysResponse response;
233 98 : auto ipcController = m_ipc.createRpcController();
234 98 : auto blockingClosure = m_ipc.createBlockingClosure();
235 98 : m_mediaKeysStub->createMediaKeys(ipcController.get(), &request, &response, blockingClosure.get());
236 :
237 : // wait for the call to complete
238 98 : blockingClosure->wait();
239 :
240 : // check the result
241 98 : if (ipcController->Failed())
242 : {
243 1 : RIALTO_CLIENT_LOG_ERROR("failed to create media keys due to '%s'", ipcController->ErrorText().c_str());
244 1 : return false;
245 : }
246 :
247 97 : m_mediaKeysHandle = response.media_keys_handle();
248 :
249 97 : return true;
250 98 : }
251 :
252 97 : void MediaKeysIpc::destroyMediaKeys()
253 : {
254 97 : if (!reattachChannelIfRequired())
255 : {
256 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
257 1 : return;
258 : }
259 :
260 96 : firebolt::rialto::DestroyMediaKeysRequest request;
261 96 : request.set_media_keys_handle(m_mediaKeysHandle);
262 :
263 96 : firebolt::rialto::DestroyMediaKeysResponse response;
264 96 : auto ipcController = m_ipc.createRpcController();
265 96 : auto blockingClosure = m_ipc.createBlockingClosure();
266 96 : m_mediaKeysStub->destroyMediaKeys(ipcController.get(), &request, &response, blockingClosure.get());
267 :
268 : // wait for the call to complete
269 96 : blockingClosure->wait();
270 :
271 : // check the result
272 96 : if (ipcController->Failed())
273 : {
274 1 : RIALTO_CLIENT_LOG_ERROR("failed to destroy media keys due to '%s'", ipcController->ErrorText().c_str());
275 : }
276 96 : }
277 :
278 0 : MediaKeyErrorStatus MediaKeysIpc::selectKeyId(int32_t keySessionId, const std::vector<uint8_t> &keyId)
279 : {
280 0 : RIALTO_CLIENT_LOG_ERROR("Not Implemented");
281 0 : return MediaKeyErrorStatus::FAIL;
282 : }
283 :
284 5 : bool MediaKeysIpc::containsKey(int32_t keySessionId, const std::vector<uint8_t> &keyId)
285 : {
286 5 : if (!reattachChannelIfRequired())
287 : {
288 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
289 1 : return false;
290 : }
291 :
292 4 : firebolt::rialto::ContainsKeyRequest request;
293 4 : request.set_media_keys_handle(m_mediaKeysHandle);
294 4 : request.set_key_session_id(keySessionId);
295 16 : for (const auto &keyIdItem : keyId)
296 : {
297 12 : request.add_key_id(keyIdItem);
298 : }
299 :
300 4 : firebolt::rialto::ContainsKeyResponse response;
301 : // Default return value to false
302 4 : response.set_contains_key(false);
303 :
304 4 : auto ipcController = m_ipc.createRpcController();
305 4 : auto blockingClosure = m_ipc.createBlockingClosure();
306 4 : m_mediaKeysStub->containsKey(ipcController.get(), &request, &response, blockingClosure.get());
307 :
308 : // wait for the call to complete
309 4 : blockingClosure->wait();
310 :
311 4 : if (ipcController->Failed())
312 : {
313 1 : RIALTO_CLIENT_LOG_ERROR("containsKey failed due to '%s'", ipcController->ErrorText().c_str());
314 1 : return false;
315 : }
316 :
317 3 : return response.contains_key();
318 4 : }
319 :
320 21 : MediaKeyErrorStatus MediaKeysIpc::createKeySession(KeySessionType sessionType, std::weak_ptr<IMediaKeysClient> client,
321 : bool isLDL, int32_t &keySessionId)
322 : {
323 21 : if (!reattachChannelIfRequired())
324 : {
325 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
326 1 : return MediaKeyErrorStatus::FAIL;
327 : }
328 :
329 20 : CreateKeySessionRequest_KeySessionType protoSessionType = CreateKeySessionRequest_KeySessionType_UNKNOWN;
330 20 : switch (sessionType)
331 : {
332 0 : case KeySessionType::TEMPORARY:
333 0 : protoSessionType = CreateKeySessionRequest_KeySessionType_TEMPORARY;
334 0 : break;
335 20 : case KeySessionType::PERSISTENT_LICENCE:
336 20 : protoSessionType = CreateKeySessionRequest_KeySessionType_PERSISTENT_LICENCE;
337 20 : break;
338 0 : case KeySessionType::PERSISTENT_RELEASE_MESSAGE:
339 0 : protoSessionType = CreateKeySessionRequest_KeySessionType_PERSISTENT_RELEASE_MESSAGE;
340 0 : break;
341 0 : default:
342 0 : RIALTO_CLIENT_LOG_WARN("Recieved unknown key session type");
343 0 : break;
344 : }
345 :
346 40 : firebolt::rialto::CreateKeySessionRequest request;
347 20 : request.set_media_keys_handle(m_mediaKeysHandle);
348 20 : request.set_session_type(protoSessionType);
349 20 : request.set_is_ldl(isLDL);
350 :
351 40 : firebolt::rialto::CreateKeySessionResponse response;
352 : // Default error status to FAIL
353 20 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
354 :
355 40 : auto ipcController = m_ipc.createRpcController();
356 20 : auto blockingClosure = m_ipc.createBlockingClosure();
357 20 : m_mediaKeysStub->createKeySession(ipcController.get(), &request, &response, blockingClosure.get());
358 :
359 : // wait for the call to complete
360 20 : blockingClosure->wait();
361 :
362 : MediaKeyErrorStatus status =
363 40 : getMediaKeyErrorStatusFromResponse("createKeySession", ipcController, response.error_status());
364 20 : if (MediaKeyErrorStatus::OK == status)
365 : {
366 18 : keySessionId = response.key_session_id();
367 18 : m_mediaKeysIpcClient = client;
368 : }
369 :
370 20 : return status;
371 : }
372 :
373 5 : MediaKeyErrorStatus MediaKeysIpc::generateRequest(int32_t keySessionId, InitDataType initDataType,
374 : const std::vector<uint8_t> &initData)
375 : {
376 5 : if (!reattachChannelIfRequired())
377 : {
378 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
379 1 : return MediaKeyErrorStatus::FAIL;
380 : }
381 :
382 4 : GenerateRequestRequest_InitDataType protoInitDataType = GenerateRequestRequest_InitDataType_UNKNOWN;
383 4 : switch (initDataType)
384 : {
385 0 : case InitDataType::CENC:
386 0 : protoInitDataType = GenerateRequestRequest_InitDataType_CENC;
387 0 : break;
388 4 : case InitDataType::KEY_IDS:
389 4 : protoInitDataType = GenerateRequestRequest_InitDataType_KEY_IDS;
390 4 : break;
391 0 : case InitDataType::WEBM:
392 0 : protoInitDataType = GenerateRequestRequest_InitDataType_WEBM;
393 0 : break;
394 0 : case InitDataType::DRMHEADER:
395 0 : protoInitDataType = GenerateRequestRequest_InitDataType_DRMHEADER;
396 0 : break;
397 0 : default:
398 0 : RIALTO_CLIENT_LOG_WARN("Recieved unknown init data type");
399 0 : break;
400 : }
401 :
402 8 : firebolt::rialto::GenerateRequestRequest request;
403 4 : request.set_media_keys_handle(m_mediaKeysHandle);
404 4 : request.set_key_session_id(keySessionId);
405 4 : request.set_init_data_type(protoInitDataType);
406 :
407 16 : for (auto it = initData.begin(); it != initData.end(); it++)
408 : {
409 12 : request.add_init_data(*it);
410 : }
411 :
412 8 : firebolt::rialto::GenerateRequestResponse response;
413 : // Default error status to FAIL
414 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
415 :
416 8 : auto ipcController = m_ipc.createRpcController();
417 4 : auto blockingClosure = m_ipc.createBlockingClosure();
418 4 : m_mediaKeysStub->generateRequest(ipcController.get(), &request, &response, blockingClosure.get());
419 :
420 : // wait for the call to complete
421 4 : blockingClosure->wait();
422 :
423 12 : return getMediaKeyErrorStatusFromResponse("generateRequest", ipcController, response.error_status());
424 : }
425 :
426 5 : MediaKeyErrorStatus MediaKeysIpc::loadSession(int32_t keySessionId)
427 : {
428 5 : if (!reattachChannelIfRequired())
429 : {
430 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
431 1 : return MediaKeyErrorStatus::FAIL;
432 : }
433 :
434 4 : firebolt::rialto::LoadSessionRequest request;
435 4 : request.set_media_keys_handle(m_mediaKeysHandle);
436 4 : request.set_key_session_id(keySessionId);
437 :
438 4 : firebolt::rialto::LoadSessionResponse response;
439 : // Default error status to FAIL
440 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
441 :
442 4 : auto ipcController = m_ipc.createRpcController();
443 4 : auto blockingClosure = m_ipc.createBlockingClosure();
444 4 : m_mediaKeysStub->loadSession(ipcController.get(), &request, &response, blockingClosure.get());
445 :
446 : // wait for the call to complete
447 4 : blockingClosure->wait();
448 :
449 8 : return getMediaKeyErrorStatusFromResponse("loadSession", ipcController, response.error_status());
450 4 : }
451 :
452 5 : MediaKeyErrorStatus MediaKeysIpc::updateSession(int32_t keySessionId, const std::vector<uint8_t> &responseData)
453 : {
454 5 : if (!reattachChannelIfRequired())
455 : {
456 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
457 1 : return MediaKeyErrorStatus::FAIL;
458 : }
459 :
460 4 : firebolt::rialto::UpdateSessionRequest request;
461 4 : request.set_media_keys_handle(m_mediaKeysHandle);
462 4 : request.set_key_session_id(keySessionId);
463 :
464 16 : for (auto it = responseData.begin(); it != responseData.end(); it++)
465 : {
466 12 : request.add_response_data(*it);
467 : }
468 :
469 4 : firebolt::rialto::UpdateSessionResponse response;
470 : // Default error status to FAIL
471 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
472 :
473 4 : auto ipcController = m_ipc.createRpcController();
474 4 : auto blockingClosure = m_ipc.createBlockingClosure();
475 4 : m_mediaKeysStub->updateSession(ipcController.get(), &request, &response, blockingClosure.get());
476 :
477 : // wait for the call to complete
478 4 : blockingClosure->wait();
479 :
480 8 : return getMediaKeyErrorStatusFromResponse("updateSession", ipcController, response.error_status());
481 4 : }
482 :
483 5 : MediaKeyErrorStatus MediaKeysIpc::setDrmHeader(int32_t keySessionId, const std::vector<uint8_t> &requestData)
484 : {
485 5 : if (!reattachChannelIfRequired())
486 : {
487 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
488 1 : return MediaKeyErrorStatus::FAIL;
489 : }
490 :
491 4 : firebolt::rialto::SetDrmHeaderRequest request;
492 4 : request.set_media_keys_handle(m_mediaKeysHandle);
493 4 : request.set_key_session_id(keySessionId);
494 16 : for (const auto &requestDataItem : requestData)
495 : {
496 12 : request.add_request_data(requestDataItem);
497 : }
498 :
499 4 : firebolt::rialto::SetDrmHeaderResponse response;
500 : // Default error status to FAIL
501 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
502 :
503 4 : auto ipcController = m_ipc.createRpcController();
504 4 : auto blockingClosure = m_ipc.createBlockingClosure();
505 4 : m_mediaKeysStub->setDrmHeader(ipcController.get(), &request, &response, blockingClosure.get());
506 :
507 : // wait for the call to complete
508 4 : blockingClosure->wait();
509 :
510 8 : return getMediaKeyErrorStatusFromResponse("setDrmHeader", ipcController, response.error_status());
511 4 : }
512 :
513 5 : MediaKeyErrorStatus MediaKeysIpc::closeKeySession(int32_t keySessionId)
514 : {
515 5 : if (!reattachChannelIfRequired())
516 : {
517 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
518 1 : return MediaKeyErrorStatus::FAIL;
519 : }
520 :
521 : // Reset client
522 4 : m_mediaKeysIpcClient.reset();
523 :
524 4 : firebolt::rialto::CloseKeySessionRequest request;
525 4 : request.set_media_keys_handle(m_mediaKeysHandle);
526 4 : request.set_key_session_id(keySessionId);
527 :
528 4 : firebolt::rialto::CloseKeySessionResponse response;
529 : // Default error status to FAIL
530 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
531 :
532 4 : auto ipcController = m_ipc.createRpcController();
533 4 : auto blockingClosure = m_ipc.createBlockingClosure();
534 4 : m_mediaKeysStub->closeKeySession(ipcController.get(), &request, &response, blockingClosure.get());
535 :
536 : // wait for the call to complete
537 4 : blockingClosure->wait();
538 :
539 8 : return getMediaKeyErrorStatusFromResponse("closeKeySession", ipcController, response.error_status());
540 4 : }
541 :
542 5 : MediaKeyErrorStatus MediaKeysIpc::removeKeySession(int32_t keySessionId)
543 : {
544 5 : if (!reattachChannelIfRequired())
545 : {
546 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
547 1 : return MediaKeyErrorStatus::FAIL;
548 : }
549 :
550 4 : firebolt::rialto::RemoveKeySessionRequest request;
551 4 : request.set_media_keys_handle(m_mediaKeysHandle);
552 4 : request.set_key_session_id(keySessionId);
553 :
554 4 : firebolt::rialto::RemoveKeySessionResponse response;
555 : // Default error status to FAIL
556 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
557 :
558 4 : auto ipcController = m_ipc.createRpcController();
559 4 : auto blockingClosure = m_ipc.createBlockingClosure();
560 4 : m_mediaKeysStub->removeKeySession(ipcController.get(), &request, &response, blockingClosure.get());
561 :
562 : // wait for the call to complete
563 4 : blockingClosure->wait();
564 :
565 8 : return getMediaKeyErrorStatusFromResponse("removeKeySession", ipcController, response.error_status());
566 4 : }
567 :
568 5 : MediaKeyErrorStatus MediaKeysIpc::deleteDrmStore()
569 : {
570 5 : if (!reattachChannelIfRequired())
571 : {
572 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
573 1 : return MediaKeyErrorStatus::FAIL;
574 : }
575 :
576 4 : firebolt::rialto::DeleteDrmStoreRequest request;
577 4 : request.set_media_keys_handle(m_mediaKeysHandle);
578 :
579 4 : firebolt::rialto::DeleteDrmStoreResponse response;
580 : // Default error status to FAIL
581 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
582 :
583 4 : auto ipcController = m_ipc.createRpcController();
584 4 : auto blockingClosure = m_ipc.createBlockingClosure();
585 4 : m_mediaKeysStub->deleteDrmStore(ipcController.get(), &request, &response, blockingClosure.get());
586 :
587 : // wait for the call to complete
588 4 : blockingClosure->wait();
589 :
590 8 : return getMediaKeyErrorStatusFromResponse("deleteDrmStore", ipcController, response.error_status());
591 4 : }
592 :
593 5 : MediaKeyErrorStatus MediaKeysIpc::deleteKeyStore()
594 : {
595 5 : if (!reattachChannelIfRequired())
596 : {
597 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
598 1 : return MediaKeyErrorStatus::FAIL;
599 : }
600 :
601 4 : firebolt::rialto::DeleteKeyStoreRequest request;
602 4 : request.set_media_keys_handle(m_mediaKeysHandle);
603 :
604 4 : firebolt::rialto::DeleteKeyStoreResponse response;
605 : // Default error status to FAIL
606 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
607 :
608 4 : auto ipcController = m_ipc.createRpcController();
609 4 : auto blockingClosure = m_ipc.createBlockingClosure();
610 4 : m_mediaKeysStub->deleteKeyStore(ipcController.get(), &request, &response, blockingClosure.get());
611 :
612 : // wait for the call to complete
613 4 : blockingClosure->wait();
614 :
615 8 : return getMediaKeyErrorStatusFromResponse("deleteKeyStore", ipcController, response.error_status());
616 4 : }
617 :
618 5 : MediaKeyErrorStatus MediaKeysIpc::getDrmStoreHash(std::vector<unsigned char> &drmStoreHash)
619 : {
620 5 : if (!reattachChannelIfRequired())
621 : {
622 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
623 1 : return MediaKeyErrorStatus::FAIL;
624 : }
625 :
626 4 : firebolt::rialto::GetDrmStoreHashRequest request;
627 4 : request.set_media_keys_handle(m_mediaKeysHandle);
628 :
629 4 : firebolt::rialto::GetDrmStoreHashResponse response;
630 : // Default error status to FAIL
631 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
632 :
633 4 : auto ipcController = m_ipc.createRpcController();
634 4 : auto blockingClosure = m_ipc.createBlockingClosure();
635 4 : m_mediaKeysStub->getDrmStoreHash(ipcController.get(), &request, &response, blockingClosure.get());
636 :
637 : // wait for the call to complete
638 4 : blockingClosure->wait();
639 :
640 4 : if (ProtoMediaKeyErrorStatus::OK == response.error_status())
641 : {
642 4 : drmStoreHash = std::vector<unsigned char>(response.drm_store_hash().begin(), response.drm_store_hash().end());
643 : }
644 :
645 8 : return getMediaKeyErrorStatusFromResponse("getDrmStoreHash", ipcController, response.error_status());
646 4 : }
647 :
648 5 : MediaKeyErrorStatus MediaKeysIpc::getKeyStoreHash(std::vector<unsigned char> &keyStoreHash)
649 : {
650 5 : if (!reattachChannelIfRequired())
651 : {
652 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
653 1 : return MediaKeyErrorStatus::FAIL;
654 : }
655 :
656 4 : firebolt::rialto::GetKeyStoreHashRequest request;
657 4 : request.set_media_keys_handle(m_mediaKeysHandle);
658 :
659 4 : firebolt::rialto::GetKeyStoreHashResponse response;
660 : // Default error status to FAIL
661 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
662 :
663 4 : auto ipcController = m_ipc.createRpcController();
664 4 : auto blockingClosure = m_ipc.createBlockingClosure();
665 4 : m_mediaKeysStub->getKeyStoreHash(ipcController.get(), &request, &response, blockingClosure.get());
666 :
667 : // wait for the call to complete
668 4 : blockingClosure->wait();
669 :
670 4 : if (ProtoMediaKeyErrorStatus::OK == response.error_status())
671 : {
672 4 : keyStoreHash = std::vector<unsigned char>(response.key_store_hash().begin(), response.key_store_hash().end());
673 : }
674 :
675 8 : return getMediaKeyErrorStatusFromResponse("getKeyStoreHash", ipcController, response.error_status());
676 4 : }
677 :
678 5 : MediaKeyErrorStatus MediaKeysIpc::getLdlSessionsLimit(uint32_t &ldlLimit)
679 : {
680 5 : if (!reattachChannelIfRequired())
681 : {
682 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
683 1 : return MediaKeyErrorStatus::FAIL;
684 : }
685 :
686 4 : firebolt::rialto::GetLdlSessionsLimitRequest request;
687 4 : request.set_media_keys_handle(m_mediaKeysHandle);
688 :
689 4 : firebolt::rialto::GetLdlSessionsLimitResponse response;
690 : // Default error status to FAIL
691 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
692 :
693 4 : auto ipcController = m_ipc.createRpcController();
694 4 : auto blockingClosure = m_ipc.createBlockingClosure();
695 4 : m_mediaKeysStub->getLdlSessionsLimit(ipcController.get(), &request, &response, blockingClosure.get());
696 :
697 : // wait for the call to complete
698 4 : blockingClosure->wait();
699 :
700 4 : if (ProtoMediaKeyErrorStatus::OK == response.error_status())
701 : {
702 2 : ldlLimit = response.ldl_limit();
703 : }
704 :
705 8 : return getMediaKeyErrorStatusFromResponse("getLdlSessionsLimit", ipcController, response.error_status());
706 4 : }
707 :
708 5 : MediaKeyErrorStatus MediaKeysIpc::getLastDrmError(int32_t keySessionId, uint32_t &errorCode)
709 : {
710 5 : if (!reattachChannelIfRequired())
711 : {
712 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
713 1 : return MediaKeyErrorStatus::FAIL;
714 : }
715 :
716 4 : firebolt::rialto::GetLastDrmErrorRequest request;
717 4 : request.set_media_keys_handle(m_mediaKeysHandle);
718 4 : request.set_key_session_id(keySessionId);
719 :
720 4 : firebolt::rialto::GetLastDrmErrorResponse response;
721 : // Default error status to FAIL
722 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
723 :
724 4 : auto ipcController = m_ipc.createRpcController();
725 4 : auto blockingClosure = m_ipc.createBlockingClosure();
726 4 : m_mediaKeysStub->getLastDrmError(ipcController.get(), &request, &response, blockingClosure.get());
727 :
728 : // wait for the call to complete
729 4 : blockingClosure->wait();
730 :
731 4 : if (ProtoMediaKeyErrorStatus::OK == response.error_status())
732 : {
733 2 : errorCode = response.error_code();
734 : }
735 :
736 8 : return getMediaKeyErrorStatusFromResponse("getLastDrmError", ipcController, response.error_status());
737 4 : }
738 :
739 5 : MediaKeyErrorStatus MediaKeysIpc::getDrmTime(uint64_t &drmTime)
740 : {
741 5 : if (!reattachChannelIfRequired())
742 : {
743 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
744 1 : return MediaKeyErrorStatus::FAIL;
745 : }
746 :
747 4 : firebolt::rialto::GetDrmTimeRequest request;
748 4 : request.set_media_keys_handle(m_mediaKeysHandle);
749 :
750 4 : firebolt::rialto::GetDrmTimeResponse response;
751 : // Default error status to FAIL
752 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
753 :
754 4 : auto ipcController = m_ipc.createRpcController();
755 4 : auto blockingClosure = m_ipc.createBlockingClosure();
756 4 : m_mediaKeysStub->getDrmTime(ipcController.get(), &request, &response, blockingClosure.get());
757 :
758 : // wait for the call to complete
759 4 : blockingClosure->wait();
760 :
761 4 : if (ProtoMediaKeyErrorStatus::OK == response.error_status())
762 : {
763 2 : drmTime = response.drm_time();
764 : }
765 :
766 8 : return getMediaKeyErrorStatusFromResponse("getDrmTime", ipcController, response.error_status());
767 4 : }
768 :
769 5 : MediaKeyErrorStatus MediaKeysIpc::getCdmKeySessionId(int32_t keySessionId, std::string &cdmKeySessionId)
770 : {
771 5 : if (!reattachChannelIfRequired())
772 : {
773 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
774 1 : return MediaKeyErrorStatus::FAIL;
775 : }
776 :
777 4 : firebolt::rialto::GetCdmKeySessionIdRequest request;
778 4 : request.set_media_keys_handle(m_mediaKeysHandle);
779 4 : request.set_key_session_id(keySessionId);
780 :
781 4 : firebolt::rialto::GetCdmKeySessionIdResponse response;
782 : // Default error status to FAIL
783 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
784 :
785 4 : auto ipcController = m_ipc.createRpcController();
786 4 : auto blockingClosure = m_ipc.createBlockingClosure();
787 4 : m_mediaKeysStub->getCdmKeySessionId(ipcController.get(), &request, &response, blockingClosure.get());
788 :
789 : // wait for the call to complete
790 4 : blockingClosure->wait();
791 :
792 4 : cdmKeySessionId = response.cdm_key_session_id();
793 :
794 8 : return getMediaKeyErrorStatusFromResponse("getCdmKeySessionId", ipcController, response.error_status());
795 4 : }
796 :
797 5 : MediaKeyErrorStatus MediaKeysIpc::releaseKeySession(int32_t keySessionId)
798 : {
799 5 : if (!reattachChannelIfRequired())
800 : {
801 1 : RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
802 1 : return MediaKeyErrorStatus::FAIL;
803 : }
804 :
805 : // Reset client
806 4 : m_mediaKeysIpcClient.reset();
807 :
808 4 : firebolt::rialto::ReleaseKeySessionRequest request;
809 4 : request.set_media_keys_handle(m_mediaKeysHandle);
810 4 : request.set_key_session_id(keySessionId);
811 :
812 4 : firebolt::rialto::ReleaseKeySessionResponse response;
813 : // Default error status to FAIL
814 4 : response.set_error_status(ProtoMediaKeyErrorStatus::FAIL);
815 :
816 4 : auto ipcController = m_ipc.createRpcController();
817 4 : auto blockingClosure = m_ipc.createBlockingClosure();
818 4 : m_mediaKeysStub->releaseKeySession(ipcController.get(), &request, &response, blockingClosure.get());
819 :
820 : // wait for the call to complete
821 4 : blockingClosure->wait();
822 :
823 8 : return getMediaKeyErrorStatusFromResponse("releaseKeySession", ipcController, response.error_status());
824 4 : }
825 :
826 3 : void MediaKeysIpc::onLicenseRequest(const std::shared_ptr<firebolt::rialto::LicenseRequestEvent> &event)
827 : {
828 3 : std::shared_ptr<IMediaKeysClient> mediaKeysIpcClient = m_mediaKeysIpcClient.lock();
829 :
830 : /* Ignore event if not for this session or no client */
831 3 : if ((event->media_keys_handle() == m_mediaKeysHandle) && (mediaKeysIpcClient))
832 : {
833 1 : std::vector<unsigned char> messageVector = std::vector<unsigned char>{event->license_request_message().begin(),
834 2 : event->license_request_message().end()};
835 1 : mediaKeysIpcClient->onLicenseRequest(event->key_session_id(), messageVector, event->url());
836 : }
837 3 : }
838 :
839 6 : void MediaKeysIpc::onLicenseRenewal(const std::shared_ptr<firebolt::rialto::LicenseRenewalEvent> &event)
840 : {
841 6 : std::shared_ptr<IMediaKeysClient> mediaKeysIpcClient = m_mediaKeysIpcClient.lock();
842 :
843 : /* Ignore event if not for this session or no client */
844 6 : if ((event->media_keys_handle() == m_mediaKeysHandle) && (mediaKeysIpcClient))
845 : {
846 2 : std::vector<unsigned char> messageVector = std::vector<unsigned char>{event->license_renewal_message().begin(),
847 4 : event->license_renewal_message().end()};
848 2 : mediaKeysIpcClient->onLicenseRenewal(event->key_session_id(), messageVector);
849 : }
850 6 : }
851 :
852 3 : void MediaKeysIpc::onKeyStatusesChanged(const std::shared_ptr<firebolt::rialto::KeyStatusesChangedEvent> &event)
853 : {
854 3 : std::shared_ptr<IMediaKeysClient> mediaKeysIpcClient = m_mediaKeysIpcClient.lock();
855 :
856 : /* Ignore event if not for this session or no client */
857 3 : if ((event->media_keys_handle() == m_mediaKeysHandle) && (mediaKeysIpcClient))
858 : {
859 1 : KeyStatusVector keyStatuses;
860 4 : for (auto it = event->key_statuses().begin(); it != event->key_statuses().end(); it++)
861 : {
862 6 : std::vector<unsigned char> keyVector = std::vector<unsigned char>{it->key_id().begin(), it->key_id().end()};
863 3 : KeyStatus keyStatus = convertKeyStatus(it->key_status());
864 3 : keyStatuses.push_back(std::make_pair(keyVector, keyStatus));
865 : }
866 1 : mediaKeysIpcClient->onKeyStatusesChanged(event->key_session_id(), keyStatuses);
867 : }
868 3 : }
869 :
870 : MediaKeyErrorStatus
871 80 : MediaKeysIpc::getMediaKeyErrorStatusFromResponse(const std::string methodName,
872 : const std::shared_ptr<google::protobuf::RpcController> &controller,
873 : ProtoMediaKeyErrorStatus status)
874 : {
875 80 : if (controller->Failed())
876 : {
877 16 : RIALTO_CLIENT_LOG_ERROR("%s failed due to '%s'", methodName.c_str(), controller->ErrorText().c_str());
878 16 : return MediaKeyErrorStatus::FAIL;
879 : }
880 64 : MediaKeyErrorStatus returnStatus = convertMediaKeyErrorStatus(status);
881 64 : if (MediaKeyErrorStatus::OK != returnStatus)
882 : {
883 16 : RIALTO_CLIENT_LOG_ERROR("%s failed due to MediaKeyErrorStatus '%s'", methodName.c_str(), toString(returnStatus));
884 16 : return returnStatus;
885 : }
886 :
887 48 : return returnStatus;
888 : }
889 :
890 : }; // namespace firebolt::rialto::client
|
