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 <algorithm>
21 : #include <exception>
22 : #include <memory>
23 : #include <string>
24 : #include <utility>
25 : #include <vector>
26 :
27 : #include "CdmService.h"
28 : #include "RialtoServerLogging.h"
29 :
30 : namespace firebolt::rialto::server::service
31 : {
32 90 : CdmService::CdmService(std::shared_ptr<IMediaKeysServerInternalFactory> &&mediaKeysFactory,
33 90 : std::shared_ptr<IMediaKeysCapabilitiesFactory> &&mediaKeysCapabilitiesFactory)
34 90 : : m_mediaKeysFactory{mediaKeysFactory}, m_mediaKeysCapabilitiesFactory{mediaKeysCapabilitiesFactory},
35 180 : m_isActive{false}
36 : {
37 90 : RIALTO_SERVER_LOG_DEBUG("CdmService is constructed");
38 : }
39 :
40 90 : CdmService::~CdmService()
41 : {
42 90 : RIALTO_SERVER_LOG_DEBUG("CdmService is destructed");
43 : }
44 :
45 85 : bool CdmService::switchToActive()
46 : {
47 85 : RIALTO_SERVER_LOG_INFO("Switching SessionServer to Active state.");
48 85 : m_isActive = true;
49 85 : return true;
50 : }
51 :
52 2 : void CdmService::switchToInactive()
53 : {
54 2 : RIALTO_SERVER_LOG_INFO("Switching SessionServer to Inactive state. Cleaning resources...");
55 2 : m_isActive = false;
56 :
57 : {
58 2 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
59 2 : m_mediaKeys.clear();
60 : }
61 : }
62 :
63 57 : bool CdmService::createMediaKeys(int mediaKeysHandle, std::string keySystem)
64 : {
65 57 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to create new media keys handle: %d", mediaKeysHandle);
66 57 : if (!m_isActive)
67 : {
68 2 : RIALTO_SERVER_LOG_ERROR("Skip to create media keys handle: %d - Session Server in Inactive state",
69 : mediaKeysHandle);
70 2 : return false;
71 : }
72 :
73 : {
74 55 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
75 55 : if (m_mediaKeys.find(mediaKeysHandle) != m_mediaKeys.end())
76 : {
77 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d already exists", mediaKeysHandle);
78 1 : return false;
79 : }
80 54 : m_mediaKeys.emplace(std::make_pair(mediaKeysHandle, m_mediaKeysFactory->createMediaKeysServerInternal(keySystem)));
81 54 : if (!m_mediaKeys.at(mediaKeysHandle))
82 : {
83 1 : RIALTO_SERVER_LOG_ERROR("Could not create MediaKeys for media keys handle: %d", mediaKeysHandle);
84 1 : m_mediaKeys.erase(mediaKeysHandle);
85 1 : return false;
86 : }
87 55 : }
88 :
89 53 : RIALTO_SERVER_LOG_INFO("New media keys handle: %d created", mediaKeysHandle);
90 53 : return true;
91 : }
92 :
93 51 : bool CdmService::destroyMediaKeys(int mediaKeysHandle)
94 : {
95 51 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to destroy media keys handle: %d", mediaKeysHandle);
96 :
97 : {
98 51 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
99 51 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
100 51 : if (mediaKeysIter == m_mediaKeys.end())
101 : {
102 2 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
103 2 : return false;
104 : }
105 49 : m_mediaKeys.erase(mediaKeysIter);
106 51 : }
107 :
108 49 : RIALTO_SERVER_LOG_INFO("Media keys handle: %d destroyed", mediaKeysHandle);
109 49 : return true;
110 : }
111 :
112 5 : MediaKeyErrorStatus CdmService::createKeySession(int mediaKeysHandle, KeySessionType sessionType,
113 : const std::shared_ptr<IMediaKeysClient> &client, bool isLDL,
114 : int32_t &keySessionId)
115 : {
116 5 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to create key session: %d", mediaKeysHandle);
117 :
118 5 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
119 5 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
120 5 : if (mediaKeysIter == m_mediaKeys.end())
121 : {
122 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
123 1 : return MediaKeyErrorStatus::FAIL;
124 : }
125 :
126 4 : MediaKeyErrorStatus status = mediaKeysIter->second->createKeySession(sessionType, client, isLDL, keySessionId);
127 4 : if (MediaKeyErrorStatus::OK == status)
128 : {
129 3 : if (m_mediaKeysClients.find(keySessionId) != m_mediaKeysClients.end())
130 : {
131 1 : RIALTO_SERVER_LOG_ERROR("Media keys client for key session: %d already exists", keySessionId);
132 1 : static_cast<void>(removeKeySessionInternal(mediaKeysHandle, keySessionId));
133 1 : return MediaKeyErrorStatus::FAIL;
134 : }
135 2 : m_mediaKeysClients.emplace(std::make_pair(keySessionId, client));
136 : }
137 :
138 3 : return status;
139 5 : }
140 :
141 3 : MediaKeyErrorStatus CdmService::generateRequest(int mediaKeysHandle, int32_t keySessionId, InitDataType initDataType,
142 : const std::vector<uint8_t> &initData)
143 : {
144 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to generate request: %d", mediaKeysHandle);
145 :
146 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
147 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
148 3 : if (mediaKeysIter == m_mediaKeys.end())
149 : {
150 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
151 1 : return MediaKeyErrorStatus::FAIL;
152 : }
153 2 : return mediaKeysIter->second->generateRequest(keySessionId, initDataType, initData);
154 3 : }
155 :
156 3 : MediaKeyErrorStatus CdmService::loadSession(int mediaKeysHandle, int32_t keySessionId)
157 : {
158 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to load session: %d", mediaKeysHandle);
159 :
160 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
161 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
162 3 : if (mediaKeysIter == m_mediaKeys.end())
163 : {
164 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
165 1 : return MediaKeyErrorStatus::FAIL;
166 : }
167 2 : return mediaKeysIter->second->loadSession(keySessionId);
168 3 : }
169 :
170 3 : MediaKeyErrorStatus CdmService::updateSession(int mediaKeysHandle, int32_t keySessionId,
171 : const std::vector<uint8_t> &responseData)
172 : {
173 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to update session: %d", mediaKeysHandle);
174 :
175 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
176 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
177 3 : if (mediaKeysIter == m_mediaKeys.end())
178 : {
179 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
180 1 : return MediaKeyErrorStatus::FAIL;
181 : }
182 2 : return mediaKeysIter->second->updateSession(keySessionId, responseData);
183 3 : }
184 :
185 3 : MediaKeyErrorStatus CdmService::closeKeySession(int mediaKeysHandle, int32_t keySessionId)
186 : {
187 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to close key session: %d", mediaKeysHandle);
188 :
189 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
190 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
191 3 : if (mediaKeysIter == m_mediaKeys.end())
192 : {
193 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
194 1 : return MediaKeyErrorStatus::FAIL;
195 : }
196 2 : return mediaKeysIter->second->closeKeySession(keySessionId);
197 3 : }
198 :
199 3 : MediaKeyErrorStatus CdmService::removeKeySession(int mediaKeysHandle, int32_t keySessionId)
200 : {
201 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to remove key session: %d", mediaKeysHandle);
202 :
203 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
204 6 : return removeKeySessionInternal(mediaKeysHandle, keySessionId);
205 3 : }
206 :
207 4 : MediaKeyErrorStatus CdmService::removeKeySessionInternal(int mediaKeysHandle, int32_t keySessionId)
208 : {
209 4 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
210 4 : if (mediaKeysIter == m_mediaKeys.end())
211 : {
212 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
213 1 : return MediaKeyErrorStatus::FAIL;
214 : }
215 :
216 3 : MediaKeyErrorStatus status = mediaKeysIter->second->removeKeySession(keySessionId);
217 3 : if (MediaKeyErrorStatus::OK == status)
218 : {
219 2 : auto mediaKeysClientsIter = m_mediaKeysClients.find(keySessionId);
220 2 : if (mediaKeysClientsIter != m_mediaKeysClients.end())
221 : {
222 1 : m_mediaKeysClients.erase(mediaKeysClientsIter);
223 : }
224 : }
225 :
226 3 : return status;
227 : }
228 :
229 3 : MediaKeyErrorStatus CdmService::getCdmKeySessionId(int mediaKeysHandle, int32_t keySessionId, std::string &cdmKeySessionId)
230 : {
231 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to get cdm key session id: %d", mediaKeysHandle);
232 :
233 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
234 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
235 3 : if (mediaKeysIter == m_mediaKeys.end())
236 : {
237 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
238 1 : return MediaKeyErrorStatus::FAIL;
239 : }
240 :
241 2 : MediaKeyErrorStatus status = mediaKeysIter->second->getCdmKeySessionId(keySessionId, cdmKeySessionId);
242 2 : return status;
243 3 : }
244 :
245 3 : bool CdmService::containsKey(int mediaKeysHandle, int32_t keySessionId, const std::vector<uint8_t> &keyId)
246 : {
247 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to check if key is present: %d", mediaKeysHandle);
248 :
249 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
250 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
251 3 : if (mediaKeysIter == m_mediaKeys.end())
252 : {
253 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
254 1 : return false;
255 : }
256 :
257 2 : return mediaKeysIter->second->containsKey(keySessionId, keyId);
258 3 : }
259 :
260 3 : MediaKeyErrorStatus CdmService::setDrmHeader(int mediaKeysHandle, int32_t keySessionId,
261 : const std::vector<uint8_t> &requestData)
262 : {
263 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to set drm header: %d", mediaKeysHandle);
264 :
265 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
266 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
267 3 : if (mediaKeysIter == m_mediaKeys.end())
268 : {
269 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
270 1 : return MediaKeyErrorStatus::FAIL;
271 : }
272 :
273 2 : return mediaKeysIter->second->setDrmHeader(keySessionId, requestData);
274 3 : }
275 :
276 3 : MediaKeyErrorStatus CdmService::deleteDrmStore(int mediaKeysHandle)
277 : {
278 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to delete drm store: %d", mediaKeysHandle);
279 :
280 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
281 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
282 3 : if (mediaKeysIter == m_mediaKeys.end())
283 : {
284 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
285 1 : return MediaKeyErrorStatus::FAIL;
286 : }
287 2 : return mediaKeysIter->second->deleteDrmStore();
288 3 : }
289 :
290 3 : MediaKeyErrorStatus CdmService::deleteKeyStore(int mediaKeysHandle)
291 : {
292 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to delete key store: %d", mediaKeysHandle);
293 :
294 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
295 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
296 3 : if (mediaKeysIter == m_mediaKeys.end())
297 : {
298 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
299 1 : return MediaKeyErrorStatus::FAIL;
300 : }
301 :
302 2 : return mediaKeysIter->second->deleteKeyStore();
303 3 : }
304 :
305 3 : MediaKeyErrorStatus CdmService::getDrmStoreHash(int mediaKeysHandle, std::vector<unsigned char> &drmStoreHash)
306 : {
307 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to get drm store hash: %d", mediaKeysHandle);
308 :
309 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
310 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
311 3 : if (mediaKeysIter == m_mediaKeys.end())
312 : {
313 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
314 1 : return MediaKeyErrorStatus::FAIL;
315 : }
316 2 : return mediaKeysIter->second->getDrmStoreHash(drmStoreHash);
317 3 : }
318 :
319 3 : MediaKeyErrorStatus CdmService::getKeyStoreHash(int mediaKeysHandle, std::vector<unsigned char> &keyStoreHash)
320 : {
321 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to get key store hash: %d", mediaKeysHandle);
322 :
323 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
324 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
325 3 : if (mediaKeysIter == m_mediaKeys.end())
326 : {
327 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
328 1 : return MediaKeyErrorStatus::FAIL;
329 : }
330 2 : return mediaKeysIter->second->getKeyStoreHash(keyStoreHash);
331 3 : }
332 :
333 3 : MediaKeyErrorStatus CdmService::getLdlSessionsLimit(int mediaKeysHandle, uint32_t &ldlLimit)
334 : {
335 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to get ldl sessions limit: %d", mediaKeysHandle);
336 :
337 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
338 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
339 3 : if (mediaKeysIter == m_mediaKeys.end())
340 : {
341 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
342 1 : return MediaKeyErrorStatus::FAIL;
343 : }
344 2 : return mediaKeysIter->second->getLdlSessionsLimit(ldlLimit);
345 3 : }
346 :
347 3 : MediaKeyErrorStatus CdmService::getLastDrmError(int mediaKeysHandle, int32_t keySessionId, uint32_t &errorCode)
348 : {
349 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to get last drm error: %d", mediaKeysHandle);
350 :
351 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
352 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
353 3 : if (mediaKeysIter == m_mediaKeys.end())
354 : {
355 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
356 1 : return MediaKeyErrorStatus::FAIL;
357 : }
358 2 : return mediaKeysIter->second->getLastDrmError(keySessionId, errorCode);
359 3 : }
360 :
361 3 : MediaKeyErrorStatus CdmService::getDrmTime(int mediaKeysHandle, uint64_t &drmTime)
362 : {
363 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to get drm time: %d", mediaKeysHandle);
364 :
365 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
366 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
367 3 : if (mediaKeysIter == m_mediaKeys.end())
368 : {
369 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
370 1 : return MediaKeyErrorStatus::FAIL;
371 : }
372 2 : return mediaKeysIter->second->getDrmTime(drmTime);
373 3 : }
374 :
375 3 : MediaKeyErrorStatus CdmService::releaseKeySession(int mediaKeysHandle, int32_t keySessionId)
376 : {
377 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to release key session: %d", mediaKeysHandle);
378 :
379 3 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
380 3 : auto mediaKeysIter = m_mediaKeys.find(mediaKeysHandle);
381 3 : if (mediaKeysIter == m_mediaKeys.end())
382 : {
383 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle: %d does not exists", mediaKeysHandle);
384 1 : return MediaKeyErrorStatus::FAIL;
385 : }
386 2 : return mediaKeysIter->second->releaseKeySession(keySessionId);
387 3 : }
388 :
389 3 : std::vector<std::string> CdmService::getSupportedKeySystems()
390 : {
391 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to getSupportedKeySystems");
392 :
393 3 : if (!m_isActive)
394 : {
395 1 : RIALTO_SERVER_LOG_ERROR("Skip to get supported key systems: Session Server in Inactive state");
396 1 : return {};
397 : }
398 :
399 2 : auto mediaKeysCapabilities = m_mediaKeysCapabilitiesFactory->getMediaKeysCapabilities();
400 2 : if (!mediaKeysCapabilities)
401 : {
402 1 : RIALTO_SERVER_LOG_ERROR("Failed to create the mediaKeysCapabilities object");
403 1 : return {};
404 : }
405 1 : return mediaKeysCapabilities->getSupportedKeySystems();
406 2 : }
407 :
408 3 : bool CdmService::supportsKeySystem(const std::string &keySystem)
409 : {
410 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to supportsKeySystem");
411 :
412 3 : if (!m_isActive)
413 : {
414 1 : RIALTO_SERVER_LOG_ERROR("Skip to get supported key systems: Session Server in Inactive state");
415 1 : return false;
416 : }
417 :
418 2 : auto mediaKeysCapabilities = m_mediaKeysCapabilitiesFactory->getMediaKeysCapabilities();
419 2 : if (!mediaKeysCapabilities)
420 : {
421 1 : RIALTO_SERVER_LOG_ERROR("Failed to create the mediaKeysCapabilities object");
422 1 : return false;
423 : }
424 1 : return mediaKeysCapabilities->supportsKeySystem(keySystem);
425 2 : }
426 :
427 4 : bool CdmService::getSupportedKeySystemVersion(const std::string &keySystem, std::string &version)
428 : {
429 4 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to getSupportedKeySystemVersion");
430 :
431 4 : if (!m_isActive)
432 : {
433 1 : RIALTO_SERVER_LOG_ERROR("Skip to get supported key systems: Session Server in Inactive state");
434 1 : return false;
435 : }
436 :
437 3 : auto mediaKeysCapabilities = m_mediaKeysCapabilitiesFactory->getMediaKeysCapabilities();
438 3 : if (!mediaKeysCapabilities)
439 : {
440 1 : RIALTO_SERVER_LOG_ERROR("Failed to create the mediaKeysCapabilities object");
441 1 : return false;
442 : }
443 2 : return mediaKeysCapabilities->getSupportedKeySystemVersion(keySystem, version);
444 3 : }
445 :
446 3 : bool CdmService::isServerCertificateSupported(const std::string &keySystem)
447 : {
448 3 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to isServerCertificateSupported");
449 :
450 3 : if (!m_isActive)
451 : {
452 1 : RIALTO_SERVER_LOG_ERROR("Skip to check if server cert is supported: Session Server in Inactive state");
453 1 : return false;
454 : }
455 :
456 2 : auto mediaKeysCapabilities = m_mediaKeysCapabilitiesFactory->getMediaKeysCapabilities();
457 2 : if (!mediaKeysCapabilities)
458 : {
459 1 : RIALTO_SERVER_LOG_ERROR("Failed to create the mediaKeysCapabilities object");
460 1 : return false;
461 : }
462 1 : return mediaKeysCapabilities->isServerCertificateSupported(keySystem);
463 2 : }
464 :
465 4 : MediaKeyErrorStatus CdmService::decrypt(int32_t keySessionId, GstBuffer *encrypted, GstCaps *caps)
466 : {
467 4 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to decrypt, key session id: %d", keySessionId);
468 :
469 4 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
470 4 : auto mediaKeysIter = std::find_if(m_mediaKeys.begin(), m_mediaKeys.end(),
471 3 : [&](const auto &iter) { return iter.second->hasSession(keySessionId); });
472 4 : if (mediaKeysIter == m_mediaKeys.end())
473 : {
474 2 : RIALTO_SERVER_LOG_ERROR("Media keys handle for mksId: %d does not exists", keySessionId);
475 2 : return MediaKeyErrorStatus::FAIL;
476 : }
477 2 : return mediaKeysIter->second->decrypt(keySessionId, encrypted, caps);
478 4 : }
479 :
480 4 : bool CdmService::isNetflixPlayreadyKeySystem(int32_t keySessionId)
481 : {
482 4 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to check if key system is Playready, key session id: %d", keySessionId);
483 :
484 4 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
485 4 : auto mediaKeysIter = std::find_if(m_mediaKeys.begin(), m_mediaKeys.end(),
486 3 : [&](const auto &iter) { return iter.second->hasSession(keySessionId); });
487 4 : if (mediaKeysIter == m_mediaKeys.end())
488 : {
489 2 : RIALTO_SERVER_LOG_ERROR("Media keys handle for mksId: %d does not exists", keySessionId);
490 2 : return false;
491 : }
492 2 : return mediaKeysIter->second->isNetflixPlayreadyKeySystem(keySessionId);
493 4 : }
494 :
495 4 : MediaKeyErrorStatus CdmService::selectKeyId(int32_t keySessionId, const std::vector<uint8_t> &keyId)
496 : {
497 4 : RIALTO_SERVER_LOG_DEBUG("CdmService requested to select key id, key session id: %d", keySessionId);
498 :
499 4 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
500 4 : auto mediaKeysIter = std::find_if(m_mediaKeys.begin(), m_mediaKeys.end(),
501 3 : [&](const auto &iter) { return iter.second->hasSession(keySessionId); });
502 4 : if (mediaKeysIter == m_mediaKeys.end())
503 : {
504 2 : RIALTO_SERVER_LOG_ERROR("Media keys handle for mksId: %d does not exists", keySessionId);
505 2 : return MediaKeyErrorStatus::FAIL;
506 : }
507 2 : return mediaKeysIter->second->selectKeyId(keySessionId, keyId);
508 4 : }
509 :
510 2 : void CdmService::incrementSessionIdUsageCounter(int32_t keySessionId)
511 : {
512 2 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
513 2 : auto mediaKeysIter = std::find_if(m_mediaKeys.begin(), m_mediaKeys.end(),
514 2 : [&](const auto &iter) { return iter.second->hasSession(keySessionId); });
515 2 : if (mediaKeysIter == m_mediaKeys.end())
516 : {
517 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle for mksId: %d does not exists", keySessionId);
518 1 : return;
519 : }
520 :
521 1 : mediaKeysIter->second->incrementSessionIdUsageCounter(keySessionId);
522 2 : }
523 :
524 2 : void CdmService::decrementSessionIdUsageCounter(int32_t keySessionId)
525 : {
526 2 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
527 2 : auto mediaKeysIter = std::find_if(m_mediaKeys.begin(), m_mediaKeys.end(),
528 2 : [&](const auto &iter) { return iter.second->hasSession(keySessionId); });
529 2 : if (mediaKeysIter == m_mediaKeys.end())
530 : {
531 1 : RIALTO_SERVER_LOG_ERROR("Media keys handle for mksId: %d does not exists", keySessionId);
532 1 : return;
533 : }
534 :
535 1 : mediaKeysIter->second->decrementSessionIdUsageCounter(keySessionId);
536 2 : }
537 :
538 1 : void CdmService::ping(const std::shared_ptr<IHeartbeatProcedure> &heartbeatProcedure)
539 : {
540 1 : std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
541 2 : for (const auto &mediaKeyPair : m_mediaKeys)
542 : {
543 1 : auto &mediaKeys = mediaKeyPair.second;
544 1 : mediaKeys->ping(heartbeatProcedure->createHandler());
545 : }
546 : }
547 : } // namespace firebolt::rialto::server::service
|
